1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2000, 2001
4 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 */
6
7 /*
8 * Support for read and write access to EEPROM like memory devices. This
9 * includes regular EEPROM as well as FRAM (ferroelectic nonvolaile RAM).
10 * FRAM devices read and write data at bus speed. In particular, there is no
11 * write delay. Also, there is no limit imposed on the number of bytes that can
12 * be transferred with a single read or write.
13 *
14 * Use the following configuration options to ensure no unneeded performance
15 * degradation (typical for EEPROM) is incured for FRAM memory:
16 *
17 * #define CONFIG_SYS_I2C_FRAM
18 * Set CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS to 0
19 *
20 */
21
22 #include <config.h>
23 #include <command.h>
24 #include <dm.h>
25 #include <eeprom.h>
26 #include <i2c.h>
27 #include <i2c_eeprom.h>
28 #include <eeprom_layout.h>
29 #include <vsprintf.h>
30 #include <linux/delay.h>
31
32 #ifndef I2C_RXTX_LEN
33 #define I2C_RXTX_LEN 128
34 #endif
35
36 #define EEPROM_PAGE_SIZE (1 << CONFIG_SYS_EEPROM_PAGE_WRITE_BITS)
37 #define EEPROM_PAGE_OFFSET(x) ((x) & (EEPROM_PAGE_SIZE - 1))
38
39 #if CONFIG_IS_ENABLED(DM_I2C)
40 static int eeprom_i2c_bus;
41 #endif
42
eeprom_write_enable(unsigned dev_addr,int state)43 __weak int eeprom_write_enable(unsigned dev_addr, int state)
44 {
45 return 0;
46 }
47
eeprom_init(int bus)48 void eeprom_init(int bus)
49 {
50 /* I2C EEPROM */
51 #if CONFIG_IS_ENABLED(DM_I2C)
52 eeprom_i2c_bus = bus;
53 #elif CONFIG_IS_ENABLED(SYS_I2C_LEGACY)
54 if (bus >= 0)
55 i2c_set_bus_num(bus);
56 i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
57 #endif
58 }
59
60 /*
61 * for CONFIG_SYS_I2C_EEPROM_ADDR_LEN == 2 (16-bit EEPROM address) offset is
62 * 0x000nxxxx for EEPROM address selectors at n, offset xxxx in EEPROM.
63 *
64 * for CONFIG_SYS_I2C_EEPROM_ADDR_LEN == 1 (8-bit EEPROM page address) offset is
65 * 0x00000nxx for EEPROM address selectors and page number at n.
66 */
eeprom_addr(unsigned dev_addr,unsigned offset,uchar * addr)67 static int eeprom_addr(unsigned dev_addr, unsigned offset, uchar *addr)
68 {
69 unsigned blk_off;
70 int alen;
71
72 blk_off = offset & 0xff; /* block offset */
73 #if CONFIG_SYS_I2C_EEPROM_ADDR_LEN == 1
74 addr[0] = offset >> 8; /* block number */
75 addr[1] = blk_off; /* block offset */
76 alen = 2;
77 #else
78 addr[0] = offset >> 16; /* block number */
79 addr[1] = offset >> 8; /* upper address octet */
80 addr[2] = blk_off; /* lower address octet */
81 alen = 3;
82 #endif /* CONFIG_SYS_I2C_EEPROM_ADDR_LEN */
83
84 addr[0] |= dev_addr; /* insert device address */
85
86 return alen;
87 }
88
eeprom_len(unsigned offset,unsigned end)89 static int eeprom_len(unsigned offset, unsigned end)
90 {
91 unsigned len = end - offset;
92
93 /*
94 * For a FRAM device there is no limit on the number of the
95 * bytes that can be accessed with the single read or write
96 * operation.
97 */
98 #if !defined(CONFIG_SYS_I2C_FRAM)
99 unsigned blk_off = offset & 0xff;
100 unsigned maxlen = EEPROM_PAGE_SIZE - EEPROM_PAGE_OFFSET(blk_off);
101
102 if (maxlen > I2C_RXTX_LEN)
103 maxlen = I2C_RXTX_LEN;
104
105 if (len > maxlen)
106 len = maxlen;
107 #endif
108
109 return len;
110 }
111
eeprom_rw_block(unsigned offset,uchar * addr,unsigned alen,uchar * buffer,unsigned len,bool read)112 static int eeprom_rw_block(unsigned offset, uchar *addr, unsigned alen,
113 uchar *buffer, unsigned len, bool read)
114 {
115 int ret = 0;
116
117 #if CONFIG_IS_ENABLED(DM_I2C)
118 struct udevice *dev;
119
120 ret = i2c_get_chip_for_busnum(eeprom_i2c_bus, addr[0],
121 alen - 1, &dev);
122 if (ret) {
123 printf("%s: Cannot find udev for a bus %d\n", __func__,
124 eeprom_i2c_bus);
125 return CMD_RET_FAILURE;
126 }
127
128 if (read)
129 ret = dm_i2c_read(dev, offset, buffer, len);
130 else
131 ret = dm_i2c_write(dev, offset, buffer, len);
132
133 #else /* Non DM I2C support - will be removed */
134
135 if (read)
136 ret = i2c_read(addr[0], offset, alen - 1, buffer, len);
137 else
138 ret = i2c_write(addr[0], offset, alen - 1, buffer, len);
139 #endif /* CONFIG_DM_I2C */
140 if (ret)
141 ret = CMD_RET_FAILURE;
142
143 return ret;
144 }
145
eeprom_rw(unsigned dev_addr,unsigned offset,uchar * buffer,unsigned cnt,bool read)146 static int eeprom_rw(unsigned dev_addr, unsigned offset, uchar *buffer,
147 unsigned cnt, bool read)
148 {
149 unsigned end = offset + cnt;
150 unsigned alen, len;
151 int rcode = 0;
152 uchar addr[3];
153
154 #if !CONFIG_IS_ENABLED(DM_I2C) && defined(CONFIG_SYS_I2C_EEPROM_BUS)
155 eeprom_init(CONFIG_SYS_I2C_EEPROM_BUS);
156 #endif
157
158 while (offset < end) {
159 alen = eeprom_addr(dev_addr, offset, addr);
160
161 len = eeprom_len(offset, end);
162
163 rcode = eeprom_rw_block(offset, addr, alen, buffer, len, read);
164
165 buffer += len;
166 offset += len;
167
168 #if CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS > 0
169 if (!read)
170 udelay(CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS * 1000);
171 #endif
172 }
173
174 return rcode;
175 }
176
eeprom_read(unsigned dev_addr,unsigned offset,uchar * buffer,unsigned cnt)177 int eeprom_read(unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt)
178 {
179 /*
180 * Read data until done or would cross a page boundary.
181 * We must write the address again when changing pages
182 * because the next page may be in a different device.
183 */
184 return eeprom_rw(dev_addr, offset, buffer, cnt, 1);
185 }
186
eeprom_write(unsigned dev_addr,unsigned offset,uchar * buffer,unsigned cnt)187 int eeprom_write(unsigned dev_addr, unsigned offset,
188 uchar *buffer, unsigned cnt)
189 {
190 int ret;
191
192 eeprom_write_enable(dev_addr, 1);
193
194 /*
195 * Write data until done or would cross a write page boundary.
196 * We must write the address again when changing pages
197 * because the address counter only increments within a page.
198 */
199 ret = eeprom_rw(dev_addr, offset, buffer, cnt, 0);
200
201 eeprom_write_enable(dev_addr, 0);
202 return ret;
203 }
204
parse_numeric_param(char * str)205 static long parse_numeric_param(char *str)
206 {
207 char *endptr;
208 long value = simple_strtol(str, &endptr, 16);
209
210 return (*endptr != '\0') ? -1 : value;
211 }
212
213 struct eeprom_dev_spec {
214 #if CONFIG_IS_ENABLED(I2C_EEPROM)
215 struct udevice *dev;
216 #endif
217 int i2c_bus;
218 ulong i2c_addr;
219 };
220
eeprom_dev_spec_init(struct eeprom_dev_spec * dev)221 static void eeprom_dev_spec_init(struct eeprom_dev_spec *dev)
222 {
223 #if CONFIG_IS_ENABLED(I2C_EEPROM)
224 if (!dev->dev)
225 #endif
226 eeprom_init(dev->i2c_bus);
227 }
228
eeprom_dev_spec_read(struct eeprom_dev_spec * dev,unsigned offset,uchar * buffer,unsigned cnt)229 static int eeprom_dev_spec_read(struct eeprom_dev_spec *dev,
230 unsigned offset, uchar *buffer, unsigned cnt)
231 {
232 #if CONFIG_IS_ENABLED(I2C_EEPROM)
233 if (dev->dev)
234 return i2c_eeprom_read(dev->dev, offset, buffer, cnt);
235 #endif
236 return eeprom_read(dev->i2c_addr, offset, buffer, cnt);
237 }
238
eeprom_dev_spec_write(struct eeprom_dev_spec * dev,unsigned offset,uchar * buffer,unsigned cnt)239 static int eeprom_dev_spec_write(struct eeprom_dev_spec *dev,
240 unsigned offset, uchar *buffer, unsigned cnt)
241 {
242 #if CONFIG_IS_ENABLED(I2C_EEPROM)
243 if (dev->dev)
244 return i2c_eeprom_write(dev->dev, offset, buffer, cnt);
245 #endif
246 return eeprom_write(dev->i2c_addr, offset, buffer, cnt);
247 }
248
249 /**
250 * parse_eeprom_dev_spec - parse the eeprom device specifier
251 *
252 * @dev: pointer to eeprom device specifier
253 * @argc: count of command line arguments that can be used to parse
254 * the device specifier
255 * @argv: command line arguments left to parse
256 *
257 * @returns: number of arguments parsed or CMD_RET_USAGE if error
258 */
parse_eeprom_dev_spec(struct eeprom_dev_spec * dev,int argc,char * const argv[])259 static int parse_eeprom_dev_spec(struct eeprom_dev_spec *dev, int argc,
260 char *const argv[])
261 {
262 #if CONFIG_IS_ENABLED(I2C_EEPROM)
263 if (argc == 0) {
264 if (!uclass_first_device_err(UCLASS_I2C_EEPROM, &dev->dev))
265 return 0;
266 }
267
268 if (argc == 1) {
269 if (!uclass_get_device_by_name(UCLASS_I2C_EEPROM, argv[0],
270 &dev->dev))
271 return 1;
272
273 /*
274 * If we could not find the device by name and the parameter is
275 * not numeric (and so won't be handled later), fail.
276 */
277 if (parse_numeric_param(argv[0]) == -1) {
278 printf("Can't get eeprom device: %s\n", argv[0]);
279 return CMD_RET_USAGE;
280 }
281 }
282 #endif
283
284 #ifdef CONFIG_SYS_I2C_EEPROM_ADDR
285 if (argc == 0) {
286 dev->i2c_bus = -1;
287 dev->i2c_addr = CONFIG_SYS_I2C_EEPROM_ADDR;
288
289 return 0;
290 }
291 #endif
292 if (argc == 1) {
293 dev->i2c_bus = -1;
294 dev->i2c_addr = parse_numeric_param(argv[0]);
295
296 return 1;
297 }
298
299 if (argc == 2) {
300 dev->i2c_bus = parse_numeric_param(argv[0]);
301 dev->i2c_addr = parse_numeric_param(argv[1]);
302
303 return 2;
304 }
305
306 return CMD_RET_USAGE;
307 }
308
309 #ifdef CONFIG_CMD_EEPROM_LAYOUT
310
311 #ifdef CONFIG_EEPROM_LAYOUT_VERSIONS
eeprom_parse_layout_version(char * str)312 __weak int eeprom_parse_layout_version(char *str)
313 {
314 return LAYOUT_VERSION_UNRECOGNIZED;
315 }
316 #endif
317
318 static unsigned char eeprom_buf[CONFIG_SYS_EEPROM_SIZE];
319
320 #endif
321
322 enum eeprom_action {
323 EEPROM_LIST,
324 EEPROM_READ,
325 EEPROM_WRITE,
326 EEPROM_PRINT,
327 EEPROM_UPDATE,
328 EEPROM_ACTION_INVALID,
329 };
330
parse_action(char * cmd)331 static enum eeprom_action parse_action(char *cmd)
332 {
333 #if CONFIG_IS_ENABLED(I2C_EEPROM)
334 if (!strncmp(cmd, "list", 4))
335 return EEPROM_LIST;
336 #endif
337 if (!strncmp(cmd, "read", 4))
338 return EEPROM_READ;
339 if (!strncmp(cmd, "write", 5))
340 return EEPROM_WRITE;
341 #ifdef CONFIG_CMD_EEPROM_LAYOUT
342 if (!strncmp(cmd, "print", 5))
343 return EEPROM_PRINT;
344 if (!strncmp(cmd, "update", 6))
345 return EEPROM_UPDATE;
346 #endif
347
348 return EEPROM_ACTION_INVALID;
349 }
350
351 #if CONFIG_IS_ENABLED(I2C_EEPROM)
do_eeprom_list(void)352 static int do_eeprom_list(void)
353 {
354 struct udevice *dev;
355 struct uclass *uc;
356 int err;
357
358 err = uclass_get(UCLASS_I2C_EEPROM, &uc);
359 if (err)
360 return CMD_RET_FAILURE;
361
362 uclass_foreach_dev(dev, uc)
363 printf("%s (%s)\n", dev->name, dev->driver->name);
364
365 return CMD_RET_SUCCESS;
366 }
367 #endif
368
do_eeprom_rw(struct eeprom_dev_spec * dev,bool read,ulong addr,ulong off,ulong cnt)369 static int do_eeprom_rw(struct eeprom_dev_spec *dev, bool read,
370 ulong addr, ulong off, ulong cnt)
371 {
372 const char *const fmt =
373 "\nEEPROM @0x%lX %s: addr 0x%08lx off 0x%04lx count %ld ... ";
374 uchar *memloc = (uchar *)addr;
375 int ret;
376
377 printf(fmt, dev->i2c_addr, read ? "read" : "write", addr, off, cnt);
378 if (read)
379 ret = eeprom_dev_spec_read(dev, off, memloc, cnt);
380 else
381 ret = eeprom_dev_spec_write(dev, off, memloc, cnt);
382 puts("done\n");
383
384 return ret;
385 }
386
387 #ifdef CONFIG_CMD_EEPROM_LAYOUT
388
do_eeprom_layout(struct eeprom_dev_spec * dev,int layout_ver,struct eeprom_layout * layout)389 static int do_eeprom_layout(struct eeprom_dev_spec *dev, int layout_ver,
390 struct eeprom_layout *layout)
391 {
392 eeprom_layout_setup(layout, eeprom_buf, CONFIG_SYS_EEPROM_SIZE,
393 layout_ver);
394
395 return eeprom_dev_spec_read(dev, 0, eeprom_buf, layout->data_size);
396 }
397
do_eeprom_print(struct eeprom_dev_spec * dev,int layout_ver)398 static int do_eeprom_print(struct eeprom_dev_spec *dev, int layout_ver)
399 {
400 struct eeprom_layout layout;
401 int ret;
402
403 ret = do_eeprom_layout(dev, layout_ver, &layout);
404 if (ret)
405 return ret;
406
407 layout.print(&layout);
408
409 return 0;
410 }
411
do_eeprom_update(struct eeprom_dev_spec * dev,int layout_ver,char * key,char * value)412 static int do_eeprom_update(struct eeprom_dev_spec *dev, int layout_ver,
413 char *key, char *value)
414 {
415 struct eeprom_layout layout;
416 int ret;
417
418 ret = do_eeprom_layout(dev, layout_ver, &layout);
419 if (ret)
420 return ret;
421
422 ret = layout.update(&layout, key, value);
423 if (ret)
424 return CMD_RET_FAILURE;
425
426 return eeprom_dev_spec_write(dev, 0, layout.data, layout.data_size);
427 }
428
429 #endif
430
eeprom_action_expected_argc(enum eeprom_action action)431 static int eeprom_action_expected_argc(enum eeprom_action action)
432 {
433 switch (action) {
434 case EEPROM_LIST:
435 return 0;
436 case EEPROM_READ:
437 case EEPROM_WRITE:
438 return 3;
439 case EEPROM_PRINT:
440 return 0;
441 case EEPROM_UPDATE:
442 return 2;
443 default:
444 return CMD_RET_USAGE;
445 }
446 }
447
448 #define NEXT_PARAM(argc, index) { (argc)--; (index)++; }
do_eeprom(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])449 int do_eeprom(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
450 {
451 enum eeprom_action action = EEPROM_ACTION_INVALID;
452 struct eeprom_dev_spec dev;
453 ulong addr = 0, cnt = 0, off = 0;
454 int ret, index = 0;
455 #ifdef CONFIG_CMD_EEPROM_LAYOUT
456 char *field_name = "";
457 char *field_value = "";
458 int layout_ver = LAYOUT_VERSION_AUTODETECT;
459 #endif
460
461 if (argc <= 1)
462 return CMD_RET_USAGE;
463
464 NEXT_PARAM(argc, index); /* Skip program name */
465
466 action = parse_action(argv[index]);
467 NEXT_PARAM(argc, index);
468
469 if (action == EEPROM_ACTION_INVALID)
470 return CMD_RET_USAGE;
471
472 #if CONFIG_IS_ENABLED(I2C_EEPROM)
473 if (action == EEPROM_LIST)
474 return do_eeprom_list();
475 #endif
476
477 #ifdef CONFIG_EEPROM_LAYOUT_VERSIONS
478 if (action == EEPROM_PRINT || action == EEPROM_UPDATE) {
479 if (!strcmp(argv[index], "-l")) {
480 NEXT_PARAM(argc, index);
481 layout_ver = eeprom_parse_layout_version(argv[index]);
482 NEXT_PARAM(argc, index);
483 }
484 }
485 #endif
486
487 ret = parse_eeprom_dev_spec(&dev,
488 argc - eeprom_action_expected_argc(action),
489 argv + index);
490 if (ret == CMD_RET_USAGE)
491 return ret;
492
493 while (ret--)
494 NEXT_PARAM(argc, index);
495
496 if (action == EEPROM_READ || action == EEPROM_WRITE) {
497 addr = parse_numeric_param(argv[index]);
498 NEXT_PARAM(argc, index);
499 off = parse_numeric_param(argv[index]);
500 NEXT_PARAM(argc, index);
501 cnt = parse_numeric_param(argv[index]);
502 }
503
504 #ifdef CONFIG_CMD_EEPROM_LAYOUT
505 if (action == EEPROM_UPDATE) {
506 field_name = argv[index];
507 NEXT_PARAM(argc, index);
508 field_value = argv[index];
509 NEXT_PARAM(argc, index);
510 }
511 #endif
512
513 eeprom_dev_spec_init(&dev);
514
515 switch (action) {
516 case EEPROM_READ:
517 case EEPROM_WRITE:
518 return do_eeprom_rw(&dev, action == EEPROM_READ,
519 addr, off, cnt);
520 #ifdef CONFIG_CMD_EEPROM_LAYOUT
521 case EEPROM_PRINT:
522 return do_eeprom_print(&dev, layout_ver);
523 case EEPROM_UPDATE:
524 return do_eeprom_update(&dev, layout_ver,
525 field_name, field_value);
526 #endif
527 default:
528 return CMD_RET_USAGE;
529 }
530 }
531
532 #ifdef CONFIG_EEPROM_LAYOUT_VERSIONS
533 #define EEPROM_LAYOUT_SPEC "[-l <layout_version>] "
534 #else
535 #define EEPROM_LAYOUT_SPEC ""
536 #endif
537
538 #if CONFIG_IS_ENABLED(I2C_EEPROM)
539 # define EEPROM_DEV_SPEC "[device_specifier]"
540 #else
541 # define EEPROM_DEV_SPEC "[[bus] devaddr]"
542 #endif
543
544 U_BOOT_CMD(
545 eeprom, 8, 1, do_eeprom,
546 "EEPROM sub-system",
547 #if CONFIG_IS_ENABLED(I2C_EEPROM)
548 "list\n"
549 "eeprom "
550 #endif
551 "read " EEPROM_DEV_SPEC " addr off cnt\n"
552 "eeprom write " EEPROM_DEV_SPEC " addr off cnt\n"
553 " - read/write `cnt' bytes from `devaddr` EEPROM at offset `off'"
554 #ifdef CONFIG_CMD_EEPROM_LAYOUT
555 "\n"
556 "eeprom print " EEPROM_LAYOUT_SPEC EEPROM_DEV_SPEC "\n"
557 " - Print layout fields and their data in human readable format\n"
558 "eeprom update " EEPROM_LAYOUT_SPEC EEPROM_DEV_SPEC " field_name field_value\n"
559 " - Update a specific eeprom field with new data.\n"
560 " The new data must be written in the same human readable format as shown by the print command."
561 #endif
562 #if CONFIG_IS_ENABLED(I2C_EEPROM)
563 "\n\n"
564 "DEVICE SPECIFIER - the eeprom device can be specified\n"
565 " [dev_name] - by device name (devices can listed with the eeprom list command)\n"
566 " [[bus] devaddr] - or by I2C bus and I2C device address\n"
567 "If no device specifier is given, the first driver-model found device is used."
568 #endif
569 #ifdef CONFIG_EEPROM_LAYOUT_VERSIONS
570 "\n\n"
571 "LAYOUT VERSIONS\n"
572 "The -l option can be used to force the command to interpret the EEPROM data using the chosen layout.\n"
573 "If the -l option is omitted, the command will auto detect the layout based on the data in the EEPROM.\n"
574 "The values which can be provided with the -l option are:\n"
575 CONFIG_EEPROM_LAYOUT_HELP_STRING"\n"
576 #endif
577 );
578