[mirror_ubuntu-jammy-kernel.git] / tools / spi / spidev_test.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * SPI testing utility (using spidev driver)
 *
 * Copyright (c) 2007  MontaVista Software, Inc.
 * Copyright (c) 2007  Anton Vorontsov <avorontsov@ru.mvista.com>
 *
 * Cross-compile with cross-gcc -I/path/to/cross-kernel/include
 */

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <fcntl.h>
#include <time.h>
#include <sys/ioctl.h>
#include <linux/ioctl.h>
#include <sys/stat.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

static void pabort(const char *s)
{
	if (errno != 0)
		perror(s);
	else
		printf("%s\n", s);

	abort();
}

static const char *device = "/dev/spidev1.1";
static uint32_t mode;
static uint8_t bits = 8;
static char *input_file;
static char *output_file;
static uint32_t speed = 500000;
static uint16_t delay;
static int verbose;
static int transfer_size;
static int iterations;
static int interval = 5; /* interval in seconds for showing transfer rate */

uint8_t default_tx[] = {
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0x40, 0x00, 0x00, 0x00, 0x00, 0x95,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0xF0, 0x0D,
};

uint8_t default_rx[ARRAY_SIZE(default_tx)] = {0, };
char *input_tx;

static void hex_dump(const void *src, size_t length, size_t line_size,
		     char *prefix)
{
	int i = 0;
	const unsigned char *address = src;
	const unsigned char *line = address;
	unsigned char c;

	printf("%s | ", prefix);
	while (length-- > 0) {
		printf("%02X ", *address++);
		if (!(++i % line_size) || (length == 0 && i % line_size)) {
			if (length == 0) {
				while (i++ % line_size)
					printf("__ ");
			}
			printf(" |");
			while (line < address) {
				c = *line++;
				printf("%c", (c < 32 || c > 126) ? '.' : c);
			}
			printf("|\n");
			if (length > 0)
				printf("%s | ", prefix);
		}
	}
}

/*
 *  Unescape - process hexadecimal escape character
 *      converts shell input "\x23" -> 0x23
 */
static int unescape(char *_dst, char *_src, size_t len)
{
	int ret = 0;
	int match;
	char *src = _src;
	char *dst = _dst;
	unsigned int ch;

	while (*src) {
		if (*src == '\\' && *(src+1) == 'x') {
			match = sscanf(src + 2, "%2x", &ch);
			if (!match)
				pabort("malformed input string");

			src += 4;
			*dst++ = (unsigned char)ch;
		} else {
			*dst++ = *src++;
		}
		ret++;
	}
	return ret;
}

static void transfer(int fd, uint8_t const *tx, uint8_t const *rx, size_t len)
{
	int ret;
	int out_fd;
	struct spi_ioc_transfer tr = {
		.tx_buf = (unsigned long)tx,
		.rx_buf = (unsigned long)rx,
		.len = len,
		.delay_usecs = delay,
		.speed_hz = speed,
		.bits_per_word = bits,
	};

	if (mode & SPI_TX_OCTAL)
		tr.tx_nbits = 8;
	else if (mode & SPI_TX_QUAD)
		tr.tx_nbits = 4;
	else if (mode & SPI_TX_DUAL)
		tr.tx_nbits = 2;
	if (mode & SPI_RX_OCTAL)
		tr.rx_nbits = 8;
	else if (mode & SPI_RX_QUAD)
		tr.rx_nbits = 4;
	else if (mode & SPI_RX_DUAL)
		tr.rx_nbits = 2;
	if (!(mode & SPI_LOOP)) {
		if (mode & (SPI_TX_OCTAL | SPI_TX_QUAD | SPI_TX_DUAL))
			tr.rx_buf = 0;
		else if (mode & (SPI_RX_OCTAL | SPI_RX_QUAD | SPI_RX_DUAL))
			tr.tx_buf = 0;
	}

	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
	if (ret < 1)
		pabort("can't send spi message");

	if (verbose)
		hex_dump(tx, len, 32, "TX");

	if (output_file) {
		out_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
		if (out_fd < 0)
			pabort("could not open output file");

		ret = write(out_fd, rx, len);
		if (ret != len)
			pabort("not all bytes written to output file");

		close(out_fd);
	}

	if (verbose)
		hex_dump(rx, len, 32, "RX");
}

