1/*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 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 <err.h> 33#include <errno.h> 34#include <sysexits.h> 35#include <fcntl.h> 36#include <stdio.h> 37#include <stdlib.h> 38#include <string.h> 39#include <stdarg.h> 40#include <unistd.h> 41#include <sys/ioctl.h> 42 43#include <dev/iicbus/iic.h> 44 45#define I2C_DEV "/dev/iic0" 46#define I2C_MODE_NOTSET 0 47#define I2C_MODE_NONE 1 48#define I2C_MODE_STOP_START 2 49#define I2C_MODE_REPEATED_START 3 50#define I2C_MODE_TRANSFER 4 51 52struct options { 53 int width; 54 int count; 55 int verbose; 56 int addr_set; 57 int binary; 58 int scan; 59 int skip; 60 int reset; 61 int mode; 62 char dir; 63 uint32_t addr; 64 uint32_t off; 65}; 66 67struct skip_range { 68 int start; 69 int end; 70}; 71 72__dead2 static void 73usage(void) 74{ 75 76 fprintf(stderr, "usage: %s -a addr [-f device] [-d [r|w]] [-o offset] " 77 "[-w [0|8|16]] [-c count] [-m [tr|ss|rs|no]] [-b] [-v]\n", 78 getprogname()); 79 fprintf(stderr, " %s -s [-f device] [-n skip_addr] -v\n", 80 getprogname()); 81 fprintf(stderr, " %s -r [-f device] -v\n", getprogname()); 82 exit(EX_USAGE); 83} 84 85static struct skip_range 86skip_get_range(char *skip_addr) 87{ 88 struct skip_range addr_range; 89 char *token; 90 91 addr_range.start = 0; 92 addr_range.end = 0; 93 94 token = strsep(&skip_addr, ".."); 95 if (token) { 96 addr_range.start = strtoul(token, 0, 16); 97 token = strsep(&skip_addr, ".."); 98 if ((token != NULL) && !atoi(token)) { 99 token = strsep(&skip_addr, ".."); 100 if (token) 101 addr_range.end = strtoul(token, 0, 16); 102 } 103 } 104 105 return (addr_range); 106} 107 108/* Parse the string to get hex 7 bits addresses */ 109static int 110skip_get_tokens(char *skip_addr, int *sk_addr, int max_index) 111{ 112 char *token; 113 int i; 114 115 for (i = 0; i < max_index; i++) { 116 token = strsep(&skip_addr, ":"); 117 if (token == NULL) 118 break; 119 sk_addr[i] = strtoul(token, 0, 16); 120 } 121 return (i); 122} 123 124static int 125scan_bus(struct iiccmd cmd, char *dev, int skip, char *skip_addr) 126{ 127 struct iic_msg rdmsg; 128 struct iic_rdwr_data rdwrdata; 129 struct skip_range addr_range = { 0, 0 }; 130 int *tokens, fd, error, i, index, j; 131 int len = 0, do_skip = 0, no_range = 1, num_found = 0, use_read_xfer = 0; 132 uint8_t rdbyte; 133 134 fd = open(dev, O_RDWR); 135 if (fd == -1) { 136 fprintf(stderr, "Error opening I2C controller (%s) for " 137 "scanning: %s\n", dev, strerror(errno)); 138 return (EX_NOINPUT); 139 } 140 141 if (skip) { 142 len = strlen(skip_addr); 143 if (strstr(skip_addr, "..") != NULL) { 144 addr_range = skip_get_range(skip_addr); 145 no_range = 0; 146 } else { 147 tokens = (int *)malloc((len / 2 + 1) * sizeof(int)); 148 if (tokens == NULL) { 149 fprintf(stderr, "Error allocating tokens " 150 "buffer\n"); 151 error = -1; 152 goto out; 153 } 154 index = skip_get_tokens(skip_addr, tokens, 155 len / 2 + 1); 156 } 157 158 if (!no_range && (addr_range.start > addr_range.end)) { 159 fprintf(stderr, "Skip address out of range\n"); 160 error = -1; 161 goto out; 162 } 163 } 164 165 printf("Scanning I2C devices on %s: ", dev); 166 167start_over: 168 if (use_read_xfer) { 169 fprintf(stderr, 170 "Hardware may not support START/STOP scanning; " 171 "trying less-reliable read method.\n"); 172 } 173 174 for (i = 1; i < 127; i++) { 175 176 if (skip && ( addr_range.start < addr_range.end)) { 177 if (i >= addr_range.start && i <= addr_range.end) 178 continue; 179 180 } else if (skip && no_range) 181 for (j = 0; j < index; j++) { 182 if (tokens[j] == i) { 183 do_skip = 1; 184 break; 185 } 186 } 187 188 if (do_skip) { 189 do_skip = 0; 190 continue; 191 } 192 193 cmd.slave = i << 1; 194 cmd.last = 1; 195 cmd.count = 0; 196 error = ioctl(fd, I2CRSTCARD, &cmd); 197 if (error) { 198 fprintf(stderr, "Controller reset failed\n"); 199 goto out; 200 } 201 if (use_read_xfer) { 202 rdmsg.buf = &rdbyte; 203 rdmsg.len = 1; 204 rdmsg.flags = IIC_M_RD; 205 rdmsg.slave = i << 1; 206 rdwrdata.msgs = &rdmsg; 207 rdwrdata.nmsgs = 1; 208 error = ioctl(fd, I2CRDWR, &rdwrdata); 209 } else { 210 cmd.slave = i << 1; 211 cmd.last = 1; 212 error = ioctl(fd, I2CSTART, &cmd); 213 if (errno == ENODEV || errno == EOPNOTSUPP) { 214 /* If START not supported try reading. */ 215 use_read_xfer = 1; 216 goto start_over; 217 } 218 ioctl(fd, I2CSTOP); 219 } 220 if (error == 0) { 221 ++num_found; 222 printf("%02x ", i); 223 } 224 } 225 226 /* 227 * If we found nothing, maybe START is not supported and returns a 228 * generic error code such as EIO or ENXIO, so try again using reads. 229 */ 230 if (num_found == 0) { 231 if (!use_read_xfer) { 232 use_read_xfer = 1; 233 goto start_over; 234 } 235 printf("<none found>"); 236 } 237 printf("\n"); 238 239 error = ioctl(fd, I2CRSTCARD, &cmd); 240out: 241 close(fd); 242 if (skip && no_range) 243 free(tokens); 244 245 if (error) { 246 fprintf(stderr, "Error scanning I2C controller (%s): %s\n", 247 dev, strerror(errno)); 248 return (EX_NOINPUT); 249 } else 250 return (EX_OK); 251} 252 253static int 254reset_bus(struct iiccmd cmd, char *dev) 255{ 256 int fd, error; 257 258 fd = open(dev, O_RDWR); 259 if (fd == -1) { 260 fprintf(stderr, "Error opening I2C controller (%s) for " 261 "resetting: %s\n", dev, strerror(errno)); 262 return (EX_NOINPUT); 263 } 264 265 printf("Resetting I2C controller on %s: ", dev); 266 error = ioctl(fd, I2CRSTCARD, &cmd); 267 close (fd); 268 269 if (error) { 270 printf("error: %s\n", strerror(errno)); 271 return (EX_IOERR); 272 } else { 273 printf("OK\n"); 274 return (EX_OK); 275 } 276} 277 278static char * 279prepare_buf(int size, uint32_t off) 280{ 281 char *buf; 282 283 buf = malloc(size); 284 if (buf == NULL) 285 return (buf); 286 287 if (size == 1) 288 buf[0] = off & 0xff; 289 else if (size == 2) { 290 buf[0] = (off >> 8) & 0xff; 291 buf[1] = off & 0xff; 292 } 293 294 return (buf); 295} 296 297static int 298i2c_write(char *dev, struct options i2c_opt, char *i2c_buf) 299{ 300 struct iiccmd cmd; 301 int error, fd, bufsize; 302 char *err_msg, *buf; 303 304 fd = open(dev, O_RDWR); 305 if (fd == -1) { 306 free(i2c_buf); 307 err(1, "open failed"); 308 } 309 310 cmd.slave = i2c_opt.addr; 311 error = ioctl(fd, I2CSTART, &cmd); 312 if (error == -1) { 313 err_msg = "ioctl: error sending start condition"; 314 goto err1; 315 } 316 317 if (i2c_opt.width) { 318 bufsize = i2c_opt.width / 8; 319 buf = prepare_buf(bufsize, i2c_opt.off); 320 if (buf == NULL) { 321 err_msg = "error: offset malloc"; 322 goto err1; 323 } 324 } else { 325 bufsize = 0; 326 buf = NULL; 327 } 328 329 switch(i2c_opt.mode) { 330 case I2C_MODE_STOP_START: 331 /* 332 * Write offset where the data will go 333 */ 334 if (i2c_opt.width) { 335 cmd.count = bufsize; 336 cmd.buf = buf; 337 error = ioctl(fd, I2CWRITE, &cmd); 338 free(buf); 339 if (error == -1) { 340 err_msg = "ioctl: error writing offset"; 341 goto err1; 342 } 343 } 344 345 error = ioctl(fd, I2CSTOP); 346 if (error == -1) { 347 err_msg = "ioctl: error sending stop condition"; 348 goto err2; 349 } 350 cmd.slave = i2c_opt.addr; 351 error = ioctl(fd, I2CSTART, &cmd); 352 if (error == -1) { 353 err_msg = "ioctl: error sending start condition"; 354 goto err1; 355 } 356 357 /* 358 * Write the data 359 */ 360 cmd.count = i2c_opt.count; 361 cmd.buf = i2c_buf; 362 cmd.last = 0; 363 error = ioctl(fd, I2CWRITE, &cmd); 364 if (error == -1) { 365 err_msg = "ioctl: error writing"; 366 goto err1; 367 } 368 break; 369 370 case I2C_MODE_REPEATED_START: 371 /* 372 * Write offset where the data will go 373 */ 374 if (i2c_opt.width) { 375 cmd.count = bufsize; 376 cmd.buf = buf; 377 error = ioctl(fd, I2CWRITE, &cmd); 378 free(buf); 379 if (error == -1) { 380 err_msg = "ioctl: error writing offset"; 381 goto err1; 382 } 383 } 384 385 cmd.slave = i2c_opt.addr; 386 error = ioctl(fd, I2CRPTSTART, &cmd); 387 if (error == -1) { 388 err_msg = "ioctl: error sending repeated start " 389 "condition"; 390 goto err1; 391 } 392 393 /* 394 * Write the data 395 */ 396 cmd.count = i2c_opt.count; 397 cmd.buf = i2c_buf; 398 cmd.last = 0; 399 error = ioctl(fd, I2CWRITE, &cmd); 400 if (error == -1) { 401 err_msg = "ioctl: error writing"; 402 goto err1; 403 } 404 break; 405 406 case I2C_MODE_NONE: /* fall through */ 407 default: 408 buf = realloc(buf, bufsize + i2c_opt.count); 409 if (buf == NULL) { 410 err_msg = "error: data malloc"; 411 goto err1; 412 } 413 414 memcpy(buf + bufsize, i2c_buf, i2c_opt.count); 415 /* 416 * Write offset and data 417 */ 418 cmd.count = bufsize + i2c_opt.count; 419 cmd.buf = buf; 420 cmd.last = 0; 421 error = ioctl(fd, I2CWRITE, &cmd); 422 free(buf); 423 if (error == -1) { 424 err_msg = "ioctl: error writing"; 425 goto err1; 426 } 427 break; 428 } 429 error = ioctl(fd, I2CSTOP); 430 if (error == -1) { 431 err_msg = "ioctl: error sending stop condition"; 432 goto err2; 433 } 434 435 close(fd); 436 return (0); 437 438err1: 439 error = ioctl(fd, I2CSTOP); 440 if (error == -1) 441 fprintf(stderr, "error sending stop condition\n"); 442err2: 443 if (err_msg) 444 fprintf(stderr, "%s\n", err_msg); 445 446 close(fd); 447 return (1); 448} 449 450static int 451i2c_read(char *dev, struct options i2c_opt, char *i2c_buf) 452{ 453 struct iiccmd cmd; 454 int fd, error, bufsize; 455 char *err_msg, data = 0, *buf; 456 457 fd = open(dev, O_RDWR); 458 if (fd == -1) 459 err(1, "open failed"); 460 461 bzero(&cmd, sizeof(cmd)); 462 463 if (i2c_opt.width) { 464 cmd.slave = i2c_opt.addr; 465 cmd.count = 1; 466 cmd.last = 0; 467 cmd.buf = &data; 468 error = ioctl(fd, I2CSTART, &cmd); 469 if (error == -1) { 470 err_msg = "ioctl: error sending start condition"; 471 goto err1; 472 } 473 bufsize = i2c_opt.width / 8; 474 buf = prepare_buf(bufsize, i2c_opt.off); 475 if (buf == NULL) { 476 err_msg = "error: offset malloc"; 477 goto err1; 478 } 479 480 cmd.count = bufsize; 481 cmd.buf = buf; 482 cmd.last = 0; 483 error = ioctl(fd, I2CWRITE, &cmd); 484 free(buf); 485 if (error == -1) { 486 err_msg = "ioctl: error writing offset"; 487 goto err1; 488 } 489 490 if (i2c_opt.mode == I2C_MODE_STOP_START) { 491 error = ioctl(fd, I2CSTOP); 492 if (error == -1) { 493 err_msg = "error sending stop condition"; 494 goto err2; 495 } 496 } 497 } 498 cmd.slave = i2c_opt.addr | 1; 499 cmd.count = 1; 500 cmd.last = 0; 501 cmd.buf = &data; 502 if (i2c_opt.mode == I2C_MODE_STOP_START || i2c_opt.width == 0) { 503 error = ioctl(fd, I2CSTART, &cmd); 504 if (error == -1) { 505 err_msg = "ioctl: error sending start condition"; 506 goto err2; 507 } 508 } else if (i2c_opt.mode == I2C_MODE_REPEATED_START) { 509 error = ioctl(fd, I2CRPTSTART, &cmd); 510 if (error == -1) { 511 err_msg = "ioctl: error sending repeated start " 512 "condition"; 513 goto err1; 514 } 515 } 516 517 cmd.count = i2c_opt.count; 518 cmd.buf = i2c_buf; 519 cmd.last = 1; 520 error = ioctl(fd, I2CREAD, &cmd); 521 if (error == -1) { 522 err_msg = "ioctl: error while reading"; 523 goto err1; 524 } 525 526 error = ioctl(fd, I2CSTOP); 527 if (error == -1) { 528 err_msg = "error sending stop condtion\n"; 529 goto err2; 530 } 531 532 close(fd); 533 return (0); 534 535err1: 536 error = ioctl(fd, I2CSTOP); 537 if (error == -1) 538 fprintf(stderr, "error sending stop condition\n"); 539err2: 540 if (err_msg) 541 fprintf(stderr, "%s\n", err_msg); 542 543 close(fd); 544 return (1); 545} 546 547/* 548 * i2c_rdwr_transfer() - use I2CRDWR to conduct a complete i2c transfer. 549 * 550 * Some i2c hardware is unable to provide direct control over START, REPEAT- 551 * START, and STOP operations. Such hardware can only perform a complete 552 * START-<data>-STOP or START-<data>-REPEAT-START-<data>-STOP sequence as a 553 * single operation. The driver framework refers to this sequence as a 554 * "transfer" so we call it "transfer mode". We assemble either one or two 555 * iic_msg structures to describe the IO operations, and hand them off to the 556 * driver to be handled as a single transfer. 557 */ 558static int 559i2c_rdwr_transfer(char *dev, struct options i2c_opt, char *i2c_buf) 560{ 561 struct iic_msg msgs[2]; 562 struct iic_rdwr_data xfer; 563 int fd, i; 564 union { 565 uint8_t buf[2]; 566 uint8_t off8; 567 uint16_t off16; 568 } off; 569 570 i = 0; 571 if (i2c_opt.width > 0) { 572 msgs[i].flags = IIC_M_WR | IIC_M_NOSTOP; 573 msgs[i].slave = i2c_opt.addr; 574 msgs[i].buf = off.buf; 575 if (i2c_opt.width == 8) { 576 off.off8 = (uint8_t)i2c_opt.off; 577 msgs[i].len = 1; 578 } else { 579 off.off16 = (uint16_t)i2c_opt.off; 580 msgs[i].len = 2; 581 } 582 ++i; 583 } 584 585 /* 586 * If the transfer direction is write and we did a write of the offset 587 * above, then we need to elide the start; this transfer is just more 588 * writing that follows the one started above. For a read, we always do 589 * a start; if we did an offset write above it'll be a repeat-start 590 * because of the NOSTOP flag used above. 591 */ 592 if (i2c_opt.dir == 'w') 593 msgs[i].flags = IIC_M_WR | ((i > 0) ? IIC_M_NOSTART : 0); 594 else 595 msgs[i].flags = IIC_M_RD; 596 msgs[i].slave = i2c_opt.addr; 597 msgs[i].len = i2c_opt.count; 598 msgs[i].buf = i2c_buf; 599 ++i; 600 601 xfer.msgs = msgs; 602 xfer.nmsgs = i; 603 604 if ((fd = open(dev, O_RDWR)) == -1) 605 err(1, "open(%s) failed", dev); 606 if (ioctl(fd, I2CRDWR, &xfer) == -1 ) 607 err(1, "ioctl(I2CRDWR) failed"); 608 close(fd); 609 610 return (0); 611} 612 613int 614main(int argc, char** argv) 615{ 616 struct iiccmd cmd; 617 struct options i2c_opt; 618 char *dev, *skip_addr, *i2c_buf; 619 int error, chunk_size, i, j, ch; 620 621 errno = 0; 622 error = 0; 623 624 /* Line-break the output every chunk_size bytes */ 625 chunk_size = 16; 626 627 dev = I2C_DEV; 628 629 /* Default values */ 630 i2c_opt.addr_set = 0; 631 i2c_opt.off = 0; 632 i2c_opt.verbose = 0; 633 i2c_opt.dir = 'r'; /* direction = read */ 634 i2c_opt.width = 8; 635 i2c_opt.count = 1; 636 i2c_opt.binary = 0; /* ASCII text output */ 637 i2c_opt.scan = 0; /* no bus scan */ 638 i2c_opt.skip = 0; /* scan all addresses */ 639 i2c_opt.reset = 0; /* no bus reset */ 640 i2c_opt.mode = I2C_MODE_NOTSET; 641 642 while ((ch = getopt(argc, argv, "a:f:d:o:w:c:m:n:sbvrh")) != -1) { 643 switch(ch) { 644 case 'a': 645 i2c_opt.addr = (strtoul(optarg, 0, 16) << 1); 646 if (i2c_opt.addr == 0 && errno == EINVAL) 647 i2c_opt.addr_set = 0; 648 else 649 i2c_opt.addr_set = 1; 650 break; 651 case 'f': 652 dev = optarg; 653 break; 654 case 'd': 655 i2c_opt.dir = optarg[0]; 656 break; 657 case 'o': 658 i2c_opt.off = strtoul(optarg, 0, 16); 659 if (i2c_opt.off == 0 && errno == EINVAL) 660 error = 1; 661 break; 662 case 'w': 663 i2c_opt.width = atoi(optarg); 664 break; 665 case 'c': 666 i2c_opt.count = atoi(optarg); 667 break; 668 case 'm': 669 if (!strcmp(optarg, "no")) 670 i2c_opt.mode = I2C_MODE_NONE; 671 else if (!strcmp(optarg, "ss")) 672 i2c_opt.mode = I2C_MODE_STOP_START; 673 else if (!strcmp(optarg, "rs")) 674 i2c_opt.mode = I2C_MODE_REPEATED_START; 675 else if (!strcmp(optarg, "tr")) 676 i2c_opt.mode = I2C_MODE_TRANSFER; 677 else 678 usage(); 679 break; 680 case 'n': 681 i2c_opt.skip = 1; 682 skip_addr = optarg; 683 break; 684 case 's': 685 i2c_opt.scan = 1; 686 break; 687 case 'b': 688 i2c_opt.binary = 1; 689 break; 690 case 'v': 691 i2c_opt.verbose = 1; 692 break; 693 case 'r': 694 i2c_opt.reset = 1; 695 break; 696 case 'h': 697 default: 698 usage(); 699 } 700 } 701 argc -= optind; 702 argv += optind; 703 704 /* Set default mode if option -m is not specified */ 705 if (i2c_opt.mode == I2C_MODE_NOTSET) { 706 if (i2c_opt.dir == 'r') 707 i2c_opt.mode = I2C_MODE_STOP_START; 708 else if (i2c_opt.dir == 'w') 709 i2c_opt.mode = I2C_MODE_NONE; 710 } 711 712 /* Basic sanity check of command line arguments */ 713 if (i2c_opt.scan) { 714 if (i2c_opt.addr_set) 715 usage(); 716 } else if (i2c_opt.reset) { 717 if (i2c_opt.addr_set) 718 usage(); 719 } else if (error) { 720 usage(); 721 } else if ((i2c_opt.dir == 'r' || i2c_opt.dir == 'w')) { 722 if ((i2c_opt.addr_set == 0) || 723 !(i2c_opt.width == 0 || i2c_opt.width == 8 || 724 i2c_opt.width == 16)) 725 usage(); 726 } 727 728 if (i2c_opt.verbose) 729 fprintf(stderr, "dev: %s, addr: 0x%x, r/w: %c, " 730 "offset: 0x%02x, width: %u, count: %u\n", dev, 731 i2c_opt.addr >> 1, i2c_opt.dir, i2c_opt.off, 732 i2c_opt.width, i2c_opt.count); 733 734 if (i2c_opt.scan) 735 exit(scan_bus(cmd, dev, i2c_opt.skip, skip_addr)); 736 737 if (i2c_opt.reset) 738 exit(reset_bus(cmd, dev)); 739 740 i2c_buf = malloc(i2c_opt.count); 741 if (i2c_buf == NULL) 742 err(1, "data malloc"); 743 744 /* 745 * For a write, read the data to be written to the chip from stdin. 746 */ 747 if (i2c_opt.dir == 'w') { 748 if (i2c_opt.verbose && !i2c_opt.binary) 749 fprintf(stderr, "Enter %u bytes of data: ", 750 i2c_opt.count); 751 for (i = 0; i < i2c_opt.count; i++) { 752 ch = getchar(); 753 if (ch == EOF) { 754 free(i2c_buf); 755 err(1, "not enough data, exiting\n"); 756 } 757 i2c_buf[i] = ch; 758 } 759 } 760 761 if (i2c_opt.mode == I2C_MODE_TRANSFER) 762 error = i2c_rdwr_transfer(dev, i2c_opt, i2c_buf); 763 else if (i2c_opt.dir == 'w') 764 error = i2c_write(dev, i2c_opt, i2c_buf); 765 else 766 error = i2c_read(dev, i2c_opt, i2c_buf); 767 768 if (error != 0) { 769 free(i2c_buf); 770 return (1); 771 } 772 773 if (i2c_opt.verbose) 774 fprintf(stderr, "\nData %s (hex):\n", i2c_opt.dir == 'r' ? 775 "read" : "written"); 776 777 i = 0; 778 j = 0; 779 while (i < i2c_opt.count) { 780 if (i2c_opt.verbose || (i2c_opt.dir == 'r' && 781 !i2c_opt.binary)) 782 fprintf (stderr, "%02hhx ", i2c_buf[i++]); 783 784 if (i2c_opt.dir == 'r' && i2c_opt.binary) { 785 fprintf(stdout, "%c", i2c_buf[j++]); 786 if(!i2c_opt.verbose) 787 i++; 788 } 789 if (!i2c_opt.verbose && (i2c_opt.dir == 'w')) 790 break; 791 if ((i % chunk_size) == 0) 792 fprintf(stderr, "\n"); 793 } 794 if ((i % chunk_size) != 0) 795 fprintf(stderr, "\n"); 796 797 free(i2c_buf); 798 return (0); 799} 800