[net-next-2.6.git] / Documentation / spi / spidev_test.c

/*
 * SPI testing utility (using spidev driver)
 *
 * Copyright (c) 2007  MontaVista Software, Inc.
 * Copyright (c) 2007  Anton Vorontsov <avorontsov@ru.mvista.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License.
 *
 * Cross-compile with cross-gcc -I/path/to/cross-kernel/include
 */

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.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)
{
	perror(s);
	abort();
}

static const char *device = "/dev/spidev1.1";
static uint8_t mode;
static uint8_t bits = 8;
static uint32_t speed = 500000;
static uint16_t delay;

static void transfer(int fd)
{
	int ret;
	uint8_t 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,
		0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD,
		0xF0, 0x0D,
	};
	uint8_t rx[ARRAY_SIZE(tx)] = {0, };
	struct spi_ioc_transfer tr = {
		.tx_buf = (unsigned long)tx,
		.rx_buf = (unsigned long)rx,
		.len = ARRAY_SIZE(tx),
		.delay_usecs = delay,
		.speed_hz = speed,
		.bits_per_word = bits,
	};

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

	for (ret = 0; ret < ARRAY_SIZE(tx); ret++) {
		if (!(ret % 6))
			puts("");
		printf("%.2X ", rx[ret]);
	}
	puts("");
}

static void print_usage(const char *prog)
{
	printf("Usage: %s [-DsbdlHOLC3]\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"
	     "  -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");
	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' },
			{ "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' },
			{ NULL, 0, 0, 0 },
		};
		int c;

		c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", 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 '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 'R':
			mode |= SPI_READY;
			break;
		default:
			print_usage(argv[0]);
			break;
		}
	}
}

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

	parse_opts(argc, argv);

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

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

	ret = ioctl(fd, SPI_IOC_RD_MODE, &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: %d\n", mode);
	printf("bits per word: %d\n", bits);
	printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);

	transfer(fd);

	close(fd);

	return ret;
}
Commit	Line	Data
22b238bd AV	1	/*
	2	* SPI testing utility (using spidev driver)
	3	*
	4	* Copyright (c) 2007 MontaVista Software, Inc.
	5	* Copyright (c) 2007 Anton Vorontsov <avorontsov@ru.mvista.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License.
	10	*
	11	* Cross-compile with cross-gcc -I/path/to/cross-kernel/include
	12	*/
	13
	14	#include <stdint.h>
	15	#include <unistd.h>
	16	#include <stdio.h>
	17	#include <stdlib.h>
	18	#include <getopt.h>
	19	#include <fcntl.h>
	20	#include <sys/ioctl.h>
	21	#include <linux/types.h>
	22	#include <linux/spi/spidev.h>
	23
	24	#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
	25
	26	static void pabort(const char *s)
	27	{
	28	perror(s);
	29	abort();
	30	}
	31
cd58310d	32	static const char *device = "/dev/spidev1.1";
22b238bd AV	33	static uint8_t mode;
	34	static uint8_t bits = 8;
	35	static uint32_t speed = 500000;
	36	static uint16_t delay;
	37
	38	static void transfer(int fd)
	39	{
	40	int ret;
	41	uint8_t tx[] = {
	42	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	43	0x40, 0x00, 0x00, 0x00, 0x00, 0x95,
	44	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	45	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	46	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	47	0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD,
	48	0xF0, 0x0D,
	49	};
	50	uint8_t rx[ARRAY_SIZE(tx)] = {0, };
	51	struct spi_ioc_transfer tr = {
	52	.tx_buf = (unsigned long)tx,
	53	.rx_buf = (unsigned long)rx,
	54	.len = ARRAY_SIZE(tx),
	55	.delay_usecs = delay,
	56	.speed_hz = speed,
	57	.bits_per_word = bits,
	58	};
	59
	60	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
95b1ed2a	61	if (ret < 1)
22b238bd AV	62	pabort("can't send spi message");
	63
	64	for (ret = 0; ret < ARRAY_SIZE(tx); ret++) {
	65	if (!(ret % 6))
	66	puts("");
	67	printf("%.2X ", rx[ret]);
	68	}
	69	puts("");
	70	}
	71
