miscutils/i2c_tools.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Minimal i2c-tools implementation for busybox.
   4  * Parts of code ported from i2c-tools:
   5  *              http://www.lm-sensors.org/wiki/I2CTools.
   6  *
   7  * Copyright (C) 2014 by Bartosz Golaszewski <bartekgola@gmail.com>
   8  *
   9  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  10  */
  11
  12 //config:config I2CGET
  13 //config:       bool "i2cget"
  14 //config:       default y
  15 //config:       select PLATFORM_LINUX
  16 //config:       help
  17 //config:         Read from I2C/SMBus chip registers.
  18 //config:
  19 //config:config I2CSET
  20 //config:       bool "i2cset"
  21 //config:       default y
  22 //config:       select PLATFORM_LINUX
  23 //config:       help
  24 //config:         Set I2C registers.
  25 //config:
  26 //config:config I2CDUMP
  27 //config:       bool "i2cdump"
  28 //config:       default y
  29 //config:       select PLATFORM_LINUX
  30 //config:       help
  31 //config:         Examine I2C registers.
  32 //config:
  33 //config:config I2CDETECT
  34 //config:       bool "i2cdetect"
  35 //config:       default y
  36 //config:       select PLATFORM_LINUX
  37 //config:       help
  38 //config:         Detect I2C chips.
  39 //config:
  40
  41 //applet:IF_I2CGET(APPLET(i2cget, BB_DIR_USR_SBIN, BB_SUID_DROP))
  42 //applet:IF_I2CSET(APPLET(i2cset, BB_DIR_USR_SBIN, BB_SUID_DROP))
  43 //applet:IF_I2CDUMP(APPLET(i2cdump, BB_DIR_USR_SBIN, BB_SUID_DROP))
  44 //applet:IF_I2CDETECT(APPLET(i2cdetect, BB_DIR_USR_SBIN, BB_SUID_DROP))
  45
  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
  50
  51 /*
  52  * Unsupported stuff:
  53  *
  54  * - upstream i2c-tools can also look-up i2c busses by name, we only accept
  55  *   numbers,
  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.
  60  */
  61
  62 #include "libbb.h"
  63 #include "common_bufsiz.h"
  64
  65 #include <linux/i2c.h>
  66 #include <linux/i2c-dev.h>
  67
  68 #define I2CDUMP_NUM_REGS                256
  69
  70 #define I2CDETECT_MODE_AUTO             0
  71 #define I2CDETECT_MODE_QUICK            1
  72 #define I2CDETECT_MODE_READ             2
  73
  74 /*
  75  * This is needed for ioctl_or_perror_and_die() since it only accepts pointers.
  76  */
  77 static ALWAYS_INLINE void *itoptr(int i)
  78 {
  79         return (void*)(intptr_t)i;
  80 }
  81
  82 static int32_t i2c_smbus_access(int fd, char read_write, uint8_t cmd,
  83                                 int size, union i2c_smbus_data *data)
  84 {
  85         struct i2c_smbus_ioctl_data args;
  86
  87         args.read_write = read_write;
  88         args.command = cmd;
  89         args.size = size;
  90         args.data = data;
  91
  92         return ioctl(fd, I2C_SMBUS, &args);
  93 }
  94
  95 static int32_t i2c_smbus_read_byte(int fd)
  96 {
  97         union i2c_smbus_data data;
  98         int err;
  99
 100         err = i2c_smbus_access(fd, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data);
 101         if (err < 0)
 102                 return err;
 103
 104         return data.byte;
 105 }
 106
 107 #if ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP
 108 static int32_t i2c_smbus_write_byte(int fd, uint8_t val)
 109 {
 110         return i2c_smbus_access(fd, I2C_SMBUS_WRITE,
 111                                 val, I2C_SMBUS_BYTE, NULL);
 112 }
 113
 114 static int32_t i2c_smbus_read_byte_data(int fd, uint8_t cmd)
 115 {
 116         union i2c_smbus_data data;
 117         int err;
 118
 119         err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
 120                                I2C_SMBUS_BYTE_DATA, &data);
 121         if (err < 0)
 122                 return err;
 123
 124         return data.byte;
 125 }
 126
 127 static int32_t i2c_smbus_read_word_data(int fd, uint8_t cmd)
 128 {
 129         union i2c_smbus_data data;
 130         int err;
 131
 132         err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
 133                                I2C_SMBUS_WORD_DATA, &data);
 134         if (err < 0)
 135                 return err;
 136
 137         return data.word;
 138 }
 139 #endif /* ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP */
 140
 141 #if ENABLE_I2CSET
 142 static int32_t i2c_smbus_write_byte_data(int file,
 143                                          uint8_t cmd, uint8_t value)
 144 {
 145         union i2c_smbus_data data;
 146
 147         data.byte = value;
 148
 149         return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
 150                                 I2C_SMBUS_BYTE_DATA, &data);
 151 }
 152
 153 static int32_t i2c_smbus_write_word_data(int file, uint8_t cmd, uint16_t value)
 154 {
 155         union i2c_smbus_data data;
 156
 157         data.word = value;
 158
 159         return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
 160                                 I2C_SMBUS_WORD_DATA, &data);
 161 }
 162
 163 static int32_t i2c_smbus_write_block_data(int file, uint8_t cmd,
 164                                    uint8_t length, const uint8_t *values)
 165 {
 166         union i2c_smbus_data data;
 167
 168         if (length > I2C_SMBUS_BLOCK_MAX)
 169                 length = I2C_SMBUS_BLOCK_MAX;
 170
 171         memcpy(data.block+1, values, length);
 172         data.block[0] = length;
 173
 174         return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
 175                                 I2C_SMBUS_BLOCK_DATA, &data);
 176 }
 177
 178 static int32_t i2c_smbus_write_i2c_block_data(int file, uint8_t cmd,
 179                                        uint8_t length, const uint8_t *values)
 180 {
 181         union i2c_smbus_data data;
 182
 183         if (length > I2C_SMBUS_BLOCK_MAX)
 184                 length = I2C_SMBUS_BLOCK_MAX;
 185
 186         memcpy(data.block+1, values, length);
 187         data.block[0] = length;
 188
 189         return i2c_smbus_access(file, I2C_SMBUS_WRITE, cmd,
 190                                 I2C_SMBUS_I2C_BLOCK_BROKEN, &data);
 191 }
 192 #endif /* ENABLE_I2CSET */
 193
 194 #if ENABLE_I2CDUMP
 195 /*
 196  * Returns the number of bytes read, vals must hold at
 197  * least I2C_SMBUS_BLOCK_MAX bytes.
 198  */
 199 static int32_t i2c_smbus_read_block_data(int fd, uint8_t cmd, uint8_t *vals)
 200 {
 201         union i2c_smbus_data data;
 202         int i, err;
 203
 204         err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
 205                                I2C_SMBUS_BLOCK_DATA, &data);
 206         if (err < 0)
 207                 return err;
 208
 209         for (i = 1; i <= data.block[0]; i++)
 210                 *vals++ = data.block[i];
 211         return data.block[0];
 212 }
 213
 214 static int32_t i2c_smbus_read_i2c_block_data(int fd, uint8_t cmd,
 215                                              uint8_t len, uint8_t *vals)
 216 {
 217         union i2c_smbus_data data;
 218         int i, err;
 219
 220         if (len > I2C_SMBUS_BLOCK_MAX)
 221                 len = I2C_SMBUS_BLOCK_MAX;
 222         data.block[0] = len;
 223
 224         err = i2c_smbus_access(fd, I2C_SMBUS_READ, cmd,
 225                                len == 32 ? I2C_SMBUS_I2C_BLOCK_BROKEN :
 226                                            I2C_SMBUS_I2C_BLOCK_DATA, &data);
 227         if (err < 0)
 228                 return err;
 229
 230         for (i = 1; i <= data.block[0]; i++)
 231                 *vals++ = data.block[i];
 232         return data.block[0];
 233 }
 234 #endif /* ENABLE_I2CDUMP */
 235
 236 #if ENABLE_I2CDETECT
 237 static int32_t i2c_smbus_write_quick(int fd, uint8_t val)
 238 {
 239         return i2c_smbus_access(fd, val, 0, I2C_SMBUS_QUICK, NULL);
 240 }
 241 #endif /* ENABLE_I2CDETECT */
 242
 243 static int i2c_bus_lookup(const char *bus_str)
 244 {
 245         return xstrtou_range(bus_str, 10, 0, 0xfffff);
 246 }
 247
 248 #if ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP
 249 static int i2c_parse_bus_addr(const char *addr_str)
 250 {
 251         /* Slave address must be in range 0x03 - 0x77. */
 252         return xstrtou_range(addr_str, 16, 0x03, 0x77);
 253 }
 254
 255 static void i2c_set_pec(int fd, int pec)
 256 {
 257         ioctl_or_perror_and_die(fd, I2C_PEC,
 258                                 itoptr(pec ? 1 : 0),
 259                                 "can't set PEC");
 260 }
 261
 262 static void i2c_set_slave_addr(int fd, int addr, int force)
 263 {
 264         ioctl_or_perror_and_die(fd, force ? I2C_SLAVE_FORCE : I2C_SLAVE,
 265                                 itoptr(addr),
 266                                 "can't set address to 0x%02x", addr);
 267 }
 268 #endif /* ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP */
 269
 270 #if ENABLE_I2CGET || ENABLE_I2CSET
 271 static int i2c_parse_data_addr(const char *data_addr)
 272 {
 273         /* Data address must be an 8 bit integer. */
 274         return xstrtou_range(data_addr, 16, 0, 0xff);
 275 }
 276 #endif /* ENABLE_I2CGET || ENABLE_I2CSET */
 277
 278 /*
 279  * Opens the device file associated with given i2c bus.
 280  *
 281  * Upstream i2c-tools also support opening devices by i2c bus name
 282  * but we drop it here for size reduction.
 283  */
 284 static int i2c_dev_open(int i2cbus)
 285 {
 286         char filename[sizeof("/dev/i2c-%d") + sizeof(int)*3];
 287         int fd;
 288
 289         sprintf(filename, "/dev/i2c-%d", i2cbus);
 290         fd = open(filename, O_RDWR);
 291         if (fd < 0) {
 292                 if (errno == ENOENT) {
 293                         filename[8] = '/'; /* change to "/dev/i2c/%d" */
 294                         fd = xopen(filename, O_RDWR);
 295                 } else {
 296                         bb_perror_msg_and_die("can't open '%s'", filename);
 297                 }
 298         }
 299
 300         return fd;
 301 }
 302
 303 /* Size reducing helpers for xxx_check_funcs(). */
 304 static void get_funcs_matrix(int fd, unsigned long *funcs)
 305 {
 306         ioctl_or_perror_and_die(fd, I2C_FUNCS, funcs,
 307                         "can't get adapter functionality matrix");
 308 }
 309
 310 #if ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP
 311 static void check_funcs_test_end(int funcs, int pec, const char *err)
 312 {
 313         if (pec && !(funcs & (I2C_FUNC_SMBUS_PEC | I2C_FUNC_I2C)))
 314                 bb_error_msg("warning: adapter does not support PEC");
 315
 316         if (err)
 317                 bb_error_msg_and_die(
 318                         "adapter has no %s capability", err);
 319 }
 320 #endif /* ENABLE_I2CGET || ENABLE_I2CSET || ENABLE_I2CDUMP */
 321
 322 /*
 323  * The below functions emit an error message and exit if the adapter doesn't
 324  * support desired functionalities.
 325  */
 326 #if ENABLE_I2CGET || ENABLE_I2CDUMP
 327 static void check_read_funcs(int fd, int mode, int data_addr, int pec)
 328 {
 329         unsigned long funcs;
 330         const char *err = NULL;
 331
 332         get_funcs_matrix(fd, &funcs);
 333         switch (mode) {
 334         case I2C_SMBUS_BYTE:
 335                 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE)) {
 336                         err = "SMBus receive byte";
 337                         break;
 338                 }
 339                 if (data_addr >= 0 && !(funcs & I2C_FUNC_SMBUS_WRITE_BYTE))
 340                         err = "SMBus send byte";
 341                 break;
 342         case I2C_SMBUS_BYTE_DATA:
 343                 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE_DATA))
 344                         err = "SMBus read byte";
 345                 break;
 346         case I2C_SMBUS_WORD_DATA:
 347                 if (!(funcs & I2C_FUNC_SMBUS_READ_WORD_DATA))
 348                         err = "SMBus read word";
 349                 break;
 350 #if ENABLE_I2CDUMP
 351         case I2C_SMBUS_BLOCK_DATA:
 352                 if (!(funcs & I2C_FUNC_SMBUS_READ_BLOCK_DATA))
 353                         err = "SMBus block read";
 354                 break;
 355
 356         case I2C_SMBUS_I2C_BLOCK_DATA:
 357                 if (!(funcs & I2C_FUNC_SMBUS_READ_I2C_BLOCK))
 358                         err = "I2C block read";
 359                 break;
 360 #endif /* ENABLE_I2CDUMP */
 361         default:
 362                 bb_error_msg_and_die("internal error");
 363         }
 364         check_funcs_test_end(funcs, pec, err);
 365 }
 366 #endif /* ENABLE_I2CGET || ENABLE_I2CDUMP */
 367
 368 #if ENABLE_I2CSET
 369 static void check_write_funcs(int fd, int mode, int pec)
 370 {
 371         unsigned long funcs;
 372         const char *err = NULL;
 373
 374         get_funcs_matrix(fd, &funcs);
 375         switch (mode) {
 376         case I2C_SMBUS_BYTE:
 377                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE))
 378                         err = "SMBus send byte";
 379                 break;
 380
 381         case I2C_SMBUS_BYTE_DATA:
 382                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
 383                         err = "SMBus write byte";
 384                 break;
 385
 386         case I2C_SMBUS_WORD_DATA:
 387                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_WORD_DATA))
 388                         err = "SMBus write word";
 389                 break;
 390
 391         case I2C_SMBUS_BLOCK_DATA:
 392                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BLOCK_DATA))
 393                         err = "SMBus block write";
 394                 break;
 395         case I2C_SMBUS_I2C_BLOCK_DATA:
 396                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_I2C_BLOCK))
 397                         err = "I2C block write";
 398                 break;
 399         }
 400         check_funcs_test_end(funcs, pec, err);
 401 }
 402 #endif /* ENABLE_I2CSET */
 403
 404 static void confirm_or_abort(void)
 405 {
 406         fprintf(stderr, "Continue? [y/N] ");
 407         fflush_all();
 408         if (!bb_ask_confirmation())
 409                 bb_error_msg_and_die("aborting");
 410 }
 411
 412 /*
 413  * Return only if user confirms the action, abort otherwise.
 414  *
 415  * The messages displayed here are much less elaborate than their i2c-tools
 416  * counterparts - this is done for size reduction.
 417  */
 418 static void confirm_action(int bus_addr, int mode, int data_addr, int pec)
 419 {
 420         bb_error_msg("WARNING! This program can confuse your I2C bus");
 421
 422         /* Don't let the user break his/her EEPROMs */
 423         if (bus_addr >= 0x50 && bus_addr <= 0x57 && pec) {
 424                 bb_error_msg_and_die("this is I2C not smbus - using PEC on I2C "
 425                         "devices may result in data loss, aborting");
 426         }
 427
 428         if (mode == I2C_SMBUS_BYTE && data_addr >= 0 && pec)
 429                 bb_error_msg("WARNING! May interpret a write byte command "
 430                         "with PEC as a write byte data command");
 431
 432         if (pec)
 433                 bb_error_msg("PEC checking enabled");
 434
 435         confirm_or_abort();
 436 }
 437
 438 #if ENABLE_I2CGET
 439 //usage:#define i2cget_trivial_usage
 440 //usage:       "[-f] [-y] BUS CHIP-ADDRESS [DATA-ADDRESS [MODE]]"
 441 //usage:#define i2cget_full_usage "\n\n"
 442 //usage:       "Read from I2C/SMBus chip registers\n"
 443 //usage:     "\n        I2CBUS  i2c bus number"
 444 //usage:     "\n        ADDRESS 0x03 - 0x77"
 445 //usage:     "\nMODE is:"
 446 //usage:     "\n        b       read byte data (default)"
 447 //usage:     "\n        w       read word data"
 448 //usage:     "\n        c       write byte/read byte"
 449 //usage:     "\n        Append p for SMBus PEC"
 450 //usage:     "\n"
 451 //usage:     "\n        -f      force access"
 452 //usage:     "\n        -y      disable interactive mode"
 453 int i2cget_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 454 int i2cget_main(int argc UNUSED_PARAM, char **argv)
 455 {
 456         const unsigned opt_f = (1 << 0), opt_y = (1 << 1);
 457         const char *const optstr = "fy";
 458
 459         int bus_num, bus_addr, data_addr = -1, status;
 460         int mode = I2C_SMBUS_BYTE, pec = 0, fd;
 461         unsigned opts;
 462
 463         opt_complementary = "-2:?4"; /* from 2 to 4 args */
 464         opts = getopt32(argv, optstr);
 465         argv += optind;
 466
 467         bus_num = i2c_bus_lookup(argv[0]);
 468         bus_addr = i2c_parse_bus_addr(argv[1]);
 469
 470         if (argv[2]) {
 471                 data_addr = i2c_parse_data_addr(argv[2]);
 472                 mode = I2C_SMBUS_BYTE_DATA;
 473                 if (argv[3]) {
 474                         switch (argv[3][0]) {
 475                         case 'b':       /* Already set */               break;
 476                         case 'w':       mode = I2C_SMBUS_WORD_DATA;     break;
 477                         case 'c':       mode = I2C_SMBUS_BYTE;          break;
 478                         default:
 479                                 bb_error_msg("invalid mode");
 480                                 bb_show_usage();
 481                         }
 482                         pec = argv[3][1] == 'p';
 483                 }
 484         }
 485
 486         fd = i2c_dev_open(bus_num);
 487         check_read_funcs(fd, mode, data_addr, pec);
 488         i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
 489
 490         if (!(opts & opt_y))
 491                 confirm_action(bus_addr, mode, data_addr, pec);
 492
 493         if (pec)
 494                 i2c_set_pec(fd, 1);
 495
 496         switch (mode) {
 497         case I2C_SMBUS_BYTE:
 498                 if (data_addr >= 0) {
 499                         status = i2c_smbus_write_byte(fd, data_addr);
 500                         if (status < 0)
 501                                 bb_error_msg("warning - write failed");
 502                 }
 503                 status = i2c_smbus_read_byte(fd);
 504                 break;
 505         case I2C_SMBUS_WORD_DATA:
 506                 status = i2c_smbus_read_word_data(fd, data_addr);
 507                 break;
 508         default: /* I2C_SMBUS_BYTE_DATA */
 509                 status = i2c_smbus_read_byte_data(fd, data_addr);
 510         }
 511         close(fd);
 512
 513         if (status < 0)
 514                 bb_perror_msg_and_die("read failed");
 515
 516         printf("0x%0*x\n", mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status);
 517
 518         return 0;
 519 }
 520 #endif /* ENABLE_I2CGET */
 521
 522 #if ENABLE_I2CSET
 523 //usage:#define i2cset_trivial_usage
 524 //usage:       "[-f] [-y] [-m MASK] BUS CHIP-ADDR DATA-ADDR [VALUE] ... [MODE]"
 525 //usage:#define i2cset_full_usage "\n\n"
 526 //usage:       "Set I2C registers\n"
 527 //usage:     "\n        I2CBUS  i2c bus number"
 528 //usage:     "\n        ADDRESS 0x03 - 0x77"
 529 //usage:     "\nMODE is:"
 530 //usage:     "\n        c       byte, no value"
 531 //usage:     "\n        b       byte data (default)"
 532 //usage:     "\n        w       word data"
 533 //usage:     "\n        i       I2C block data"
 534 //usage:     "\n        s       SMBus block data"
 535 //usage:     "\n        Append p for SMBus PEC"
 536 //usage:     "\n"
 537 //usage:     "\n        -f      force access"
 538 //usage:     "\n        -y      disable interactive mode"
 539 //usage:     "\n        -r      read back and compare the result"
 540 //usage:     "\n        -m MASK mask specifying which bits to write"
 541 int i2cset_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 542 int i2cset_main(int argc, char **argv)
 543 {
 544         const unsigned opt_f = (1 << 0), opt_y = (1 << 1),
 545                               opt_m = (1 << 2), opt_r = (1 << 3);
 546         const char *const optstr = "fym:r";
 547
 548         int bus_num, bus_addr, data_addr, mode = I2C_SMBUS_BYTE, pec = 0;
 549         int val, blen = 0, mask = 0, fd, status;
 550         unsigned char block[I2C_SMBUS_BLOCK_MAX];
 551         char *opt_m_arg = NULL;
 552         unsigned opts;
 553
 554         opt_complementary = "-3"; /* from 3 to ? args */
 555         opts = getopt32(argv, optstr, &opt_m_arg);
 556         argv += optind;
 557         argc -= optind;
 558
 559         bus_num = i2c_bus_lookup(argv[0]);
 560         bus_addr = i2c_parse_bus_addr(argv[1]);
 561         data_addr = i2c_parse_data_addr(argv[2]);
 562
 563         if (argv[3]) {
 564                 if (!argv[4] && argv[3][0] != 'c') {
 565                         mode = I2C_SMBUS_BYTE_DATA; /* Implicit b */
 566                 } else {
 567                         switch (argv[argc-1][0]) {
 568                         case 'c': /* Already set */                     break;
 569                         case 'b': mode = I2C_SMBUS_BYTE_DATA;           break;
 570                         case 'w': mode = I2C_SMBUS_WORD_DATA;           break;
 571                         case 's': mode = I2C_SMBUS_BLOCK_DATA;          break;
 572                         case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA;      break;
 573                         default:
 574                                 bb_error_msg("invalid mode");
 575                                 bb_show_usage();
 576                         }
 577
 578                         pec = argv[argc-1][1] == 'p';
 579                         if (mode == I2C_SMBUS_BLOCK_DATA ||
 580                                         mode == I2C_SMBUS_I2C_BLOCK_DATA) {
 581                                 if (pec && mode == I2C_SMBUS_I2C_BLOCK_DATA)
 582                                         bb_error_msg_and_die(
 583                                                 "PEC not supported for I2C "
 584                                                 "block writes");
 585                                 if (opts & opt_m)
 586                                         bb_error_msg_and_die(
 587                                                 "mask not supported for block "
 588                                                 "writes");
 589                         }
 590                 }
 591         }
 592
 593         /* Prepare the value(s) to be written according to current mode. */
 594         switch (mode) {
 595         case I2C_SMBUS_BYTE_DATA:
 596                 val = xstrtou_range(argv[3], 0, 0, 0xff);
 597                 break;
 598         case I2C_SMBUS_WORD_DATA:
 599                 val = xstrtou_range(argv[3], 0, 0, 0xffff);
 600                 break;
 601         case I2C_SMBUS_BLOCK_DATA:
 602         case I2C_SMBUS_I2C_BLOCK_DATA:
 603                 for (blen = 3; blen < (argc - 1); blen++)
 604                         block[blen] = xstrtou_range(argv[blen], 0, 0, 0xff);
 605                 val = -1;
 606                 break;
 607         default:
 608                 val = -1;
 609                 break;
 610         }
 611
 612         if (opts & opt_m) {
 613                 mask = xstrtou_range(opt_m_arg, 0, 0,
 614                                 (mode == I2C_SMBUS_BYTE ||
 615                                  mode == I2C_SMBUS_BYTE_DATA) ? 0xff : 0xffff);
 616         }
 617
 618         fd = i2c_dev_open(bus_num);
 619         check_write_funcs(fd, mode, pec);
 620         i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
 621
 622         if (!(opts & opt_y))
 623                 confirm_action(bus_addr, mode, data_addr, pec);
 624
 625         /*
 626          * If we're using mask - read the current value here and adjust the
 627          * value to be written.
 628          */
 629         if (opts & opt_m) {
 630                 int tmpval;
 631
 632                 switch (mode) {
 633                 case I2C_SMBUS_BYTE:
 634                         tmpval = i2c_smbus_read_byte(fd);
 635                         break;
 636                 case I2C_SMBUS_WORD_DATA:
 637                         tmpval = i2c_smbus_read_word_data(fd, data_addr);
 638                         break;
 639                 default:
 640                         tmpval = i2c_smbus_read_byte_data(fd, data_addr);
 641                 }
 642
 643                 if (tmpval < 0)
 644                         bb_perror_msg_and_die("can't read old value");
 645
 646                 val = (val & mask) | (tmpval & ~mask);
 647
 648                 if (!(opts & opt_y)) {
 649                         bb_error_msg("old value 0x%0*x, write mask "
 650                                 "0x%0*x, will write 0x%0*x to register "
 651                                 "0x%02x",
 652                                 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, tmpval,
 653                                 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, mask,
 654                                 mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val,
 655                                 data_addr);
 656                         confirm_or_abort();
 657                 }
 658         }
 659
 660         if (pec)
 661                 i2c_set_pec(fd, 1);
 662
 663         switch (mode) {
 664         case I2C_SMBUS_BYTE:
 665                 status = i2c_smbus_write_byte(fd, data_addr);
 666                 break;
 667         case I2C_SMBUS_WORD_DATA:
 668                 status = i2c_smbus_write_word_data(fd, data_addr, val);
 669                 break;
 670         case I2C_SMBUS_BLOCK_DATA:
 671                 status = i2c_smbus_write_block_data(fd, data_addr,
 672                                                     blen, block);
 673                 break;
 674         case I2C_SMBUS_I2C_BLOCK_DATA:
 675                 status = i2c_smbus_write_i2c_block_data(fd, data_addr,
 676                                                         blen, block);
 677                 break;
 678         default: /* I2C_SMBUS_BYTE_DATA */
 679                 status = i2c_smbus_write_byte_data(fd, data_addr, val);
 680                 break;
 681         }
 682         if (status < 0)
 683                 bb_perror_msg_and_die("write failed");
 684
 685         if (pec)
 686                 i2c_set_pec(fd, 0); /* Clear PEC. */
 687
 688         /* No readback required - we're done. */
 689         if (!(opts & opt_r))
 690                 return 0;
 691
 692         switch (mode) {
 693         case I2C_SMBUS_BYTE:
 694                 status = i2c_smbus_read_byte(fd);
 695                 val = data_addr;
 696                 break;
 697         case I2C_SMBUS_WORD_DATA:
 698                 status = i2c_smbus_read_word_data(fd, data_addr);
 699                 break;
 700         default: /* I2C_SMBUS_BYTE_DATA */
 701                 status = i2c_smbus_read_byte_data(fd, data_addr);
 702         }
 703
 704         if (status < 0) {
 705                 puts("Warning - readback failed");
 706         } else
 707         if (status != val) {
 708                 printf("Warning - data mismatch - wrote "
 709                        "0x%0*x, read back 0x%0*x\n",
 710                        mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val,
 711                        mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status);
 712         } else {
 713                 printf("Value 0x%0*x written, readback matched\n",
 714                        mode == I2C_SMBUS_WORD_DATA ? 4 : 2, val);
 715         }
 716
 717         return 0;
 718 }
 719 #endif /* ENABLE_I2CSET */
 720
 721 #if ENABLE_I2CDUMP
 722 static int read_block_data(int buf_fd, int mode, int *block)
 723 {
 724         uint8_t cblock[I2C_SMBUS_BLOCK_MAX + I2CDUMP_NUM_REGS];
 725         int res, blen = 0, tmp, i;
 726
 727         if (mode == I2C_SMBUS_BLOCK_DATA) {
 728                 blen = i2c_smbus_read_block_data(buf_fd, 0, cblock);
 729                 if (blen <= 0)
 730                         goto fail;
 731         } else {
 732                 for (res = 0; res < I2CDUMP_NUM_REGS; res += tmp) {
 733                         tmp = i2c_smbus_read_i2c_block_data(
 734                                         buf_fd, res, I2C_SMBUS_BLOCK_MAX,
 735                                         cblock + res);
 736                         if (tmp <= 0) {
 737                                 blen = tmp;
 738                                 goto fail;
 739                         }
 740                 }
 741
 742                 if (res >= I2CDUMP_NUM_REGS)
 743                         res = I2CDUMP_NUM_REGS;
 744
 745                 for (i = 0; i < res; i++)
 746                         block[i] = cblock[i];
 747
 748                 if (mode != I2C_SMBUS_BLOCK_DATA)
 749                         for (i = res; i < I2CDUMP_NUM_REGS; i++)
 750                                 block[i] = -1;
 751         }
 752
 753         return blen;
 754
 755  fail:
 756         bb_error_msg_and_die("block read failed: %d", blen);
 757 }
 758
 759 /* Dump all but word data. */
 760 static void dump_data(int bus_fd, int mode, unsigned first,
 761                       unsigned last, int *block, int blen)
 762 {
 763         int i, j, res;
 764
 765         puts("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f"
 766              "    0123456789abcdef");
 767
 768         for (i = 0; i < I2CDUMP_NUM_REGS; i += 0x10) {
 769                 if (mode == I2C_SMBUS_BLOCK_DATA && i >= blen)
 770                         break;
 771                 if (i/16 < first/16)
 772                         continue;
 773                 if (i/16 > last/16)
 774                         break;
 775
 776                 printf("%02x: ", i);
 777                 for (j = 0; j < 16; j++) {
 778                         fflush_all();
 779                         /* Skip unwanted registers */
 780                         if (i+j < first || i+j > last) {
 781                                 printf("   ");
 782                                 if (mode == I2C_SMBUS_WORD_DATA) {
 783                                         printf("   ");
 784                                         j++;
 785                                 }
 786                                 continue;
 787                         }
 788
 789                         switch (mode) {
 790                         case I2C_SMBUS_BYTE_DATA:
 791                                 res = i2c_smbus_read_byte_data(bus_fd, i+j);
 792                                 block[i+j] = res;
 793                                 break;
 794                         case I2C_SMBUS_WORD_DATA:
 795                                 res = i2c_smbus_read_word_data(bus_fd, i+j);
 796                                 if (res < 0) {
 797                                         block[i+j] = res;
 798                                         block[i+j+1] = res;
 799                                 } else {
 800                                         block[i+j] = res & 0xff;
 801                                         block[i+j+1] = res >> 8;
 802                                 }
 803                                 break;
 804                         case I2C_SMBUS_BYTE:
 805                                 res = i2c_smbus_read_byte(bus_fd);
 806                                 block[i+j] = res;
 807                                 break;
 808                         default:
 809                                 res = block[i+j];
 810                         }
 811
 812                         if (mode == I2C_SMBUS_BLOCK_DATA &&
 813                             i+j >= blen) {
 814                                 printf("   ");
 815                         } else if (res < 0) {
 816                                 printf("XX ");
 817                                 if (mode == I2C_SMBUS_WORD_DATA)
 818                                         printf("XX ");
 819                         } else {
 820                                 printf("%02x ", block[i+j]);
 821                                 if (mode == I2C_SMBUS_WORD_DATA)
 822                                         printf("%02x ", block[i+j+1]);
 823                         }
 824
 825                         if (mode == I2C_SMBUS_WORD_DATA)
 826                                 j++;
 827                 }
 828                 printf("   ");
 829
 830                 for (j = 0; j < 16; j++) {
 831                         if (mode == I2C_SMBUS_BLOCK_DATA && i+j >= blen)
 832                                 break;
 833                         /* Skip unwanted registers */
 834                         if (i+j < first || i+j > last) {
 835                                 bb_putchar(' ');
 836                                 continue;
 837                         }
 838
 839                         res = block[i+j];
 840                         if (res < 0) {
 841                                 bb_putchar('X');
 842                         } else if (res == 0x00 || res == 0xff) {
 843                                 bb_putchar('.');
 844                         } else if (res < 32 || res >= 127) {
 845                                 bb_putchar('?');
 846                         } else {
 847                                 bb_putchar(res);
 848                         }
 849                 }
 850                 bb_putchar('\n');
 851         }
 852 }
 853
 854 static void dump_word_data(int bus_fd, unsigned first, unsigned last)
 855 {
 856         int i, j, rv;
 857
 858         /* Word data. */
 859         puts("     0,8  1,9  2,a  3,b  4,c  5,d  6,e  7,f");
 860         for (i = 0; i < 256; i += 8) {
 861                 if (i/8 < first/8)
 862                         continue;
 863                 if (i/8 > last/8)
 864                         break;
 865
 866                 printf("%02x: ", i);
 867                 for (j = 0; j < 8; j++) {
 868                         /* Skip unwanted registers. */
 869                         if (i+j < first || i+j > last) {
 870                                 printf("     ");
 871                                 continue;
 872                         }
 873
 874                         rv = i2c_smbus_read_word_data(bus_fd, i+j);
 875                         if (rv < 0)
 876                                 printf("XXXX ");
 877                         else
 878                                 printf("%04x ", rv & 0xffff);
 879                 }
 880                 bb_putchar('\n');
 881         }
 882 }
 883
 884 //usage:#define i2cdump_trivial_usage
 885 //usage:       "[-f] [-r FIRST-LAST] [-y] BUS ADDR [MODE]"
 886 //usage:#define i2cdump_full_usage "\n\n"
 887 //usage:       "Examine I2C registers\n"
 888 //usage:     "\n        I2CBUS  i2c bus number"
 889 //usage:     "\n        ADDRESS 0x03 - 0x77"
 890 //usage:     "\nMODE is:"
 891 //usage:     "\n        b       byte (default)"
 892 //usage:     "\n        w       word"
 893 //usage:     "\n        W       word on even register addresses"
 894 //usage:     "\n        i       I2C block"
 895 //usage:     "\n        s       SMBus block"
 896 //usage:     "\n        c       consecutive byte"
 897 //usage:     "\n        Append p for SMBus PEC"
 898 //usage:     "\n"
 899 //usage:     "\n        -f      force access"
 900 //usage:     "\n        -y      disable interactive mode"
 901 //usage:     "\n        -r      limit the number of registers being accessed"
 902 int i2cdump_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 903 int i2cdump_main(int argc UNUSED_PARAM, char **argv)
 904 {
 905         const unsigned opt_f = (1 << 0), opt_y = (1 << 1),
 906                               opt_r = (1 << 2);
 907         const char *const optstr = "fyr:";
 908
 909         int bus_num, bus_addr, mode = I2C_SMBUS_BYTE_DATA, even = 0, pec = 0;
 910         unsigned first = 0x00, last = 0xff, opts;
 911         int block[I2CDUMP_NUM_REGS];
 912         char *opt_r_str, *dash;
 913         int fd, res;
 914
 915         opt_complementary = "-2:?3"; /* from 2 to 3 args */
 916         opts = getopt32(argv, optstr, &opt_r_str);
 917         argv += optind;
 918
 919         bus_num = i2c_bus_lookup(argv[0]);
 920         bus_addr = i2c_parse_bus_addr(argv[1]);
 921
 922         if (argv[2]) {
 923                 switch (argv[2][0]) {
 924                 case 'b': /* Already set. */                    break;
 925                 case 'c': mode = I2C_SMBUS_BYTE;                break;
 926                 case 'w': mode = I2C_SMBUS_WORD_DATA;           break;
 927                 case 'W':
 928                         mode = I2C_SMBUS_WORD_DATA;
 929                         even = 1;
 930                         break;
 931                 case 's': mode = I2C_SMBUS_BLOCK_DATA;          break;
 932                 case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA;      break;
 933                 default:
 934                         bb_error_msg_and_die("invalid mode");
 935                 }
 936
 937                 if (argv[2][1] == 'p') {
 938                         if (argv[2][0] == 'W' || argv[2][0] == 'i') {
 939                                 bb_error_msg_and_die(
 940                                         "pec not supported for -W and -i");
 941                         } else {
 942                                 pec = 1;
 943                         }
 944                 }
 945         }
 946
 947         if (opts & opt_r) {
 948                 first = strtol(opt_r_str, &dash, 0);
 949                 if (dash == opt_r_str || *dash != '-' || first > 0xff)
 950                         bb_error_msg_and_die("invalid range");
 951                 last = xstrtou_range(++dash, 0, first, 0xff);
 952
 953                 /* Range is not available for every mode. */
 954                 switch (mode) {
 955                 case I2C_SMBUS_BYTE:
 956                 case I2C_SMBUS_BYTE_DATA:
 957                         break;
 958                 case I2C_SMBUS_WORD_DATA:
 959                         if (!even || (!(first % 2) && last % 2))
 960                                 break;
 961                         /* Fall through */
 962                 default:
 963                         bb_error_msg_and_die(
 964                                 "range not compatible with selected mode");
 965                 }
 966         }
 967
 968         fd = i2c_dev_open(bus_num);
 969         check_read_funcs(fd, mode, -1 /* data_addr */, pec);
 970         i2c_set_slave_addr(fd, bus_addr, opts & opt_f);
 971
 972         if (pec)
 973                 i2c_set_pec(fd, 1);
 974
 975         if (!(opts & opt_y))
 976                 confirm_action(bus_addr, mode, -1 /* data_addr */, pec);
 977
 978         /* All but word data. */
 979         if (mode != I2C_SMBUS_WORD_DATA || even) {
 980                 int blen = 0;
 981
 982                 if (mode == I2C_SMBUS_BLOCK_DATA || mode == I2C_SMBUS_I2C_BLOCK_DATA)
 983                         blen = read_block_data(fd, mode, block);
 984
 985                 if (mode == I2C_SMBUS_BYTE) {
 986                         res = i2c_smbus_write_byte(fd, first);
 987                         if (res < 0)
 988                                 bb_perror_msg_and_die("write start address");
 989                 }
 990
 991                 dump_data(fd, mode, first, last, block, blen);
 992         } else {
 993                 dump_word_data(fd, first, last);
 994         }
 995
 996         return 0;
 997 }
 998 #endif /* ENABLE_I2CDUMP */
 999