static void print_usage(const char *prog)
{
	printf("Usage: %s [-DsbdlHOLC3vpNR24SI]\n", prog);
	puts("  -D --device   device to use (default /dev/spidev1.1)\n"
	     "  -s --speed    max speed (Hz)\n"
	     "  -d --delay    delay (usec)\n"
	     "  -b --bpw      bits per word\n"
	     "  -i --input    input data from a file (e.g. \"test.bin\")\n"
	     "  -o --output   output data to a file (e.g. \"results.bin\")\n"
	     "  -l --loop     loopback\n"
	     "  -H --cpha     clock phase\n"
	     "  -O --cpol     clock polarity\n"
	     "  -L --lsb      least significant bit first\n"
	     "  -C --cs-high  chip select active high\n"
	     "  -3 --3wire    SI/SO signals shared\n"
	     "  -v --verbose  Verbose (show tx buffer)\n"
	     "  -p            Send data (e.g. \"1234\\xde\\xad\")\n"
	     "  -N --no-cs    no chip select\n"
	     "  -R --ready    slave pulls low to pause\n"
	     "  -2 --dual     dual transfer\n"
	     "  -4 --quad     quad transfer\n"
	     "  -8 --octal    octal transfer\n"
	     "  -S --size     transfer size\n"
	     "  -I --iter     iterations\n");
	exit(1);
}

static void parse_opts(int argc, char *argv[])
{
	while (1) {
		static const struct option lopts[] = {
			{ "device",  1, 0, 'D' },
			{ "speed",   1, 0, 's' },
			{ "delay",   1, 0, 'd' },
			{ "bpw",     1, 0, 'b' },
			{ "input",   1, 0, 'i' },
			{ "output",  1, 0, 'o' },
			{ "loop",    0, 0, 'l' },
			{ "cpha",    0, 0, 'H' },
			{ "cpol",    0, 0, 'O' },
			{ "lsb",     0, 0, 'L' },
			{ "cs-high", 0, 0, 'C' },
			{ "3wire",   0, 0, '3' },
			{ "no-cs",   0, 0, 'N' },
			{ "ready",   0, 0, 'R' },
			{ "dual",    0, 0, '2' },
			{ "verbose", 0, 0, 'v' },
			{ "quad",    0, 0, '4' },
			{ "octal",   0, 0, '8' },
			{ "size",    1, 0, 'S' },
			{ "iter",    1, 0, 'I' },
			{ NULL, 0, 0, 0 },
		};
		int c;

		c = getopt_long(argc, argv, "D:s:d:b:i:o:lHOLC3NR248p:vS:I:",
				lopts, NULL);

		if (c == -1)
			break;

		switch (c) {
		case 'D':
			device = optarg;
			break;
		case 's':
			speed = atoi(optarg);
			break;
		case 'd':
			delay = atoi(optarg);
			break;
		case 'b':
			bits = atoi(optarg);
			break;
		case 'i':
			input_file = optarg;
			break;
		case 'o':
			output_file = optarg;
			break;
		case 'l':
			mode |= SPI_LOOP;
			break;
		case 'H':
			mode |= SPI_CPHA;
			break;
		case 'O':
			mode |= SPI_CPOL;
			break;
		case 'L':
			mode |= SPI_LSB_FIRST;
			break;
		case 'C':
			mode |= SPI_CS_HIGH;
			break;
		case '3':
			mode |= SPI_3WIRE;
			break;
		case 'N':
			mode |= SPI_NO_CS;
			break;
		case 'v':
			verbose = 1;
			break;
		case 'R':
			mode |= SPI_READY;
			break;
		case 'p':
			input_tx = optarg;
			break;
		case '2':
			mode |= SPI_TX_DUAL;
			break;
		case '4':
			mode |= SPI_TX_QUAD;
			break;
		case '8':
			mode |= SPI_TX_OCTAL;
			break;
		case 'S':
			transfer_size = atoi(optarg);
			break;
		case 'I':
			iterations = atoi(optarg);
			break;
		default:
			print_usage(argv[0]);
		}
	}
	if (mode & SPI_LOOP) {
		if (mode & SPI_TX_DUAL)
			mode |= SPI_RX_DUAL;
		if (mode & SPI_TX_QUAD)
			mode |= SPI_RX_QUAD;
		if (mode & SPI_TX_OCTAL)
			mode |= SPI_RX_OCTAL;
	}
}

