blob: 80831561c6711f70be75c7740380073b008d4ecf [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk81a88242002-10-26 15:22:42 +00002/*
Heiko Schocher3f4978c2012-01-16 21:12:24 +00003 * (C) Copyright 2009
4 * Sergey Kubushyn, himself, ksi@koi8.net
5 *
6 * Changes for unified multibus/multiadapter I2C support.
7 *
wdenk81a88242002-10-26 15:22:42 +00008 * (C) Copyright 2001
9 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
wdenk81a88242002-10-26 15:22:42 +000010 */
11
12/*
13 * I2C Functions similar to the standard memory functions.
14 *
15 * There are several parameters in many of the commands that bear further
16 * explanations:
17 *
wdenk81a88242002-10-26 15:22:42 +000018 * {i2c_chip} is the I2C chip address (the first byte sent on the bus).
19 * Each I2C chip on the bus has a unique address. On the I2C data bus,
20 * the address is the upper seven bits and the LSB is the "read/write"
21 * bit. Note that the {i2c_chip} address specified on the command
22 * line is not shifted up: e.g. a typical EEPROM memory chip may have
23 * an I2C address of 0x50, but the data put on the bus will be 0xA0
24 * for write and 0xA1 for read. This "non shifted" address notation
25 * matches at least half of the data sheets :-/.
26 *
27 * {addr} is the address (or offset) within the chip. Small memory
28 * chips have 8 bit addresses. Large memory chips have 16 bit
29 * addresses. Other memory chips have 9, 10, or 11 bit addresses.
30 * Many non-memory chips have multiple registers and {addr} is used
31 * as the register index. Some non-memory chips have only one register
32 * and therefore don't need any {addr} parameter.
33 *
34 * The default {addr} parameter is one byte (.1) which works well for
35 * memories and registers with 8 bits of address space.
36 *
37 * You can specify the length of the {addr} field with the optional .0,
38 * .1, or .2 modifier (similar to the .b, .w, .l modifier). If you are
39 * manipulating a single register device which doesn't use an address
40 * field, use "0.0" for the address and the ".0" length field will
41 * suppress the address in the I2C data stream. This also works for
42 * successive reads using the I2C auto-incrementing memory pointer.
43 *
44 * If you are manipulating a large memory with 2-byte addresses, use
45 * the .2 address modifier, e.g. 210.2 addresses location 528 (decimal).
46 *
47 * Then there are the unfortunate memory chips that spill the most
48 * significant 1, 2, or 3 bits of address into the chip address byte.
49 * This effectively makes one chip (logically) look like 2, 4, or
50 * 8 chips. This is handled (awkwardly) by #defining
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020051 * CONFIG_SYS_I2C_EEPROM_ADDR_OVERFLOW and using the .1 modifier on the
wdenk81a88242002-10-26 15:22:42 +000052 * {addr} field (since .1 is the default, it doesn't actually have to
53 * be specified). Examples: given a memory chip at I2C chip address
54 * 0x50, the following would happen...
Peter Tyser0f89c542009-04-18 22:34:03 -050055 * i2c md 50 0 10 display 16 bytes starting at 0x000
wdenk81a88242002-10-26 15:22:42 +000056 * On the bus: <S> A0 00 <E> <S> A1 <rd> ... <rd>
Peter Tyser0f89c542009-04-18 22:34:03 -050057 * i2c md 50 100 10 display 16 bytes starting at 0x100
wdenk81a88242002-10-26 15:22:42 +000058 * On the bus: <S> A2 00 <E> <S> A3 <rd> ... <rd>
Peter Tyser0f89c542009-04-18 22:34:03 -050059 * i2c md 50 210 10 display 16 bytes starting at 0x210
wdenk81a88242002-10-26 15:22:42 +000060 * On the bus: <S> A4 10 <E> <S> A5 <rd> ... <rd>
61 * This is awfully ugly. It would be nice if someone would think up
62 * a better way of handling this.
63 *
64 * Adapted from cmd_mem.c which is copyright Wolfgang Denk (wd@denx.de).
65 */
66
67#include <common.h>
Simon Glass0098e172014-04-10 20:01:30 -060068#include <bootretry.h>
Simon Glass18d66532014-04-10 20:01:25 -060069#include <cli.h>
wdenk81a88242002-10-26 15:22:42 +000070#include <command.h>
Simon Glass24b852a2015-11-08 23:47:45 -070071#include <console.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>
Simon Glass63656b72014-12-10 08:55:48 -070074#include <errno.h>
wdenk81a88242002-10-26 15:22:42 +000075#include <i2c.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060076#include <log.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>
Simon Glassc05ed002020-05-10 11:40:11 -060080#include <linux/delay.h>
Simon Glass3db71102019-11-14 12:57:16 -070081#include <u-boot/crc.h>
wdenk81a88242002-10-26 15:22:42 +000082
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
Tom Rini65cc0e22022-11-16 13:10:41 -0500100#if defined(CFG_SYS_I2C_NOPROBES)
Tom Rini1353b252022-12-02 16:42:30 -0500101#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY)
Ben Warrenbb99ad62006-09-07 16:50:54 -0400102static struct
103{
104 uchar bus;
105 uchar addr;
Tom Rini65cc0e22022-11-16 13:10:41 -0500106} i2c_no_probes[] = CFG_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 */
Tom Rini65cc0e22022-11-16 13:10:41 -0500112static uchar i2c_no_probes[] = CFG_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)]
Tom Rini55dabcc2021-08-18 23:12:24 -0400117#endif /* CONFIG_IS_ENABLED(SYS_I2C_LEGACY) */
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 */
Igor Opaniuk2147a162021-02-09 13:52:45 +0200127#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700128#define DEFAULT_ADDR_LEN (-1)
129#else
130#define DEFAULT_ADDR_LEN 1
131#endif
132
Igor Opaniuk2147a162021-02-09 13:52:45 +0200133#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700134static 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{
Lukasz Majewskie46f8a32017-03-21 12:08:25 +0100153#ifdef CONFIG_I2C_SET_DEFAULT_BUS_NUM
154 if (!i2c_cur_bus) {
155 if (cmd_i2c_set_bus_num(CONFIG_I2C_DEFAULT_BUS_NUMBER)) {
156 printf("Default I2C bus %d not found\n",
157 CONFIG_I2C_DEFAULT_BUS_NUMBER);
158 return -ENODEV;
159 }
160 }
161#endif
162
Simon Glass63656b72014-12-10 08:55:48 -0700163 if (!i2c_cur_bus) {
164 puts("No I2C bus selected\n");
165 return -ENODEV;
166 }
167 *busp = i2c_cur_bus;
168
169 return 0;
170}
171
172static int i2c_get_cur_bus_chip(uint chip_addr, struct udevice **devp)
173{
174 struct udevice *bus;
175 int ret;
176
177 ret = i2c_get_cur_bus(&bus);
178 if (ret)
179 return ret;
180
Simon Glass25ab4b02015-01-25 08:26:55 -0700181 return i2c_get_chip(bus, chip_addr, 1, devp);
Simon Glass63656b72014-12-10 08:55:48 -0700182}
183
184#endif
185
Marek Vasut06afa382012-11-12 14:34:27 +0000186/**
187 * i2c_init_board() - Board-specific I2C bus init
188 *
189 * This function is the default no-op implementation of I2C bus
Robert P. J. Day62a3b7d2016-07-15 13:44:45 -0400190 * initialization. This function can be overridden by board-specific
Marek Vasut06afa382012-11-12 14:34:27 +0000191 * implementation if needed.
192 */
Marek Vasut2515d842012-11-12 14:34:25 +0000193__weak
194void i2c_init_board(void)
Stefan Biglerc649dda2011-04-08 16:24:08 +0200195{
Stefan Biglerc649dda2011-04-08 16:24:08 +0200196}
Stefan Biglerc649dda2011-04-08 16:24:08 +0200197
Marek Vasut06afa382012-11-12 14:34:27 +0000198/**
199 * get_alen() - Small parser helper function to get address length
200 *
201 * Returns the address length.
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100202 */
Marek Vasut1aa9a042022-08-26 23:15:55 +0200203static uint get_alen(char *arg, int default_len)
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100204{
Marek Vasut1aa9a042022-08-26 23:15:55 +0200205 int j;
206 int alen;
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100207
Simon Glass63656b72014-12-10 08:55:48 -0700208 alen = default_len;
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100209 for (j = 0; j < 8; j++) {
210 if (arg[j] == '.') {
211 alen = arg[j+1] - '0';
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100212 break;
213 } else if (arg[j] == '\0')
214 break;
215 }
216 return alen;
217}
218
Simon Glassc1a6f372014-11-11 10:46:17 -0700219enum i2c_err_op {
220 I2C_ERR_READ,
221 I2C_ERR_WRITE,
222};
223
224static int i2c_report_err(int ret, enum i2c_err_op op)
225{
226 printf("Error %s the chip: %d\n",
227 op == I2C_ERR_READ ? "reading" : "writing", ret);
228
229 return CMD_RET_FAILURE;
230}
231
Marek Vasut06afa382012-11-12 14:34:27 +0000232/**
233 * do_i2c_read() - Handle the "i2c read" command-line command
234 * @cmdtp: Command data struct pointer
235 * @flag: Command flag
236 * @argc: Command-line argument count
237 * @argv: Array of command-line arguments
238 *
239 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
240 * on error.
241 *
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100242 * Syntax:
243 * i2c read {i2c_chip} {devaddr}{.0, .1, .2} {len} {memaddr}
244 */
Simon Glass09140112020-05-10 11:40:03 -0600245static int do_i2c_read(struct cmd_tbl *cmdtp, int flag, int argc,
246 char *const argv[])
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100247{
Masahiro Yamada54684612014-12-20 03:34:23 +0900248 uint chip;
Simon Glass63656b72014-12-10 08:55:48 -0700249 uint devaddr, length;
Marek Vasut1aa9a042022-08-26 23:15:55 +0200250 int alen;
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100251 u_char *memaddr;
Simon Glass63656b72014-12-10 08:55:48 -0700252 int ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200253#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700254 struct udevice *dev;
255#endif
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100256
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200257 if (argc != 5)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000258 return CMD_RET_USAGE;
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100259
260 /*
261 * I2C chip address
262 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600263 chip = hextoul(argv[1], NULL);
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100264
265 /*
266 * I2C data address within the chip. This can be 1 or
267 * 2 bytes long. Some day it might be 3 bytes long :-).
268 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600269 devaddr = hextoul(argv[2], NULL);
Simon Glass63656b72014-12-10 08:55:48 -0700270 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200271 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000272 return CMD_RET_USAGE;
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100273
274 /*
275 * Length is the number of objects, not number of bytes.
276 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600277 length = hextoul(argv[3], NULL);
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100278
279 /*
280 * memaddr is the address where to store things in memory
281 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600282 memaddr = (u_char *)hextoul(argv[4], NULL);
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100283
Igor Opaniuk2147a162021-02-09 13:52:45 +0200284#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700285 ret = i2c_get_cur_bus_chip(chip, &dev);
286 if (!ret && alen != -1)
287 ret = i2c_set_chip_offset_len(dev, alen);
288 if (!ret)
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700289 ret = dm_i2c_read(dev, devaddr, memaddr, length);
Simon Glass63656b72014-12-10 08:55:48 -0700290#else
291 ret = i2c_read(chip, devaddr, alen, memaddr, length);
292#endif
293 if (ret)
294 return i2c_report_err(ret, I2C_ERR_READ);
295
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100296 return 0;
297}
298
Simon Glass09140112020-05-10 11:40:03 -0600299static int do_i2c_write(struct cmd_tbl *cmdtp, int flag, int argc,
300 char *const argv[])
York Sunff5d2dc2012-09-16 08:02:30 +0000301{
Masahiro Yamada54684612014-12-20 03:34:23 +0900302 uint chip;
Simon Glass63656b72014-12-10 08:55:48 -0700303 uint devaddr, length;
Marek Vasut1aa9a042022-08-26 23:15:55 +0200304 int alen;
York Sunff5d2dc2012-09-16 08:02:30 +0000305 u_char *memaddr;
Simon Glass63656b72014-12-10 08:55:48 -0700306 int ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200307#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700308 struct udevice *dev;
Lubomir Popoved16f142015-01-30 19:56:04 +0200309 struct dm_i2c_chip *i2c_chip;
Simon Glass63656b72014-12-10 08:55:48 -0700310#endif
York Sunff5d2dc2012-09-16 08:02:30 +0000311
Lubomir Popoved16f142015-01-30 19:56:04 +0200312 if ((argc < 5) || (argc > 6))
York Sunff5d2dc2012-09-16 08:02:30 +0000313 return cmd_usage(cmdtp);
314
315 /*
316 * memaddr is the address where to store things in memory
317 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600318 memaddr = (u_char *)hextoul(argv[1], NULL);
York Sunff5d2dc2012-09-16 08:02:30 +0000319
320 /*
321 * I2C chip address
322 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600323 chip = hextoul(argv[2], NULL);
York Sunff5d2dc2012-09-16 08:02:30 +0000324
325 /*
326 * I2C data address within the chip. This can be 1 or
327 * 2 bytes long. Some day it might be 3 bytes long :-).
328 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600329 devaddr = hextoul(argv[3], NULL);
Simon Glass63656b72014-12-10 08:55:48 -0700330 alen = get_alen(argv[3], DEFAULT_ADDR_LEN);
York Sunff5d2dc2012-09-16 08:02:30 +0000331 if (alen > 3)
332 return cmd_usage(cmdtp);
333
334 /*
Lubomir Popoved16f142015-01-30 19:56:04 +0200335 * Length is the number of bytes.
York Sunff5d2dc2012-09-16 08:02:30 +0000336 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600337 length = hextoul(argv[4], NULL);
York Sunff5d2dc2012-09-16 08:02:30 +0000338
Igor Opaniuk2147a162021-02-09 13:52:45 +0200339#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700340 ret = i2c_get_cur_bus_chip(chip, &dev);
341 if (!ret && alen != -1)
342 ret = i2c_set_chip_offset_len(dev, alen);
343 if (ret)
344 return i2c_report_err(ret, I2C_ERR_WRITE);
Simon Glasscaa4daa2020-12-03 16:55:18 -0700345 i2c_chip = dev_get_parent_plat(dev);
Lubomir Popoved16f142015-01-30 19:56:04 +0200346 if (!i2c_chip)
347 return i2c_report_err(ret, I2C_ERR_WRITE);
Simon Glass63656b72014-12-10 08:55:48 -0700348#endif
349
Lubomir Popoved16f142015-01-30 19:56:04 +0200350 if (argc == 6 && !strcmp(argv[5], "-s")) {
351 /*
352 * Write all bytes in a single I2C transaction. If the target
353 * device is an EEPROM, it is your responsibility to not cross
354 * a page boundary. No write delay upon completion, take this
355 * into account if linking commands.
356 */
Igor Opaniuk2147a162021-02-09 13:52:45 +0200357#if CONFIG_IS_ENABLED(DM_I2C)
Lubomir Popoved16f142015-01-30 19:56:04 +0200358 i2c_chip->flags &= ~DM_I2C_CHIP_WR_ADDRESS;
359 ret = dm_i2c_write(dev, devaddr, memaddr, length);
Simon Glass63656b72014-12-10 08:55:48 -0700360#else
Lubomir Popoved16f142015-01-30 19:56:04 +0200361 ret = i2c_write(chip, devaddr, alen, memaddr, length);
Simon Glass63656b72014-12-10 08:55:48 -0700362#endif
363 if (ret)
364 return i2c_report_err(ret, I2C_ERR_WRITE);
Lubomir Popoved16f142015-01-30 19:56:04 +0200365 } else {
366 /*
367 * Repeated addressing - perform <length> separate
368 * write transactions of one byte each
369 */
370 while (length-- > 0) {
Igor Opaniuk2147a162021-02-09 13:52:45 +0200371#if CONFIG_IS_ENABLED(DM_I2C)
Lubomir Popoved16f142015-01-30 19:56:04 +0200372 i2c_chip->flags |= DM_I2C_CHIP_WR_ADDRESS;
373 ret = dm_i2c_write(dev, devaddr++, memaddr++, 1);
374#else
375 ret = i2c_write(chip, devaddr++, alen, memaddr++, 1);
376#endif
377 if (ret)
378 return i2c_report_err(ret, I2C_ERR_WRITE);
York Sunff5d2dc2012-09-16 08:02:30 +0000379/*
380 * No write delay with FRAM devices.
381 */
382#if !defined(CONFIG_SYS_I2C_FRAM)
Lubomir Popoved16f142015-01-30 19:56:04 +0200383 udelay(11000);
York Sunff5d2dc2012-09-16 08:02:30 +0000384#endif
Lubomir Popoved16f142015-01-30 19:56:04 +0200385 }
York Sunff5d2dc2012-09-16 08:02:30 +0000386 }
387 return 0;
388}
389
Igor Opaniuk2147a162021-02-09 13:52:45 +0200390#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass09140112020-05-10 11:40:03 -0600391static int do_i2c_flags(struct cmd_tbl *cmdtp, int flag, int argc,
Simon Glass63656b72014-12-10 08:55:48 -0700392 char *const argv[])
393{
394 struct udevice *dev;
395 uint flags;
396 int chip;
397 int ret;
398
399 if (argc < 2)
400 return CMD_RET_USAGE;
401
Simon Glass7e5f4602021-07-24 09:03:29 -0600402 chip = hextoul(argv[1], NULL);
Simon Glass63656b72014-12-10 08:55:48 -0700403 ret = i2c_get_cur_bus_chip(chip, &dev);
404 if (ret)
405 return i2c_report_err(ret, I2C_ERR_READ);
406
407 if (argc > 2) {
Simon Glass7e5f4602021-07-24 09:03:29 -0600408 flags = hextoul(argv[2], NULL);
Simon Glass63656b72014-12-10 08:55:48 -0700409 ret = i2c_set_chip_flags(dev, flags);
410 } else {
411 ret = i2c_get_chip_flags(dev, &flags);
412 if (!ret)
413 printf("%x\n", flags);
414 }
415 if (ret)
416 return i2c_report_err(ret, I2C_ERR_READ);
417
418 return 0;
419}
Simon Glassc10c8e32015-08-22 18:31:33 -0600420
Simon Glass09140112020-05-10 11:40:03 -0600421static int do_i2c_olen(struct cmd_tbl *cmdtp, int flag, int argc,
422 char *const argv[])
Simon Glassc10c8e32015-08-22 18:31:33 -0600423{
424 struct udevice *dev;
425 uint olen;
426 int chip;
427 int ret;
428
429 if (argc < 2)
430 return CMD_RET_USAGE;
431
Simon Glass7e5f4602021-07-24 09:03:29 -0600432 chip = hextoul(argv[1], NULL);
Simon Glassc10c8e32015-08-22 18:31:33 -0600433 ret = i2c_get_cur_bus_chip(chip, &dev);
434 if (ret)
435 return i2c_report_err(ret, I2C_ERR_READ);
436
437 if (argc > 2) {
Simon Glass7e5f4602021-07-24 09:03:29 -0600438 olen = hextoul(argv[2], NULL);
Simon Glassc10c8e32015-08-22 18:31:33 -0600439 ret = i2c_set_chip_offset_len(dev, olen);
440 } else {
441 ret = i2c_get_chip_offset_len(dev);
442 if (ret >= 0) {
443 printf("%x\n", ret);
444 ret = 0;
445 }
446 }
447 if (ret)
448 return i2c_report_err(ret, I2C_ERR_READ);
449
450 return 0;
451}
Simon Glass63656b72014-12-10 08:55:48 -0700452#endif
453
Marek Vasut06afa382012-11-12 14:34:27 +0000454/**
455 * do_i2c_md() - Handle the "i2c md" command-line command
456 * @cmdtp: Command data struct pointer
457 * @flag: Command flag
458 * @argc: Command-line argument count
459 * @argv: Array of command-line arguments
460 *
461 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
462 * on error.
463 *
Frans Meulenbroeks4a8cf332010-03-26 09:46:39 +0100464 * Syntax:
465 * i2c md {i2c_chip} {addr}{.0, .1, .2} {len}
466 */
Simon Glass09140112020-05-10 11:40:03 -0600467static int do_i2c_md(struct cmd_tbl *cmdtp, int flag, int argc,
468 char *const argv[])
wdenk81a88242002-10-26 15:22:42 +0000469{
Masahiro Yamada54684612014-12-20 03:34:23 +0900470 uint chip;
Simon Glass63656b72014-12-10 08:55:48 -0700471 uint addr, length;
Marek Vasut1aa9a042022-08-26 23:15:55 +0200472 int alen;
Marek Vasute4573fe2022-08-26 23:15:56 +0200473 int j;
474 uint nbytes, linebytes;
Simon Glass63656b72014-12-10 08:55:48 -0700475 int ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200476#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700477 struct udevice *dev;
478#endif
wdenk81a88242002-10-26 15:22:42 +0000479
480 /* We use the last specified parameters, unless new ones are
481 * entered.
482 */
483 chip = i2c_dp_last_chip;
484 addr = i2c_dp_last_addr;
485 alen = i2c_dp_last_alen;
486 length = i2c_dp_last_length;
487
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200488 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000489 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000490
491 if ((flag & CMD_FLAG_REPEAT) == 0) {
492 /*
493 * New command specified.
494 */
wdenk81a88242002-10-26 15:22:42 +0000495
496 /*
497 * I2C chip address
498 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600499 chip = hextoul(argv[1], NULL);
wdenk81a88242002-10-26 15:22:42 +0000500
501 /*
502 * I2C data address within the chip. This can be 1 or
503 * 2 bytes long. Some day it might be 3 bytes long :-).
504 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600505 addr = hextoul(argv[2], NULL);
Simon Glass63656b72014-12-10 08:55:48 -0700506 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200507 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000508 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000509
510 /*
511 * If another parameter, it is the length to display.
512 * Length is the number of objects, not number of bytes.
513 */
514 if (argc > 3)
Simon Glass7e5f4602021-07-24 09:03:29 -0600515 length = hextoul(argv[3], NULL);
wdenk81a88242002-10-26 15:22:42 +0000516 }
517
Igor Opaniuk2147a162021-02-09 13:52:45 +0200518#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700519 ret = i2c_get_cur_bus_chip(chip, &dev);
520 if (!ret && alen != -1)
521 ret = i2c_set_chip_offset_len(dev, alen);
522 if (ret)
523 return i2c_report_err(ret, I2C_ERR_READ);
524#endif
525
wdenk81a88242002-10-26 15:22:42 +0000526 /*
527 * Print the lines.
528 *
529 * We buffer all read data, so we can make sure data is read only
530 * once.
531 */
532 nbytes = length;
533 do {
534 unsigned char linebuf[DISP_LINE_LEN];
535 unsigned char *cp;
536
537 linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
538
Igor Opaniuk2147a162021-02-09 13:52:45 +0200539#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700540 ret = dm_i2c_read(dev, addr, linebuf, linebytes);
Simon Glass63656b72014-12-10 08:55:48 -0700541#else
542 ret = i2c_read(chip, addr, alen, linebuf, linebytes);
543#endif
544 if (ret)
Masahiro Yamada9e533cb2015-02-05 13:50:26 +0900545 return i2c_report_err(ret, I2C_ERR_READ);
Timur Tabie857a5b2006-11-28 12:09:35 -0600546 else {
wdenk81a88242002-10-26 15:22:42 +0000547 printf("%04x:", addr);
548 cp = linebuf;
549 for (j=0; j<linebytes; j++) {
550 printf(" %02x", *cp++);
551 addr++;
552 }
wdenk4b9206e2004-03-23 22:14:11 +0000553 puts (" ");
wdenk81a88242002-10-26 15:22:42 +0000554 cp = linebuf;
555 for (j=0; j<linebytes; j++) {
556 if ((*cp < 0x20) || (*cp > 0x7e))
wdenk4b9206e2004-03-23 22:14:11 +0000557 puts (".");
wdenk81a88242002-10-26 15:22:42 +0000558 else
559 printf("%c", *cp);
560 cp++;
561 }
wdenk4b9206e2004-03-23 22:14:11 +0000562 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000563 }
564 nbytes -= linebytes;
565 } while (nbytes > 0);
566
567 i2c_dp_last_chip = chip;
568 i2c_dp_last_addr = addr;
569 i2c_dp_last_alen = alen;
570 i2c_dp_last_length = length;
571
572 return 0;
573}
574
Marek Vasut06afa382012-11-12 14:34:27 +0000575/**
576 * do_i2c_mw() - Handle the "i2c mw" command-line command
577 * @cmdtp: Command data struct pointer
578 * @flag: Command flag
579 * @argc: Command-line argument count
580 * @argv: Array of command-line arguments
581 *
582 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
583 * on error.
wdenk81a88242002-10-26 15:22:42 +0000584 *
585 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500586 * i2c mw {i2c_chip} {addr}{.0, .1, .2} {data} [{count}]
wdenk81a88242002-10-26 15:22:42 +0000587 */
Simon Glass09140112020-05-10 11:40:03 -0600588static int do_i2c_mw(struct cmd_tbl *cmdtp, int flag, int argc,
589 char *const argv[])
wdenk81a88242002-10-26 15:22:42 +0000590{
Masahiro Yamada54684612014-12-20 03:34:23 +0900591 uint chip;
wdenk81a88242002-10-26 15:22:42 +0000592 ulong addr;
Marek Vasut1aa9a042022-08-26 23:15:55 +0200593 int alen;
wdenk81a88242002-10-26 15:22:42 +0000594 uchar byte;
Marek Vasut1aa9a042022-08-26 23:15:55 +0200595 int count;
Simon Glass63656b72014-12-10 08:55:48 -0700596 int ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200597#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700598 struct udevice *dev;
599#endif
wdenk81a88242002-10-26 15:22:42 +0000600
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200601 if ((argc < 4) || (argc > 5))
Simon Glass4c12eeb2011-12-10 08:44:01 +0000602 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000603
604 /*
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200605 * Chip is always specified.
606 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600607 chip = hextoul(argv[1], NULL);
wdenk81a88242002-10-26 15:22:42 +0000608
609 /*
610 * Address is always specified.
611 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600612 addr = hextoul(argv[2], NULL);
Simon Glass63656b72014-12-10 08:55:48 -0700613 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200614 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000615 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000616
Igor Opaniuk2147a162021-02-09 13:52:45 +0200617#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700618 ret = i2c_get_cur_bus_chip(chip, &dev);
619 if (!ret && alen != -1)
620 ret = i2c_set_chip_offset_len(dev, alen);
621 if (ret)
622 return i2c_report_err(ret, I2C_ERR_WRITE);
623#endif
wdenk81a88242002-10-26 15:22:42 +0000624 /*
625 * Value to write is always specified.
626 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600627 byte = hextoul(argv[3], NULL);
wdenk81a88242002-10-26 15:22:42 +0000628
629 /*
630 * Optional count
631 */
Timur Tabie857a5b2006-11-28 12:09:35 -0600632 if (argc == 5)
Simon Glass7e5f4602021-07-24 09:03:29 -0600633 count = hextoul(argv[4], NULL);
Timur Tabie857a5b2006-11-28 12:09:35 -0600634 else
wdenk81a88242002-10-26 15:22:42 +0000635 count = 1;
wdenk81a88242002-10-26 15:22:42 +0000636
637 while (count-- > 0) {
Igor Opaniuk2147a162021-02-09 13:52:45 +0200638#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700639 ret = dm_i2c_write(dev, addr++, &byte, 1);
Simon Glass63656b72014-12-10 08:55:48 -0700640#else
641 ret = i2c_write(chip, addr++, alen, &byte, 1);
642#endif
643 if (ret)
Masahiro Yamada9e533cb2015-02-05 13:50:26 +0900644 return i2c_report_err(ret, I2C_ERR_WRITE);
wdenk81a88242002-10-26 15:22:42 +0000645 /*
646 * Wait for the write to complete. The write can take
647 * up to 10mSec (we allow a little more time).
wdenk81a88242002-10-26 15:22:42 +0000648 */
d4f5c722005-08-12 21:16:13 +0200649/*
650 * No write delay with FRAM devices.
651 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200652#if !defined(CONFIG_SYS_I2C_FRAM)
wdenk81a88242002-10-26 15:22:42 +0000653 udelay(11000);
d4f5c722005-08-12 21:16:13 +0200654#endif
wdenk81a88242002-10-26 15:22:42 +0000655 }
656
Marek Vasut06afa382012-11-12 14:34:27 +0000657 return 0;
wdenk81a88242002-10-26 15:22:42 +0000658}
659
Marek Vasut06afa382012-11-12 14:34:27 +0000660/**
661 * do_i2c_crc() - Handle the "i2c crc32" command-line command
662 * @cmdtp: Command data struct pointer
663 * @flag: Command flag
664 * @argc: Command-line argument count
665 * @argv: Array of command-line arguments
666 *
667 * Calculate a CRC on memory
668 *
669 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
670 * on error.
wdenk81a88242002-10-26 15:22:42 +0000671 *
672 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500673 * i2c crc32 {i2c_chip} {addr}{.0, .1, .2} {count}
wdenk81a88242002-10-26 15:22:42 +0000674 */
Simon Glass09140112020-05-10 11:40:03 -0600675static int do_i2c_crc(struct cmd_tbl *cmdtp, int flag, int argc,
676 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;
Marek Vasut1aa9a042022-08-26 23:15:55 +0200680 int alen;
681 int count;
wdenk81a88242002-10-26 15:22:42 +0000682 uchar byte;
683 ulong crc;
684 ulong err;
Simon Glass63656b72014-12-10 08:55:48 -0700685 int ret = 0;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200686#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700687 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 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600696 chip = hextoul(argv[1], NULL);
wdenk81a88242002-10-26 15:22:42 +0000697
698 /*
699 * Address is always specified.
700 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600701 addr = hextoul(argv[2], NULL);
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
Igor Opaniuk2147a162021-02-09 13:52:45 +0200706#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700707 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 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600716 count = hextoul(argv[3], NULL);
wdenk81a88242002-10-26 15:22:42 +0000717
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) {
Igor Opaniuk2147a162021-02-09 13:52:45 +0200726#if CONFIG_IS_ENABLED(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++;
Simon Glassb2ea91b2019-11-14 12:57:15 -0700733 crc = crc32(crc, &byte, 1);
wdenk81a88242002-10-26 15:22:42 +0000734 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 */
Simon Glass09140112020-05-10 11:40:03 -0600760static int mod_i2c_mem(struct cmd_tbl *cmdtp, int incrflag, int flag, int argc,
761 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;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200770#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700771 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 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600796 chip = hextoul(argv[1], NULL);
wdenk81a88242002-10-26 15:22:42 +0000797
798 /*
799 * Address is always specified.
800 */
Simon Glass7e5f4602021-07-24 09:03:29 -0600801 addr = hextoul(argv[2], NULL);
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
Igor Opaniuk2147a162021-02-09 13:52:45 +0200807#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700808 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);
Igor Opaniuk2147a162021-02-09 13:52:45 +0200821#if CONFIG_IS_ENABLED(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
Simon Glass7e5f4602021-07-24 09:03:29 -0600856 data = hextoul(console_buffer, &endp);
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();
Igor Opaniuk2147a162021-02-09 13:52:45 +0200868#if CONFIG_IS_ENABLED(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);
Tom Rini88cd7d02021-08-17 17:59:45 -0400878#if CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS > 0
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200879 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 */
Simon Glass09140112020-05-10 11:40:03 -0600909static int do_i2c_probe(struct cmd_tbl *cmdtp, int flag, int argc,
910 char *const argv[])
wdenk81a88242002-10-26 15:22:42 +0000911{
912 int j;
Eric Nelson54b99e52012-09-23 10:12:56 +0000913 int addr = -1;
914 int found = 0;
Tom Rini65cc0e22022-11-16 13:10:41 -0500915#if defined(CFG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000916 int k, skip;
Heiko Schocher3f4978c2012-01-16 21:12:24 +0000917 unsigned int bus = GET_BUS_NUM;
Ben Warrenbb99ad62006-09-07 16:50:54 -0400918#endif /* NOPROBES */
Simon Glass63656b72014-12-10 08:55:48 -0700919 int ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200920#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700921 struct udevice *bus, *dev;
922
923 if (i2c_get_cur_bus(&bus))
924 return CMD_RET_FAILURE;
925#endif
wdenk81a88242002-10-26 15:22:42 +0000926
Eric Nelson54b99e52012-09-23 10:12:56 +0000927 if (argc == 2)
928 addr = simple_strtol(argv[1], 0, 16);
929
wdenk4b9206e2004-03-23 22:14:11 +0000930 puts ("Valid chip addresses:");
Timur Tabie857a5b2006-11-28 12:09:35 -0600931 for (j = 0; j < 128; j++) {
Eric Nelson54b99e52012-09-23 10:12:56 +0000932 if ((0 <= addr) && (j != addr))
933 continue;
934
Tom Rini65cc0e22022-11-16 13:10:41 -0500935#if defined(CFG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000936 skip = 0;
Axel Lincfb25cc2013-06-22 21:56:35 +0800937 for (k = 0; k < ARRAY_SIZE(i2c_no_probes); k++) {
Timur Tabie857a5b2006-11-28 12:09:35 -0600938 if (COMPARE_BUS(bus, k) && COMPARE_ADDR(j, k)) {
wdenk81a88242002-10-26 15:22:42 +0000939 skip = 1;
940 break;
941 }
942 }
943 if (skip)
944 continue;
945#endif
Igor Opaniuk2147a162021-02-09 13:52:45 +0200946#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700947 ret = dm_i2c_probe(bus, j, 0, &dev);
Simon Glass63656b72014-12-10 08:55:48 -0700948#else
949 ret = i2c_probe(j);
950#endif
951 if (ret == 0) {
wdenk81a88242002-10-26 15:22:42 +0000952 printf(" %02X", j);
Eric Nelson54b99e52012-09-23 10:12:56 +0000953 found++;
954 }
wdenk81a88242002-10-26 15:22:42 +0000955 }
wdenk4b9206e2004-03-23 22:14:11 +0000956 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000957
Tom Rini65cc0e22022-11-16 13:10:41 -0500958#if defined(CFG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000959 puts ("Excluded chip addresses:");
Axel Lincfb25cc2013-06-22 21:56:35 +0800960 for (k = 0; k < ARRAY_SIZE(i2c_no_probes); k++) {
Timur Tabie857a5b2006-11-28 12:09:35 -0600961 if (COMPARE_BUS(bus,k))
Ben Warrenbb99ad62006-09-07 16:50:54 -0400962 printf(" %02X", NO_PROBE_ADDR(k));
963 }
wdenk4b9206e2004-03-23 22:14:11 +0000964 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000965#endif
966
Eric Nelson54b99e52012-09-23 10:12:56 +0000967 return (0 == found);
wdenk81a88242002-10-26 15:22:42 +0000968}
969
Marek Vasut06afa382012-11-12 14:34:27 +0000970/**
971 * do_i2c_loop() - Handle the "i2c loop" command-line command
972 * @cmdtp: Command data struct pointer
973 * @flag: Command flag
974 * @argc: Command-line argument count
975 * @argv: Array of command-line arguments
976 *
977 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
978 * on error.
979 *
wdenk81a88242002-10-26 15:22:42 +0000980 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500981 * i2c loop {i2c_chip} {addr}{.0, .1, .2} [{length}] [{delay}]
wdenk81a88242002-10-26 15:22:42 +0000982 * {length} - Number of bytes to read
983 * {delay} - A DECIMAL number and defaults to 1000 uSec
984 */
Simon Glass09140112020-05-10 11:40:03 -0600985static int do_i2c_loop(struct cmd_tbl *cmdtp, int flag, int argc,
986 char *const argv[])
wdenk81a88242002-10-26 15:22:42 +0000987{
Masahiro Yamada54684612014-12-20 03:34:23 +0900988 uint chip;
Marek Vasut1aa9a042022-08-26 23:15:55 +0200989 int alen;
wdenk81a88242002-10-26 15:22:42 +0000990 uint addr;
991 uint length;
992 u_char bytes[16];
993 int delay;
Simon Glass63656b72014-12-10 08:55:48 -0700994 int ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +0200995#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -0700996 struct udevice *dev;
997#endif
wdenk81a88242002-10-26 15:22:42 +0000998
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200999 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001000 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +00001001
1002 /*
1003 * Chip is always specified.
1004 */
Simon Glass7e5f4602021-07-24 09:03:29 -06001005 chip = hextoul(argv[1], NULL);
wdenk81a88242002-10-26 15:22:42 +00001006
1007 /*
1008 * Address is always specified.
1009 */
Simon Glass7e5f4602021-07-24 09:03:29 -06001010 addr = hextoul(argv[2], NULL);
Simon Glass63656b72014-12-10 08:55:48 -07001011 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +02001012 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001013 return CMD_RET_USAGE;
Igor Opaniuk2147a162021-02-09 13:52:45 +02001014#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001015 ret = i2c_get_cur_bus_chip(chip, &dev);
1016 if (!ret && alen != -1)
1017 ret = i2c_set_chip_offset_len(dev, alen);
1018 if (ret)
1019 return i2c_report_err(ret, I2C_ERR_WRITE);
1020#endif
wdenk81a88242002-10-26 15:22:42 +00001021
1022 /*
1023 * Length is the number of objects, not number of bytes.
1024 */
1025 length = 1;
Simon Glass7e5f4602021-07-24 09:03:29 -06001026 length = hextoul(argv[3], NULL);
Timur Tabie857a5b2006-11-28 12:09:35 -06001027 if (length > sizeof(bytes))
wdenk81a88242002-10-26 15:22:42 +00001028 length = sizeof(bytes);
wdenk81a88242002-10-26 15:22:42 +00001029
1030 /*
1031 * The delay time (uSec) is optional.
1032 */
1033 delay = 1000;
Timur Tabie857a5b2006-11-28 12:09:35 -06001034 if (argc > 3)
Simon Glass0b1284e2021-07-24 09:03:30 -06001035 delay = dectoul(argv[4], NULL);
wdenk81a88242002-10-26 15:22:42 +00001036 /*
1037 * Run the loop...
1038 */
Timur Tabie857a5b2006-11-28 12:09:35 -06001039 while (1) {
Igor Opaniuk2147a162021-02-09 13:52:45 +02001040#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001041 ret = dm_i2c_read(dev, addr, bytes, length);
Simon Glass63656b72014-12-10 08:55:48 -07001042#else
1043 ret = i2c_read(chip, addr, alen, bytes, length);
1044#endif
1045 if (ret)
1046 i2c_report_err(ret, I2C_ERR_READ);
wdenk81a88242002-10-26 15:22:42 +00001047 udelay(delay);
1048 }
1049
1050 /* NOTREACHED */
1051 return 0;
1052}
1053
wdenk81a88242002-10-26 15:22:42 +00001054/*
1055 * The SDRAM command is separately configured because many
1056 * (most?) embedded boards don't use SDRAM DIMMs.
Marek Vasut06afa382012-11-12 14:34:27 +00001057 *
1058 * FIXME: Document and probably move elsewhere!
wdenk81a88242002-10-26 15:22:42 +00001059 */
Jon Loeligerc76fe472007-07-08 18:02:23 -05001060#if defined(CONFIG_CMD_SDRAM)
Larry Johnson632de062008-01-11 23:26:18 -05001061static void print_ddr2_tcyc (u_char const b)
1062{
1063 printf ("%d.", (b >> 4) & 0x0F);
1064 switch (b & 0x0F) {
1065 case 0x0:
1066 case 0x1:
1067 case 0x2:
1068 case 0x3:
1069 case 0x4:
1070 case 0x5:
1071 case 0x6:
1072 case 0x7:
1073 case 0x8:
1074 case 0x9:
1075 printf ("%d ns\n", b & 0x0F);
1076 break;
1077 case 0xA:
1078 puts ("25 ns\n");
1079 break;
1080 case 0xB:
1081 puts ("33 ns\n");
1082 break;
1083 case 0xC:
1084 puts ("66 ns\n");
1085 break;
1086 case 0xD:
1087 puts ("75 ns\n");
1088 break;
1089 default:
1090 puts ("?? ns\n");
1091 break;
1092 }
1093}
1094
1095static void decode_bits (u_char const b, char const *str[], int const do_once)
1096{
1097 u_char mask;
1098
1099 for (mask = 0x80; mask != 0x00; mask >>= 1, ++str) {
1100 if (b & mask) {
1101 puts (*str);
1102 if (do_once)
1103 return;
1104 }
1105 }
1106}
wdenk81a88242002-10-26 15:22:42 +00001107
1108/*
1109 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -05001110 * i2c sdram {i2c_chip}
wdenk81a88242002-10-26 15:22:42 +00001111 */
Simon Glass09140112020-05-10 11:40:03 -06001112static int do_sdram(struct cmd_tbl *cmdtp, int flag, int argc,
1113 char *const argv[])
wdenk81a88242002-10-26 15:22:42 +00001114{
Michal Simek18c4e7f2016-02-15 11:58:37 +01001115 enum { unknown, EDO, SDRAM, DDR, DDR2, DDR3, DDR4 } type;
Larry Johnson632de062008-01-11 23:26:18 -05001116
Masahiro Yamada54684612014-12-20 03:34:23 +09001117 uint chip;
wdenk81a88242002-10-26 15:22:42 +00001118 u_char data[128];
1119 u_char cksum;
Nobuhiro Iwamatsu28df8ed2017-12-01 14:39:40 +09001120 int j, ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +02001121#if CONFIG_IS_ENABLED(DM_I2C)
Nobuhiro Iwamatsu28df8ed2017-12-01 14:39:40 +09001122 struct udevice *dev;
1123#endif
wdenk81a88242002-10-26 15:22:42 +00001124
Larry Johnson632de062008-01-11 23:26:18 -05001125 static const char *decode_CAS_DDR2[] = {
1126 " TBD", " 6", " 5", " 4", " 3", " 2", " TBD", " TBD"
1127 };
1128
1129 static const char *decode_CAS_default[] = {
1130 " TBD", " 7", " 6", " 5", " 4", " 3", " 2", " 1"
1131 };
1132
1133 static const char *decode_CS_WE_default[] = {
1134 " TBD", " 6", " 5", " 4", " 3", " 2", " 1", " 0"
1135 };
1136
1137 static const char *decode_byte21_default[] = {
1138 " TBD (bit 7)\n",
1139 " Redundant row address\n",
1140 " Differential clock input\n",
1141 " Registerd DQMB inputs\n",
1142 " Buffered DQMB inputs\n",
1143 " On-card PLL\n",
1144 " Registered address/control lines\n",
1145 " Buffered address/control lines\n"
1146 };
1147
1148 static const char *decode_byte22_DDR2[] = {
1149 " TBD (bit 7)\n",
1150 " TBD (bit 6)\n",
1151 " TBD (bit 5)\n",
1152 " TBD (bit 4)\n",
1153 " TBD (bit 3)\n",
1154 " Supports partial array self refresh\n",
1155 " Supports 50 ohm ODT\n",
1156 " Supports weak driver\n"
1157 };
1158
1159 static const char *decode_row_density_DDR2[] = {
1160 "512 MiB", "256 MiB", "128 MiB", "16 GiB",
1161 "8 GiB", "4 GiB", "2 GiB", "1 GiB"
1162 };
1163
1164 static const char *decode_row_density_default[] = {
1165 "512 MiB", "256 MiB", "128 MiB", "64 MiB",
1166 "32 MiB", "16 MiB", "8 MiB", "4 MiB"
1167 };
1168
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001169 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001170 return CMD_RET_USAGE;
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001171
wdenk81a88242002-10-26 15:22:42 +00001172 /*
1173 * Chip is always specified.
Larry Johnson632de062008-01-11 23:26:18 -05001174 */
Simon Glass7e5f4602021-07-24 09:03:29 -06001175 chip = hextoul(argv[1], NULL);
wdenk81a88242002-10-26 15:22:42 +00001176
Igor Opaniuk2147a162021-02-09 13:52:45 +02001177#if CONFIG_IS_ENABLED(DM_I2C)
Nobuhiro Iwamatsu28df8ed2017-12-01 14:39:40 +09001178 ret = i2c_get_cur_bus_chip(chip, &dev);
1179 if (!ret)
1180 ret = dm_i2c_read(dev, 0, data, sizeof(data));
1181#else
1182 ret = i2c_read(chip, 0, 1, data, sizeof(data));
1183#endif
1184 if (ret) {
wdenk4b9206e2004-03-23 22:14:11 +00001185 puts ("No SDRAM Serial Presence Detect found.\n");
wdenk81a88242002-10-26 15:22:42 +00001186 return 1;
1187 }
1188
1189 cksum = 0;
1190 for (j = 0; j < 63; j++) {
1191 cksum += data[j];
1192 }
Timur Tabie857a5b2006-11-28 12:09:35 -06001193 if (cksum != data[63]) {
wdenk81a88242002-10-26 15:22:42 +00001194 printf ("WARNING: Configuration data checksum failure:\n"
Larry Johnson632de062008-01-11 23:26:18 -05001195 " is 0x%02x, calculated 0x%02x\n", data[63], cksum);
wdenk81a88242002-10-26 15:22:42 +00001196 }
Larry Johnson632de062008-01-11 23:26:18 -05001197 printf ("SPD data revision %d.%d\n",
wdenk81a88242002-10-26 15:22:42 +00001198 (data[62] >> 4) & 0x0F, data[62] & 0x0F);
Larry Johnson632de062008-01-11 23:26:18 -05001199 printf ("Bytes used 0x%02X\n", data[0]);
1200 printf ("Serial memory size 0x%02X\n", 1 << data[1]);
1201
wdenk4b9206e2004-03-23 22:14:11 +00001202 puts ("Memory type ");
Larry Johnson632de062008-01-11 23:26:18 -05001203 switch (data[2]) {
Larry Johnson0df6b842008-01-10 22:23:39 -05001204 case 2:
1205 type = EDO;
1206 puts ("EDO\n");
1207 break;
1208 case 4:
1209 type = SDRAM;
1210 puts ("SDRAM\n");
1211 break;
Michal Simek18c4e7f2016-02-15 11:58:37 +01001212 case 7:
1213 type = DDR;
1214 puts("DDR\n");
1215 break;
Larry Johnson0df6b842008-01-10 22:23:39 -05001216 case 8:
1217 type = DDR2;
1218 puts ("DDR2\n");
1219 break;
Michal Simek18c4e7f2016-02-15 11:58:37 +01001220 case 11:
1221 type = DDR3;
1222 puts("DDR3\n");
1223 break;
1224 case 12:
1225 type = DDR4;
1226 puts("DDR4\n");
1227 break;
Larry Johnson0df6b842008-01-10 22:23:39 -05001228 default:
1229 type = unknown;
1230 puts ("unknown\n");
1231 break;
wdenk81a88242002-10-26 15:22:42 +00001232 }
Larry Johnson632de062008-01-11 23:26:18 -05001233
wdenk4b9206e2004-03-23 22:14:11 +00001234 puts ("Row address bits ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001235 if ((data[3] & 0x00F0) == 0)
Larry Johnson632de062008-01-11 23:26:18 -05001236 printf ("%d\n", data[3] & 0x0F);
Timur Tabie857a5b2006-11-28 12:09:35 -06001237 else
Larry Johnson632de062008-01-11 23:26:18 -05001238 printf ("%d/%d\n", data[3] & 0x0F, (data[3] >> 4) & 0x0F);
1239
wdenk4b9206e2004-03-23 22:14:11 +00001240 puts ("Column address bits ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001241 if ((data[4] & 0x00F0) == 0)
Larry Johnson632de062008-01-11 23:26:18 -05001242 printf ("%d\n", data[4] & 0x0F);
Timur Tabie857a5b2006-11-28 12:09:35 -06001243 else
Larry Johnson632de062008-01-11 23:26:18 -05001244 printf ("%d/%d\n", data[4] & 0x0F, (data[4] >> 4) & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001245
1246 switch (type) {
1247 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001248 printf ("Number of ranks %d\n",
1249 (data[5] & 0x07) + 1);
Larry Johnson0df6b842008-01-10 22:23:39 -05001250 break;
1251 default:
Larry Johnson632de062008-01-11 23:26:18 -05001252 printf ("Module rows %d\n", data[5]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001253 break;
1254 }
1255
1256 switch (type) {
1257 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001258 printf ("Module data width %d bits\n", data[6]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001259 break;
1260 default:
Larry Johnson632de062008-01-11 23:26:18 -05001261 printf ("Module data width %d bits\n",
1262 (data[7] << 8) | data[6]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001263 break;
1264 }
1265
wdenk4b9206e2004-03-23 22:14:11 +00001266 puts ("Interface signal levels ");
wdenk81a88242002-10-26 15:22:42 +00001267 switch(data[8]) {
Larry Johnson0df6b842008-01-10 22:23:39 -05001268 case 0: puts ("TTL 5.0 V\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +00001269 case 1: puts ("LVTTL\n"); break;
Larry Johnson0df6b842008-01-10 22:23:39 -05001270 case 2: puts ("HSTL 1.5 V\n"); break;
1271 case 3: puts ("SSTL 3.3 V\n"); break;
1272 case 4: puts ("SSTL 2.5 V\n"); break;
1273 case 5: puts ("SSTL 1.8 V\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +00001274 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +00001275 }
Larry Johnson0df6b842008-01-10 22:23:39 -05001276
1277 switch (type) {
1278 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001279 printf ("SDRAM cycle time ");
1280 print_ddr2_tcyc (data[9]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001281 break;
1282 default:
Larry Johnson632de062008-01-11 23:26:18 -05001283 printf ("SDRAM cycle time %d.%d ns\n",
1284 (data[9] >> 4) & 0x0F, data[9] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001285 break;
1286 }
1287
1288 switch (type) {
1289 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001290 printf ("SDRAM access time 0.%d%d ns\n",
1291 (data[10] >> 4) & 0x0F, data[10] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001292 break;
1293 default:
Larry Johnson632de062008-01-11 23:26:18 -05001294 printf ("SDRAM access time %d.%d ns\n",
1295 (data[10] >> 4) & 0x0F, data[10] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001296 break;
1297 }
1298
wdenk4b9206e2004-03-23 22:14:11 +00001299 puts ("EDC configuration ");
Larry Johnson632de062008-01-11 23:26:18 -05001300 switch (data[11]) {
wdenk4b9206e2004-03-23 22:14:11 +00001301 case 0: puts ("None\n"); break;
1302 case 1: puts ("Parity\n"); break;
1303 case 2: puts ("ECC\n"); break;
1304 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +00001305 }
Larry Johnson632de062008-01-11 23:26:18 -05001306
Timur Tabie857a5b2006-11-28 12:09:35 -06001307 if ((data[12] & 0x80) == 0)
wdenk4b9206e2004-03-23 22:14:11 +00001308 puts ("No self refresh, rate ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001309 else
wdenk4b9206e2004-03-23 22:14:11 +00001310 puts ("Self refresh, rate ");
Larry Johnson632de062008-01-11 23:26:18 -05001311
wdenk81a88242002-10-26 15:22:42 +00001312 switch(data[12] & 0x7F) {
Larry Johnson632de062008-01-11 23:26:18 -05001313 case 0: puts ("15.625 us\n"); break;
1314 case 1: puts ("3.9 us\n"); break;
1315 case 2: puts ("7.8 us\n"); break;
1316 case 3: puts ("31.3 us\n"); break;
1317 case 4: puts ("62.5 us\n"); break;
1318 case 5: puts ("125 us\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +00001319 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +00001320 }
Larry Johnson0df6b842008-01-10 22:23:39 -05001321
1322 switch (type) {
1323 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001324 printf ("SDRAM width (primary) %d\n", data[13]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001325 break;
1326 default:
Larry Johnson632de062008-01-11 23:26:18 -05001327 printf ("SDRAM width (primary) %d\n", data[13] & 0x7F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001328 if ((data[13] & 0x80) != 0) {
Larry Johnson632de062008-01-11 23:26:18 -05001329 printf (" (second bank) %d\n",
1330 2 * (data[13] & 0x7F));
Larry Johnson0df6b842008-01-10 22:23:39 -05001331 }
1332 break;
wdenk81a88242002-10-26 15:22:42 +00001333 }
Larry Johnson0df6b842008-01-10 22:23:39 -05001334
1335 switch (type) {
1336 case DDR2:
1337 if (data[14] != 0)
Larry Johnson632de062008-01-11 23:26:18 -05001338 printf ("EDC width %d\n", data[14]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001339 break;
1340 default:
1341 if (data[14] != 0) {
Larry Johnson632de062008-01-11 23:26:18 -05001342 printf ("EDC width %d\n",
1343 data[14] & 0x7F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001344
1345 if ((data[14] & 0x80) != 0) {
Larry Johnson632de062008-01-11 23:26:18 -05001346 printf (" (second bank) %d\n",
1347 2 * (data[14] & 0x7F));
Larry Johnson0df6b842008-01-10 22:23:39 -05001348 }
1349 }
1350 break;
1351 }
1352
Larry Johnson632de062008-01-11 23:26:18 -05001353 if (DDR2 != type) {
1354 printf ("Min clock delay, back-to-back random column addresses "
1355 "%d\n", data[15]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001356 }
1357
wdenk4b9206e2004-03-23 22:14:11 +00001358 puts ("Burst length(s) ");
1359 if (data[16] & 0x80) puts (" Page");
1360 if (data[16] & 0x08) puts (" 8");
1361 if (data[16] & 0x04) puts (" 4");
1362 if (data[16] & 0x02) puts (" 2");
1363 if (data[16] & 0x01) puts (" 1");
1364 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001365 printf ("Number of banks %d\n", data[17]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001366
1367 switch (type) {
1368 case DDR2:
1369 puts ("CAS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001370 decode_bits (data[18], decode_CAS_DDR2, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001371 putc ('\n');
1372 break;
1373 default:
1374 puts ("CAS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001375 decode_bits (data[18], decode_CAS_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001376 putc ('\n');
1377 break;
1378 }
1379
1380 if (DDR2 != type) {
1381 puts ("CS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001382 decode_bits (data[19], decode_CS_WE_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001383 putc ('\n');
1384 }
1385
1386 if (DDR2 != type) {
1387 puts ("WE latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001388 decode_bits (data[20], decode_CS_WE_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001389 putc ('\n');
1390 }
1391
1392 switch (type) {
1393 case DDR2:
1394 puts ("Module attributes:\n");
1395 if (data[21] & 0x80)
1396 puts (" TBD (bit 7)\n");
1397 if (data[21] & 0x40)
1398 puts (" Analysis probe installed\n");
1399 if (data[21] & 0x20)
1400 puts (" TBD (bit 5)\n");
1401 if (data[21] & 0x10)
1402 puts (" FET switch external enable\n");
Larry Johnson632de062008-01-11 23:26:18 -05001403 printf (" %d PLLs on DIMM\n", (data[21] >> 2) & 0x03);
Larry Johnson0df6b842008-01-10 22:23:39 -05001404 if (data[20] & 0x11) {
Larry Johnson632de062008-01-11 23:26:18 -05001405 printf (" %d active registers on DIMM\n",
1406 (data[21] & 0x03) + 1);
Larry Johnson0df6b842008-01-10 22:23:39 -05001407 }
1408 break;
1409 default:
1410 puts ("Module attributes:\n");
1411 if (!data[21])
1412 puts (" (none)\n");
Larry Johnson632de062008-01-11 23:26:18 -05001413 else
1414 decode_bits (data[21], decode_byte21_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001415 break;
1416 }
1417
1418 switch (type) {
1419 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001420 decode_bits (data[22], decode_byte22_DDR2, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001421 break;
1422 default:
1423 puts ("Device attributes:\n");
1424 if (data[22] & 0x80) puts (" TBD (bit 7)\n");
1425 if (data[22] & 0x40) puts (" TBD (bit 6)\n");
1426 if (data[22] & 0x20) puts (" Upper Vcc tolerance 5%\n");
1427 else puts (" Upper Vcc tolerance 10%\n");
1428 if (data[22] & 0x10) puts (" Lower Vcc tolerance 5%\n");
1429 else puts (" Lower Vcc tolerance 10%\n");
1430 if (data[22] & 0x08) puts (" Supports write1/read burst\n");
1431 if (data[22] & 0x04) puts (" Supports precharge all\n");
1432 if (data[22] & 0x02) puts (" Supports auto precharge\n");
1433 if (data[22] & 0x01) puts (" Supports early RAS# precharge\n");
1434 break;
1435 }
1436
1437 switch (type) {
1438 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001439 printf ("SDRAM cycle time (2nd highest CAS latency) ");
1440 print_ddr2_tcyc (data[23]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001441 break;
1442 default:
Larry Johnson632de062008-01-11 23:26:18 -05001443 printf ("SDRAM cycle time (2nd highest CAS latency) %d."
1444 "%d ns\n", (data[23] >> 4) & 0x0F, data[23] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001445 break;
1446 }
1447
1448 switch (type) {
1449 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001450 printf ("SDRAM access from clock (2nd highest CAS latency) 0."
1451 "%d%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001452 break;
1453 default:
Larry Johnson632de062008-01-11 23:26:18 -05001454 printf ("SDRAM access from clock (2nd highest CAS latency) %d."
1455 "%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001456 break;
1457 }
1458
1459 switch (type) {
1460 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001461 printf ("SDRAM cycle time (3rd highest CAS latency) ");
1462 print_ddr2_tcyc (data[25]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001463 break;
1464 default:
Larry Johnson632de062008-01-11 23:26:18 -05001465 printf ("SDRAM cycle time (3rd highest CAS latency) %d."
1466 "%d ns\n", (data[25] >> 4) & 0x0F, data[25] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001467 break;
1468 }
1469
1470 switch (type) {
1471 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001472 printf ("SDRAM access from clock (3rd highest CAS latency) 0."
1473 "%d%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001474 break;
1475 default:
Larry Johnson632de062008-01-11 23:26:18 -05001476 printf ("SDRAM access from clock (3rd highest CAS latency) %d."
1477 "%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001478 break;
1479 }
1480
1481 switch (type) {
1482 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001483 printf ("Minimum row precharge %d.%02d ns\n",
1484 (data[27] >> 2) & 0x3F, 25 * (data[27] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001485 break;
1486 default:
Larry Johnson632de062008-01-11 23:26:18 -05001487 printf ("Minimum row precharge %d ns\n", data[27]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001488 break;
1489 }
1490
1491 switch (type) {
1492 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001493 printf ("Row active to row active min %d.%02d ns\n",
1494 (data[28] >> 2) & 0x3F, 25 * (data[28] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001495 break;
1496 default:
Larry Johnson632de062008-01-11 23:26:18 -05001497 printf ("Row active to row active min %d ns\n", data[28]);
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 printf ("RAS to CAS delay min %d.%02d ns\n",
1504 (data[29] >> 2) & 0x3F, 25 * (data[29] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001505 break;
1506 default:
Larry Johnson632de062008-01-11 23:26:18 -05001507 printf ("RAS to CAS delay min %d ns\n", data[29]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001508 break;
1509 }
1510
Larry Johnson632de062008-01-11 23:26:18 -05001511 printf ("Minimum RAS pulse width %d ns\n", data[30]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001512
1513 switch (type) {
1514 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001515 puts ("Density of each row ");
1516 decode_bits (data[31], decode_row_density_DDR2, 1);
1517 putc ('\n');
Larry Johnson0df6b842008-01-10 22:23:39 -05001518 break;
1519 default:
Larry Johnson632de062008-01-11 23:26:18 -05001520 puts ("Density of each row ");
1521 decode_bits (data[31], decode_row_density_default, 1);
1522 putc ('\n');
Larry Johnson0df6b842008-01-10 22:23:39 -05001523 break;
1524 }
1525
1526 switch (type) {
1527 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001528 puts ("Command and Address setup ");
Larry Johnson0df6b842008-01-10 22:23:39 -05001529 if (data[32] >= 0xA0) {
Larry Johnson632de062008-01-11 23:26:18 -05001530 printf ("1.%d%d ns\n",
1531 ((data[32] >> 4) & 0x0F) - 10, data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001532 } else {
Larry Johnson632de062008-01-11 23:26:18 -05001533 printf ("0.%d%d ns\n",
1534 ((data[32] >> 4) & 0x0F), data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001535 }
1536 break;
1537 default:
Larry Johnson632de062008-01-11 23:26:18 -05001538 printf ("Command and Address setup %c%d.%d ns\n",
1539 (data[32] & 0x80) ? '-' : '+',
1540 (data[32] >> 4) & 0x07, data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001541 break;
1542 }
1543
1544 switch (type) {
1545 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001546 puts ("Command and Address hold ");
Larry Johnson0df6b842008-01-10 22:23:39 -05001547 if (data[33] >= 0xA0) {
Larry Johnson632de062008-01-11 23:26:18 -05001548 printf ("1.%d%d ns\n",
1549 ((data[33] >> 4) & 0x0F) - 10, data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001550 } else {
Larry Johnson632de062008-01-11 23:26:18 -05001551 printf ("0.%d%d ns\n",
1552 ((data[33] >> 4) & 0x0F), data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001553 }
1554 break;
1555 default:
Larry Johnson632de062008-01-11 23:26:18 -05001556 printf ("Command and Address hold %c%d.%d ns\n",
1557 (data[33] & 0x80) ? '-' : '+',
1558 (data[33] >> 4) & 0x07, data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001559 break;
1560 }
1561
1562 switch (type) {
1563 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001564 printf ("Data signal input setup 0.%d%d ns\n",
1565 (data[34] >> 4) & 0x0F, data[34] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001566 break;
1567 default:
Larry Johnson632de062008-01-11 23:26:18 -05001568 printf ("Data signal input setup %c%d.%d ns\n",
1569 (data[34] & 0x80) ? '-' : '+',
1570 (data[34] >> 4) & 0x07, data[34] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001571 break;
1572 }
1573
1574 switch (type) {
1575 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001576 printf ("Data signal input hold 0.%d%d ns\n",
1577 (data[35] >> 4) & 0x0F, data[35] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001578 break;
1579 default:
Larry Johnson632de062008-01-11 23:26:18 -05001580 printf ("Data signal input hold %c%d.%d ns\n",
1581 (data[35] & 0x80) ? '-' : '+',
1582 (data[35] >> 4) & 0x07, data[35] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001583 break;
1584 }
1585
wdenk4b9206e2004-03-23 22:14:11 +00001586 puts ("Manufacturer's JEDEC ID ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001587 for (j = 64; j <= 71; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001588 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001589 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001590 printf ("Manufacturing Location %02X\n", data[72]);
wdenk4b9206e2004-03-23 22:14:11 +00001591 puts ("Manufacturer's Part Number ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001592 for (j = 73; j <= 90; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001593 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001594 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001595 printf ("Revision Code %02X %02X\n", data[91], data[92]);
1596 printf ("Manufacturing Date %02X %02X\n", data[93], data[94]);
wdenk4b9206e2004-03-23 22:14:11 +00001597 puts ("Assembly Serial Number ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001598 for (j = 95; j <= 98; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001599 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001600 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +00001601
Larry Johnson0df6b842008-01-10 22:23:39 -05001602 if (DDR2 != type) {
Larry Johnson632de062008-01-11 23:26:18 -05001603 printf ("Speed rating PC%d\n",
1604 data[126] == 0x66 ? 66 : data[126]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001605 }
wdenk81a88242002-10-26 15:22:42 +00001606 return 0;
1607}
Jon Loeliger90253172007-07-10 11:02:44 -05001608#endif
wdenk81a88242002-10-26 15:22:42 +00001609
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001610/*
1611 * Syntax:
1612 * i2c edid {i2c_chip}
1613 */
1614#if defined(CONFIG_I2C_EDID)
Simon Glass09140112020-05-10 11:40:03 -06001615int do_edid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001616{
Masahiro Yamada54684612014-12-20 03:34:23 +09001617 uint chip;
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001618 struct edid1_info edid;
Simon Glass63656b72014-12-10 08:55:48 -07001619 int ret;
Igor Opaniuk2147a162021-02-09 13:52:45 +02001620#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001621 struct udevice *dev;
1622#endif
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001623
1624 if (argc < 2) {
1625 cmd_usage(cmdtp);
1626 return 1;
1627 }
1628
Simon Glass7e5f4602021-07-24 09:03:29 -06001629 chip = hextoul(argv[1], NULL);
Igor Opaniuk2147a162021-02-09 13:52:45 +02001630#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001631 ret = i2c_get_cur_bus_chip(chip, &dev);
1632 if (!ret)
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001633 ret = dm_i2c_read(dev, 0, (uchar *)&edid, sizeof(edid));
Simon Glass63656b72014-12-10 08:55:48 -07001634#else
1635 ret = i2c_read(chip, 0, 1, (uchar *)&edid, sizeof(edid));
1636#endif
1637 if (ret)
1638 return i2c_report_err(ret, I2C_ERR_READ);
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001639
1640 if (edid_check_info(&edid)) {
1641 puts("Content isn't valid EDID.\n");
1642 return 1;
1643 }
1644
1645 edid_print_info(&edid);
1646 return 0;
1647
1648}
1649#endif /* CONFIG_I2C_EDID */
1650
Igor Opaniuk2147a162021-02-09 13:52:45 +02001651#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass59aa9df2015-05-04 11:30:57 -06001652static void show_bus(struct udevice *bus)
1653{
1654 struct udevice *dev;
1655
Simon Glass36c03d12020-12-16 21:20:31 -07001656 printf("Bus %d:\t%s", dev_seq(bus), bus->name);
Simon Glass59aa9df2015-05-04 11:30:57 -06001657 if (device_active(bus))
Simon Glass8b85dfc2020-12-16 21:20:07 -07001658 printf(" (active %d)", dev_seq(bus));
Simon Glass59aa9df2015-05-04 11:30:57 -06001659 printf("\n");
1660 for (device_find_first_child(bus, &dev);
1661 dev;
1662 device_find_next_child(&dev)) {
Simon Glasscaa4daa2020-12-03 16:55:18 -07001663 struct dm_i2c_chip *chip = dev_get_parent_plat(dev);
Simon Glass59aa9df2015-05-04 11:30:57 -06001664
1665 printf(" %02x: %s, offset len %x, flags %x\n",
1666 chip->chip_addr, dev->name, chip->offset_len,
1667 chip->flags);
1668 }
1669}
1670#endif
1671
Marek Vasut06afa382012-11-12 14:34:27 +00001672/**
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001673 * do_i2c_show_bus() - Handle the "i2c bus" command-line command
Marek Vasut06afa382012-11-12 14:34:27 +00001674 * @cmdtp: Command data struct pointer
1675 * @flag: Command flag
1676 * @argc: Command-line argument count
1677 * @argv: Array of command-line arguments
1678 *
1679 * Returns zero always.
1680 */
Tom Rini55dabcc2021-08-18 23:12:24 -04001681#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY) || CONFIG_IS_ENABLED(DM_I2C)
Simon Glass09140112020-05-10 11:40:03 -06001682static int do_i2c_show_bus(struct cmd_tbl *cmdtp, int flag, int argc,
1683 char *const argv[])
Heiko Schocher67b23a32008-10-15 09:39:47 +02001684{
Heiko Schocher67b23a32008-10-15 09:39:47 +02001685 if (argc == 1) {
1686 /* show all busses */
Igor Opaniuk2147a162021-02-09 13:52:45 +02001687#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass59aa9df2015-05-04 11:30:57 -06001688 struct udevice *bus;
1689 struct uclass *uc;
1690 int ret;
1691
1692 ret = uclass_get(UCLASS_I2C, &uc);
1693 if (ret)
1694 return CMD_RET_FAILURE;
1695 uclass_foreach_dev(bus, uc)
1696 show_bus(bus);
1697#else
1698 int i;
1699
Tom Rinicdc5ed82022-11-16 13:10:29 -05001700 for (i = 0; i < CFG_SYS_NUM_I2C_BUSES; i++) {
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001701 printf("Bus %d:\t%s", i, I2C_ADAP_NR(i)->name);
Tom Rinid8964b32022-12-04 10:13:57 -05001702#ifndef CFG_SYS_I2C_DIRECT_BUS
Simon Glass59aa9df2015-05-04 11:30:57 -06001703 int j;
1704
Tom Rini65cc0e22022-11-16 13:10:41 -05001705 for (j = 0; j < CFG_SYS_I2C_MAX_HOPS; j++) {
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001706 if (i2c_bus[i].next_hop[j].chip == 0)
1707 break;
1708 printf("->%s@0x%2x:%d",
1709 i2c_bus[i].next_hop[j].mux.name,
1710 i2c_bus[i].next_hop[j].chip,
1711 i2c_bus[i].next_hop[j].channel);
Heiko Schocher67b23a32008-10-15 09:39:47 +02001712 }
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001713#endif
1714 printf("\n");
Heiko Schocher67b23a32008-10-15 09:39:47 +02001715 }
Simon Glass59aa9df2015-05-04 11:30:57 -06001716#endif
Heiko Schocher67b23a32008-10-15 09:39:47 +02001717 } else {
Simon Glass59aa9df2015-05-04 11:30:57 -06001718 int i;
1719
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001720 /* show specific bus */
Simon Glass0b1284e2021-07-24 09:03:30 -06001721 i = dectoul(argv[1], NULL);
Igor Opaniuk2147a162021-02-09 13:52:45 +02001722#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass59aa9df2015-05-04 11:30:57 -06001723 struct udevice *bus;
1724 int ret;
1725
1726 ret = uclass_get_device_by_seq(UCLASS_I2C, i, &bus);
1727 if (ret) {
1728 printf("Invalid bus %d: err=%d\n", i, ret);
1729 return CMD_RET_FAILURE;
1730 }
1731 show_bus(bus);
1732#else
Tom Rinicdc5ed82022-11-16 13:10:29 -05001733 if (i >= CFG_SYS_NUM_I2C_BUSES) {
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001734 printf("Invalid bus %d\n", i);
1735 return -1;
1736 }
1737 printf("Bus %d:\t%s", i, I2C_ADAP_NR(i)->name);
Tom Rinid8964b32022-12-04 10:13:57 -05001738#ifndef CFG_SYS_I2C_DIRECT_BUS
Simon Glass59aa9df2015-05-04 11:30:57 -06001739 int j;
Tom Rini65cc0e22022-11-16 13:10:41 -05001740 for (j = 0; j < CFG_SYS_I2C_MAX_HOPS; j++) {
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001741 if (i2c_bus[i].next_hop[j].chip == 0)
1742 break;
1743 printf("->%s@0x%2x:%d",
1744 i2c_bus[i].next_hop[j].mux.name,
1745 i2c_bus[i].next_hop[j].chip,
1746 i2c_bus[i].next_hop[j].channel);
1747 }
1748#endif
1749 printf("\n");
Simon Glass59aa9df2015-05-04 11:30:57 -06001750#endif
Heiko Schocher67b23a32008-10-15 09:39:47 +02001751 }
Heiko Schocher67b23a32008-10-15 09:39:47 +02001752
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001753 return 0;
1754}
1755#endif
1756
Marek Vasut06afa382012-11-12 14:34:27 +00001757/**
1758 * do_i2c_bus_num() - Handle the "i2c dev" command-line command
1759 * @cmdtp: Command data struct pointer
1760 * @flag: Command flag
1761 * @argc: Command-line argument count
1762 * @argv: Array of command-line arguments
1763 *
1764 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1765 * on error.
1766 */
Tom Rini1353b252022-12-02 16:42:30 -05001767#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY) || CONFIG_IS_ENABLED(DM_I2C)
Simon Glass09140112020-05-10 11:40:03 -06001768static int do_i2c_bus_num(struct cmd_tbl *cmdtp, int flag, int argc,
1769 char *const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001770{
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001771 int ret = 0;
Simon Glass63656b72014-12-10 08:55:48 -07001772 int bus_no;
Ben Warrenbb99ad62006-09-07 16:50:54 -04001773
Simon Glass63656b72014-12-10 08:55:48 -07001774 if (argc == 1) {
Timur Tabie857a5b2006-11-28 12:09:35 -06001775 /* querying current setting */
Igor Opaniuk2147a162021-02-09 13:52:45 +02001776#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001777 struct udevice *bus;
1778
1779 if (!i2c_get_cur_bus(&bus))
Simon Glass8b85dfc2020-12-16 21:20:07 -07001780 bus_no = dev_seq(bus);
Simon Glass63656b72014-12-10 08:55:48 -07001781 else
1782 bus_no = -1;
1783#else
1784 bus_no = i2c_get_bus_num();
1785#endif
1786 printf("Current bus is %d\n", bus_no);
1787 } else {
Simon Glass0b1284e2021-07-24 09:03:30 -06001788 bus_no = dectoul(argv[1], NULL);
Tom Rini55dabcc2021-08-18 23:12:24 -04001789#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY)
Tom Rinicdc5ed82022-11-16 13:10:29 -05001790 if (bus_no >= CFG_SYS_NUM_I2C_BUSES) {
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001791 printf("Invalid bus %d\n", bus_no);
1792 return -1;
1793 }
Heiko Schocher880a4122013-08-23 09:39:16 +02001794#endif
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001795 printf("Setting bus to %d\n", bus_no);
Igor Opaniuk2147a162021-02-09 13:52:45 +02001796#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001797 ret = cmd_i2c_set_bus_num(bus_no);
1798#else
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001799 ret = i2c_set_bus_num(bus_no);
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001800#endif
Timur Tabie857a5b2006-11-28 12:09:35 -06001801 if (ret)
Ben Warrenbb99ad62006-09-07 16:50:54 -04001802 printf("Failure changing bus number (%d)\n", ret);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001803 }
Simon Glass4fbd2582015-12-29 05:22:50 -07001804
1805 return ret ? CMD_RET_FAILURE : 0;
Ben Warrenbb99ad62006-09-07 16:50:54 -04001806}
Tom Rini55dabcc2021-08-18 23:12:24 -04001807#endif /* CONFIG_IS_ENABLED(SYS_I2C_LEGACY) */
Ben Warrenbb99ad62006-09-07 16:50:54 -04001808
Marek Vasut06afa382012-11-12 14:34:27 +00001809/**
1810 * do_i2c_bus_speed() - Handle the "i2c speed" command-line command
1811 * @cmdtp: Command data struct pointer
1812 * @flag: Command flag
1813 * @argc: Command-line argument count
1814 * @argv: Array of command-line arguments
1815 *
1816 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1817 * on error.
1818 */
Simon Glass09140112020-05-10 11:40:03 -06001819static int do_i2c_bus_speed(struct cmd_tbl *cmdtp, int flag, int argc,
1820 char *const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001821{
1822 int speed, ret=0;
1823
Igor Opaniuk2147a162021-02-09 13:52:45 +02001824#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001825 struct udevice *bus;
1826
1827 if (i2c_get_cur_bus(&bus))
1828 return 1;
1829#endif
1830 if (argc == 1) {
Igor Opaniuk2147a162021-02-09 13:52:45 +02001831#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glassca88b9b2015-02-05 21:41:32 -07001832 speed = dm_i2c_get_bus_speed(bus);
Simon Glass63656b72014-12-10 08:55:48 -07001833#else
1834 speed = i2c_get_bus_speed();
1835#endif
Timur Tabie857a5b2006-11-28 12:09:35 -06001836 /* querying current speed */
Simon Glass63656b72014-12-10 08:55:48 -07001837 printf("Current bus speed=%d\n", speed);
1838 } else {
Simon Glass0b1284e2021-07-24 09:03:30 -06001839 speed = dectoul(argv[1], NULL);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001840 printf("Setting bus speed to %d Hz\n", speed);
Igor Opaniuk2147a162021-02-09 13:52:45 +02001841#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glassca88b9b2015-02-05 21:41:32 -07001842 ret = dm_i2c_set_bus_speed(bus, speed);
Simon Glass63656b72014-12-10 08:55:48 -07001843#else
Ben Warrenbb99ad62006-09-07 16:50:54 -04001844 ret = i2c_set_bus_speed(speed);
Simon Glass63656b72014-12-10 08:55:48 -07001845#endif
Timur Tabie857a5b2006-11-28 12:09:35 -06001846 if (ret)
Ben Warrenbb99ad62006-09-07 16:50:54 -04001847 printf("Failure changing bus speed (%d)\n", ret);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001848 }
Simon Glass4fbd2582015-12-29 05:22:50 -07001849
1850 return ret ? CMD_RET_FAILURE : 0;
Ben Warrenbb99ad62006-09-07 16:50:54 -04001851}
1852
Marek Vasut06afa382012-11-12 14:34:27 +00001853/**
1854 * do_i2c_mm() - Handle the "i2c mm" command-line command
1855 * @cmdtp: Command data struct pointer
1856 * @flag: Command flag
1857 * @argc: Command-line argument count
1858 * @argv: Array of command-line arguments
1859 *
1860 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1861 * on error.
1862 */
Simon Glass09140112020-05-10 11:40:03 -06001863static int do_i2c_mm(struct cmd_tbl *cmdtp, int flag, int argc,
1864 char *const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001865{
1866 return mod_i2c_mem (cmdtp, 1, flag, argc, argv);
1867}
1868
Marek Vasut06afa382012-11-12 14:34:27 +00001869/**
1870 * do_i2c_nm() - Handle the "i2c nm" command-line command
1871 * @cmdtp: Command data struct pointer
1872 * @flag: Command flag
1873 * @argc: Command-line argument count
1874 * @argv: Array of command-line arguments
1875 *
1876 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1877 * on error.
1878 */
Simon Glass09140112020-05-10 11:40:03 -06001879static int do_i2c_nm(struct cmd_tbl *cmdtp, int flag, int argc,
1880 char *const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001881{
1882 return mod_i2c_mem (cmdtp, 0, flag, argc, argv);
1883}
1884
Marek Vasut06afa382012-11-12 14:34:27 +00001885/**
1886 * do_i2c_reset() - Handle the "i2c reset" command-line command
1887 * @cmdtp: Command data struct pointer
1888 * @flag: Command flag
1889 * @argc: Command-line argument count
1890 * @argv: Array of command-line arguments
1891 *
1892 * Returns zero always.
1893 */
Simon Glass09140112020-05-10 11:40:03 -06001894static int do_i2c_reset(struct cmd_tbl *cmdtp, int flag, int argc,
1895 char *const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001896{
Igor Opaniuk2147a162021-02-09 13:52:45 +02001897#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001898 struct udevice *bus;
1899
1900 if (i2c_get_cur_bus(&bus))
1901 return CMD_RET_FAILURE;
1902 if (i2c_deblock(bus)) {
1903 printf("Error: Not supported by the driver\n");
1904 return CMD_RET_FAILURE;
1905 }
Tom Rini55dabcc2021-08-18 23:12:24 -04001906#elif CONFIG_IS_ENABLED(SYS_I2C_LEGACY)
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001907 i2c_init(I2C_ADAP->speed, I2C_ADAP->slaveaddr);
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001908#endif
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001909 return 0;
1910}
1911
Simon Glass09140112020-05-10 11:40:03 -06001912static struct cmd_tbl cmd_i2c_sub[] = {
Tom Rini55dabcc2021-08-18 23:12:24 -04001913#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY) || CONFIG_IS_ENABLED(DM_I2C)
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001914 U_BOOT_CMD_MKENT(bus, 1, 1, do_i2c_show_bus, "", ""),
Heiko Schocher9a2accb2012-10-25 10:32:14 +02001915#endif
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001916 U_BOOT_CMD_MKENT(crc32, 3, 1, do_i2c_crc, "", ""),
Tom Rini1353b252022-12-02 16:42:30 -05001917#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY) || CONFIG_IS_ENABLED(DM_I2C)
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001918 U_BOOT_CMD_MKENT(dev, 1, 1, do_i2c_bus_num, "", ""),
Tom Rini1353b252022-12-02 16:42:30 -05001919#endif
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001920#if defined(CONFIG_I2C_EDID)
1921 U_BOOT_CMD_MKENT(edid, 1, 1, do_edid, "", ""),
1922#endif /* CONFIG_I2C_EDID */
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001923 U_BOOT_CMD_MKENT(loop, 3, 1, do_i2c_loop, "", ""),
1924 U_BOOT_CMD_MKENT(md, 3, 1, do_i2c_md, "", ""),
1925 U_BOOT_CMD_MKENT(mm, 2, 1, do_i2c_mm, "", ""),
1926 U_BOOT_CMD_MKENT(mw, 3, 1, do_i2c_mw, "", ""),
1927 U_BOOT_CMD_MKENT(nm, 2, 1, do_i2c_nm, "", ""),
1928 U_BOOT_CMD_MKENT(probe, 0, 1, do_i2c_probe, "", ""),
Frans Meulenbroeks652e5352010-02-25 10:12:16 +01001929 U_BOOT_CMD_MKENT(read, 5, 1, do_i2c_read, "", ""),
Lubomir Popoved16f142015-01-30 19:56:04 +02001930 U_BOOT_CMD_MKENT(write, 6, 0, do_i2c_write, "", ""),
Igor Opaniuk2147a162021-02-09 13:52:45 +02001931#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001932 U_BOOT_CMD_MKENT(flags, 2, 1, do_i2c_flags, "", ""),
Simon Glassc10c8e32015-08-22 18:31:33 -06001933 U_BOOT_CMD_MKENT(olen, 2, 1, do_i2c_olen, "", ""),
Simon Glass63656b72014-12-10 08:55:48 -07001934#endif
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001935 U_BOOT_CMD_MKENT(reset, 0, 1, do_i2c_reset, "", ""),
1936#if defined(CONFIG_CMD_SDRAM)
1937 U_BOOT_CMD_MKENT(sdram, 1, 1, do_sdram, "", ""),
1938#endif
1939 U_BOOT_CMD_MKENT(speed, 1, 1, do_i2c_bus_speed, "", ""),
1940};
1941
Marek Vasut06afa382012-11-12 14:34:27 +00001942/**
1943 * do_i2c() - Handle the "i2c" command-line command
1944 * @cmdtp: Command data struct pointer
1945 * @flag: Command flag
1946 * @argc: Command-line argument count
1947 * @argv: Array of command-line arguments
1948 *
1949 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1950 * on error.
1951 */
Simon Glass09140112020-05-10 11:40:03 -06001952static int do_i2c(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001953{
Simon Glass09140112020-05-10 11:40:03 -06001954 struct cmd_tbl *c;
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001955
Heiko Schocher4444b222010-09-17 13:10:35 +02001956 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001957 return CMD_RET_USAGE;
Heiko Schocher4444b222010-09-17 13:10:35 +02001958
Peter Tysere96ad5d2009-04-18 22:34:04 -05001959 /* Strip off leading 'i2c' command argument */
1960 argc--;
1961 argv++;
1962
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001963 c = find_cmd_tbl(argv[0], &cmd_i2c_sub[0], ARRAY_SIZE(cmd_i2c_sub));
1964
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001965 if (c)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001966 return c->cmd(cmdtp, flag, argc, argv);
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001967 else
Simon Glass4c12eeb2011-12-10 08:44:01 +00001968 return CMD_RET_USAGE;
Ben Warrenbb99ad62006-09-07 16:50:54 -04001969}
wdenk8bde7f72003-06-27 21:31:46 +00001970
1971/***************************************************/
Tom Rini36162182023-10-07 15:13:08 -04001972U_BOOT_LONGHELP(i2c,
Tom Rini55dabcc2021-08-18 23:12:24 -04001973#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY) || CONFIG_IS_ENABLED(DM_I2C)
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001974 "bus [muxtype:muxaddr:muxchannel] - show I2C bus info\n"
Christoph Muellner19f8c4d2018-12-04 11:27:18 +01001975 "i2c " /* That's the prefix for the crc32 command below. */
Heiko Schocher9a2accb2012-10-25 10:32:14 +02001976#endif
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001977 "crc32 chip address[.0, .1, .2] count - compute CRC32 checksum\n"
Tom Rini1353b252022-12-02 16:42:30 -05001978#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY) || CONFIG_IS_ENABLED(DM_I2C)
Peter Tyser9bc2e4e2008-10-01 12:25:04 -05001979 "i2c dev [dev] - show or set current I2C bus\n"
Tom Rini1353b252022-12-02 16:42:30 -05001980#endif
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001981#if defined(CONFIG_I2C_EDID)
1982 "i2c edid chip - print EDID configuration information\n"
1983#endif /* CONFIG_I2C_EDID */
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001984 "i2c loop chip address[.0, .1, .2] [# of objects] - looping read of device\n"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001985 "i2c md chip address[.0, .1, .2] [# of objects] - read from I2C device\n"
1986 "i2c mm chip address[.0, .1, .2] - write to I2C device (auto-incrementing)\n"
1987 "i2c mw chip address[.0, .1, .2] value [count] - write to I2C device (fill)\n"
1988 "i2c nm chip address[.0, .1, .2] - write to I2C device (constant address)\n"
Eric Nelson54b99e52012-09-23 10:12:56 +00001989 "i2c probe [address] - test for and show device(s) on the I2C bus\n"
Simon Glass63656b72014-12-10 08:55:48 -07001990 "i2c read chip address[.0, .1, .2] length memaddress - read to memory\n"
Lubomir Popoved16f142015-01-30 19:56:04 +02001991 "i2c write memaddress chip address[.0, .1, .2] length [-s] - write memory\n"
1992 " to I2C; the -s option selects bulk write in a single transaction\n"
Igor Opaniuk2147a162021-02-09 13:52:45 +02001993#if CONFIG_IS_ENABLED(DM_I2C)
Simon Glass63656b72014-12-10 08:55:48 -07001994 "i2c flags chip [flags] - set or get chip flags\n"
Simon Glassc10c8e32015-08-22 18:31:33 -06001995 "i2c olen chip [offset_length] - set or get chip offset length\n"
Simon Glass63656b72014-12-10 08:55:48 -07001996#endif
Heiko Schochere43a27c2008-10-15 09:33:30 +02001997 "i2c reset - re-init the I2C Controller\n"
Jon Loeligerc76fe472007-07-08 18:02:23 -05001998#if defined(CONFIG_CMD_SDRAM)
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001999 "i2c sdram chip - print SDRAM configuration information\n"
Jon Loeliger90253172007-07-10 11:02:44 -05002000#endif
Tom Rini36162182023-10-07 15:13:08 -04002001 "i2c speed [speed] - show or set I2C bus speed");
Kim Phillips088f1b12012-10-29 13:34:31 +00002002
2003U_BOOT_CMD(
Lubomir Popoved16f142015-01-30 19:56:04 +02002004 i2c, 7, 1, do_i2c,
Kim Phillips088f1b12012-10-29 13:34:31 +00002005 "I2C sub-system",
2006 i2c_help_text
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01002007);