xref: /openbmc/linux/tools/spi/spidev_test.c (revision b229a7f5)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * SPI testing utility (using spidev driver)
4  *
5  * Copyright (c) 2007  MontaVista Software, Inc.
6  * Copyright (c) 2007  Anton Vorontsov <avorontsov@ru.mvista.com>
7  *
8  * Cross-compile with cross-gcc -I/path/to/cross-kernel/include
9  */
10 
11 #include <stdint.h>
12 #include <unistd.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <errno.h>
17 #include <getopt.h>
18 #include <fcntl.h>
19 #include <time.h>
20 #include <sys/ioctl.h>
21 #include <linux/ioctl.h>
22 #include <sys/stat.h>
23 #include <linux/types.h>
24 #include <linux/spi/spidev.h>
25 
26 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
27 
pabort(const char * s)28 static void pabort(const char *s)
29 {
30 	if (errno != 0)
31 		perror(s);
32 	else
33 		printf("%s\n", s);
34 
35 	abort();
36 }
37 
38 static const char *device = "/dev/spidev1.1";
39 static uint32_t mode;
40 static uint8_t bits = 8;
41 static char *input_file;
42 static char *output_file;
43 static uint32_t speed = 500000;
44 static uint16_t delay;
45 static int verbose;
46 static int transfer_size;
47 static int iterations;
48 static int interval = 5; /* interval in seconds for showing transfer rate */
49 
50 static uint8_t default_tx[] = {
51 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
52 	0x40, 0x00, 0x00, 0x00, 0x00, 0x95,
53 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
54 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
55 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
56 	0xF0, 0x0D,
57 };
58 
59 static uint8_t default_rx[ARRAY_SIZE(default_tx)] = {0, };
60 static char *input_tx;
61 
hex_dump(const void * src,size_t length,size_t line_size,char * prefix)62 static void hex_dump(const void *src, size_t length, size_t line_size,
63 		     char *prefix)
64 {
65 	int i = 0;
66 	const unsigned char *address = src;
67 	const unsigned char *line = address;
68 	unsigned char c;
69 
70 	printf("%s | ", prefix);
71 	while (length-- > 0) {
72 		printf("%02X ", *address++);
73 		if (!(++i % line_size) || (length == 0 && i % line_size)) {
74 			if (length == 0) {
75 				while (i++ % line_size)
76 					printf("__ ");
77 			}
78 			printf(" |");
79 			while (line < address) {
80 				c = *line++;
81 				printf("%c", (c < 32 || c > 126) ? '.' : c);
82 			}
83 			printf("|\n");
84 			if (length > 0)
85 				printf("%s | ", prefix);
86 		}
87 	}
88 }
89 
90 /*
91  *  Unescape - process hexadecimal escape character
92  *      converts shell input "\x23" -> 0x23
93  */
unescape(char * _dst,char * _src,size_t len)94 static int unescape(char *_dst, char *_src, size_t len)
95 {
96 	int ret = 0;
97 	int match;
98 	char *src = _src;
99 	char *dst = _dst;
100 	unsigned int ch;
101 
102 	while (*src) {
103 		if (*src == '\\' && *(src+1) == 'x') {
104 			match = sscanf(src + 2, "%2x", &ch);
105 			if (!match)
106 				pabort("malformed input string");
107 
108 			src += 4;
109 			*dst++ = (unsigned char)ch;
110 		} else {
111 			*dst++ = *src++;
112 		}
113 		ret++;
114 	}
115 	return ret;
116 }
117 
transfer(int fd,uint8_t const * tx,uint8_t const * rx,size_t len)118 static void transfer(int fd, uint8_t const *tx, uint8_t const *rx, size_t len)
119 {
120 	int ret;
121 	int out_fd;
122 	struct spi_ioc_transfer tr = {
123 		.tx_buf = (unsigned long)tx,
124 		.rx_buf = (unsigned long)rx,
125 		.len = len,
126 		.delay_usecs = delay,
127 		.speed_hz = speed,
128 		.bits_per_word = bits,
129 	};
130 
131 	if (mode & SPI_TX_OCTAL)
132 		tr.tx_nbits = 8;
133 	else if (mode & SPI_TX_QUAD)
134 		tr.tx_nbits = 4;
135 	else if (mode & SPI_TX_DUAL)
136 		tr.tx_nbits = 2;
137 	if (mode & SPI_RX_OCTAL)
138 		tr.rx_nbits = 8;
139 	else if (mode & SPI_RX_QUAD)
140 		tr.rx_nbits = 4;
141 	else if (mode & SPI_RX_DUAL)
142 		tr.rx_nbits = 2;
143 	if (!(mode & SPI_LOOP)) {
144 		if (mode & (SPI_TX_OCTAL | SPI_TX_QUAD | SPI_TX_DUAL))
145 			tr.rx_buf = 0;
146 		else if (mode & (SPI_RX_OCTAL | SPI_RX_QUAD | SPI_RX_DUAL))
147 			tr.tx_buf = 0;
148 	}
149 
150 	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
151 	if (ret < 1)
152 		pabort("can't send spi message");
153 
154 	if (verbose)
155 		hex_dump(tx, len, 32, "TX");
156 
157 	if (output_file) {
158 		out_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
159 		if (out_fd < 0)
160 			pabort("could not open output file");
161 
162 		ret = write(out_fd, rx, len);
163 		if (ret != len)
164 			pabort("not all bytes written to output file");
165 
166 		close(out_fd);
167 	}
168 
169 	if (verbose)
170 		hex_dump(rx, len, 32, "RX");
171 }
172 
print_usage(const char * prog)173 static void print_usage(const char *prog)
174 {
175 	printf("Usage: %s [-2348CDFHILMNORSZbdilopsv]\n", prog);
176 	puts("general device settings:\n"
177 		 "  -D --device         device to use (default /dev/spidev1.1)\n"
178 		 "  -s --speed          max speed (Hz)\n"
179 		 "  -d --delay          delay (usec)\n"
180 		 "  -l --loop           loopback\n"
181 		 "spi mode:\n"
182 		 "  -H --cpha           clock phase\n"
183 		 "  -O --cpol           clock polarity\n"
184 		 "  -F --rx-cpha-flip   flip CPHA on Rx only xfer\n"
185 		 "number of wires for transmission:\n"
186 		 "  -2 --dual           dual transfer\n"
187 		 "  -4 --quad           quad transfer\n"
188 		 "  -8 --octal          octal transfer\n"
189 		 "  -3 --3wire          SI/SO signals shared\n"
190 		 "  -Z --3wire-hiz      high impedance turnaround\n"
191 		 "data:\n"
192 		 "  -i --input          input data from a file (e.g. \"test.bin\")\n"
193 		 "  -o --output         output data to a file (e.g. \"results.bin\")\n"
194 		 "  -p                  Send data (e.g. \"1234\\xde\\xad\")\n"
195 		 "  -S --size           transfer size\n"
196 		 "  -I --iter           iterations\n"
197 		 "additional parameters:\n"
198 		 "  -b --bpw            bits per word\n"
199 		 "  -L --lsb            least significant bit first\n"
200 		 "  -C --cs-high        chip select active high\n"
201 		 "  -N --no-cs          no chip select\n"
202 		 "  -R --ready          slave pulls low to pause\n"
203 		 "  -M --mosi-idle-low  leave mosi line low when idle\n"
204 		 "misc:\n"
205 		 "  -v --verbose        Verbose (show tx buffer)\n");
206 	exit(1);
207 }
208 
parse_opts(int argc,char * argv[])209 static void parse_opts(int argc, char *argv[])
210 {
211 	while (1) {
212 		static const struct option lopts[] = {
213 			{ "device",        1, 0, 'D' },
214 			{ "speed",         1, 0, 's' },
215 			{ "delay",         1, 0, 'd' },
216 			{ "loop",          0, 0, 'l' },
217 			{ "cpha",          0, 0, 'H' },
218 			{ "cpol",          0, 0, 'O' },
219 			{ "rx-cpha-flip",  0, 0, 'F' },
220 			{ "dual",          0, 0, '2' },
221 			{ "quad",          0, 0, '4' },
222 			{ "octal",         0, 0, '8' },
223 			{ "3wire",         0, 0, '3' },
224 			{ "3wire-hiz",     0, 0, 'Z' },
225 			{ "input",         1, 0, 'i' },
226 			{ "output",        1, 0, 'o' },
227 			{ "size",          1, 0, 'S' },
228 			{ "iter",          1, 0, 'I' },
229 			{ "bpw",           1, 0, 'b' },
230 			{ "lsb",           0, 0, 'L' },
231 			{ "cs-high",       0, 0, 'C' },
232 			{ "no-cs",         0, 0, 'N' },
233 			{ "ready",         0, 0, 'R' },
234 			{ "mosi-idle-low", 0, 0, 'M' },
235 			{ "verbose",       0, 0, 'v' },
236 			{ NULL, 0, 0, 0 },
237 		};
238 		int c;
239 
240 		c = getopt_long(argc, argv, "D:s:d:b:i:o:lHOLC3ZFMNR248p:vS:I:",
241 				lopts, NULL);
242 
243 		if (c == -1)
244 			break;
245 
246 		switch (c) {
247 		case 'D':
248 			device = optarg;
249 			break;
250 		case 's':
251 			speed = atoi(optarg);
252 			break;
253 		case 'd':
254 			delay = atoi(optarg);
255 			break;
256 		case 'b':
257 			bits = atoi(optarg);
258 			break;
259 		case 'i':
260 			input_file = optarg;
261 			break;
262 		case 'o':
263 			output_file = optarg;
264 			break;
265 		case 'l':
266 			mode |= SPI_LOOP;
267 			break;
268 		case 'H':
269 			mode |= SPI_CPHA;
270 			break;
271 		case 'O':
272 			mode |= SPI_CPOL;
273 			break;
274 		case 'L':
275 			mode |= SPI_LSB_FIRST;
276 			break;
277 		case 'C':
278 			mode |= SPI_CS_HIGH;
279 			break;
280 		case '3':
281 			mode |= SPI_3WIRE;
282 			break;
283 		case 'Z':
284 			mode |= SPI_3WIRE_HIZ;
285 			break;
286 		case 'F':
287 			mode |= SPI_RX_CPHA_FLIP;
288 			break;
289 		case 'M':
290 			mode |= SPI_MOSI_IDLE_LOW;
291 			break;
292 		case 'N':
293 			mode |= SPI_NO_CS;
294 			break;
295 		case 'v':
296 			verbose = 1;
297 			break;
298 		case 'R':
299 			mode |= SPI_READY;
300 			break;
301 		case 'p':
302 			input_tx = optarg;
303 			break;
304 		case '2':
305 			mode |= SPI_TX_DUAL;
306 			break;
307 		case '4':
308 			mode |= SPI_TX_QUAD;
309 			break;
310 		case '8':
311 			mode |= SPI_TX_OCTAL;
312 			break;
313 		case 'S':
314 			transfer_size = atoi(optarg);
315 			break;
316 		case 'I':
317 			iterations = atoi(optarg);
318 			break;
319 		default:
320 			print_usage(argv[0]);
321 		}
322 	}
323 	if (mode & SPI_LOOP) {
324 		if (mode & SPI_TX_DUAL)
325 			mode |= SPI_RX_DUAL;
326 		if (mode & SPI_TX_QUAD)
327 			mode |= SPI_RX_QUAD;
328 		if (mode & SPI_TX_OCTAL)
329 			mode |= SPI_RX_OCTAL;
330 	}
331 }
332 
transfer_escaped_string(int fd,char * str)333 static void transfer_escaped_string(int fd, char *str)
334 {
335 	size_t size = strlen(str);
336 	uint8_t *tx;
337 	uint8_t *rx;
338 
339 	tx = malloc(size);
340 	if (!tx)
341 		pabort("can't allocate tx buffer");
342 
343 	rx = malloc(size);
344 	if (!rx)
345 		pabort("can't allocate rx buffer");
346 
347 	size = unescape((char *)tx, str, size);
348 	transfer(fd, tx, rx, size);
349 	free(rx);
350 	free(tx);
351 }
352 
transfer_file(int fd,char * filename)353 static void transfer_file(int fd, char *filename)
354 {
355 	ssize_t bytes;
356 	struct stat sb;
357 	int tx_fd;
358 	uint8_t *tx;
359 	uint8_t *rx;
360 
361 	if (stat(filename, &sb) == -1)
362 		pabort("can't stat input file");
363 
364 	tx_fd = open(filename, O_RDONLY);
365 	if (tx_fd < 0)
366 		pabort("can't open input file");
367 
368 	tx = malloc(sb.st_size);
369 	if (!tx)
370 		pabort("can't allocate tx buffer");
371 
372 	rx = malloc(sb.st_size);
373 	if (!rx)
374 		pabort("can't allocate rx buffer");
375 
376 	bytes = read(tx_fd, tx, sb.st_size);
377 	if (bytes != sb.st_size)
378 		pabort("failed to read input file");
379 
380 	transfer(fd, tx, rx, sb.st_size);
381 	free(rx);
382 	free(tx);
383 	close(tx_fd);
384 }
385 
386 static uint64_t _read_count;
387 static uint64_t _write_count;
388 
show_transfer_rate(void)389 static void show_transfer_rate(void)
390 {
391 	static uint64_t prev_read_count, prev_write_count;
392 	double rx_rate, tx_rate;
393 
394 	rx_rate = ((_read_count - prev_read_count) * 8) / (interval*1000.0);
395 	tx_rate = ((_write_count - prev_write_count) * 8) / (interval*1000.0);
396 
397 	printf("rate: tx %.1fkbps, rx %.1fkbps\n", rx_rate, tx_rate);
398 
399 	prev_read_count = _read_count;
400 	prev_write_count = _write_count;
401 }
402 
transfer_buf(int fd,int len)403 static void transfer_buf(int fd, int len)
404 {
405 	uint8_t *tx;
406 	uint8_t *rx;
407 	int i;
408 
409 	tx = malloc(len);
410 	if (!tx)
411 		pabort("can't allocate tx buffer");
412 	for (i = 0; i < len; i++)
413 		tx[i] = random();
414 
415 	rx = malloc(len);
416 	if (!rx)
417 		pabort("can't allocate rx buffer");
418 
419 	transfer(fd, tx, rx, len);
420 
421 	_write_count += len;
422 	_read_count += len;
423 
424 	if (mode & SPI_LOOP) {
425 		if (memcmp(tx, rx, len)) {
426 			fprintf(stderr, "transfer error !\n");
427 			hex_dump(tx, len, 32, "TX");
428 			hex_dump(rx, len, 32, "RX");
429 			exit(1);
430 		}
431 	}
432 
433 	free(rx);
434 	free(tx);
435 }
436 
main(int argc,char * argv[])437 int main(int argc, char *argv[])
438 {
439 	int ret = 0;
440 	int fd;
441 	uint32_t request;
442 
443 	parse_opts(argc, argv);
444 
445 	if (input_tx && input_file)
446 		pabort("only one of -p and --input may be selected");
447 
448 	fd = open(device, O_RDWR);
449 	if (fd < 0)
450 		pabort("can't open device");
451 
452 	/*
453 	 * spi mode
454 	 */
455 	/* WR is make a request to assign 'mode' */
456 	request = mode;
457 	ret = ioctl(fd, SPI_IOC_WR_MODE32, &mode);
458 	if (ret == -1)
459 		pabort("can't set spi mode");
460 
461 	/* RD is read what mode the device actually is in */
462 	ret = ioctl(fd, SPI_IOC_RD_MODE32, &mode);
463 	if (ret == -1)
464 		pabort("can't get spi mode");
465 	/* Drivers can reject some mode bits without returning an error.
466 	 * Read the current value to identify what mode it is in, and if it
467 	 * differs from the requested mode, warn the user.
468 	 */
469 	if (request != mode)
470 		printf("WARNING device does not support requested mode 0x%x\n",
471 			request);
472 
473 	/*
474 	 * bits per word
475 	 */
476 	ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
477 	if (ret == -1)
478 		pabort("can't set bits per word");
479 
480 	ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
481 	if (ret == -1)
482 		pabort("can't get bits per word");
483 
484 	/*
485 	 * max speed hz
486 	 */
487 	ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
488 	if (ret == -1)
489 		pabort("can't set max speed hz");
490 
491 	ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
492 	if (ret == -1)
493 		pabort("can't get max speed hz");
494 
495 	printf("spi mode: 0x%x\n", mode);
496 	printf("bits per word: %u\n", bits);
497 	printf("max speed: %u Hz (%u kHz)\n", speed, speed/1000);
498 
499 	if (input_tx)
500 		transfer_escaped_string(fd, input_tx);
501 	else if (input_file)
502 		transfer_file(fd, input_file);
503 	else if (transfer_size) {
504 		struct timespec last_stat;
505 
506 		clock_gettime(CLOCK_MONOTONIC, &last_stat);
507 
508 		while (iterations-- > 0) {
509 			struct timespec current;
510 
511 			transfer_buf(fd, transfer_size);
512 
513 			clock_gettime(CLOCK_MONOTONIC, &current);
514 			if (current.tv_sec - last_stat.tv_sec > interval) {
515 				show_transfer_rate();
516 				last_stat = current;
517 			}
518 		}
519 		printf("total: tx %.1fKB, rx %.1fKB\n",
520 		       _write_count/1024.0, _read_count/1024.0);
521 	} else
522 		transfer(fd, default_tx, default_rx, sizeof(default_tx));
523 
524 	close(fd);
525 
526 	return ret;
527 }
528