static void transfer_escaped_string(int fd, char *str)
{
	size_t size = strlen(str);
	uint8_t *tx;
	uint8_t *rx;

	tx = malloc(size);
	if (!tx)
		pabort("can't allocate tx buffer");

	rx = malloc(size);
	if (!rx)
		pabort("can't allocate rx buffer");

	size = unescape((char *)tx, str, size);
	transfer(fd, tx, rx, size);
	free(rx);
	free(tx);
}

static void transfer_file(int fd, char *filename)
{
	ssize_t bytes;
	struct stat sb;
	int tx_fd;
	uint8_t *tx;
	uint8_t *rx;

	if (stat(filename, &sb) == -1)
		pabort("can't stat input file");

	tx_fd = open(filename, O_RDONLY);
	if (tx_fd < 0)
		pabort("can't open input file");

	tx = malloc(sb.st_size);
	if (!tx)
		pabort("can't allocate tx buffer");

	rx = malloc(sb.st_size);
	if (!rx)
		pabort("can't allocate rx buffer");

	bytes = read(tx_fd, tx, sb.st_size);
	if (bytes != sb.st_size)
		pabort("failed to read input file");

	transfer(fd, tx, rx, sb.st_size);
	free(rx);
	free(tx);
	close(tx_fd);
}

static uint64_t _read_count;
static uint64_t _write_count;

static void show_transfer_rate(void)
{
	static uint64_t prev_read_count, prev_write_count;
	double rx_rate, tx_rate;

	rx_rate = ((_read_count - prev_read_count) * 8) / (interval*1000.0);
	tx_rate = ((_write_count - prev_write_count) * 8) / (interval*1000.0);

	printf("rate: tx %.1fkbps, rx %.1fkbps\n", rx_rate, tx_rate);

	prev_read_count = _read_count;
	prev_write_count = _write_count;
}

static void transfer_buf(int fd, int len)
{
	uint8_t *tx;
	uint8_t *rx;
	int i;

	tx = malloc(len);
	if (!tx)
		pabort("can't allocate tx buffer");
	for (i = 0; i < len; i++)
		tx[i] = random();

	rx = malloc(len);
	if (!rx)
		pabort("can't allocate rx buffer");

	transfer(fd, tx, rx, len);

	_write_count += len;
	_read_count += len;

	if (mode & SPI_LOOP) {
		if (memcmp(tx, rx, len)) {
			fprintf(stderr, "transfer error !\n");
			hex_dump(tx, len, 32, "TX");
			hex_dump(rx, len, 32, "RX");
			exit(1);
		}
	}

	free(rx);
	free(tx);
}

int main(int argc, char *argv[])
{
	int ret = 0;
	int fd;

	parse_opts(argc, argv);

	if (input_tx && input_file)
		pabort("only one of -p and --input may be selected");

	fd = open(device, O_RDWR);
	if (fd < 0)
		pabort("can't open device");

	/*
	 * spi mode
	 */
	ret = ioctl(fd, SPI_IOC_WR_MODE32, &mode);
	if (ret == -1)
		pabort("can't set spi mode");

	ret = ioctl(fd, SPI_IOC_RD_MODE32, &mode);
	if (ret == -1)
		pabort("can't get spi mode");

	/*
	 * bits per word
	 */
	ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
	if (ret == -1)
		pabort("can't set bits per word");

	ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
	if (ret == -1)
		pabort("can't get bits per word");

	/*
	 * max speed hz
	 */
	ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
	if (ret == -1)
		pabort("can't set max speed hz");

	ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
	if (ret == -1)
		pabort("can't get max speed hz");

	printf("spi mode: 0x%x\n", mode);
	printf("bits per word: %u\n", bits);
	printf("max speed: %u Hz (%u kHz)\n", speed, speed/1000);

	if (input_tx)
		transfer_escaped_string(fd, input_tx);
	else if (input_file)
		transfer_file(fd, input_file);
	else if (transfer_size) {
		struct timespec last_stat;

		clock_gettime(CLOCK_MONOTONIC, &last_stat);

		while (iterations-- > 0) {
			struct timespec current;

			transfer_buf(fd, transfer_size);

			clock_gettime(CLOCK_MONOTONIC, &current);
			if (current.tv_sec - last_stat.tv_sec > interval) {
				show_transfer_rate();
				last_stat = current;
			}
		}
		printf("total: tx %.1fKB, rx %.1fKB\n",
		       _write_count/1024.0, _read_count/1024.0);
	} else
		transfer(fd, default_tx, default_rx, sizeof(default_tx));

	close(fd);

	return ret;
}
Commit	Line	Data
84a14ae8	1	// SPDX-License-Identifier: GPL-2.0-only
22b238bd AV	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	*
22b238bd AV	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>
b78ce7ed	15	#include <string.h>
470a072e	16	#include <errno.h>
22b238bd AV	17	#include <getopt.h>
22b238bd AV	18	#include <fcntl.h>
9006a7b3	19	#include <time.h>
22b238bd	20	#include <sys/ioctl.h>
8736f802	21	#include <linux/ioctl.h>
7af475a5	22	#include <sys/stat.h>
22b238bd AV	23	#include <linux/types.h>
	24	#include <linux/spi/spidev.h>
	25
	26	#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
	27
	28	static void pabort(const char *s)
	29	{
470a072e TY	30	if (errno != 0)
	31	perror(s);
	32	else
	33	printf("%s\n", s);
	34
22b238bd AV	35	abort();
	36	}
	37
