usr.sbin/i2c/i2c.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (C) 2008-2009 Semihalf, Michal Hajduk and Bartlomiej Sieka
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <assert.h>
  33 #include <ctype.h>
  34 #include <err.h>
  35 #include <errno.h>
  36 #include <sysexits.h>
  37 #include <fcntl.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <unistd.h>
  42 #include <sys/endian.h>
  43 #include <sys/ioctl.h>
  44
  45 #include <dev/iicbus/iic.h>
  46
  47 #define I2C_DEV                 "/dev/iic0"
  48 #define I2C_MODE_NOTSET         0
  49 #define I2C_MODE_NONE           1
  50 #define I2C_MODE_STOP_START     2
  51 #define I2C_MODE_REPEATED_START 3
  52 #define I2C_MODE_TRANSFER       4
  53
  54 struct options {
  55         const char      *width;
  56         unsigned        count;
  57         int             verbose;
  58         int             binary;
  59         const char      *skip;
  60         int             mode;
  61         char            dir;
  62         uint32_t        addr;
  63         uint32_t        off;
  64         uint8_t         off_buf[2];
  65         size_t          off_len;
  66 };
  67
  68 #define N_FDCACHE 128
  69 static int fd_cache[N_FDCACHE];
  70
  71 __dead2 static void
  72 usage(const char *msg)
  73 {
  74
  75         if (msg != NULL)
  76                 fprintf(stderr, "%s\n", msg);
  77         fprintf(stderr, "usage: %s -a addr [-f device] [-d [r|w]] [-o offset] "
  78             "[-w [0|8|16|16LE|16BE]] [-c count] [-m [tr|ss|rs|no]] [-b] [-v]\n",
  79             getprogname());
  80         fprintf(stderr, "       %s -s [-f device] [-n skip_addr] -v\n",
  81             getprogname());
  82         fprintf(stderr, "       %s -r [-f device] -v\n", getprogname());
  83         exit(EX_USAGE);
  84 }
  85
  86 static int
  87 i2c_do_stop(int fd)
  88 {
  89         int i;
  90
  91         i = ioctl(fd, I2CSTOP);
  92         if (i < 0)
  93                 fprintf(stderr, "ioctl: error sending stop condition: %s\n",
  94                     strerror(errno));
  95         return (i);
  96 }
  97
  98 static int
  99 i2c_do_start(int fd, struct iiccmd *cmd)
 100 {
 101         int i;
 102
 103         i = ioctl(fd, I2CSTART, cmd);
 104         if (i < 0)
 105                 fprintf(stderr, "ioctl: error sending start condition: %s\n",
 106                     strerror(errno));
 107         return (i);
 108 }
 109
 110 static int
 111 i2c_do_repeatstart(int fd, struct iiccmd *cmd)
 112 {
 113         int i;
 114
 115         i = ioctl(fd, I2CRPTSTART, cmd);
 116         if (i < 0)
 117                 fprintf(stderr, "ioctl: error sending repeated start: %s\n",
 118                     strerror(errno));
 119         return (i);
 120 }
 121
 122 static int
 123 i2c_do_write(int fd, struct iiccmd *cmd)
 124 {
 125         int i;
 126
 127         i = ioctl(fd, I2CWRITE, cmd);
 128         if (i < 0)
 129                 fprintf(stderr, "ioctl: error writing: %s\n",
 130                     strerror(errno));
 131         return (i);
 132 }
 133
 134 static int
 135 i2c_do_read(int fd, struct iiccmd *cmd)
 136 {
 137         int i;
 138
 139         i = ioctl(fd, I2CREAD, cmd);
 140         if (i < 0)
 141                 fprintf(stderr, "ioctl: error reading: %s\n",
 142                     strerror(errno));
 143         return (i);
 144 }
 145
 146 static int
 147 i2c_do_reset(int fd)
 148 {
 149         struct iiccmd cmd;
 150         int i;
 151
 152         memset(&cmd, 0, sizeof cmd);
 153         i = ioctl(fd, I2CRSTCARD, &cmd);
 154         if (i < 0)
 155                 fprintf(stderr, "ioctl: error resetting controller: %s\n",
 156                     strerror(errno));
 157         return (i);
 158 }
 159
 160 static void
 161 parse_skip(const char *skip, char blacklist[128])
 162 {
 163         const char *p;
 164         unsigned x, y;
 165
 166         for (p = skip; *p != '\0';) {
 167                 if (*p == '0' && p[1] == 'x')
 168                         p += 2;
 169                 if (!isxdigit(*p))
 170                         usage("Bad -n argument, expected (first) hex-digit");
 171                 x = digittoint(*p++) << 4;
 172                 if (!isxdigit(*p))
 173                         usage("Bad -n argument, expected (second) hex-digit");
 174                 x |= digittoint(*p++);
 175                 if (x == 0 || x > 0x7f)
 176                         usage("Bad -n argument, (01..7f)");
 177                 if (*p == ':' || *p == ',' || *p == '\0') {
 178                         blacklist[x] = 1;
 179                         if (*p != '\0')
 180                                 p++;
 181                         continue;
 182                 }
 183                 if (*p == '-') {
 184                         p++;
 185                 } else if (*p == '.' && p[1] == '.') {
 186                         p += 2;
 187                 } else {
 188                         usage("Bad -n argument, ([:|,|..|-])");
 189                 }
 190                 if (*p == '0' && p[1] == 'x')
 191                         p += 2;
 192                 if (!isxdigit(*p))
 193                         usage("Bad -n argument, expected (first) hex-digit");
 194                 y = digittoint(*p++) << 4;
 195                 if (!isxdigit(*p))
 196                         usage("Bad -n argument, expected (second) hex-digit");
 197                 y |= digittoint(*p++);
 198                 if (y == 0 || y > 0x7f)
 199                         usage("Bad -n argument, (01..7f)");
 200                 if (y < x)
 201                         usage("Bad -n argument, (end < start)");
 202                 for (;x <= y; x++)
 203                         blacklist[x] = 1;
 204                 if (*p == ':' || *p == ',')
 205                         p++;
 206         }
 207 }
 208
 209 static int
 210 scan_bus(const char *dev, int fd, const char *skip, int verbose)
 211 {
 212         struct iiccmd cmd;
 213         struct iic_msg rdmsg;
 214         struct iic_rdwr_data rdwrdata;
 215         int error;
 216         unsigned u;
 217         int num_found = 0, use_read_xfer;
 218         uint8_t rdbyte;
 219         char blacklist[128];
 220         const char *sep = "";
 221
 222         memset(blacklist, 0, sizeof blacklist);
 223
 224         if (skip != NULL)
 225                 parse_skip(skip, blacklist);
 226
 227         for (use_read_xfer = 0; use_read_xfer < 2; use_read_xfer++) {
 228                 for (u = 1; u < 127; u++) {
 229                         if (blacklist[u])
 230                                 continue;
 231
 232                         cmd.slave = u << 1;
 233                         cmd.last = 1;
 234                         cmd.count = 0;
 235                         if (i2c_do_reset(fd))
 236                                 return (EX_NOINPUT);
 237
 238                         if (use_read_xfer) {
 239                                 rdmsg.buf = &rdbyte;
 240                                 rdmsg.len = 1;
 241                                 rdmsg.flags = IIC_M_RD;
 242                                 rdmsg.slave = u << 1;
 243                                 rdwrdata.msgs = &rdmsg;
 244                                 rdwrdata.nmsgs = 1;
 245                                 error = ioctl(fd, I2CRDWR, &rdwrdata);
 246                         } else {
 247                                 error = ioctl(fd, I2CSTART, &cmd);
 248                                 if (errno == ENODEV || errno == EOPNOTSUPP)
 249                                         break; /* Try reads instead */
 250                                 (void)ioctl(fd, I2CSTOP);
 251                         }
 252                         if (error == 0) {
 253                                 if (!num_found++ && verbose) {
 254                                         fprintf(stderr,
 255                                             "Scanning I2C devices on %s:\n",
 256                                             dev);
 257                                 }
 258                                 printf("%s%02x", sep, u);
 259                                 sep = " ";
 260                         }
 261                 }
 262                 if (num_found > 0)
 263                         break;
 264                 if (verbose && !use_read_xfer)
 265                         fprintf(stderr,
 266                             "Hardware may not support START/STOP scanning; "
 267                             "trying less-reliable read method.\n");
 268         }
 269         if (num_found == 0 && verbose)
 270                 printf("<Nothing Found>");
 271
 272         printf("\n");
 273
 274         return (i2c_do_reset(fd));
 275 }
 276
 277 static int
 278 reset_bus(const char *dev, int fd, int verbose)
 279 {
 280
 281         if (verbose)
 282                 fprintf(stderr, "Resetting I2C controller on %s\n", dev);
 283         return (i2c_do_reset(fd));
 284 }
 285
 286 static const char *
 287 encode_offset(const char *width, unsigned offset, uint8_t *dst, size_t *len)
 288 {
 289
 290         if (!strcmp(width, "0")) {
 291                 *len = 0;
 292                 return (NULL);
 293         }
 294         if (!strcmp(width, "8")) {
 295                 if (offset > 0xff)
 296                         return ("Invalid 8-bit offset\n");
 297                 *dst = offset;
 298                 *len = 1;
 299                 return (NULL);
 300         }
 301         if (offset > 0xffff)
 302                 return ("Invalid 16-bit offset\n");
 303         if (!strcmp(width, "16LE") || !strcmp(width, "16")) {
 304                 le16enc(dst, offset);
 305                 *len = 2;
 306                 return (NULL);
 307         }
 308         if (!strcmp(width, "16BE")) {
 309                 be16enc(dst, offset);
 310                 *len = 2;
 311                 return (NULL);
 312         }
 313         return ("Invalid offset width, must be: 0|8|16|16LE|16BE\n");
 314 }
 315
 316 static int
 317 write_offset(int fd, struct options i2c_opt, struct iiccmd *cmd)
 318 {
 319
 320         if (i2c_opt.off_len > 0) {
 321                 cmd->count = i2c_opt.off_len;
 322                 cmd->buf = (void*)i2c_opt.off_buf;
 323                 return (i2c_do_write(fd, cmd));
 324         }
 325         return (0);
 326 }
 327
 328 static int
 329 i2c_write(int fd, struct options i2c_opt, uint8_t *i2c_buf)
 330 {
 331         struct iiccmd cmd;
 332         char buf[i2c_opt.off_len + i2c_opt.count];
 333
 334         memset(&cmd, 0, sizeof(cmd));
 335         cmd.slave = i2c_opt.addr;
 336
 337         if (i2c_do_start(fd, &cmd))
 338                 return (i2c_do_stop(fd) | 1);
 339
 340         switch(i2c_opt.mode) {
 341         case I2C_MODE_STOP_START:
 342                 if (write_offset(fd, i2c_opt, &cmd))
 343                         return (i2c_do_stop(fd) | 1);
 344
 345                 if (i2c_do_stop(fd))
 346                         return (1);
 347
 348                 if (i2c_do_start(fd, &cmd))
 349                         return (i2c_do_stop(fd) | 1);
 350
 351                 /*
 352                  * Write the data
 353                  */
 354                 cmd.count = i2c_opt.count;
 355                 cmd.buf = (void*)i2c_buf;
 356                 cmd.last = 0;
 357                 if (i2c_do_write(fd, &cmd))
 358                         return (i2c_do_stop(fd) | 1);
 359                 break;
 360
 361         case I2C_MODE_REPEATED_START:
 362                 if (write_offset(fd, i2c_opt, &cmd))
 363                         return (i2c_do_stop(fd) | 1);
 364
 365                 if (i2c_do_repeatstart(fd, &cmd))
 366                         return (i2c_do_stop(fd) | 1);
 367
 368                 /*
 369                  * Write the data
 370                  */
 371                 cmd.count = i2c_opt.count;
 372                 cmd.buf = (void*)i2c_buf;
 373                 cmd.last = 0;
 374                 if (i2c_do_write(fd, &cmd))
 375                         return (i2c_do_stop(fd) | 1);
 376                 break;
 377
 378         case I2C_MODE_NONE: /* fall through */
 379         default:
 380                 memcpy(buf, i2c_opt.off_buf, i2c_opt.off_len);
 381                 memcpy(buf + i2c_opt.off_len, i2c_buf, i2c_opt.count);
 382                 /*
 383                  * Write offset and data
 384                  */
 385                 cmd.count = i2c_opt.off_len + i2c_opt.count;
 386                 cmd.buf = (void*)buf;
 387                 cmd.last = 0;
 388                 if (i2c_do_write(fd, &cmd))
 389                         return (i2c_do_stop(fd) | 1);
 390                 break;
 391         }
 392
 393         return (i2c_do_stop(fd));
 394 }
 395
 396 static int
 397 i2c_read(int fd, struct options i2c_opt, uint8_t *i2c_buf)
 398 {
 399         struct iiccmd cmd;
 400         char data = 0;
 401
 402         memset(&cmd, 0, sizeof(cmd));
 403         cmd.slave = i2c_opt.addr;
 404
 405         if (i2c_opt.off_len) {
 406                 cmd.count = 1;
 407                 cmd.last = 0;
 408                 cmd.buf = &data;
 409                 if (i2c_do_start(fd, &cmd))
 410                         return (i2c_do_stop(fd) | 1);
 411
 412                 if (write_offset(fd, i2c_opt, &cmd))
 413                         return (i2c_do_stop(fd) | 1);
 414
 415                 if (i2c_opt.mode == I2C_MODE_STOP_START && i2c_do_stop(fd))
 416                         return (1);
 417         }
 418         cmd.slave = i2c_opt.addr | 1;
 419         cmd.count = 1;
 420         cmd.last = 0;
 421         cmd.buf = &data;
 422         if (i2c_opt.mode == I2C_MODE_STOP_START || i2c_opt.off_len == 0) {
 423                 if (i2c_do_start(fd, &cmd))
 424                         return (i2c_do_stop(fd) | 1);
 425         } else if (i2c_opt.mode == I2C_MODE_REPEATED_START) {
 426                 if (i2c_do_repeatstart(fd, &cmd))
 427                         return (i2c_do_stop(fd) | 1);
 428         }
 429
 430         cmd.count = i2c_opt.count;
 431         cmd.buf = (void*)i2c_buf;
 432         cmd.last = 1;
 433         if (i2c_do_read(fd, &cmd))
 434                 return (i2c_do_stop(fd) | 1);
 435
 436         return (i2c_do_stop(fd));
 437 }
 438
 439 /*
 440  * i2c_rdwr_transfer() - use I2CRDWR to conduct a complete i2c transfer.
 441  *
 442  * Some i2c hardware is unable to provide direct control over START, REPEAT-
 443  * START, and STOP operations.  Such hardware can only perform a complete
 444  * START-<data>-STOP or START-<data>-REPEAT-START-<data>-STOP sequence as a
 445  * single operation.  The driver framework refers to this sequence as a
 446  * "transfer" so we call it "transfer mode".  We assemble either one or two
 447  * iic_msg structures to describe the IO operations, and hand them off to the
 448  * driver to be handled as a single transfer.
 449  */
 450 static int
 451 i2c_rdwr_transfer(int fd, struct options i2c_opt, uint8_t *i2c_buf)
 452 {
 453         struct iic_msg msgs[2], *msgp = msgs;
 454         struct iic_rdwr_data xfer;
 455         int flag = 0;
 456
 457         if (i2c_opt.off_len) {
 458                 msgp->flags = IIC_M_WR | IIC_M_NOSTOP;
 459                 msgp->slave = i2c_opt.addr;
 460                 msgp->buf   = i2c_opt.off_buf;
 461                 msgp->len   = i2c_opt.off_len;
 462                 msgp++;
 463                 flag = IIC_M_NOSTART;
 464         }
 465
 466         /*
 467          * If the transfer direction is write and we did a write of the offset
 468          * above, then we need to elide the start; this transfer is just more
 469          * writing that follows the one started above.  For a read, we always do
 470          * a start; if we did an offset write above it'll be a repeat-start
 471          * because of the NOSTOP flag used above.
 472          */
 473         if (i2c_opt.dir == 'w')
 474                 msgp->flags = IIC_M_WR | flag;
 475         else
 476                 msgp->flags = IIC_M_RD;
 477         msgp->slave = i2c_opt.addr;
 478         msgp->len   = i2c_opt.count;
 479         msgp->buf   = i2c_buf;
 480         msgp++;
 481
 482         xfer.msgs = msgs;
 483         xfer.nmsgs = msgp - msgs;
 484
 485         if (ioctl(fd, I2CRDWR, &xfer) == -1 )
 486                 err(1, "ioctl(I2CRDWR) failed");
 487
 488         return (0);
 489 }
 490
 491 static int
 492 access_bus(int fd, struct options i2c_opt)
 493 {
 494         uint8_t i2c_buf[i2c_opt.count];
 495         int error;
 496         unsigned u, chunk_size = 16;
 497
 498         /*
 499          * For a write, read the data to be written to the chip from stdin.
 500          */
 501         if (i2c_opt.dir == 'w') {
 502                 if (i2c_opt.verbose && !i2c_opt.binary)
 503                         fprintf(stderr, "Enter %u bytes of data: ",
 504                             i2c_opt.count);
 505                 if (fread(i2c_buf, 1, i2c_opt.count, stdin) != i2c_opt.count)
 506                         err(1, "not enough data, exiting\n");
 507         }
 508
 509         if (i2c_opt.mode == I2C_MODE_TRANSFER)
 510                 error = i2c_rdwr_transfer(fd, i2c_opt, i2c_buf);
 511         else if (i2c_opt.dir == 'w')
 512                 error = i2c_write(fd, i2c_opt, i2c_buf);
 513         else
 514                 error = i2c_read(fd, i2c_opt, i2c_buf);
 515
 516         if (error == 0) {
 517                 if (i2c_opt.dir == 'r' && i2c_opt.binary) {
 518                         (void)fwrite(i2c_buf, 1, i2c_opt.count, stdout);
 519                 } else if (i2c_opt.verbose || i2c_opt.dir == 'r') {
 520                         if (i2c_opt.verbose)
 521                                 fprintf(stderr, "\nData %s (hex):\n",
 522                                     i2c_opt.dir == 'r' ?  "read" : "written");
 523
 524                         for (u = 0; u < i2c_opt.count; u++) {
 525                                 printf("%02hhx ", i2c_buf[u]);
 526                                 if ((u % chunk_size) == chunk_size - 1)
 527                                         printf("\n");
 528                         }
 529                         if ((u % chunk_size) != 0)
 530                                 printf("\n");
 531                 }
 532         }
 533
 534         return (error);
 535 }
 536
 537 static const char *widths[] = {
 538         "0",
 539         "8",
 540         "16LE",
 541         "16BE",
 542         "16",
 543         NULL,
 544 };
 545
 546 static int
 547 command_bus(struct options i2c_opt, char *cmd)
 548 {
 549         int error, fd;
 550         char devbuf[64];
 551         uint8_t dbuf[BUFSIZ];
 552         unsigned bus;
 553         const char *width = NULL;
 554         const char *err_msg;
 555         unsigned offset;
 556         unsigned u;
 557         size_t length;
 558
 559         while (isspace(*cmd))
 560                 cmd++;
 561
 562         switch(*cmd) {
 563         case 0:
 564         case '#':
 565                 return (0);
 566         case 'p':
 567         case 'P':
 568                 printf("%s", cmd);
 569                 return (0);
 570         case 'r':
 571         case 'R':
 572                 i2c_opt.dir = 'r';
 573                 break;
 574         case 'w':
 575         case 'W':
 576                 i2c_opt.dir = 'w';
 577                 break;
 578         default:
 579                 fprintf(stderr,
 580                     "Did not understand command: 0x%02x ", *cmd);
 581                 if (isgraph(*cmd))
 582                         fprintf(stderr, "'%c'", *cmd);
 583                 fprintf(stderr, "\n");
 584                 return(-1);
 585         }
 586         cmd++;
 587
 588         bus = strtoul(cmd, &cmd, 0);
 589         if (bus == 0 && errno == EINVAL) {
 590                 fprintf(stderr, "Could not translate bus number\n");
 591                 return(-1);
 592         }
 593
 594         i2c_opt.addr = strtoul(cmd, &cmd, 0);
 595         if (i2c_opt.addr == 0 && errno == EINVAL) {
 596                 fprintf(stderr, "Could not translate device\n");
 597                 return(-1);
 598         }
 599         if (i2c_opt.addr < 1 || i2c_opt.addr > 0x7f) {
 600                 fprintf(stderr, "Invalid device (0x%x)\n", i2c_opt.addr);
 601                 return(-1);
 602         }
 603         i2c_opt.addr <<= 1;
 604
 605         while(isspace(*cmd))
 606                 cmd++;
 607
 608         for(u = 0; widths[u]; u++) {
 609                 length = strlen(widths[u]);
 610                 if (memcmp(cmd, widths[u], length))
 611                         continue;
 612                 if (!isspace(cmd[length]))
 613                         continue;
 614                 width = widths[u];
 615                 cmd += length;
 616                 break;
 617         }
 618         if (width == NULL) {
 619                 fprintf(stderr, "Invalid width\n");
 620                 return(-1);
 621         }
 622
 623         offset = strtoul(cmd, &cmd, 0);
 624         if (offset == 0 && errno == EINVAL) {
 625                 fprintf(stderr, "Could not translate offset\n");
 626                 return(-1);
 627         }
 628
 629         err_msg = encode_offset(width, offset,
 630             i2c_opt.off_buf, &i2c_opt.off_len);
 631         if (err_msg) {
 632                 fprintf(stderr, "%s", err_msg);
 633                 return(-1);
 634         }
 635
 636         if (i2c_opt.dir == 'r') {
 637                 i2c_opt.count = strtoul(cmd, &cmd, 0);
 638                 if (i2c_opt.count == 0 && errno == EINVAL) {
 639                         fprintf(stderr, "Could not translate length\n");
 640                         return(-1);
 641                 }
 642         } else {
 643                 i2c_opt.count = 0;
 644                 while (1) {
 645                         while(isspace(*cmd))
 646                                 cmd++;
 647                         if (!*cmd)
 648                                 break;
 649                         if (!isxdigit(*cmd)) {
 650                                 fprintf(stderr, "Not a hex digit.\n");
 651                                 return(-1);
 652                         }
 653                         dbuf[i2c_opt.count] = digittoint(*cmd++) << 4;
 654                         while(isspace(*cmd))
 655                                 cmd++;
 656                         if (!*cmd) {
 657                                 fprintf(stderr,
 658                                     "Uneven number of hex digits.\n");
 659                                 return(-1);
 660                         }
 661                         if (!isxdigit(*cmd)) {
 662                                 fprintf(stderr, "Not a hex digit.\n");
 663                                 return(-1);
 664                         }
 665                         dbuf[i2c_opt.count++] |= digittoint(*cmd++);
 666                 }
 667         }
 668         assert(bus < N_FDCACHE);
 669         fd = fd_cache[bus];
 670         if (fd < 0) {
 671                 (void)sprintf(devbuf, "/dev/iic%u", bus);
 672                 fd = open(devbuf, O_RDWR);
 673                 if (fd == -1) {
 674                         fprintf(stderr, "Error opening I2C controller (%s): %s\n",
 675                             devbuf, strerror(errno));
 676                         return (EX_NOINPUT);
 677                 }
 678                 fd_cache[bus] = fd;
 679         }
 680
 681         error = i2c_rdwr_transfer(fd, i2c_opt, dbuf);
 682         if (error)
 683                 return(-1);
 684
 685         if (i2c_opt.dir == 'r') {
 686                 for (u = 0; u < i2c_opt.count; u++)
 687                         printf("%02x", dbuf[u]);
 688                 printf("\n");
 689         }
 690         return (0);
 691 }
 692
 693 static int
 694 exec_bus(struct options i2c_opt, char *cmd)
 695 {
 696         int error;
 697
 698         while (isspace(*cmd))
 699                 cmd++;
 700         if (*cmd == '#' || *cmd == '\0')
 701                 return (0);
 702         error = command_bus(i2c_opt, cmd);
 703         if (i2c_opt.verbose) {
 704                 (void)fflush(stderr);
 705                 printf(error ? "ERROR\n" : "OK\n");
 706                 error = 0;
 707         } else if (error) {
 708                 fprintf(stderr, "  in: %s", cmd);
 709         }
 710         (void)fflush(stdout);
 711         return (error);
 712 }
 713
 714 static int
 715 instruct_bus(struct options i2c_opt, int argc, char **argv)
 716 {
 717         char buf[BUFSIZ];
 718         int rd_cmds = (argc == 0);
 719         int error;
 720
 721         while (argc-- > 0) {
 722                 if (argc == 0 && !strcmp(*argv, "-")) {
 723                         rd_cmds = 1;
 724                 } else {
 725                         error = exec_bus(i2c_opt, *argv);
 726                         if (error)
 727                                 return (error);
 728                 }
 729                 argv++;
 730         }
 731         if (!rd_cmds)
 732                 return (0);
 733         while (fgets(buf, sizeof buf, stdin) != NULL) {
 734                 error = exec_bus(i2c_opt, buf);
 735                 if (error)
 736                         return (error);
 737         }
 738         return (0);
 739 }
 740
 741 int
 742 main(int argc, char** argv)
 743 {
 744         struct options i2c_opt;
 745         const char *dev, *err_msg;
 746         int fd, error = 0, ch;
 747         const char *optflags = "a:f:d:o:iw:c:m:n:sbvrh";
 748         char do_what = 0;
 749
 750         dev = I2C_DEV;
 751         for (ch = 0; ch < N_FDCACHE; ch++)
 752                 fd_cache[ch] = -1;
 753
 754         /* Default values */
 755         i2c_opt.off = 0;
 756         i2c_opt.verbose = 0;
 757         i2c_opt.dir = 'r';      /* direction = read */
 758         i2c_opt.width = "8";
 759         i2c_opt.count = 1;
 760         i2c_opt.binary = 0;     /* ASCII text output */
 761         i2c_opt.skip = NULL;    /* scan all addresses */
 762         i2c_opt.mode = I2C_MODE_TRANSFER;
 763
 764         /* Find out what we are going to do */
 765
 766         while ((ch = getopt(argc, argv, optflags)) != -1) {
 767                 switch(ch) {
 768                 case 'a':
 769                 case 'i':
 770                 case 'r':
 771                 case 's':
 772                         if (do_what)
 773                                 usage("Only one of [-a|-h|-r|-s]");
 774                         do_what = ch;
 775                         break;
 776                 case 'h':
 777                         usage("Help:");
 778                         break;
 779                 default:
 780                         break;
 781                 }
 782         }
 783
 784         /* Then handle the legal subset of arguments */
 785
 786         switch (do_what) {
 787         case 0: usage("Pick one of [-a|-h|-i|-r|-s]"); break;
 788         case 'a': optflags = "a:f:d:w:o:c:m:bv"; break;
 789         case 'i': optflags = "iv"; break;
 790         case 'r': optflags = "rf:v"; break;
 791         case 's': optflags = "sf:n:v"; break;
 792         default: assert("Bad do_what");
 793         }
 794
 795         optreset = 1;
 796         optind = 1;
 797
 798         while ((ch = getopt(argc, argv, optflags)) != -1) {
 799                 switch(ch) {
 800                 case 'a':
 801                         i2c_opt.addr = strtoul(optarg, 0, 16);
 802                         if (i2c_opt.addr == 0 && errno == EINVAL)
 803                                 usage("Bad -a argument (hex)");
 804                         if (i2c_opt.addr == 0 || i2c_opt.addr > 0x7f)
 805                                 usage("Bad -a argument (01..7f)");
 806                         i2c_opt.addr <<= 1;
 807                         break;
 808                 case 'b':
 809                         i2c_opt.binary = 1;
 810                         break;
 811                 case 'c':
 812                         i2c_opt.count = (strtoul(optarg, 0, 10));
 813                         if (i2c_opt.count == 0 && errno == EINVAL)
 814                                 usage("Bad -c argument (decimal)");
 815                         break;
 816                 case 'd':
 817                         if (strcmp(optarg, "r") && strcmp(optarg, "w"))
 818                                 usage("Bad -d argument ([r|w])");
 819                         i2c_opt.dir = optarg[0];
 820                         break;
 821                 case 'f':
 822                         dev = optarg;
 823                         break;
 824                 case 'i': break;
 825                 case 'm':
 826                         if (!strcmp(optarg, "no"))
 827                                 i2c_opt.mode = I2C_MODE_NONE;
 828                         else if (!strcmp(optarg, "ss"))
 829                                 i2c_opt.mode = I2C_MODE_STOP_START;
 830                         else if (!strcmp(optarg, "rs"))
 831                                 i2c_opt.mode = I2C_MODE_REPEATED_START;
 832                         else if (!strcmp(optarg, "tr"))
 833                                 i2c_opt.mode = I2C_MODE_TRANSFER;
 834                         else
 835                                 usage("Bad -m argument ([no|ss|rs|tr])");
 836                         break;
 837                 case 'n':
 838                         i2c_opt.skip = optarg;
 839                         break;
 840                 case 'o':
 841                         i2c_opt.off = strtoul(optarg, 0, 16);
 842                         if (i2c_opt.off == 0 && errno == EINVAL)
 843                                 usage("Bad -o argument (hex)");
 844                         break;
 845                 case 'r': break;
 846                 case 's': break;
 847                 case 'v':
 848                         i2c_opt.verbose = 1;
 849                         break;
 850                 case 'w':
 851                         i2c_opt.width = optarg;         // checked later.
 852                         break;
 853                 default:
 854                         fprintf(stderr, "Illegal -%c option", ch);
 855                         usage(NULL);
 856                 }
 857         }
 858         argc -= optind;
 859         argv += optind;
 860         if (do_what == 'i')
 861                 return(instruct_bus(i2c_opt, argc, argv));
 862         if (argc > 0)
 863                 usage("Too many arguments");
 864
 865         /* Set default mode if option -m is not specified */
 866         if (i2c_opt.mode == I2C_MODE_NOTSET) {
 867                 if (i2c_opt.dir == 'r')
 868                         i2c_opt.mode = I2C_MODE_STOP_START;
 869                 else if (i2c_opt.dir == 'w')
 870                         i2c_opt.mode = I2C_MODE_NONE;
 871         }
 872
 873         err_msg = encode_offset(i2c_opt.width, i2c_opt.off,
 874             i2c_opt.off_buf, &i2c_opt.off_len);
 875         if (err_msg != NULL) {
 876                 fprintf(stderr, "%s", err_msg);
 877                 return(EX_USAGE);
 878         }
 879
 880         if (i2c_opt.verbose)
 881                 fprintf(stderr, "dev: %s, addr: 0x%x, r/w: %c, "
 882                     "offset: 0x%02x, width: %s, count: %u\n", dev,
 883                     i2c_opt.addr >> 1, i2c_opt.dir, i2c_opt.off,
 884                     i2c_opt.width, i2c_opt.count);
 885
 886         fd = open(dev, O_RDWR);
 887         if (fd == -1) {
 888                 fprintf(stderr, "Error opening I2C controller (%s): %s\n",
 889                     dev, strerror(errno));
 890                 return (EX_NOINPUT);
 891         }
 892
 893         switch (do_what) {
 894         case 'a':
 895                 error = access_bus(fd, i2c_opt);
 896                 break;
 897         case 's':
 898                 error = scan_bus(dev, fd, i2c_opt.skip, i2c_opt.verbose);
 899                 break;
 900         case 'r':
 901                 error = reset_bus(dev, fd, i2c_opt.verbose);
 902                 break;
 903         default:
 904                 assert("Bad do_what");
 905         }
 906
 907         ch = close(fd);
 908         assert(ch == 0);
 909         return (error);
 910 }