1000 #if ENABLE_I2CDETECT
1001 enum adapter_type {
1002         ADT_DUMMY = 0,
1003         ADT_ISA,
1004         ADT_I2C,
1005         ADT_SMBUS,
1006 };
1007
1008 struct adap_desc {
1009         const char *funcs;
1010         const char *algo;
1011 };
1012
1013 static const struct adap_desc adap_descs[] = {
1014         { .funcs        = "dummy",
1015           .algo         = "Dummy bus", },
1016         { .funcs        = "isa",
1017           .algo         = "ISA bus", },
1018         { .funcs        = "i2c",
1019           .algo         = "I2C adapter", },
1020         { .funcs        = "smbus",
1021           .algo         = "SMBus adapter", },
1022 };
1023
1024 struct i2c_func
1025 {
1026         long value;
1027         const char* name;
1028 };
1029
1030 static const struct i2c_func i2c_funcs_tab[] = {
1031         { .value = I2C_FUNC_I2C,
1032           .name = "I2C" },
1033         { .value = I2C_FUNC_SMBUS_QUICK,
1034           .name = "SMBus quick command" },
1035         { .value = I2C_FUNC_SMBUS_WRITE_BYTE,
1036           .name = "SMBus send byte" },
1037         { .value = I2C_FUNC_SMBUS_READ_BYTE,
1038           .name = "SMBus receive byte" },
1039         { .value = I2C_FUNC_SMBUS_WRITE_BYTE_DATA,
1040           .name = "SMBus write byte" },
1041         { .value = I2C_FUNC_SMBUS_READ_BYTE_DATA,
1042           .name = "SMBus read byte" },
1043         { .value = I2C_FUNC_SMBUS_WRITE_WORD_DATA,
1044           .name = "SMBus write word" },
1045         { .value = I2C_FUNC_SMBUS_READ_WORD_DATA,
1046           .name = "SMBus read word" },
1047         { .value = I2C_FUNC_SMBUS_PROC_CALL,
1048           .name = "SMBus process call" },
1049         { .value = I2C_FUNC_SMBUS_WRITE_BLOCK_DATA,
1050           .name = "SMBus block write" },
1051         { .value = I2C_FUNC_SMBUS_READ_BLOCK_DATA,
1052           .name = "SMBus block read" },
1053         { .value = I2C_FUNC_SMBUS_BLOCK_PROC_CALL,
1054           .name = "SMBus block process call" },
1055         { .value = I2C_FUNC_SMBUS_PEC,
1056           .name = "SMBus PEC" },
1057         { .value = I2C_FUNC_SMBUS_WRITE_I2C_BLOCK,
1058           .name = "I2C block write" },
1059         { .value = I2C_FUNC_SMBUS_READ_I2C_BLOCK,
1060           .name = "I2C block read" },
1061         { .value = 0, .name = NULL }
1062 };
1063
1064 static enum adapter_type i2cdetect_get_funcs(int bus)
1065 {
1066         enum adapter_type ret;
1067         unsigned long funcs;
1068         int fd;
1069
1070         fd = i2c_dev_open(bus);
1071
1072         get_funcs_matrix(fd, &funcs);
1073         if (funcs & I2C_FUNC_I2C)
1074                 ret = ADT_I2C;
1075         else if (funcs & (I2C_FUNC_SMBUS_BYTE |
1076                           I2C_FUNC_SMBUS_BYTE_DATA |
1077                           I2C_FUNC_SMBUS_WORD_DATA))
1078                 ret = ADT_SMBUS;
1079         else
1080                 ret = ADT_DUMMY;
1081
1082         close(fd);
1083
1084         return ret;
1085 }
1086
1087 static void NORETURN list_i2c_busses_and_exit(void)
1088 {
1089         const char *const i2cdev_path = "/sys/class/i2c-dev";
1090
1091         char path[NAME_MAX], name[128];
1092         struct dirent *de, *subde;
1093         enum adapter_type adt;
1094         DIR *dir, *subdir;
1095         int rv, bus;
1096         char *pos;
1097         FILE *fp;
1098
1099         /*
1100          * XXX Upstream i2cdetect also looks for i2c bus info in /proc/bus/i2c,
1101          * but we won't bother since it's only useful on older kernels (before
1102          * 2.6.5). We expect sysfs to be present and mounted at /sys/.
1103          */
1104
1105         dir = xopendir(i2cdev_path);
1106         while ((de = readdir(dir))) {
1107                 if (de->d_name[0] == '.')
1108                         continue;
1109
1110                 /* Simple version for ISA chips. */
1111                 snprintf(path, NAME_MAX, "%s/%s/name",
1112                          i2cdev_path, de->d_name);
1113                 fp = fopen(path, "r");
1114                 if (fp == NULL) {
1115                         snprintf(path, NAME_MAX,
1116                                  "%s/%s/device/name",
1117                                  i2cdev_path, de->d_name);
1118                         fp = fopen(path, "r");
1119                 }
1120
1121                 /* Non-ISA chips require the hard-way. */
1122                 if (fp == NULL) {
1123                         snprintf(path, NAME_MAX,
1124                                  "%s/%s/device/name",
1125                                  i2cdev_path, de->d_name);
1126                         subdir = opendir(path);
1127                         if (subdir == NULL)
1128                                 continue;
1129
1130                         while ((subde = readdir(subdir))) {
1131                                 if (subde->d_name[0] == '.')
1132                                         continue;
1133
1134                                 if (is_prefixed_with(subde->d_name, "i2c-")) {
1135                                         snprintf(path, NAME_MAX,
1136                                                  "%s/%s/device/%s/name",
1137                                                  i2cdev_path, de->d_name,
1138                                                  subde->d_name);
1139                                         fp = fopen(path, "r");
1140                                         break;
1141                                 }
1142                         }
1143                 }
1144
1145                 if (fp != NULL) {
1146                         /*
1147                          * Get the rest of the info and display a line
1148                          * for a single bus.
1149                          */
1150                         memset(name, 0, sizeof(name));
1151                         pos = fgets(name, sizeof(name), fp);
1152                         fclose(fp);
1153                         if (pos == NULL)
1154                                 continue;
1155
1156                         pos = strchr(name, '\n');
1157                         if (pos != NULL)
1158                                 *pos = '\0';
1159
1160                         rv = sscanf(de->d_name, "i2c-%d", &bus);
1161                         if (rv != 1)
1162                                 continue;
1163
1164                         if (is_prefixed_with(name, "ISA"))
1165                                 adt = ADT_ISA;
1166                         else
1167                                 adt = i2cdetect_get_funcs(bus);
1168
1169                         printf(
1170                                 "i2c-%d\t%-10s\t%-32s\t%s\n",
1171                                 bus, adap_descs[adt].funcs,
1172                                 name, adap_descs[adt].algo);
1173                 }
1174         }
1175
1176         exit(EXIT_SUCCESS);
1177 }
1178
1179 static void NORETURN no_support(const char *cmd)
1180 {
1181         bb_error_msg_and_die("bus doesn't support %s", cmd);
1182 }
1183
1184 static void will_skip(const char *cmd)
1185 {
1186         bb_error_msg(
1187                 "warning: can't use %s command, "
1188                 "will skip some addresses", cmd);
1189 }
1190
1191 //usage:#define i2cdetect_trivial_usage
1192 //usage:       "[-F I2CBUS] [-l] [-y] [-a] [-q|-r] I2CBUS [FIRST LAST]"
1193 //usage:#define i2cdetect_full_usage "\n\n"
1194 //usage:       "Detect I2C chips.\n"
1195 //usage:     "\n        I2CBUS  i2c bus number"
1196 //usage:     "\n        FIRST and LAST limit the probing range"
1197 //usage:     "\n"
1198 //usage:     "\n        -l      output list of installed busses"
1199 //usage:     "\n        -y      disable interactive mode"
1200 //usage:     "\n        -a      force scanning of non-regular addresses"
1201 //usage:     "\n        -q      use smbus quick write commands for probing (default)"
1202 //usage:     "\n        -r      use smbus read byte commands for probing"
1203 //usage:     "\n        -F      display list of functionalities"
1204 int i2cdetect_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1205 int i2cdetect_main(int argc UNUSED_PARAM, char **argv)
1206 {
1207         const unsigned opt_y = (1 << 0), opt_a = (1 << 1),
1208                               opt_q = (1 << 2), opt_r = (1 << 3),
1209                               opt_F = (1 << 4), opt_l = (1 << 5);
1210         const char *const optstr = "yaqrFl";
1211
1212         int fd, bus_num, i, j, mode = I2CDETECT_MODE_AUTO, status, cmd;
1213         unsigned first = 0x03, last = 0x77, opts;
1214         unsigned long funcs;
1215
1216         opt_complementary = "q--r:r--q:" /* mutually exclusive */
1217                         "?3"; /* up to 3 args */
1218         opts = getopt32(argv, optstr);
1219         argv += optind;
1220
1221         if (opts & opt_l)
1222                 list_i2c_busses_and_exit();
1223
1224         if (!argv[0])
1225                 bb_show_usage();
1226
1227         bus_num = i2c_bus_lookup(argv[0]);
1228         fd = i2c_dev_open(bus_num);
1229         get_funcs_matrix(fd, &funcs);
1230
1231         if (opts & opt_F) {
1232                 /* Only list the functionalities. */
1233                 printf("Functionalities implemented by bus #%d\n", bus_num);
1234                 for (i = 0; i2c_funcs_tab[i].value; i++) {
1235                         printf("%-32s %s\n", i2c_funcs_tab[i].name,
1236                                funcs & i2c_funcs_tab[i].value ? "yes" : "no");
1237                 }
1238
1239                 return EXIT_SUCCESS;
1240         }
1241
1242         if (opts & opt_r)
1243                 mode = I2CDETECT_MODE_READ;
1244         else if (opts & opt_q)
1245                 mode = I2CDETECT_MODE_QUICK;
1246
1247         if (opts & opt_a) {
1248                 first = 0x00;
1249                 last = 0x7f;
1250         }
1251
1252         /* Read address range. */
1253         if (argv[1]) {
1254                 first = xstrtou_range(argv[1], 16, first, last);
1255                 if (argv[2])
1256                         last = xstrtou_range(argv[2], 16, first, last);
1257         }
1258
1259         if (!(funcs & (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_READ_BYTE))) {
1260                 no_support("detection commands");
1261         } else
1262         if (mode == I2CDETECT_MODE_QUICK && !(funcs & I2C_FUNC_SMBUS_QUICK)) {
1263                 no_support("SMBus quick write");
1264         } else
1265         if (mode == I2CDETECT_MODE_READ && !(funcs & I2C_FUNC_SMBUS_READ_BYTE)) {
1266                 no_support("SMBus receive byte");
1267         }
1268
1269         if (mode == I2CDETECT_MODE_AUTO) {
1270                 if (!(funcs & I2C_FUNC_SMBUS_QUICK))
1271                         will_skip("SMBus quick write");
1272                 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE))
1273                         will_skip("SMBus receive byte");
1274         }
1275
1276         if (!(opts & opt_y))
1277                 confirm_action(-1, -1, -1, 0);
1278
1279         puts("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f");
1280         for (i = 0; i < 128; i += 16) {
1281                 printf("%02x: ", i);
1282                 for (j = 0; j < 16; j++) {
1283                         fflush_all();
1284
1285                         cmd = mode;
1286                         if (mode == I2CDETECT_MODE_AUTO) {
1287                                 if ((i+j >= 0x30 && i+j <= 0x37) ||
1288                                     (i+j >= 0x50 && i+j <= 0x5F))
1289                                         cmd = I2CDETECT_MODE_READ;
1290                                 else
1291                                         cmd = I2CDETECT_MODE_QUICK;
1292                         }
1293
1294                         /* Skip unwanted addresses. */
1295                         if (i+j < first
1296                          || i+j > last
1297                          || (cmd == I2CDETECT_MODE_READ && !(funcs & I2C_FUNC_SMBUS_READ_BYTE))
1298                          || (cmd == I2CDETECT_MODE_QUICK && !(funcs & I2C_FUNC_SMBUS_QUICK)))
1299                         {
1300                                 printf("   ");
1301                                 continue;
1302                         }
1303
1304                         status = ioctl(fd, I2C_SLAVE, itoptr(i + j));
1305                         if (status < 0) {
1306                                 if (errno == EBUSY) {
1307                                         printf("UU ");
1308                                         continue;
1309                                 }
1310
1311                                 bb_perror_msg_and_die(
1312                                         "can't set address to 0x%02x", i + j);
1313                         }
1314
1315                         switch (cmd) {
1316                         case I2CDETECT_MODE_READ:
1317                                 /*
1318                                  * This is known to lock SMBus on various
1319                                  * write-only chips (mainly clock chips).
1320                                  */
1321                                 status = i2c_smbus_read_byte(fd);
1322                                 break;
1323                         default: /* I2CDETECT_MODE_QUICK: */
1324                                 /*
1325                                  * This is known to corrupt the Atmel
1326                                  * AT24RF08 EEPROM.
1327                                  */
1328                                 status = i2c_smbus_write_quick(fd,
1329                                                                I2C_SMBUS_WRITE);
1330                                 break;
1331                         }
1332
1333                         if (status < 0)
1334                                 printf("-- ");
1335                         else
1336                                 printf("%02x ", i+j);
1337                 }
1338                 bb_putchar('\n');
1339         }
1340
1341         return 0;
1342 }
1343 #endif /* ENABLE_I2CDETECT */