cd58310d	38	static const char *device = "/dev/spidev1.1";
c2e78c34	39	static uint32_t mode;
22b238bd	40	static uint8_t bits = 8;
7af475a5	41	static char *input_file;
983b2788	42	static char *output_file;
22b238bd AV	43	static uint32_t speed = 500000;
22b238bd AV	44	static uint16_t delay;
31a5c5a7	45	static int verbose;
9006a7b3 FI	46	static int transfer_size;
	47	static int iterations;
	48	static int interval = 5; /* interval in seconds for showing transfer rate */
22b238bd	49
30061915 AR	50	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	uint8_t default_rx[ARRAY_SIZE(default_tx)] = {0, };
	60	char *input_tx;
	61
b2cfc904 JC	62	static void hex_dump(const void *src, size_t length, size_t line_size,
b2cfc904 JC	63	char *prefix)
b78ce7ed AR	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	}
35386dfd	78	printf(" \|");
b78ce7ed AR	79	while (line < address) {
b78ce7ed AR	80	c = *line++;
35386dfd	81	printf("%c", (c < 32 \|\| c > 126) ? '.' : c);
b78ce7ed	82	}
35386dfd	83	printf("\|\n");
b78ce7ed AR	84	if (length > 0)
	85	printf("%s \| ", prefix);
	86	}
	87	}
	88	}
	89
30061915 AR	90	/*
	91	* Unescape - process hexadecimal escape character
	92	* converts shell input "\x23" -> 0x23
	93	*/
07eec628	94	static int unescape(char _dst, char _src, size_t len)
30061915 AR	95	{
30061915 AR	96	int ret = 0;
a20874f7	97	int match;
30061915 AR	98	char *src = _src;
	99	char *dst = _dst;
	100	unsigned int ch;
	101
	102	while (*src) {
	103	if (src == '\\' && (src+1) == 'x') {
a20874f7 JC	104	match = sscanf(src + 2, "%2x", &ch);
	105	if (!match)
	106	pabort("malformed input string");
	107
30061915 AR	108	src += 4;
	109	*dst++ = (unsigned char)ch;
	110	} else {
	111	dst++ = src++;
	112	}
	113	ret++;
	114	}
	115	return ret;
	116	}
	117
	118	static void transfer(int fd, uint8_t const tx, uint8_t const rx, size_t len)
22b238bd AV	119	{
22b238bd AV	120	int ret;
983b2788	121	int out_fd;
22b238bd AV	122	struct spi_ioc_transfer tr = {
	123	.tx_buf = (unsigned long)tx,
	124	.rx_buf = (unsigned long)rx,
30061915	125	.len = len,
22b238bd AV	126	.delay_usecs = delay,
	127	.speed_hz = speed,
	128	.bits_per_word = bits,
	129	};
	130
896fa735 GU	131	if (mode & SPI_TX_OCTAL)
	132	tr.tx_nbits = 8;
	133	else if (mode & SPI_TX_QUAD)
c2e78c34 GU	134	tr.tx_nbits = 4;
	135	else if (mode & SPI_TX_DUAL)
	136	tr.tx_nbits = 2;
896fa735 GU	137	if (mode & SPI_RX_OCTAL)
	138	tr.rx_nbits = 8;
	139	else if (mode & SPI_RX_QUAD)
c2e78c34 GU	140	tr.rx_nbits = 4;
	141	else if (mode & SPI_RX_DUAL)
	142	tr.rx_nbits = 2;
	143	if (!(mode & SPI_LOOP)) {
896fa735	144	if (mode & (SPI_TX_OCTAL \| SPI_TX_QUAD \| SPI_TX_DUAL))
c2e78c34	145	tr.rx_buf = 0;
896fa735	146	else if (mode & (SPI_RX_OCTAL \| SPI_RX_QUAD \| SPI_RX_DUAL))
c2e78c34 GU	147	tr.tx_buf = 0;
	148	}
	149
22b238bd	150	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
95b1ed2a	151	if (ret < 1)
22b238bd AV	152	pabort("can't send spi message");
22b238bd AV	153
31a5c5a7	154	if (verbose)
30061915	155	hex_dump(tx, len, 32, "TX");
983b2788 JC	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)
edd3899c	164	pabort("not all bytes written to output file");
983b2788 JC	165
	166	close(out_fd);
	167	}
	168