b7ed698c	72	static void print_usage(const char *prog)
22b238bd AV	73	{
	74	printf("Usage: %s [-DsbdlHOLC3]\n", prog);
	75	puts(" -D --device device to use (default /dev/spidev1.1)\n"
	76	" -s --speed max speed (Hz)\n"
	77	" -d --delay delay (usec)\n"
	78	" -b --bpw bits per word \n"
	79	" -l --loop loopback\n"
	80	" -H --cpha clock phase\n"
	81	" -O --cpol clock polarity\n"
	82	" -L --lsb least significant bit first\n"
	83	" -C --cs-high chip select active high\n"
	84	" -3 --3wire SI/SO signals shared\n");
	85	exit(1);
	86	}
	87
b7ed698c	88	static void parse_opts(int argc, char *argv[])
22b238bd AV	89	{
22b238bd AV	90	while (1) {
cd58310d	91	static const struct option lopts[] = {
22b238bd AV	92	{ "device", 1, 0, 'D' },
	93	{ "speed", 1, 0, 's' },
	94	{ "delay", 1, 0, 'd' },
	95	{ "bpw", 1, 0, 'b' },
	96	{ "loop", 0, 0, 'l' },
	97	{ "cpha", 0, 0, 'H' },
	98	{ "cpol", 0, 0, 'O' },
	99	{ "lsb", 0, 0, 'L' },
	100	{ "cs-high", 0, 0, 'C' },
	101	{ "3wire", 0, 0, '3' },
b55f627f DB	102	{ "no-cs", 0, 0, 'N' },
b55f627f DB	103	{ "ready", 0, 0, 'R' },
22b238bd AV	104	{ NULL, 0, 0, 0 },
	105	};
	106	int c;
	107
b55f627f	108	c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);
22b238bd AV	109
	110	if (c == -1)
	111	break;
	112
	113	switch (c) {
	114	case 'D':
	115	device = optarg;
	116	break;
	117	case 's':
	118	speed = atoi(optarg);
	119	break;
	120	case 'd':
	121	delay = atoi(optarg);
	122	break;
	123	case 'b':
	124	bits = atoi(optarg);
	125	break;
	126	case 'l':
	127	mode \|= SPI_LOOP;
	128	break;
	129	case 'H':
	130	mode \|= SPI_CPHA;
	131	break;
	132	case 'O':
	133	mode \|= SPI_CPOL;
	134	break;
	135	case 'L':
	136	mode \|= SPI_LSB_FIRST;
	137	break;
	138	case 'C':
	139	mode \|= SPI_CS_HIGH;
	140	break;
	141	case '3':
	142	mode \|= SPI_3WIRE;
	143	break;
b55f627f DB	144	case 'N':
	145	mode \|= SPI_NO_CS;
	146	break;
	147	case 'R':
	148	mode \|= SPI_READY;
	149	break;
22b238bd AV	150	default:
	151	print_usage(argv[0]);
	152	break;
	153	}
	154	}
	155	}
	156
	157	int main(int argc, char *argv[])
	158	{
	159	int ret = 0;
	160	int fd;
	161
	162	parse_opts(argc, argv);
	163
	164	fd = open(device, O_RDWR);
	165	if (fd < 0)
	166	pabort("can't open device");
	167
	168	/*
	169	* spi mode
	170	*/
	171	ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
	172	if (ret == -1)
	173	pabort("can't set spi mode");
	174
	175	ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
	176	if (ret == -1)
	177	pabort("can't get spi mode");
	178
	179	/*
	180	* bits per word
	181	*/
	182	ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
	183	if (ret == -1)
	184	pabort("can't set bits per word");
	185
	186	ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
	187	if (ret == -1)
	188	pabort("can't get bits per word");
	189
	190	/*
	191	* max speed hz
	192	*/
	193	ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
	194	if (ret == -1)
	195	pabort("can't set max speed hz");
	196
	197	ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
	198	if (ret == -1)
	199	pabort("can't get max speed hz");
	200
	201	printf("spi mode: %d\n", mode);
	202	printf("bits per word: %d\n", bits);
	203	printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
	204
	205	transfer(fd);
	206
	207	close(fd);
	208
	209	return ret;
	210	}