1 /* vi: set sw=4 ts=4: */
3 * Minimal i2c-tools implementation for busybox.
4 * Parts of code ported from i2c-tools:
5 * http://www.lm-sensors.org/wiki/I2CTools.
7 * Copyright (C) 2014 by Bartosz Golaszewski <bartekgola@gmail.com>
9 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
11 //config:config I2CGET
12 //config: bool "i2cget (5.6 kb)"
14 //config: select PLATFORM_LINUX
16 //config: Read from I2C/SMBus chip registers.
18 //config:config I2CSET
19 //config: bool "i2cset (6.9 kb)"
21 //config: select PLATFORM_LINUX
23 //config: Set I2C registers.
25 //config:config I2CDUMP
26 //config: bool "i2cdump (7.2 kb)"
28 //config: select PLATFORM_LINUX
30 //config: Examine I2C registers.
32 //config:config I2CDETECT
33 //config: bool "i2cdetect (7.2 kb)"
35 //config: select PLATFORM_LINUX
37 //config: Detect I2C chips.
40 //applet:IF_I2CGET(APPLET(i2cget, BB_DIR_USR_SBIN, BB_SUID_DROP))
41 //applet:IF_I2CSET(APPLET(i2cset, BB_DIR_USR_SBIN, BB_SUID_DROP))
42 //applet:IF_I2CDUMP(APPLET(i2cdump, BB_DIR_USR_SBIN, BB_SUID_DROP))
43 //applet:IF_I2CDETECT(APPLET(i2cdetect, BB_DIR_USR_SBIN, BB_SUID_DROP))
44 /* not NOEXEC: if hw operation stalls, use less memory in "hung" process */
46 //kbuild:lib-$(CONFIG_I2CGET) += i2c_tools.o
47 //kbuild:lib-$(CONFIG_I2CSET) += i2c_tools.o
48 //kbuild:lib-$(CONFIG_I2CDUMP) += i2c_tools.o
49 //kbuild:lib-$(CONFIG_I2CDETECT) += i2c_tools.o
54 * - upstream i2c-tools can also look-up i2c busses by name, we only accept
56 * - bank and bankreg parameters for i2cdump are not supported because of
57 * their limited usefulness (see i2cdump manual entry for more info),
58 * - i2cdetect doesn't look for bus info in /proc as it does in upstream, but
59 * it shouldn't be a problem in modern kernels.
64 #include <linux/i2c.h>
66 #define I2CDUMP_NUM_REGS 256
68 #define I2CDETECT_MODE_AUTO 0
69 #define I2CDETECT_MODE_QUICK 1
70 #define I2CDETECT_MODE_READ 2
72 /* linux/i2c-dev.h from i2c-tools overwrites the one from linux uapi
73 * and defines symbols already defined by linux/i2c.h.
74 * Also, it defines a bunch of static inlines which we would rather NOT
75 * inline. What a mess.
76 * We need only these definitions from linux/i2c-dev.h:
78 #define I2C_SLAVE 0x0703
79 #define I2C_SLAVE_FORCE 0x0706
80 #define I2C_FUNCS 0x0705
81 #define I2C_PEC 0x0708
82 #define I2C_SMBUS 0x0720
83 struct i2c_smbus_ioctl_data {
87 union i2c_smbus_data *data;
89 /* end linux/i2c-dev.h */
92 * This is needed for ioctl_or_perror_and_die() since it only accepts pointers.
94 static ALWAYS_INLINE void *itoptr(int i)
96 return (void*)(intptr_t)i;
99 static int32_t i2c_smbus_access(int fd, char read_write, uint8_t cmd,
100 int size, union i2c_smbus_data *data)
102 struct i2c_smbus_ioctl_data args;
104 args.read_write = read_write;
109 return ioctl(fd, I2C_SMBUS, &args);
112 static int32_t i2c_smbus_read_byte(int fd)
114 union i2c_smbus_data data;
117 err = i2c_smbus_access(fd, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data);
124 #if ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP
125 static int32_t i2c_smbus_write_byte(int fd, uint8_t val)
127 return i2c_smbus_access(fd, I2C_SMBUS_WRITE,
128 val, I2C_SMBUS_BYTE, NULL);
131 static int32_t i2c_smbus_read_byte_data(int fd, uint8_t cmd)
133 union i2c_smbus_data data;
136 err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
137 I2C_SMBUS_BYTE_DATA, &data);
144 static int32_t i2c_smbus_read_word_data(int fd, uint8_t cmd)
146 union i2c_smbus_data data;
149 err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
150 I2C_SMBUS_WORD_DATA, &data);
156 #endif /* ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP */
159 static int32_t i2c_smbus_write_byte_data(int file,
160 uint8_t cmd, uint8_t value)
162 union i2c_smbus_data data;
166 return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
167 I2C_SMBUS_BYTE_DATA, &data);
170 static int32_t i2c_smbus_write_word_data(int file, uint8_t cmd, uint16_t value)
172 union i2c_smbus_data data;
176 return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
177 I2C_SMBUS_WORD_DATA, &data);
180 static int32_t i2c_smbus_write_block_data(int file, uint8_t cmd,
181 uint8_t length, const uint8_t *values)
183 union i2c_smbus_data data;
185 if (length > I2C_SMBUS_BLOCK_MAX)
186 length = I2C_SMBUS_BLOCK_MAX;
188 memcpy(data.block+1, values, length);
189 data.block[0] = length;
191 return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
192 I2C_SMBUS_BLOCK_DATA, &data);
195 static int32_t i2c_smbus_write_i2c_block_data(int file, uint8_t cmd,
196 uint8_t length, const uint8_t *values)
198 union i2c_smbus_data data;
200 if (length > I2C_SMBUS_BLOCK_MAX)
201 length = I2C_SMBUS_BLOCK_MAX;
203 memcpy(data.block+1, values, length);
204 data.block[0] = length;
206 return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
207 I2C_SMBUS_I2C_BLOCK_BROKEN, &data);
209 #endif /* ENABLE_I2CSET */
213 * Returns the number of bytes read, vals must hold at
214 * least I2C_SMBUS_BLOCK_MAX bytes.
216 static int32_t i2c_smbus_read_block_data(int fd, uint8_t cmd, uint8_t *vals)
218 union i2c_smbus_data data;
221 err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
222 I2C_SMBUS_BLOCK_DATA, &data);
226 for (i = 1; i <= data.block[0]; i++)
227 *vals++ = data.block[i];
228 return data.block[0];
231 static int32_t i2c_smbus_read_i2c_block_data(int fd, uint8_t cmd,
232 uint8_t len, uint8_t *vals)
234 union i2c_smbus_data data;
237 if (len > I2C_SMBUS_BLOCK_MAX)
238 len = I2C_SMBUS_BLOCK_MAX;
241 err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
242 len == 32 ? I2C_SMBUS_I2C_BLOCK_BROKEN :
243 I2C_SMBUS_I2C_BLOCK_DATA, &data);
247 for (i = 1; i <= data.block[0]; i++)
248 *vals++ = data.block[i];
249 return data.block[0];
251 #endif /* ENABLE_I2CDUMP */
254 static int32_t i2c_smbus_write_quick(int fd, uint8_t val)
256 return i2c_smbus_access(fd, val, 0, I2C_SMBUS_QUICK, NULL);
258 #endif /* ENABLE_I2CDETECT */
260 static int i2c_bus_lookup(const char *bus_str)
262 return xstrtou_range(bus_str, 10, 0, 0xfffff);
265 #if ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP
266 static int i2c_parse_bus_addr(const char *addr_str)
268 /* Slave address must be in range 0x03 - 0x77. */
269 return xstrtou_range(addr_str, 16, 0x03, 0x77);
272 static void i2c_set_pec(int fd, int pec)
274 ioctl_or_perror_and_die(fd, I2C_PEC,
279 static void i2c_set_slave_addr(int fd, int addr, int force)
281 ioctl_or_perror_and_die(fd, force ? I2C_SLAVE_FORCE : I2C_SLAVE,
283 "can't set address to 0x%02x", addr);
285 #endif /* ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP */
287 #if ENABLE_I2CGET || ENABLE_I2CSET
288 static int i2c_parse_data_addr(const char *data_addr)
290 /* Data address must be an 8 bit integer. */
291 return xstrtou_range(data_addr, 16, 0, 0xff);
293 #endif /* ENABLE_I2CGET || ENABLE_I2CSET */
296 * Opens the device file associated with given i2c bus.
298 * Upstream i2c-tools also support opening devices by i2c bus name
299 * but we drop it here for size reduction.
301 static int i2c_dev_open(int i2cbus)
303 char filename[sizeof("/dev/i2c-%d") + sizeof(int)*3];
306 sprintf(filename, "/dev/i2c-%d", i2cbus);
307 fd = open(filename, O_RDWR);
309 if (errno == ENOENT) {
310 filename[8] = '/'; /* change to "/dev/i2c/%d" */
311 fd = xopen(filename, O_RDWR);
313 bb_perror_msg_and_die("can't open '%s'", filename);
320 /* Size reducing helpers for xxx_check_funcs(). */
321 static void get_funcs_matrix(int fd, unsigned long *funcs)
323 ioctl_or_perror_and_die(fd, I2C_FUNCS, funcs,
324 "can't get adapter functionality matrix");
327 #if ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP
328 static void check_funcs_test_end(int funcs, int pec, const char *err)
330 if (pec && !(funcs & (I2C_FUNC_SMBUS_PEC | I2C_FUNC_I2C)))
331 bb_error_msg("warning: adapter does not support PEC");
334 bb_error_msg_and_die(
335 "adapter has no %s capability", err);
337 #endif /* ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP */
340 * The below functions emit an error message and exit if the adapter doesn't
341 * support desired functionalities.
343 #if ENABLE_I2CGET || ENABLE_I2CDUMP
344 static void check_read_funcs(int fd, int mode, int data_addr, int pec)
347 const char *err = NULL;
349 get_funcs_matrix(fd, &funcs);
352 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE)) {
353 err = "SMBus receive byte";
356 if (data_addr >= 0 && !(funcs & I2C_FUNC_SMBUS_WRITE_BYTE))
357 err = "SMBus send byte";
359 case I2C_SMBUS_BYTE_DATA:
360 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE_DATA))
361 err = "SMBus read byte";
363 case I2C_SMBUS_WORD_DATA:
364 if (!(funcs & I2C_FUNC_SMBUS_READ_WORD_DATA))
365 err = "SMBus read word";
368 case I2C_SMBUS_BLOCK_DATA:
369 if (!(funcs & I2C_FUNC_SMBUS_READ_BLOCK_DATA))
370 err = "SMBus block read";
373 case I2C_SMBUS_I2C_BLOCK_DATA:
374 if (!(funcs & I2C_FUNC_SMBUS_READ_I2C_BLOCK))
375 err = "I2C block read";
377 #endif /* ENABLE_I2CDUMP */
379 bb_error_msg_and_die("internal error");
381 check_funcs_test_end(funcs, pec, err);
383 #endif /* ENABLE_I2CGET || ENABLE_I2CDUMP */
386 static void check_write_funcs(int fd, int mode, int pec)
389 const char *err = NULL;
391 get_funcs_matrix(fd, &funcs);
394 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE))
395 err = "SMBus send byte";
398 case I2C_SMBUS_BYTE_DATA:
399 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
400 err = "SMBus write byte";
403 case I2C_SMBUS_WORD_DATA:
404 if (!(funcs & I2C_FUNC_SMBUS_WRITE_WORD_DATA))
405 err = "SMBus write word";
408 case I2C_SMBUS_BLOCK_DATA:
409 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BLOCK_DATA))
410 err = "SMBus block write";
412 case I2C_SMBUS_I2C_BLOCK_DATA:
413 if (!(funcs & I2C_FUNC_SMBUS_WRITE_I2C_BLOCK))
414 err = "I2C block write";
417 check_funcs_test_end(funcs, pec, err);
419 #endif /* ENABLE_I2CSET */
421 static void confirm_or_abort(void)
423 fprintf(stderr, "Continue? [y/N] ");
425 if (!bb_ask_confirmation())
426 bb_error_msg_and_die("aborting");
430 * Return only if user confirms the action, abort otherwise.
432 * The messages displayed here are much less elaborate than their i2c-tools
433 * counterparts - this is done for size reduction.
435 static void confirm_action(int bus_addr, int mode, int data_addr, int pec)
437 bb_error_msg("WARNING! This program can confuse your I2C bus");
439 /* Don't let the user break his/her EEPROMs */
440 if (bus_addr >= 0x50 && bus_addr <= 0x57 && pec) {
441 bb_error_msg_and_die("this is I2C not smbus - using PEC on I2C "
442 "devices may result in data loss, aborting");
445 if (mode == I2C_SMBUS_BYTE && data_addr >= 0 && pec)
446 bb_error_msg("WARNING! May interpret a write byte command "
447 "with PEC as a write byte data command");
450 bb_error_msg("PEC checking enabled");
456 //usage:#define i2cget_trivial_usage
457 //usage: "[-fy] BUS CHIP-ADDRESS [DATA-ADDRESS [MODE]]"
458 //usage:#define i2cget_full_usage "\n\n"
459 //usage: "Read from I2C/SMBus chip registers"
461 //usage: "\n I2CBUS I2C bus number"
462 //usage: "\n ADDRESS 0x03-0x77"
463 //usage: "\nMODE is:"
464 //usage: "\n b Read byte data (default)"
465 //usage: "\n w Read word data"
466 //usage: "\n c Write byte/read byte"
467 //usage: "\n Append p for SMBus PEC"
469 //usage: "\n -f Force access"
470 //usage: "\n -y Disable interactive mode"
471 int i2cget_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
472 int i2cget_main(int argc UNUSED_PARAM, char **argv)
474 const unsigned opt_f = (1 << 0), opt_y = (1 << 1);
476 int bus_num, bus_addr, data_addr = -1, status;
477 int mode = I2C_SMBUS_BYTE, pec = 0, fd;
480 opts = getopt32(argv, "^" "fy" "\0" "-2:?4"/*from 2 to 4 args*/);
483 bus_num = i2c_bus_lookup(argv[0]);
484 bus_addr = i2c_parse_bus_addr(argv[1]);
487 data_addr = i2c_parse_data_addr(argv[2]);
488 mode = I2C_SMBUS_BYTE_DATA;
490 switch (argv[3][0]) {
491 case 'b': /* Already set */ break;
492 case 'w': mode = I2C_SMBUS_WORD_DATA; break;
493 case 'c': mode = I2C_SMBUS_BYTE; break;
495 bb_error_msg("invalid mode");
498 pec = argv[3][1] == 'p';
502 fd = i2c_dev_open(bus_num);
503 check_read_funcs(fd, mode, data_addr, pec);
504 i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
507 confirm_action(bus_addr, mode, data_addr, pec);
514 if (data_addr >= 0) {
515 status = i2c_smbus_write_byte(fd, data_addr);
517 bb_error_msg("warning - write failed");
519 status = i2c_smbus_read_byte(fd);
521 case I2C_SMBUS_WORD_DATA:
522 status = i2c_smbus_read_word_data(fd, data_addr);
524 default: /* I2C_SMBUS_BYTE_DATA */
525 status = i2c_smbus_read_byte_data(fd, data_addr);
530 bb_perror_msg_and_die("read failed");
532 printf("0x%0*x\n", mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status);
536 #endif /* ENABLE_I2CGET */
539 //usage:#define i2cset_trivial_usage
540 //usage: "[-fy] [-m MASK] BUS CHIP-ADDRESS DATA-ADDRESS [VALUE] ... [MODE]"
541 //usage:#define i2cset_full_usage "\n\n"
542 //usage: "Set I2C registers"
544 //usage: "\n I2CBUS I2C bus number"
545 //usage: "\n ADDRESS 0x03-0x77"
546 //usage: "\nMODE is:"
547 //usage: "\n c Byte, no value"
548 //usage: "\n b Byte data (default)"
549 //usage: "\n w Word data"
550 //usage: "\n i I2C block data"
551 //usage: "\n s SMBus block data"
552 //usage: "\n Append p for SMBus PEC"
554 //usage: "\n -f Force access"
555 //usage: "\n -y Disable interactive mode"
556 //usage: "\n -r Read back and compare the result"
557 //usage: "\n -m MASK Mask specifying which bits to write"
558 int i2cset_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
559 int i2cset_main(int argc, char **argv)
561 const unsigned opt_f = (1 << 0), opt_y = (1 << 1),
562 opt_m = (1 << 2), opt_r = (1 << 3);
564 int bus_num, bus_addr, data_addr, mode = I2C_SMBUS_BYTE, pec = 0;
565 int val, blen = 0, mask = 0, fd, status;
566 unsigned char block[I2C_SMBUS_BLOCK_MAX];
567 char *opt_m_arg = NULL;
570 opts = getopt32(argv, "^" "fym:r" "\0" "-3"/*from 3 to ? args*/, &opt_m_arg);
574 bus_num = i2c_bus_lookup(argv[0]);
575 bus_addr = i2c_parse_bus_addr(argv[1]);
576 data_addr = i2c_parse_data_addr(argv[2]);
579 if (!argv[4] && argv[3][0] != 'c') {
580 mode = I2C_SMBUS_BYTE_DATA; /* Implicit b */
582 switch (argv[argc-1][0]) {
583 case 'c': /* Already set */ break;
584 case 'b': mode = I2C_SMBUS_BYTE_DATA; break;
585 case 'w': mode = I2C_SMBUS_WORD_DATA; break;
586 case 's': mode = I2C_SMBUS_BLOCK_DATA; break;
587 case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA; break;
589 bb_error_msg("invalid mode");
593 pec = argv[argc-1][1] == 'p';
594 if (mode == I2C_SMBUS_BLOCK_DATA ||
595 mode == I2C_SMBUS_I2C_BLOCK_DATA) {
596 if (pec && mode == I2C_SMBUS_I2C_BLOCK_DATA)
597 bb_error_msg_and_die(
598 "PEC not supported for I2C "
601 bb_error_msg_and_die(
602 "mask not supported for block "
608 /* Prepare the value(s) to be written according to current mode. */
610 case I2C_SMBUS_BYTE_DATA:
611 val = xstrtou_range(argv[3], 0, 0, 0xff);
613 case I2C_SMBUS_WORD_DATA:
614 val = xstrtou_range(argv[3], 0, 0, 0xffff);
616 case I2C_SMBUS_BLOCK_DATA:
617 case I2C_SMBUS_I2C_BLOCK_DATA:
618 for (blen = 3; blen < (argc - 1); blen++)
619 block[blen] = xstrtou_range(argv[blen], 0, 0, 0xff);
628 mask = xstrtou_range(opt_m_arg, 0, 0,
629 (mode == I2C_SMBUS_BYTE ||
630 mode == I2C_SMBUS_BYTE_DATA) ? 0xff : 0xffff);
633 fd = i2c_dev_open(bus_num);
634 check_write_funcs(fd, mode, pec);
635 i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
638 confirm_action(bus_addr, mode, data_addr, pec);
641 * If we're using mask - read the current value here and adjust the
642 * value to be written.
649 tmpval = i2c_smbus_read_byte(fd);
651 case I2C_SMBUS_WORD_DATA:
652 tmpval = i2c_smbus_read_word_data(fd, data_addr);
655 tmpval = i2c_smbus_read_byte_data(fd, data_addr);
659 bb_perror_msg_and_die("can't read old value");
661 val = (val & mask) | (tmpval & ~mask);
663 if (!(opts & opt_y)) {
664 bb_error_msg("old value 0x%0*x, write mask "
665 "0x%0*x, will write 0x%0*x to register "
667 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, tmpval,
668 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, mask,
669 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val,
680 status = i2c_smbus_write_byte(fd, data_addr);
682 case I2C_SMBUS_WORD_DATA:
683 status = i2c_smbus_write_word_data(fd, data_addr, val);
685 case I2C_SMBUS_BLOCK_DATA:
686 status = i2c_smbus_write_block_data(fd, data_addr,
689 case I2C_SMBUS_I2C_BLOCK_DATA:
690 status = i2c_smbus_write_i2c_block_data(fd, data_addr,
693 default: /* I2C_SMBUS_BYTE_DATA */
694 status = i2c_smbus_write_byte_data(fd, data_addr, val);
698 bb_perror_msg_and_die("write failed");
701 i2c_set_pec(fd, 0); /* Clear PEC. */
703 /* No readback required - we're done. */
709 status = i2c_smbus_read_byte(fd);
712 case I2C_SMBUS_WORD_DATA:
713 status = i2c_smbus_read_word_data(fd, data_addr);
715 default: /* I2C_SMBUS_BYTE_DATA */
716 status = i2c_smbus_read_byte_data(fd, data_addr);
720 puts("Warning - readback failed");
723 printf("Warning - data mismatch - wrote "
724 "0x%0*x, read back 0x%0*x\n",
725 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val,
726 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status);
728 printf("Value 0x%0*x written, readback matched\n",
729 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val);
734 #endif /* ENABLE_I2CSET */
737 static int read_block_data(int buf_fd, int mode, int *block)
739 uint8_t cblock[I2C_SMBUS_BLOCK_MAX + I2CDUMP_NUM_REGS];
740 int res, blen = 0, tmp, i;
742 if (mode == I2C_SMBUS_BLOCK_DATA) {
743 blen = i2c_smbus_read_block_data(buf_fd, 0, cblock);
747 for (res = 0; res < I2CDUMP_NUM_REGS; res += tmp) {
748 tmp = i2c_smbus_read_i2c_block_data(
749 buf_fd, res, I2C_SMBUS_BLOCK_MAX,
757 if (res >= I2CDUMP_NUM_REGS)
758 res = I2CDUMP_NUM_REGS;
760 for (i = 0; i < res; i++)
761 block[i] = cblock[i];
763 if (mode != I2C_SMBUS_BLOCK_DATA)
764 for (i = res; i < I2CDUMP_NUM_REGS; i++)
771 bb_error_msg_and_die("block read failed: %d", blen);
774 /* Dump all but word data. */
775 static void dump_data(int bus_fd, int mode, unsigned first,
776 unsigned last, int *block, int blen)
780 puts(" 0 1 2 3 4 5 6 7 8 9 a b c d e f"
781 " 0123456789abcdef");
783 for (i = 0; i < I2CDUMP_NUM_REGS; i += 0x10) {
784 if (mode == I2C_SMBUS_BLOCK_DATA && i >= blen)
792 for (j = 0; j < 16; j++) {
794 /* Skip unwanted registers */
795 if (i+j < first || i+j > last) {
797 if (mode == I2C_SMBUS_WORD_DATA) {
805 case I2C_SMBUS_BYTE_DATA:
806 res = i2c_smbus_read_byte_data(bus_fd, i+j);
809 case I2C_SMBUS_WORD_DATA:
810 res = i2c_smbus_read_word_data(bus_fd, i+j);
815 block[i+j] = res & 0xff;
816 block[i+j+1] = res >> 8;
820 res = i2c_smbus_read_byte(bus_fd);
827 if (mode == I2C_SMBUS_BLOCK_DATA &&
830 } else if (res < 0) {
832 if (mode == I2C_SMBUS_WORD_DATA)
835 printf("%02x ", block[i+j]);
836 if (mode == I2C_SMBUS_WORD_DATA)
837 printf("%02x ", block[i+j+1]);
840 if (mode == I2C_SMBUS_WORD_DATA)
845 for (j = 0; j < 16; j++) {
846 if (mode == I2C_SMBUS_BLOCK_DATA && i+j >= blen)
848 /* Skip unwanted registers */
849 if (i+j < first || i+j > last) {
857 } else if (res == 0x00 || res == 0xff) {
859 } else if (res < 32 || res >= 127) {
869 static void dump_word_data(int bus_fd, unsigned first, unsigned last)
874 puts(" 0,8 1,9 2,a 3,b 4,c 5,d 6,e 7,f");
875 for (i = 0; i < 256; i += 8) {
882 for (j = 0; j < 8; j++) {
883 /* Skip unwanted registers. */
884 if (i+j < first || i+j > last) {
889 rv = i2c_smbus_read_word_data(bus_fd, i+j);
893 printf("%04x ", rv & 0xffff);
899 //usage:#define i2cdump_trivial_usage
900 //usage: "[-fy] [-r FIRST-LAST] BUS ADDR [MODE]"
901 //usage:#define i2cdump_full_usage "\n\n"
902 //usage: "Examine I2C registers"
904 //usage: "\n I2CBUS I2C bus number"
905 //usage: "\n ADDRESS 0x03-0x77"
906 //usage: "\nMODE is:"
907 //usage: "\n b Byte (default)"
909 //usage: "\n W Word on even register addresses"
910 //usage: "\n i I2C block"
911 //usage: "\n s SMBus block"
912 //usage: "\n c Consecutive byte"
913 //usage: "\n Append p for SMBus PEC"
915 //usage: "\n -f Force access"
916 //usage: "\n -y Disable interactive mode"
917 //usage: "\n -r Limit the number of registers being accessed"
918 int i2cdump_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
919 int i2cdump_main(int argc UNUSED_PARAM, char **argv)
921 const unsigned opt_f = (1 << 0), opt_y = (1 << 1),
924 int bus_num, bus_addr, mode = I2C_SMBUS_BYTE_DATA, even = 0, pec = 0;
925 unsigned first = 0x00, last = 0xff, opts;
926 int block[I2CDUMP_NUM_REGS];
927 char *opt_r_str, *dash;
930 opts = getopt32(argv, "^"
932 "\0" "-2:?3" /* from 2 to 3 args */,
937 bus_num = i2c_bus_lookup(argv[0]);
938 bus_addr = i2c_parse_bus_addr(argv[1]);
941 switch (argv[2][0]) {
942 case 'b': /* Already set. */ break;
943 case 'c': mode = I2C_SMBUS_BYTE; break;
944 case 'w': mode = I2C_SMBUS_WORD_DATA; break;
946 mode = I2C_SMBUS_WORD_DATA;
949 case 's': mode = I2C_SMBUS_BLOCK_DATA; break;
950 case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA; break;
952 bb_error_msg_and_die("invalid mode");
955 if (argv[2][1] == 'p') {
956 if (argv[2][0] == 'W' || argv[2][0] == 'i') {
957 bb_error_msg_and_die(
958 "pec not supported for -W and -i");
966 first = strtol(opt_r_str, &dash, 0);
967 if (dash == opt_r_str || *dash != '-' || first > 0xff)
968 bb_error_msg_and_die("invalid range");
969 last = xstrtou_range(++dash, 0, first, 0xff);
971 /* Range is not available for every mode. */
974 case I2C_SMBUS_BYTE_DATA:
976 case I2C_SMBUS_WORD_DATA:
977 if (!even || (!(first % 2) && last % 2))
981 bb_error_msg_and_die(
982 "range not compatible with selected mode");
986 fd = i2c_dev_open(bus_num);
987 check_read_funcs(fd, mode, -1 /* data_addr */, pec);
988 i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
994 confirm_action(bus_addr, mode, -1 /* data_addr */, pec);
996 /* All but word data. */
997 if (mode != I2C_SMBUS_WORD_DATA || even) {
1000 if (mode == I2C_SMBUS_BLOCK_DATA || mode == I2C_SMBUS_I2C_BLOCK_DATA)
1001 blen = read_block_data(fd, mode, block);
1003 if (mode == I2C_SMBUS_BYTE) {
1004 res = i2c_smbus_write_byte(fd, first);
1006 bb_perror_msg_and_die("write start address");
1009 dump_data(fd, mode, first, last, block, blen);
1011 dump_word_data(fd, first, last);
1016 #endif /* ENABLE_I2CDUMP */
1018 #if ENABLE_I2CDETECT
1031 static const struct adap_desc adap_descs[] = {
1033 .algo = "Dummy bus", },
1035 .algo = "ISA bus", },
1037 .algo = "I2C adapter", },
1039 .algo = "SMBus adapter", },
1048 static const struct i2c_func i2c_funcs_tab[] = {
1049 { .value = I2C_FUNC_I2C,
1051 { .value = I2C_FUNC_SMBUS_QUICK,
1052 .name = "SMBus quick command" },
1053 { .value = I2C_FUNC_SMBUS_WRITE_BYTE,
1054 .name = "SMBus send byte" },
1055 { .value = I2C_FUNC_SMBUS_READ_BYTE,
1056 .name = "SMBus receive byte" },
1057 { .value = I2C_FUNC_SMBUS_WRITE_BYTE_DATA,
1058 .name = "SMBus write byte" },
1059 { .value = I2C_FUNC_SMBUS_READ_BYTE_DATA,
1060 .name = "SMBus read byte" },
1061 { .value = I2C_FUNC_SMBUS_WRITE_WORD_DATA,
1062 .name = "SMBus write word" },
1063 { .value = I2C_FUNC_SMBUS_READ_WORD_DATA,
1064 .name = "SMBus read word" },
1065 { .value = I2C_FUNC_SMBUS_PROC_CALL,
1066 .name = "SMBus process call" },
1067 { .value = I2C_FUNC_SMBUS_WRITE_BLOCK_DATA,
1068 .name = "SMBus block write" },
1069 { .value = I2C_FUNC_SMBUS_READ_BLOCK_DATA,
1070 .name = "SMBus block read" },
1071 { .value = I2C_FUNC_SMBUS_BLOCK_PROC_CALL,
1072 .name = "SMBus block process call" },
1073 { .value = I2C_FUNC_SMBUS_PEC,
1074 .name = "SMBus PEC" },
1075 { .value = I2C_FUNC_SMBUS_WRITE_I2C_BLOCK,
1076 .name = "I2C block write" },
1077 { .value = I2C_FUNC_SMBUS_READ_I2C_BLOCK,
1078 .name = "I2C block read" },
1079 { .value = 0, .name = NULL }
1082 static enum adapter_type i2cdetect_get_funcs(int bus)
1084 enum adapter_type ret;
1085 unsigned long funcs;
1088 fd = i2c_dev_open(bus);
1090 get_funcs_matrix(fd, &funcs);
1091 if (funcs & I2C_FUNC_I2C)
1093 else if (funcs & (I2C_FUNC_SMBUS_BYTE |
1094 I2C_FUNC_SMBUS_BYTE_DATA |
1095 I2C_FUNC_SMBUS_WORD_DATA))
1105 static void NORETURN list_i2c_busses_and_exit(void)
1107 const char *const i2cdev_path = "/sys/class/i2c-dev";
1109 char path[NAME_MAX], name[128];
1110 struct dirent *de, *subde;
1111 enum adapter_type adt;
1118 * XXX Upstream i2cdetect also looks for i2c bus info in /proc/bus/i2c,
1119 * but we won't bother since it's only useful on older kernels (before
1120 * 2.6.5). We expect sysfs to be present and mounted at /sys/.
1123 dir = xopendir(i2cdev_path);
1124 while ((de = readdir(dir))) {
1125 if (de->d_name[0] == '.')
1128 /* Simple version for ISA chips. */
1129 snprintf(path, NAME_MAX, "%s/%s/name",
1130 i2cdev_path, de->d_name);
1131 fp = fopen(path, "r");
1133 snprintf(path, NAME_MAX,
1134 "%s/%s/device/name",
1135 i2cdev_path, de->d_name);
1136 fp = fopen(path, "r");
1139 /* Non-ISA chips require the hard-way. */
1141 snprintf(path, NAME_MAX,
1142 "%s/%s/device/name",
1143 i2cdev_path, de->d_name);
1144 subdir = opendir(path);
1148 while ((subde = readdir(subdir))) {
1149 if (subde->d_name[0] == '.')
1152 if (is_prefixed_with(subde->d_name, "i2c-")) {
1153 snprintf(path, NAME_MAX,
1154 "%s/%s/device/%s/name",
1155 i2cdev_path, de->d_name,
1157 fp = fopen(path, "r");
1165 * Get the rest of the info and display a line
1168 memset(name, 0, sizeof(name));
1169 pos = fgets(name, sizeof(name), fp);
1174 pos = strchr(name, '\n');
1178 rv = sscanf(de->d_name, "i2c-%d", &bus);
1182 if (is_prefixed_with(name, "ISA"))
1185 adt = i2cdetect_get_funcs(bus);
1188 "i2c-%d\t%-10s\t%-32s\t%s\n",
1189 bus, adap_descs[adt].funcs,
1190 name, adap_descs[adt].algo);
1197 static void NORETURN no_support(const char *cmd)
1199 bb_error_msg_and_die("bus doesn't support %s", cmd);
1202 static void will_skip(const char *cmd)
1205 "warning: can't use %s command, "
1206 "will skip some addresses", cmd);
1209 //usage:#define i2cdetect_trivial_usage
1210 //usage: "-l | -F I2CBUS | [-ya] [-q|-r] I2CBUS [FIRST LAST]"
1211 //usage:#define i2cdetect_full_usage "\n\n"
1212 //usage: "Detect I2C chips"
1214 //usage: "\n -l List installed buses"
1215 //usage: "\n -F BUS# List functionalities on this bus"
1216 //usage: "\n -y Disable interactive mode"
1217 //usage: "\n -a Force scanning of non-regular addresses"
1218 //usage: "\n -q Use smbus quick write commands for probing (default)"
1219 //usage: "\n -r Use smbus read byte commands for probing"
1220 //usage: "\n FIRST and LAST limit probing range"
1221 int i2cdetect_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1222 int i2cdetect_main(int argc UNUSED_PARAM, char **argv)
1224 const unsigned opt_y = (1 << 0), opt_a = (1 << 1),
1225 opt_q = (1 << 2), opt_r = (1 << 3),
1226 opt_F = (1 << 4), opt_l = (1 << 5);
1228 int fd, bus_num, i, j, mode = I2CDETECT_MODE_AUTO, status, cmd;
1229 unsigned first = 0x03, last = 0x77, opts;
1230 unsigned long funcs;
1232 opts = getopt32(argv, "^"
1235 "q--r:r--q:"/*mutually exclusive*/
1236 "?3"/*up to 3 args*/
1241 list_i2c_busses_and_exit();
1246 bus_num = i2c_bus_lookup(argv[0]);
1247 fd = i2c_dev_open(bus_num);
1248 get_funcs_matrix(fd, &funcs);
1251 /* Only list the functionalities. */
1252 printf("Functionalities implemented by bus #%d\n", bus_num);
1253 for (i = 0; i2c_funcs_tab[i].value; i++) {
1254 printf("%-32s %s\n", i2c_funcs_tab[i].name,
1255 funcs & i2c_funcs_tab[i].value ? "yes" : "no");
1258 return EXIT_SUCCESS;
1262 mode = I2CDETECT_MODE_READ;
1263 else if (opts & opt_q)
1264 mode = I2CDETECT_MODE_QUICK;
1271 /* Read address range. */
1273 first = xstrtou_range(argv[1], 16, first, last);
1275 last = xstrtou_range(argv[2], 16, first, last);
1278 if (!(funcs & (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_READ_BYTE))) {
1279 no_support("detection commands");
1281 if (mode == I2CDETECT_MODE_QUICK && !(funcs & I2C_FUNC_SMBUS_QUICK)) {
1282 no_support("SMBus quick write");
1284 if (mode == I2CDETECT_MODE_READ && !(funcs & I2C_FUNC_SMBUS_READ_BYTE)) {
1285 no_support("SMBus receive byte");
1288 if (mode == I2CDETECT_MODE_AUTO) {
1289 if (!(funcs & I2C_FUNC_SMBUS_QUICK))
1290 will_skip("SMBus quick write");
1291 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE))
1292 will_skip("SMBus receive byte");
1295 if (!(opts & opt_y))
1296 confirm_action(-1, -1, -1, 0);
1298 puts(" 0 1 2 3 4 5 6 7 8 9 a b c d e f");
1299 for (i = 0; i < 128; i += 16) {
1300 printf("%02x: ", i);
1301 for (j = 0; j < 16; j++) {
1305 if (mode == I2CDETECT_MODE_AUTO) {
1306 if ((i+j >= 0x30 && i+j <= 0x37) ||
1307 (i+j >= 0x50 && i+j <= 0x5F))
1308 cmd = I2CDETECT_MODE_READ;
1310 cmd = I2CDETECT_MODE_QUICK;
1313 /* Skip unwanted addresses. */
1316 || (cmd == I2CDETECT_MODE_READ && !(funcs & I2C_FUNC_SMBUS_READ_BYTE))
1317 || (cmd == I2CDETECT_MODE_QUICK && !(funcs & I2C_FUNC_SMBUS_QUICK)))
1323 status = ioctl(fd, I2C_SLAVE, itoptr(i + j));
1325 if (errno == EBUSY) {
1330 bb_perror_msg_and_die(
1331 "can't set address to 0x%02x", i + j);
1335 case I2CDETECT_MODE_READ:
1337 * This is known to lock SMBus on various
1338 * write-only chips (mainly clock chips).
1340 status = i2c_smbus_read_byte(fd);
1342 default: /* I2CDETECT_MODE_QUICK: */
1344 * This is known to corrupt the Atmel
1347 status = i2c_smbus_write_quick(fd,
1355 printf("%02x ", i+j);
1362 #endif /* ENABLE_I2CDETECT */