9006a7b3	169	if (verbose)
983b2788	170	hex_dump(rx, len, 32, "RX");
22b238bd AV	171	}
22b238bd AV	172
b7ed698c	173	static void print_usage(const char *prog)
22b238bd	174	{
9006a7b3	175	printf("Usage: %s [-DsbdlHOLC3vpNR24SI]\n", prog);
22b238bd AV	176	puts(" -D --device device to use (default /dev/spidev1.1)\n"
	177	" -s --speed max speed (Hz)\n"
	178	" -d --delay delay (usec)\n"
b2cfc904	179	" -b --bpw bits per word\n"
7af475a5	180	" -i --input input data from a file (e.g. \"test.bin\")\n"
983b2788	181	" -o --output output data to a file (e.g. \"results.bin\")\n"
22b238bd AV	182	" -l --loop loopback\n"
	183	" -H --cpha clock phase\n"
	184	" -O --cpol clock polarity\n"
	185	" -L --lsb least significant bit first\n"
	186	" -C --cs-high chip select active high\n"
925d16a2	187	" -3 --3wire SI/SO signals shared\n"
31a5c5a7	188	" -v --verbose Verbose (show tx buffer)\n"
30061915	189	" -p Send data (e.g. \"1234\\xde\\xad\")\n"
925d16a2	190	" -N --no-cs no chip select\n"
c2e78c34 GU	191	" -R --ready slave pulls low to pause\n"
c2e78c34 GU	192	" -2 --dual dual transfer\n"
9006a7b3	193	" -4 --quad quad transfer\n"
896fa735	194	" -8 --octal octal transfer\n"
9006a7b3 FI	195	" -S --size transfer size\n"
9006a7b3 FI	196	" -I --iter iterations\n");
22b238bd AV	197	exit(1);
	198	}
	199
