1/*-
2 * Copyright (C) 2008-2009 Semihalf, Michal Hajduk and Bartlomiej Sieka
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD$");
29
30#include <err.h>
31#include <errno.h>
32#include <sysexits.h>
33#include <fcntl.h>
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <stdarg.h>
38#include <unistd.h>
39#include <sys/ioctl.h>
40
41#include <dev/iicbus/iic.h>
42
43#define	I2C_DEV			"/dev/iic0"
44#define	I2C_MODE_NOTSET		0
45#define	I2C_MODE_NONE		1
46#define	I2C_MODE_STOP_START	2
47#define	I2C_MODE_REPEATED_START	3
48
49struct options {
50	int	width;
51	int	count;
52	int	verbose;
53	int	addr_set;
54	int	binary;
55	int	scan;
56	int	skip;
57	int	reset;
58	int	mode;
59	char	dir;
60	uint32_t	addr;
61	uint32_t	off;
62};
63
64struct skip_range {
65	int	start;
66	int	end;
67};
68
69__dead2 static void
70usage(void)
71{
72
73	fprintf(stderr, "usage: %s -a addr [-f device] [-d [r|w]] [-o offset] "
74	    "[-w [0|8|16]] [-c count] [-m [ss|rs|no]] [-b] [-v]\n",
75	    getprogname());
76	fprintf(stderr, "       %s -s [-f device] [-n skip_addr] -v\n",
77	    getprogname());
78	fprintf(stderr, "       %s -r [-f device] -v\n", getprogname());
79	exit(EX_USAGE);
80}
81
82static struct skip_range
83skip_get_range(char *skip_addr)
84{
85	struct skip_range addr_range;
86	char *token;
87
88	addr_range.start = 0;
89	addr_range.end = 0;
90
91	token = strsep(&skip_addr, "..");
92	if (token) {
93		addr_range.start = strtoul(token, 0, 16);
94		token = strsep(&skip_addr, "..");
95		if ((token != NULL) && !atoi(token)) {
96			token = strsep(&skip_addr, "..");
97			if (token)
98				addr_range.end = strtoul(token, 0, 16);
99		}
100	}
101
102	return (addr_range);
103}
104
105/* Parse the string to get hex 7 bits addresses */
106static int
107skip_get_tokens(char *skip_addr, int *sk_addr, int max_index)
108{
109	char *token;
110	int i;
111
112	for (i = 0; i < max_index; i++) {
113		token = strsep(&skip_addr, ":");
114		if (token == NULL)
115			break;
116		sk_addr[i] = strtoul(token, 0, 16);
117	}
118	return (i);
119}
120
121static int
122scan_bus(struct iiccmd cmd, char *dev, int skip, char *skip_addr)
123{
124	struct skip_range addr_range = { 0, 0 };
125	int *tokens, fd, error, i, index, j;
126	int len = 0, do_skip = 0, no_range = 1;
127
128	fd = open(dev, O_RDWR);
129	if (fd == -1) {
130		fprintf(stderr, "Error opening I2C controller (%s) for "
131		    "scanning: %s\n", dev, strerror(errno));
132		return (EX_NOINPUT);
133	}
134
135	if (skip) {
136		len = strlen(skip_addr);
137		if (strstr(skip_addr, "..") != NULL) {
138			addr_range = skip_get_range(skip_addr);
139			no_range = 0;
140		} else {
141			tokens = (int *)malloc((len / 2 + 1) * sizeof(int));
142			if (tokens == NULL) {
143				fprintf(stderr, "Error allocating tokens "
144				    "buffer\n");
145				goto out;
146			}
147			index = skip_get_tokens(skip_addr, tokens,
148			    len / 2 + 1);
149		}
150
151		if (!no_range && (addr_range.start > addr_range.end)) {
152			fprintf(stderr, "Skip address out of range\n");
153			goto out;
154		}
155	}
156
157	printf("Scanning I2C devices on %s: ", dev);
158	for (i = 1; i < 127; i++) {
159
160		if (skip && ( addr_range.start < addr_range.end)) {
161			if (i >= addr_range.start && i <= addr_range.end)
162				continue;
163
164		} else if (skip && no_range)
165			for (j = 0; j < index; j++) {
166				if (tokens[j] == i) {
167					do_skip = 1;
168					break;
169				}
170			}
171
172		if (do_skip) {
173			do_skip = 0;
174			continue;
175		}
176
177		cmd.slave = i << 1;
178		cmd.last = 1;
179		cmd.count = 0;
180		error = ioctl(fd, I2CRSTCARD, &cmd);
181		if (error)
182			goto out;
183
184		cmd.slave = i << 1;
185		cmd.last = 1;
186		error = ioctl(fd, I2CSTART, &cmd);
187		if (!error)
188			printf("%x ", i);
189		cmd.slave = i << 1;
190		cmd.last = 1;
191		error = ioctl(fd, I2CSTOP, &cmd);
192	}
193	printf("\n");
194
195	error = ioctl(fd, I2CRSTCARD, &cmd);
196out:
197	close(fd);
198	if (skip && no_range)
199		free(tokens);
200
201	if (error) {
202		fprintf(stderr, "Error scanning I2C controller (%s): %s\n",
203		    dev, strerror(errno));
204		return (EX_NOINPUT);
205	} else
206		return (EX_OK);
207}
208
209static int
210reset_bus(struct iiccmd cmd, char *dev)
211{
212	int fd, error;
213
214	fd = open(dev, O_RDWR);
215	if (fd == -1) {
216		fprintf(stderr, "Error opening I2C controller (%s) for "
217		    "resetting: %s\n", dev, strerror(errno));
218		return (EX_NOINPUT);
219	}
220
221	printf("Resetting I2C controller on %s: ", dev);
222	error = ioctl(fd, I2CRSTCARD, &cmd);
223	close (fd);
224
225	if (error) {
226		printf("error: %s\n", strerror(errno));
227		return (EX_IOERR);
228	} else {
229		printf("OK\n");
230		return (EX_OK);
231	}
232}
233
234static char *
235prepare_buf(int size, uint32_t off)
236{
237	char *buf;
238
239	buf = malloc(size);
240	if (buf == NULL)
241		return (buf);
242
243	if (size == 1)
244		buf[0] = off & 0xff;
245	else if (size == 2) {
246		buf[0] = (off >> 8) & 0xff;
247		buf[1] = off & 0xff;
248	}
249
250	return (buf);
251}
252
253static int
254i2c_write(char *dev, struct options i2c_opt, char *i2c_buf)
255{
256	struct iiccmd cmd;
257	int ch, i, error, fd, bufsize;
258	char *err_msg, *buf;
259
260	/*
261	 * Read data to be written to the chip from stdin
262	 */
263	if (i2c_opt.verbose && !i2c_opt.binary)
264		fprintf(stderr, "Enter %u bytes of data: ", i2c_opt.count);
265
266	for (i = 0; i < i2c_opt.count; i++) {
267		ch = getchar();
268		if (ch == EOF) {
269			free(i2c_buf);
270			err(1, "not enough data, exiting\n");
271		}
272		i2c_buf[i] = ch;
273	}
274
275	fd = open(dev, O_RDWR);
276	if (fd == -1) {
277		free(i2c_buf);
278		err(1, "open failed");
279	}
280
281	/*
282	 * Write offset where the data will go
283	 */
284	cmd.slave = i2c_opt.addr;
285	error = ioctl(fd, I2CSTART, &cmd);
286	if (error == -1) {
287		err_msg = "ioctl: error sending start condition";
288		goto err1;
289	}
290
291	if (i2c_opt.width) {
292		bufsize = i2c_opt.width / 8;
293		buf = prepare_buf(bufsize, i2c_opt.off);
294		if (buf == NULL) {
295			err_msg = "error: offset malloc";
296			goto err1;
297		}
298
299		cmd.count = bufsize;
300		cmd.buf = buf;
301		error = ioctl(fd, I2CWRITE, &cmd);
302		free(buf);
303		if (error == -1) {
304			err_msg = "ioctl: error when write offset";
305			goto err1;
306		}
307	}
308
309	/* Mode - stop start */
310	if (i2c_opt.mode == I2C_MODE_STOP_START) {
311		cmd.slave = i2c_opt.addr;
312		error = ioctl(fd, I2CSTOP, &cmd);
313		if (error == -1) {
314			err_msg = "ioctl: error sending stop condition";
315			goto err2;
316		}
317		cmd.slave = i2c_opt.addr;
318		error = ioctl(fd, I2CSTART, &cmd);
319		if (error == -1) {
320			err_msg = "ioctl: error sending start condition";
321			goto err1;
322		}
323	}
324	/* Mode - repeated start */
325	if (i2c_opt.mode == I2C_MODE_REPEATED_START) {
326		cmd.slave = i2c_opt.addr;
327		error = ioctl(fd, I2CRPTSTART, &cmd);
328		if (error == -1) {
329			err_msg = "ioctl: error sending repeated start "
330			    "condition";
331			goto err1;
332		}
333	}
334
335	/*
336	 * Write the data
337	 */
338	cmd.count = i2c_opt.count;
339	cmd.buf = i2c_buf;
340	cmd.last = 0;
341	error = ioctl(fd, I2CWRITE, &cmd);
342	if (error == -1) {
343		err_msg = "ioctl: error when write";
344		goto err1;
345	}
346	cmd.slave = i2c_opt.addr;
347	error = ioctl(fd, I2CSTOP, &cmd);
348	if (error == -1) {
349		err_msg = "ioctl: error sending stop condition";
350		goto err2;
351	}
352
353	close(fd);
354	return (0);
355
356err1:
357	cmd.slave = i2c_opt.addr;
358	error = ioctl(fd, I2CSTOP, &cmd);
359	if (error == -1)
360		fprintf(stderr, "error sending stop condtion\n");
361err2:
362	if (err_msg)
363		fprintf(stderr, "%s", err_msg);
364
365	close(fd);
366	return (1);
367}
368
369static int
370i2c_read(char *dev, struct options i2c_opt, char *i2c_buf)
371{
372	struct iiccmd cmd;
373	int i, fd, error, bufsize;
374	char *err_msg, data = 0, *buf;
375
376	fd = open(dev, O_RDWR);
377	if (fd == -1)
378		err(1, "open failed");
379
380	bzero(&cmd, sizeof(cmd));
381
382	if (i2c_opt.width) {
383		cmd.slave = i2c_opt.addr;
384		cmd.count = 1;
385		cmd.last = 0;
386		cmd.buf = &data;
387		error = ioctl(fd, I2CSTART, &cmd);
388		if (error == -1) {
389			err_msg = "ioctl: error sending start condition";
390			goto err1;
391		}
392		bufsize = i2c_opt.width / 8;
393		buf = prepare_buf(bufsize, i2c_opt.off);
394		if (buf == NULL) {
395			err_msg = "error: offset malloc";
396			goto err1;
397		}
398
399		cmd.count = bufsize;
400		cmd.buf = buf;
401		cmd.last = 0;
402		error = ioctl(fd, I2CWRITE, &cmd);
403		free(buf);
404		if (error == -1) {
405			err_msg = "ioctl: error when write offset";
406			goto err1;
407		}
408
409		if (i2c_opt.mode == I2C_MODE_STOP_START) {
410			cmd.slave = i2c_opt.addr;
411			error = ioctl(fd, I2CSTOP, &cmd);
412			if (error == -1)
413				goto err2;
414		}
415	}
416	cmd.slave = i2c_opt.addr;
417	cmd.count = 1;
418	cmd.last = 0;
419	cmd.buf = &data;
420	if (i2c_opt.mode == I2C_MODE_STOP_START) {
421		error = ioctl(fd, I2CSTART, &cmd);
422		if (error == -1) {
423			err_msg = "ioctl: error sending start condition";
424			goto err1;
425		}
426	} else if (i2c_opt.mode == I2C_MODE_REPEATED_START) {
427		error = ioctl(fd, I2CRPTSTART, &cmd);
428		if (error == -1) {
429			err_msg = "ioctl: error sending repeated start "
430			    "condition";
431			goto err1;
432		}
433	}
434	error = ioctl(fd, I2CSTOP, &cmd);
435	if (error == -1)
436		goto err2;
437
438	for (i = 0; i < i2c_opt.count; i++) {
439		error = read(fd, &i2c_buf[i], 1);
440		if (error == -1) {
441			err_msg = "ioctl: error while reading";
442			goto err1;
443		}
444	}
445
446	close(fd);
447	return (0);
448
449err1:
450	cmd.slave = i2c_opt.addr;
451	error = ioctl(fd, I2CSTOP, &cmd);
452	if (error == -1)
453		fprintf(stderr, "error sending stop condtion\n");
454err2:
455	if (err_msg)
456		fprintf(stderr, "%s", err_msg);
457
458	close(fd);
459	return (1);
460}
461
462int
463main(int argc, char** argv)
464{
465	struct iiccmd cmd;
466	struct options i2c_opt;
467	char *dev, *skip_addr, *err_msg, *i2c_buf;
468	int error, chunk_size, i, j, ch;
469
470	errno = 0;
471	error = 0;
472
473	/* Line-break the output every chunk_size bytes */
474	chunk_size = 16;
475
476	dev = I2C_DEV;
477	err_msg = NULL;
478
479	/* Default values */
480	i2c_opt.addr_set = 0;
481	i2c_opt.off = 0;
482	i2c_opt.verbose = 0;
483	i2c_opt.dir = 'r';	/* direction = read */
484	i2c_opt.width = 8;
485	i2c_opt.count = 1;
486	i2c_opt.binary = 0;	/* ASCII text output */
487	i2c_opt.scan = 0;	/* no bus scan */
488	i2c_opt.skip = 0;	/* scan all addresses */
489	i2c_opt.reset = 0;	/* no bus reset */
490	i2c_opt.mode = I2C_MODE_NOTSET;
491
492	while ((ch = getopt(argc, argv, "a:f:d:o:w:c:m:n:sbvrh")) != -1) {
493		switch(ch) {
494		case 'a':
495			i2c_opt.addr = (strtoul(optarg, 0, 16) << 1);
496			if (i2c_opt.addr == 0 && errno == EINVAL)
497				i2c_opt.addr_set = 0;
498			else
499				i2c_opt.addr_set = 1;
500			break;
501		case 'f':
502			dev = optarg;
503			break;
504		case 'd':
505			i2c_opt.dir = optarg[0];
506			break;
507		case 'o':
508			i2c_opt.off = strtoul(optarg, 0, 16);
509			if (i2c_opt.off == 0 && errno == EINVAL)
510				error = 1;
511			break;
512		case 'w':
513			i2c_opt.width = atoi(optarg);
514			break;
515		case 'c':
516			i2c_opt.count = atoi(optarg);
517			break;
518		case 'm':
519			if (!strcmp(optarg, "no"))
520				i2c_opt.mode = I2C_MODE_NONE;
521			else if (!strcmp(optarg, "ss"))
522				i2c_opt.mode = I2C_MODE_STOP_START;
523			else if (!strcmp(optarg, "rs"))
524				i2c_opt.mode = I2C_MODE_REPEATED_START;
525			else
526				usage();
527			break;
528		case 'n':
529			i2c_opt.skip = 1;
530			skip_addr = optarg;
531			break;
532		case 's':
533			i2c_opt.scan = 1;
534			break;
535		case 'b':
536			i2c_opt.binary = 1;
537			break;
538		case 'v':
539			i2c_opt.verbose = 1;
540			break;
541		case 'r':
542			i2c_opt.reset = 1;
543			break;
544		case 'h':
545		default:
546			usage();
547		}
548	}
549	argc -= optind;
550	argv += optind;
551
552	/* Set default mode if option -m is not specified */
553	if (i2c_opt.mode == I2C_MODE_NOTSET) {
554		if (i2c_opt.dir == 'r')
555			i2c_opt.mode = I2C_MODE_STOP_START;
556		else if (i2c_opt.dir == 'w')
557			i2c_opt.mode = I2C_MODE_NONE;
558	}
559
560	/* Basic sanity check of command line arguments */
561	if (i2c_opt.scan) {
562		if (i2c_opt.addr_set)
563			usage();
564	} else if (i2c_opt.reset) {
565		if (i2c_opt.addr_set)
566			usage();
567	} else if (error) {
568		usage();
569	} else if ((i2c_opt.dir == 'r' || i2c_opt.dir == 'w')) {
570		if ((i2c_opt.addr_set == 0) ||
571		    !(i2c_opt.width == 0 || i2c_opt.width == 8 ||
572		    i2c_opt.width == 16))
573		usage();
574	}
575
576	if (i2c_opt.verbose)
577		fprintf(stderr, "dev: %s, addr: 0x%x, r/w: %c, "
578		    "offset: 0x%02x, width: %u, count: %u\n", dev,
579		    i2c_opt.addr >> 1, i2c_opt.dir, i2c_opt.off,
580		    i2c_opt.width, i2c_opt.count);
581
582	if (i2c_opt.scan)
583		exit(scan_bus(cmd, dev, i2c_opt.skip, skip_addr));
584
585	if (i2c_opt.reset)
586		exit(reset_bus(cmd, dev));
587
588	i2c_buf = malloc(i2c_opt.count);
589	if (i2c_buf == NULL)
590		err(1, "data malloc");
591
592	if (i2c_opt.dir == 'w') {
593		error = i2c_write(dev, i2c_opt, i2c_buf);
594		if (error) {
595			free(i2c_buf);
596			return (1);
597		}
598	}
599	if (i2c_opt.dir == 'r') {
600		error = i2c_read(dev, i2c_opt, i2c_buf);
601		if (error) {
602			free(i2c_buf);
603			return (1);
604		}
605	}
606
607	if (i2c_opt.verbose)
608		fprintf(stderr, "\nData %s (hex):\n", i2c_opt.dir == 'r' ?
609		    "read" : "written");
610
611	i = 0;
612	j = 0;
613	while (i < i2c_opt.count) {
614		if (i2c_opt.verbose || (i2c_opt.dir == 'r' &&
615		    !i2c_opt.binary))
616			fprintf (stderr, "%02hhx ", i2c_buf[i++]);
617
618		if (i2c_opt.dir == 'r' && i2c_opt.binary) {
619			fprintf(stdout, "%c", i2c_buf[j++]);
620			if(!i2c_opt.verbose)
621				i++;
622		}
623		if (!i2c_opt.verbose && (i2c_opt.dir == 'w'))
624			break;
625		if ((i % chunk_size) == 0)
626			fprintf(stderr, "\n");
627	}
628	if ((i % chunk_size) != 0)
629		fprintf(stderr, "\n");
630
631	free(i2c_buf);
632	return (0);
633}
634