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, mask, fd, status;
566 unsigned char block[I2C_SMBUS_BLOCK_MAX];
567 char *opt_m_arg = NULL;
570 opts = getopt32(argv, "^"
572 "\0" "-3", /* minimum 3 args */
577 argc--; /* now argv[argc] is last arg */
579 bus_num = i2c_bus_lookup(argv[0]);
580 bus_addr = i2c_parse_bus_addr(argv[1]);
581 data_addr = i2c_parse_data_addr(argv[2]);
584 if (!argv[4] && argv[3][0] != 'c') {
585 mode = I2C_SMBUS_BYTE_DATA; /* Implicit b */
587 switch (argv[argc][0]) {
588 case 'c': /* Already set */
590 case 'b': mode = I2C_SMBUS_BYTE_DATA;
592 case 'w': mode = I2C_SMBUS_WORD_DATA;
594 case 's': mode = I2C_SMBUS_BLOCK_DATA;
596 case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA;
599 bb_error_msg("invalid mode");
603 pec = (argv[argc][1] == 'p');
604 if (mode == I2C_SMBUS_BLOCK_DATA
605 || mode == I2C_SMBUS_I2C_BLOCK_DATA
607 if (pec && mode == I2C_SMBUS_I2C_BLOCK_DATA)
608 bb_error_msg_and_die(
609 "PEC not supported for I2C "
612 bb_error_msg_and_die(
613 "mask not supported for block "
619 /* Prepare the value(s) to be written according to current mode. */
623 case I2C_SMBUS_BYTE_DATA:
624 val = xstrtou_range(argv[3], 0, 0, 0xff);
626 case I2C_SMBUS_WORD_DATA:
627 val = xstrtou_range(argv[3], 0, 0, 0xffff);
629 case I2C_SMBUS_BLOCK_DATA:
630 case I2C_SMBUS_I2C_BLOCK_DATA:
631 for (blen = 3; blen < argc; blen++)
632 block[blen - 3] = xstrtou_range(argv[blen], 0, 0, 0xff);
642 mask = xstrtou_range(opt_m_arg, 0, 0,
643 (mode == I2C_SMBUS_BYTE ||
644 mode == I2C_SMBUS_BYTE_DATA) ? 0xff : 0xffff);
647 fd = i2c_dev_open(bus_num);
648 check_write_funcs(fd, mode, pec);
649 i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
652 confirm_action(bus_addr, mode, data_addr, pec);
655 * If we're using mask - read the current value here and adjust the
656 * value to be written.
663 tmpval = i2c_smbus_read_byte(fd);
665 case I2C_SMBUS_WORD_DATA:
666 tmpval = i2c_smbus_read_word_data(fd, data_addr);
669 tmpval = i2c_smbus_read_byte_data(fd, data_addr);
673 bb_perror_msg_and_die("can't read old value");
675 val = (val & mask) | (tmpval & ~mask);
677 if (!(opts & opt_y)) {
678 bb_error_msg("old value 0x%0*x, write mask "
679 "0x%0*x, will write 0x%0*x to register "
681 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, tmpval,
682 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, mask,
683 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val,
694 status = i2c_smbus_write_byte(fd, data_addr);
696 case I2C_SMBUS_WORD_DATA:
697 status = i2c_smbus_write_word_data(fd, data_addr, val);
699 case I2C_SMBUS_BLOCK_DATA:
700 status = i2c_smbus_write_block_data(fd, data_addr,
703 case I2C_SMBUS_I2C_BLOCK_DATA:
704 status = i2c_smbus_write_i2c_block_data(fd, data_addr,
707 default: /* I2C_SMBUS_BYTE_DATA */
708 status = i2c_smbus_write_byte_data(fd, data_addr, val);
712 bb_perror_msg_and_die("write failed");
715 i2c_set_pec(fd, 0); /* Clear PEC. */
717 /* No readback required - we're done. */
723 status = i2c_smbus_read_byte(fd);
726 case I2C_SMBUS_WORD_DATA:
727 status = i2c_smbus_read_word_data(fd, data_addr);
729 default: /* I2C_SMBUS_BYTE_DATA */
730 status = i2c_smbus_read_byte_data(fd, data_addr);
734 puts("Warning - readback failed");
737 printf("Warning - data mismatch - wrote "
738 "0x%0*x, read back 0x%0*x\n",
739 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val,
740 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status);
742 printf("Value 0x%0*x written, readback matched\n",
743 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val);
748 #endif /* ENABLE_I2CSET */
751 static int read_block_data(int buf_fd, int mode, int *block)
753 uint8_t cblock[I2C_SMBUS_BLOCK_MAX + I2CDUMP_NUM_REGS];
754 int res, blen = 0, tmp, i;
756 if (mode == I2C_SMBUS_BLOCK_DATA) {
757 blen = i2c_smbus_read_block_data(buf_fd, 0, cblock);
761 for (res = 0; res < I2CDUMP_NUM_REGS; res += tmp) {
762 tmp = i2c_smbus_read_i2c_block_data(
763 buf_fd, res, I2C_SMBUS_BLOCK_MAX,
771 if (res >= I2CDUMP_NUM_REGS)
772 res = I2CDUMP_NUM_REGS;
774 for (i = 0; i < res; i++)
775 block[i] = cblock[i];
777 if (mode != I2C_SMBUS_BLOCK_DATA)
778 for (i = res; i < I2CDUMP_NUM_REGS; i++)
785 bb_error_msg_and_die("block read failed: %d", blen);
788 /* Dump all but word data. */
789 static void dump_data(int bus_fd, int mode, unsigned first,
790 unsigned last, int *block, int blen)
794 puts(" 0 1 2 3 4 5 6 7 8 9 a b c d e f"
795 " 0123456789abcdef");
797 for (i = 0; i < I2CDUMP_NUM_REGS; i += 0x10) {
798 if (mode == I2C_SMBUS_BLOCK_DATA && i >= blen)
806 for (j = 0; j < 16; j++) {
808 /* Skip unwanted registers */
809 if (i+j < first || i+j > last) {
811 if (mode == I2C_SMBUS_WORD_DATA) {
819 case I2C_SMBUS_BYTE_DATA:
820 res = i2c_smbus_read_byte_data(bus_fd, i+j);
823 case I2C_SMBUS_WORD_DATA:
824 res = i2c_smbus_read_word_data(bus_fd, i+j);
829 block[i+j] = res & 0xff;
830 block[i+j+1] = res >> 8;
834 res = i2c_smbus_read_byte(bus_fd);
841 if (mode == I2C_SMBUS_BLOCK_DATA &&
844 } else if (res < 0) {
846 if (mode == I2C_SMBUS_WORD_DATA)
849 printf("%02x ", block[i+j]);
850 if (mode == I2C_SMBUS_WORD_DATA)
851 printf("%02x ", block[i+j+1]);
854 if (mode == I2C_SMBUS_WORD_DATA)
859 for (j = 0; j < 16; j++) {
860 if (mode == I2C_SMBUS_BLOCK_DATA && i+j >= blen)
862 /* Skip unwanted registers */
863 if (i+j < first || i+j > last) {
871 } else if (res == 0x00 || res == 0xff) {
873 } else if (res < 32 || res >= 127) {
883 static void dump_word_data(int bus_fd, unsigned first, unsigned last)
888 puts(" 0,8 1,9 2,a 3,b 4,c 5,d 6,e 7,f");
889 for (i = 0; i < 256; i += 8) {
896 for (j = 0; j < 8; j++) {
897 /* Skip unwanted registers. */
898 if (i+j < first || i+j > last) {
903 rv = i2c_smbus_read_word_data(bus_fd, i+j);
907 printf("%04x ", rv & 0xffff);
913 //usage:#define i2cdump_trivial_usage
914 //usage: "[-fy] [-r FIRST-LAST] BUS ADDR [MODE]"
915 //usage:#define i2cdump_full_usage "\n\n"
916 //usage: "Examine I2C registers"
918 //usage: "\n I2CBUS I2C bus number"
919 //usage: "\n ADDRESS 0x03-0x77"
920 //usage: "\nMODE is:"
921 //usage: "\n b Byte (default)"
923 //usage: "\n W Word on even register addresses"
924 //usage: "\n i I2C block"
925 //usage: "\n s SMBus block"
926 //usage: "\n c Consecutive byte"
927 //usage: "\n Append p for SMBus PEC"
929 //usage: "\n -f Force access"
930 //usage: "\n -y Disable interactive mode"
931 //usage: "\n -r Limit the number of registers being accessed"
932 int i2cdump_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
933 int i2cdump_main(int argc UNUSED_PARAM, char **argv)
935 const unsigned opt_f = (1 << 0), opt_y = (1 << 1),
938 int bus_num, bus_addr, mode = I2C_SMBUS_BYTE_DATA, even = 0, pec = 0;
939 unsigned first = 0x00, last = 0xff, opts;
940 int block[I2CDUMP_NUM_REGS];
941 char *opt_r_str, *dash;
944 opts = getopt32(argv, "^"
946 "\0" "-2:?3" /* from 2 to 3 args */,
951 bus_num = i2c_bus_lookup(argv[0]);
952 bus_addr = i2c_parse_bus_addr(argv[1]);
955 switch (argv[2][0]) {
956 case 'b': /* Already set. */ break;
957 case 'c': mode = I2C_SMBUS_BYTE; break;
958 case 'w': mode = I2C_SMBUS_WORD_DATA; break;
960 mode = I2C_SMBUS_WORD_DATA;
963 case 's': mode = I2C_SMBUS_BLOCK_DATA; break;
964 case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA; break;
966 bb_error_msg_and_die("invalid mode");
969 if (argv[2][1] == 'p') {
970 if (argv[2][0] == 'W' || argv[2][0] == 'i') {
971 bb_error_msg_and_die(
972 "pec not supported for -W and -i");
980 first = strtol(opt_r_str, &dash, 0);
981 if (dash == opt_r_str || *dash != '-' || first > 0xff)
982 bb_error_msg_and_die("invalid range");
983 last = xstrtou_range(++dash, 0, first, 0xff);
985 /* Range is not available for every mode. */
988 case I2C_SMBUS_BYTE_DATA:
990 case I2C_SMBUS_WORD_DATA:
991 if (!even || (!(first % 2) && last % 2))
995 bb_error_msg_and_die(
996 "range not compatible with selected mode");
1000 fd = i2c_dev_open(bus_num);
1001 check_read_funcs(fd, mode, -1 /* data_addr */, pec);
1002 i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
1007 if (!(opts & opt_y))
1008 confirm_action(bus_addr, mode, -1 /* data_addr */, pec);
1010 /* All but word data. */
1011 if (mode != I2C_SMBUS_WORD_DATA || even) {
1014 if (mode == I2C_SMBUS_BLOCK_DATA || mode == I2C_SMBUS_I2C_BLOCK_DATA)
1015 blen = read_block_data(fd, mode, block);
1017 if (mode == I2C_SMBUS_BYTE) {
1018 res = i2c_smbus_write_byte(fd, first);
1020 bb_perror_msg_and_die("write start address");
1023 dump_data(fd, mode, first, last, block, blen);
1025 dump_word_data(fd, first, last);
1030 #endif /* ENABLE_I2CDUMP */
1032 #if ENABLE_I2CDETECT
1045 static const struct adap_desc adap_descs[] = {
1047 .algo = "Dummy bus", },
1049 .algo = "ISA bus", },
1051 .algo = "I2C adapter", },
1053 .algo = "SMBus adapter", },
1062 static const struct i2c_func i2c_funcs_tab[] = {
1063 { .value = I2C_FUNC_I2C,
1065 { .value = I2C_FUNC_SMBUS_QUICK,
1066 .name = "SMBus quick command" },
1067 { .value = I2C_FUNC_SMBUS_WRITE_BYTE,
1068 .name = "SMBus send byte" },
1069 { .value = I2C_FUNC_SMBUS_READ_BYTE,
1070 .name = "SMBus receive byte" },
1071 { .value = I2C_FUNC_SMBUS_WRITE_BYTE_DATA,
1072 .name = "SMBus write byte" },
1073 { .value = I2C_FUNC_SMBUS_READ_BYTE_DATA,
1074 .name = "SMBus read byte" },
1075 { .value = I2C_FUNC_SMBUS_WRITE_WORD_DATA,
1076 .name = "SMBus write word" },
1077 { .value = I2C_FUNC_SMBUS_READ_WORD_DATA,
1078 .name = "SMBus read word" },
1079 { .value = I2C_FUNC_SMBUS_PROC_CALL,
1080 .name = "SMBus process call" },
1081 { .value = I2C_FUNC_SMBUS_WRITE_BLOCK_DATA,
1082 .name = "SMBus block write" },
1083 { .value = I2C_FUNC_SMBUS_READ_BLOCK_DATA,
1084 .name = "SMBus block read" },
1085 { .value = I2C_FUNC_SMBUS_BLOCK_PROC_CALL,
1086 .name = "SMBus block process call" },
1087 { .value = I2C_FUNC_SMBUS_PEC,
1088 .name = "SMBus PEC" },
1089 { .value = I2C_FUNC_SMBUS_WRITE_I2C_BLOCK,
1090 .name = "I2C block write" },
1091 { .value = I2C_FUNC_SMBUS_READ_I2C_BLOCK,
1092 .name = "I2C block read" },
1093 { .value = 0, .name = NULL }
1096 static enum adapter_type i2cdetect_get_funcs(int bus)
1098 enum adapter_type ret;
1099 unsigned long funcs;
1102 fd = i2c_dev_open(bus);
1104 get_funcs_matrix(fd, &funcs);
1105 if (funcs & I2C_FUNC_I2C)
1107 else if (funcs & (I2C_FUNC_SMBUS_BYTE |
1108 I2C_FUNC_SMBUS_BYTE_DATA |
1109 I2C_FUNC_SMBUS_WORD_DATA))
1119 static void NORETURN list_i2c_busses_and_exit(void)
1121 const char *const i2cdev_path = "/sys/class/i2c-dev";
1123 char path[NAME_MAX], name[128];
1124 struct dirent *de, *subde;
1125 enum adapter_type adt;
1132 * XXX Upstream i2cdetect also looks for i2c bus info in /proc/bus/i2c,
1133 * but we won't bother since it's only useful on older kernels (before
1134 * 2.6.5). We expect sysfs to be present and mounted at /sys/.
1137 dir = xopendir(i2cdev_path);
1138 while ((de = readdir(dir))) {
1139 if (de->d_name[0] == '.')
1142 /* Simple version for ISA chips. */
1143 snprintf(path, NAME_MAX, "%s/%s/name",
1144 i2cdev_path, de->d_name);
1145 fp = fopen(path, "r");
1147 snprintf(path, NAME_MAX,
1148 "%s/%s/device/name",
1149 i2cdev_path, de->d_name);
1150 fp = fopen(path, "r");
1153 /* Non-ISA chips require the hard-way. */
1155 snprintf(path, NAME_MAX,
1156 "%s/%s/device/name",
1157 i2cdev_path, de->d_name);
1158 subdir = opendir(path);
1162 while ((subde = readdir(subdir))) {
1163 if (subde->d_name[0] == '.')
1166 if (is_prefixed_with(subde->d_name, "i2c-")) {
1167 snprintf(path, NAME_MAX,
1168 "%s/%s/device/%s/name",
1169 i2cdev_path, de->d_name,
1171 fp = fopen(path, "r");
1179 * Get the rest of the info and display a line
1182 memset(name, 0, sizeof(name));
1183 pos = fgets(name, sizeof(name), fp);
1188 pos = strchr(name, '\n');
1192 rv = sscanf(de->d_name, "i2c-%d", &bus);
1196 if (is_prefixed_with(name, "ISA"))
1199 adt = i2cdetect_get_funcs(bus);
1202 "i2c-%d\t%-10s\t%-32s\t%s\n",
1203 bus, adap_descs[adt].funcs,
1204 name, adap_descs[adt].algo);
1211 static void NORETURN no_support(const char *cmd)
1213 bb_error_msg_and_die("bus doesn't support %s", cmd);
1216 static void will_skip(const char *cmd)
1219 "warning: can't use %s command, "
1220 "will skip some addresses", cmd);
1223 //usage:#define i2cdetect_trivial_usage
1224 //usage: "-l | -F I2CBUS | [-ya] [-q|-r] I2CBUS [FIRST LAST]"
1225 //usage:#define i2cdetect_full_usage "\n\n"
1226 //usage: "Detect I2C chips"
1228 //usage: "\n -l List installed buses"
1229 //usage: "\n -F BUS# List functionalities on this bus"
1230 //usage: "\n -y Disable interactive mode"
1231 //usage: "\n -a Force scanning of non-regular addresses"
1232 //usage: "\n -q Use smbus quick write commands for probing (default)"
1233 //usage: "\n -r Use smbus read byte commands for probing"
1234 //usage: "\n FIRST and LAST limit probing range"
1235 int i2cdetect_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1236 int i2cdetect_main(int argc UNUSED_PARAM, char **argv)
1238 const unsigned opt_y = (1 << 0), opt_a = (1 << 1),
1239 opt_q = (1 << 2), opt_r = (1 << 3),
1240 opt_F = (1 << 4), opt_l = (1 << 5);
1242 int fd, bus_num, i, j, mode = I2CDETECT_MODE_AUTO, status, cmd;
1243 unsigned first = 0x03, last = 0x77, opts;
1244 unsigned long funcs;
1246 opts = getopt32(argv, "^"
1249 "q--r:r--q:"/*mutually exclusive*/
1250 "?3"/*up to 3 args*/
1255 list_i2c_busses_and_exit();
1260 bus_num = i2c_bus_lookup(argv[0]);
1261 fd = i2c_dev_open(bus_num);
1262 get_funcs_matrix(fd, &funcs);
1265 /* Only list the functionalities. */
1266 printf("Functionalities implemented by bus #%d\n", bus_num);
1267 for (i = 0; i2c_funcs_tab[i].value; i++) {
1268 printf("%-32s %s\n", i2c_funcs_tab[i].name,
1269 funcs & i2c_funcs_tab[i].value ? "yes" : "no");
1272 return EXIT_SUCCESS;
1276 mode = I2CDETECT_MODE_READ;
1277 else if (opts & opt_q)
1278 mode = I2CDETECT_MODE_QUICK;
1285 /* Read address range. */
1287 first = xstrtou_range(argv[1], 16, first, last);
1289 last = xstrtou_range(argv[2], 16, first, last);
1292 if (!(funcs & (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_READ_BYTE))) {
1293 no_support("detection commands");
1295 if (mode == I2CDETECT_MODE_QUICK && !(funcs & I2C_FUNC_SMBUS_QUICK)) {
1296 no_support("SMBus quick write");
1298 if (mode == I2CDETECT_MODE_READ && !(funcs & I2C_FUNC_SMBUS_READ_BYTE)) {
1299 no_support("SMBus receive byte");
1302 if (mode == I2CDETECT_MODE_AUTO) {
1303 if (!(funcs & I2C_FUNC_SMBUS_QUICK))
1304 will_skip("SMBus quick write");
1305 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE))
1306 will_skip("SMBus receive byte");
1309 if (!(opts & opt_y))
1310 confirm_action(-1, -1, -1, 0);
1312 puts(" 0 1 2 3 4 5 6 7 8 9 a b c d e f");
1313 for (i = 0; i < 128; i += 16) {
1314 printf("%02x: ", i);
1315 for (j = 0; j < 16; j++) {
1319 if (mode == I2CDETECT_MODE_AUTO) {
1320 if ((i+j >= 0x30 && i+j <= 0x37) ||
1321 (i+j >= 0x50 && i+j <= 0x5F))
1322 cmd = I2CDETECT_MODE_READ;
1324 cmd = I2CDETECT_MODE_QUICK;
1327 /* Skip unwanted addresses. */
1330 || (cmd == I2CDETECT_MODE_READ && !(funcs & I2C_FUNC_SMBUS_READ_BYTE))
1331 || (cmd == I2CDETECT_MODE_QUICK && !(funcs & I2C_FUNC_SMBUS_QUICK)))
1337 status = ioctl(fd, I2C_SLAVE, itoptr(i + j));
1339 if (errno == EBUSY) {
1344 bb_perror_msg_and_die(
1345 "can't set address to 0x%02x", i + j);
1349 case I2CDETECT_MODE_READ:
1351 * This is known to lock SMBus on various
1352 * write-only chips (mainly clock chips).
1354 status = i2c_smbus_read_byte(fd);
1356 default: /* I2CDETECT_MODE_QUICK: */
1358 * This is known to corrupt the Atmel
1361 status = i2c_smbus_write_quick(fd,
1369 printf("%02x ", i+j);
1376 #endif /* ENABLE_I2CDETECT */