b7ed698c	200	static void parse_opts(int argc, char *argv[])
22b238bd AV	201	{
22b238bd AV	202	while (1) {
cd58310d	203	static const struct option lopts[] = {
22b238bd AV	204	{ "device", 1, 0, 'D' },
	205	{ "speed", 1, 0, 's' },
	206	{ "delay", 1, 0, 'd' },
	207	{ "bpw", 1, 0, 'b' },
7af475a5	208	{ "input", 1, 0, 'i' },
983b2788	209	{ "output", 1, 0, 'o' },
22b238bd AV	210	{ "loop", 0, 0, 'l' },
	211	{ "cpha", 0, 0, 'H' },
	212	{ "cpol", 0, 0, 'O' },
	213	{ "lsb", 0, 0, 'L' },
	214	{ "cs-high", 0, 0, 'C' },
	215	{ "3wire", 0, 0, '3' },
b55f627f DB	216	{ "no-cs", 0, 0, 'N' },
b55f627f DB	217	{ "ready", 0, 0, 'R' },
c2e78c34	218	{ "dual", 0, 0, '2' },
31a5c5a7	219	{ "verbose", 0, 0, 'v' },
c2e78c34	220	{ "quad", 0, 0, '4' },
896fa735	221	{ "octal", 0, 0, '8' },
9006a7b3 FI	222	{ "size", 1, 0, 'S' },
9006a7b3 FI	223	{ "iter", 1, 0, 'I' },
22b238bd AV	224	{ NULL, 0, 0, 0 },
	225	};
	226	int c;
	227
896fa735	228	c = getopt_long(argc, argv, "D:s:d:b:i:o:lHOLC3NR248p:vS:I:",
7af475a5	229	lopts, NULL);
22b238bd AV	230
	231	if (c == -1)
	232	break;
	233
	234	switch (c) {
	235	case 'D':
	236	device = optarg;
	237	break;
	238	case 's':
	239	speed = atoi(optarg);
	240	break;
	241	case 'd':
	242	delay = atoi(optarg);
	243	break;
	244	case 'b':
	245	bits = atoi(optarg);
	246	break;
7af475a5 JC	247	case 'i':
	248	input_file = optarg;
	249	break;
983b2788 JC	250	case 'o':
	251	output_file = optarg;
	252	break;
22b238bd AV	253	case 'l':
	254	mode \|= SPI_LOOP;
	255	break;
	256	case 'H':
	257	mode \|= SPI_CPHA;
	258	break;
	259	case 'O':
	260	mode \|= SPI_CPOL;
	261	break;
	262	case 'L':
	263	mode \|= SPI_LSB_FIRST;
	264	break;
	265	case 'C':
	266	mode \|= SPI_CS_HIGH;
	267	break;
	268	case '3':
	269	mode \|= SPI_3WIRE;
	270	break;
b55f627f DB	271	case 'N':
	272	mode \|= SPI_NO_CS;
	273	break;
31a5c5a7 AR	274	case 'v':
	275	verbose = 1;
	276	break;
b55f627f DB	277	case 'R':
	278	mode \|= SPI_READY;
	279	break;
30061915 AR	280	case 'p':
	281	input_tx = optarg;
	282	break;
c2e78c34 GU	283	case '2':
	284	mode \|= SPI_TX_DUAL;
	285	break;
	286	case '4':
	287	mode \|= SPI_TX_QUAD;
	288	break;
896fa735 GU	289	case '8':
	290	mode \|= SPI_TX_OCTAL;
	291	break;
9006a7b3 FI	292	case 'S':
	293	transfer_size = atoi(optarg);
	294	break;
	295	case 'I':
	296	iterations = atoi(optarg);
	297	break;
22b238bd AV	298	default:
22b238bd AV	299	print_usage(argv[0]);
22b238bd AV	300	}
22b238bd AV	301	}
c2e78c34 GU	302	if (mode & SPI_LOOP) {
	303	if (mode & SPI_TX_DUAL)
	304	mode \|= SPI_RX_DUAL;
	305	if (mode & SPI_TX_QUAD)
	306	mode \|= SPI_RX_QUAD;
896fa735 GU	307	if (mode & SPI_TX_OCTAL)
896fa735 GU	308	mode \|= SPI_RX_OCTAL;
c2e78c34	309	}
22b238bd AV	310	}
22b238bd AV	311
5c437a40 JC	312	static void transfer_escaped_string(int fd, char *str)
5c437a40 JC	313	{
0278b34b	314	size_t size = strlen(str);
5c437a40 JC	315	uint8_t *tx;
	316	uint8_t *rx;
	317
	318	tx = malloc(size);
	319	if (!tx)
	320	pabort("can't allocate tx buffer");
	321
	322	rx = malloc(size);
	323	if (!rx)
	324	pabort("can't allocate rx buffer");
	325
	326	size = unescape((char *)tx, str, size);
	327	transfer(fd, tx, rx, size);
	328	free(rx);
	329	free(tx);
	330	}
	331
7af475a5 JC	332	static void transfer_file(int fd, char *filename)
	333	{
	334	ssize_t bytes;
	335	struct stat sb;
	336	int tx_fd;
	337	uint8_t *tx;
	338	uint8_t *rx;
	339
	340	if (stat(filename, &sb) == -1)
	341	pabort("can't stat input file");
	342
	343	tx_fd = open(filename, O_RDONLY);
e634b76c	344	if (tx_fd < 0)
7af475a5 JC	345	pabort("can't open input file");
	346
	347	tx = malloc(sb.st_size);
	348	if (!tx)
	349	pabort("can't allocate tx buffer");
	350
	351	rx = malloc(sb.st_size);
	352	if (!rx)
	353	pabort("can't allocate rx buffer");
	354
	355	bytes = read(tx_fd, tx, sb.st_size);
	356	if (bytes != sb.st_size)
	357	pabort("failed to read input file");
	358
	359	transfer(fd, tx, rx, sb.st_size);
	360	free(rx);
	361	free(tx);
	362	close(tx_fd);
	363	}
	364
9006a7b3 FI	365	static uint64_t _read_count;
	366	static uint64_t _write_count;
	367
	368	static void show_transfer_rate(void)
	369	{
	370	static uint64_t prev_read_count, prev_write_count;
	371	double rx_rate, tx_rate;
	372
	373	rx_rate = ((_read_count - prev_read_count) * 8) / (interval*1000.0);
	374	tx_rate = ((_write_count - prev_write_count) * 8) / (interval*1000.0);
	375
	376	printf("rate: tx %.1fkbps, rx %.1fkbps\n", rx_rate, tx_rate);
	377
	378	prev_read_count = _read_count;
	379	prev_write_count = _write_count;
	380	}
	381
	382	static void transfer_buf(int fd, int len)
	383	{
	384	uint8_t *tx;
	385	uint8_t *rx;
	386	int i;
	387
	388	tx = malloc(len);
	389	if (!tx)
	390	pabort("can't allocate tx buffer");
	391	for (i = 0; i < len; i++)
	392	tx[i] = random();
	393
	394	rx = malloc(len);
	395	if (!rx)
	396	pabort("can't allocate rx buffer");
	397
	398	transfer(fd, tx, rx, len);
	399
	400	_write_count += len;
	401	_read_count += len;
	402
	403	if (mode & SPI_LOOP) {
	404	if (memcmp(tx, rx, len)) {
	405	fprintf(stderr, "transfer error !\n");
	406	hex_dump(tx, len, 32, "TX");
	407	hex_dump(rx, len, 32, "RX");
	408	exit(1);
	409	}
	410	}
	411
	412	free(rx);
	413	free(tx);
	414	}
	415
22b238bd AV	416	int main(int argc, char *argv[])
	417	{
	418	int ret = 0;
	419	int fd;
	420
	421	parse_opts(argc, argv);
	422
1f3c3632 TY	423	if (input_tx && input_file)
	424	pabort("only one of -p and --input may be selected");
	425
22b238bd AV	426	fd = open(device, O_RDWR);
	427	if (fd < 0)
	428	pabort("can't open device");
	429
	430	/*
	431	* spi mode
	432	*/
c2e78c34	433	ret = ioctl(fd, SPI_IOC_WR_MODE32, &mode);
22b238bd AV	434	if (ret == -1)
	435	pabort("can't set spi mode");
	436
c2e78c34	437	ret = ioctl(fd, SPI_IOC_RD_MODE32, &mode);
22b238bd AV	438	if (ret == -1)
	439	pabort("can't get spi mode");
	440
	441	/*
	442	* bits per word
	443	*/
	444	ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
	445	if (ret == -1)
	446	pabort("can't set bits per word");
	447
	448	ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
	449	if (ret == -1)
	450	pabort("can't get bits per word");
	451
	452	/*
	453	* max speed hz
	454	*/
	455	ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
	456	if (ret == -1)
	457	pabort("can't set max speed hz");
	458
	459	ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
	460	if (ret == -1)
	461	pabort("can't get max speed hz");
	462
c2e78c34	463	printf("spi mode: 0x%x\n", mode);
9ec8ade8 GU	464	printf("bits per word: %u\n", bits);
9ec8ade8 GU	465	printf("max speed: %u Hz (%u kHz)\n", speed, speed/1000);
22b238bd	466
5c437a40 JC	467	if (input_tx)
5c437a40 JC	468	transfer_escaped_string(fd, input_tx);
7af475a5 JC	469	else if (input_file)
7af475a5 JC	470	transfer_file(fd, input_file);
9006a7b3 FI	471	else if (transfer_size) {
	472	struct timespec last_stat;
	473
	474	clock_gettime(CLOCK_MONOTONIC, &last_stat);
	475
	476	while (iterations-- > 0) {
	477	struct timespec current;
	478
	479	transfer_buf(fd, transfer_size);
	480
	481	clock_gettime(CLOCK_MONOTONIC, &current);
	482	if (current.tv_sec - last_stat.tv_sec > interval) {
	483	show_transfer_rate();
	484	last_stat = current;
	485	}
	486	}
	487	printf("total: tx %.1fKB, rx %.1fKB\n",
	488	_write_count/1024.0, _read_count/1024.0);
	489	} else
30061915	490	transfer(fd, default_tx, default_rx, sizeof(default_tx));
22b238bd AV	491
	492	close(fd);
	493
	494	return ret;
	495	}