Add spi(8), a utility for communicating with a device on a SPI bus from
userland, conceptually similar to what i2c(8) provides for i2c devices. Submitted by: Bob Frazier Differential Revision: https://reviews.freebsd.org/D15029
This commit is contained in:
Ian Lepore
parent
b7a8f5e16f
commit
6666009530
@ -84,6 +84,7 @@ SUBDIR= adduser \
|
||||
setpmac \
|
||||
smbmsg \
|
||||
snapinfo \
|
||||
spi \
|
||||
spray \
|
||||
syslogd \
|
||||
sysrc \
|
||||
|
||||
9
usr.sbin/spi/Makefile
Normal file
9
usr.sbin/spi/Makefile
Normal file
@ -0,0 +1,9 @@
|
||||
# $FreeBSD$
|
||||
|
||||
#.include <src.opts.mk>
|
||||
|
||||
PROG= spi
|
||||
|
||||
MAN8= spi.8
|
||||
|
||||
.include <bsd.prog.mk>
|
||||
197
usr.sbin/spi/spi.8
Normal file
197
usr.sbin/spi/spi.8
Normal file
@ -0,0 +1,197 @@
|
||||
.\" Copyright (c) 2018 by S.F.T. Inc.
|
||||
.\"
|
||||
.\" Redistribution and use in source and binary forms, with or without
|
||||
.\" modification, are permitted provided that the following conditions
|
||||
.\" are met:
|
||||
.\" 1. Redistributions of source code must retain the above copyright
|
||||
.\" notice, this list of conditions and the following disclaimer.
|
||||
.\" 2. Redistributions in binary form must reproduce the above copyright
|
||||
.\" notice, this list of conditions and the following disclaimer in the
|
||||
.\" documentation and/or other materials provided with the distribution.
|
||||
.\"
|
||||
.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
||||
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
.\" SUCH DAMAGE.
|
||||
.\"
|
||||
.\" $FreeBSD$
|
||||
.\"
|
||||
.Dd "15 April 2018"
|
||||
.Dt spi 8
|
||||
.Os
|
||||
.Sh NAME
|
||||
.Nm spi
|
||||
.Nd communicate on SPI bus with slave devices
|
||||
.Sh SYNOPSIS
|
||||
.Nm
|
||||
.Op Fl f Ar device
|
||||
.Op Fl d Ar r|w|rw
|
||||
.Op Fl m Ar mode
|
||||
.Op Fl s Ar max-speed
|
||||
.Op Fl c Ar count
|
||||
.Op Fl C Ar cmd_bytes
|
||||
.Op Fl A
|
||||
.Op Fl b
|
||||
.Op Fl L
|
||||
.Op Fl v
|
||||
.Nm
|
||||
.Op Fl i
|
||||
.Op Fl f Ar device
|
||||
.Op Fl v
|
||||
.Nm
|
||||
.Op Fl h
|
||||
.Sh DESCRIPTION
|
||||
The
|
||||
.Nm
|
||||
utility can be used to perform raw data transfers
|
||||
.Pq read, write, or simultaneous read/write
|
||||
with devices on the SPI bus, via the
|
||||
.Xr spigen 4
|
||||
device.
|
||||
.Pp
|
||||
Each
|
||||
.Xr spigen 4
|
||||
device is associated with a specific
|
||||
.Sq chip select
|
||||
.Pq cs
|
||||
pin on the spibus, and therefore needs to be specified.
|
||||
If no device name is specified on the command line,
|
||||
.Nm
|
||||
assumes
|
||||
.Sq spigen0.0 .
|
||||
.Pp
|
||||
For more information on the spigen device, see
|
||||
.Xr spigen 4 .
|
||||
.Pp
|
||||
The options are as follows:
|
||||
.Bl -tag -width ".Fl f Ar device"
|
||||
.It Fl A
|
||||
Specifies ASCII mode.
|
||||
Both read and write data is input and output as
|
||||
2-character hexadecimal values, optionally separated by white space,
|
||||
such as 00 01 02 etc.
|
||||
When combined with the
|
||||
.Sq -b
|
||||
flag, the data on stdin remains a sequence of ASCII hexadecimal
|
||||
byte values, but the output reverts to binary mode.
|
||||
.It Fl b
|
||||
Binary
|
||||
.Pq output
|
||||
mode.
|
||||
Only has an effect when
|
||||
.Sq -A
|
||||
has been specified.
|
||||
Reverts the output back to binary
|
||||
.Pq rather than ASCII ,
|
||||
while leaving the input format as-is.
|
||||
Use in combination with
|
||||
.Sq -A
|
||||
to allow using something like
|
||||
.Sq echo
|
||||
to pass hexadecimal values to the SPI device, but output the received data
|
||||
on stdout as binary.
|
||||
.It Fl C Ar command bytes
|
||||
Sends one or more
|
||||
.Sq command
|
||||
bytes, skipping any bytes read-in during the transfer.
|
||||
The byte values should be specified as a quoted parameter, similar to the
|
||||
format for data on stdin for
|
||||
.Sq -A ,
|
||||
that is, 2 character hexadecimal values, optionally separated by white space.
|
||||
An SPI device will typically require that a command be sent, followed by
|
||||
bytes of data.
|
||||
You can use this option to send the command without receiving any data bytes
|
||||
during the command sequence.
|
||||
.It Fl c Ar count
|
||||
The total number of bytes to transfer as a decimal integer.
|
||||
If a write or a read/write transaction is being performed, and fewer than
|
||||
this number of bytes are read in from stdin, the remaining bytes will be
|
||||
sent with a value of
|
||||
.Sq 0 .
|
||||
If the length can be determined from the input file size, you can use a
|
||||
.Sq count
|
||||
value of
|
||||
.Sq -1
|
||||
to base the transfer on the input file's size.
|
||||
.It Fl d Ar r|w|rw
|
||||
Transfer direction: Use
|
||||
.Sq r
|
||||
for read,
|
||||
.Sq w for write, and
|
||||
.Sq rw
|
||||
for simultaneous read and write.
|
||||
.It Fl f Ar device
|
||||
SPI device to use
|
||||
.Pq default is /dev/spigen0 .
|
||||
.It Fl h
|
||||
Print help text to stderr, explaining the command line options.
|
||||
.It Fl i
|
||||
Displays information about the SPI device to stderr.
|
||||
Whenever this flag is specified, no data is read or written, and the mode
|
||||
and clock speed are not changed.
|
||||
.It Fl L
|
||||
LSB bit order.
|
||||
The default is MSB, i.e., the highest order bit is
|
||||
transmitted first.
|
||||
Specifying -L caused the LSB to be transmitted and read first.
|
||||
.It Fl m Ar 0 - 3
|
||||
SPI mode, 0 through 3.
|
||||
This defines the clock phase and timing with respect to reading and writing
|
||||
data, as per the SPI specification.
|
||||
.It Fl s Ar speed
|
||||
Specify the maximum speed, in Hz, for the SPI clock.
|
||||
The bus will operate at its highest available speed which does not
|
||||
exceed this maximum.
|
||||
.It Fl v
|
||||
Specifies Verbose mode.
|
||||
Diagnostics and information are written to stderr.
|
||||
You can specify
|
||||
.Sq -v
|
||||
more than once to increase verbosity.
|
||||
.El
|
||||
.Sh EXAMPLES
|
||||
Here are a few examples of using the spi utility:
|
||||
.Bl -bullet
|
||||
.It
|
||||
Get information about the default SPI device
|
||||
.Pp
|
||||
spi -i
|
||||
.It
|
||||
Set the maximum clock speed to 200Khz and the mode to 3 on spigen0.1, but do
|
||||
not transmit nor receive any data
|
||||
.Pp
|
||||
spi -f spigen0.1 -s 200000 -m 3
|
||||
.It
|
||||
Send a command sequence consisting of 2 bytes, and read 2 additional bytes
|
||||
from the SPI device, using the current mode and speed on the default device
|
||||
.Pp
|
||||
spi -d r -C "00 01" -c 2
|
||||
.It
|
||||
Transmit a byte value of 5, and receive 2 bytes, displaying their values as
|
||||
2-byte ASCII hexadecimal, with mode 2, and a maximum clock speed of 500khz.
|
||||
.Pp
|
||||
echo "05" | spi -A -d rw -m 2 -s 500000 -c 2
|
||||
.It
|
||||
Send a binary file, and output the SPI result through
|
||||
.Sq od
|
||||
as hexadecimal bytes, using the current maximum clock speed and SPI mode.
|
||||
.Pp
|
||||
spi -d rw -c -1 <input_file.bin | od -An -t x1
|
||||
.It
|
||||
Send 2 bytes of data, receive a total of 4 bytes, and output the SPI result
|
||||
as binary data, piped through
|
||||
.Sq od ,
|
||||
displaying it as two hexadecimal unsigned short integer values.
|
||||
.Pp
|
||||
echo "00 01" | spi -A -b -d rw -c 4 | od -t x2
|
||||
.El
|
||||
.Pp
|
||||
.Sh SEE ALSO
|
||||
.Xr spigen 4
|
||||
958
usr.sbin/spi/spi.c
Normal file
958
usr.sbin/spi/spi.c
Normal file
@ -0,0 +1,958 @@
|
||||
/*-
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*
|
||||
* Copyright (c) 2018 S.F.T. Inc.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/ioccom.h>
|
||||
#include <sys/spigenio.h>
|
||||
#include <sys/sysctl.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <inttypes.h>
|
||||
#include <limits.h>
|
||||
#include <memory.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define DEFAULT_DEVICE_NAME "/dev/spigen0.0"
|
||||
|
||||
#define DEFAULT_BUFFER_SIZE 8192
|
||||
|
||||
#define DIR_READ 0
|
||||
#define DIR_WRITE 1
|
||||
#define DIR_READWRITE 2
|
||||
#define DIR_NONE -1
|
||||
|
||||
struct spi_options {
|
||||
int mode; /* mode (0,1,2,3, -1 == use default) */
|
||||
int speed; /* speed (in Hz, -1 == use default) */
|
||||
int count; /* count (0 through 'n' bytes, negative for
|
||||
* stdin length) */
|
||||
int binary; /* non-zero for binary output or zero for
|
||||
* ASCII output when ASCII != 0 */
|
||||
int ASCII; /* zero for binary input and output.
|
||||
* non-zero for ASCII input, 'binary'
|
||||
* determines output */
|
||||
int lsb; /* non-zero for LSB order (default order is
|
||||
* MSB) */
|
||||
int verbose; /* non-zero for verbosity */
|
||||
int ncmd; /* bytes to skip for incoming data */
|
||||
uint8_t *pcmd; /* command data (NULL if none) */
|
||||
};
|
||||
|
||||
static void usage(void);
|
||||
static int interpret_command_bytes(const char *parg, struct spi_options *popt);
|
||||
static void * prep_write_buffer(struct spi_options *popt);
|
||||
static int _read_write(int hdev, void *bufw, void *bufr, int cbrw, int lsb);
|
||||
static int _do_data_output(void *pr, struct spi_options *popt);
|
||||
static int get_info(int hdev, const char *dev_name);
|
||||
static int set_mode(int hdev, struct spi_options *popt);
|
||||
static int set_speed(int hdev, struct spi_options *popt);
|
||||
static int hexval(char c);
|
||||
static int perform_read(int hdev, struct spi_options *popt);
|
||||
static int perform_write(int hdev, struct spi_options *popt);
|
||||
static int perform_readwrite(int hdev, struct spi_options *popt);
|
||||
static void verbose_dump_buffer(void *pbuf, int icount, int lsb);
|
||||
|
||||
/*
|
||||
* LSB array - reversebits[n] is the LSB value of n as an MSB. Use this array
|
||||
* to obtain a reversed bit pattern of the index value when bits must
|
||||
* be sent/received in an LSB order vs the default MSB
|
||||
*/
|
||||
static uint8_t reversebits[256] = {
|
||||
0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
|
||||
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
|
||||
0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
|
||||
0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
|
||||
0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
|
||||
0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
|
||||
0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
|
||||
0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
|
||||
0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
|
||||
0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
|
||||
0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
|
||||
0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
|
||||
0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
|
||||
0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
|
||||
0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
|
||||
0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
|
||||
0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
|
||||
0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
|
||||
0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
|
||||
0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
|
||||
0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
|
||||
0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
|
||||
0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
|
||||
0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
|
||||
0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
|
||||
0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
|
||||
0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
|
||||
0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
|
||||
0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
|
||||
0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
|
||||
0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
|
||||
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
|
||||
};
|
||||
|
||||
|
||||
static void
|
||||
usage(void)
|
||||
{
|
||||
fputs(getprogname(), stderr);
|
||||
fputs(" - communicate on SPI bus with slave devices\n"
|
||||
"Usage:\n"
|
||||
" spi [-f device] [-d r|w|rw] [-m mode] [-s max-speed] [-c count]\n"
|
||||
" [-C \"command bytes\"] [-A] [-b] [-L] [-v]\n"
|
||||
" spi -i [-f device] [-v]\n"
|
||||
" spi -h\n"
|
||||
" where\n"
|
||||
" -f specifies the device (default is spigen0.0)\n"
|
||||
" -d specifies the operation (r, w, or rw; default is rw)\n"
|
||||
" -m specifies the mode (0, 1, 2, or 3)\n"
|
||||
" -s specifies the maximum speed (default is 0, device default)\n"
|
||||
" -c specifies the number of data bytes to transfer (default 0, i.e. none)\n"
|
||||
" A negative value uses the length of the input data\n"
|
||||
" -C specifies 'command bytes' to be sent, as 2 byte hexadecimal values\n"
|
||||
" (these should be quoted, separated by optional white space)\n"
|
||||
" -L specifies 'LSB' order on the SPI bus (default is MSB)\n"
|
||||
" -i query information about the device\n"
|
||||
" -A uses ASCII for input/output as 2-digit hex values\n"
|
||||
" -b Override output format as binary (only valid with '-A')\n"
|
||||
" -v verbose output\n"
|
||||
" -h prints this message\n"
|
||||
"\n"
|
||||
"NOTE: setting the mode and/or speed is 'sticky'. Subsequent transactions\n"
|
||||
" on that device will, by default, use the previously set values.\n"
|
||||
"\n",
|
||||
stderr);
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char *argv[], char *envp[] __unused)
|
||||
{
|
||||
struct spi_options opt;
|
||||
int err, ch, hdev, finfo, fdir;
|
||||
char *pstr;
|
||||
char dev_name[PATH_MAX * 2 + 5];
|
||||
|
||||
finfo = 0;
|
||||
fdir = DIR_NONE;
|
||||
|
||||
hdev = -1;
|
||||
err = 0;
|
||||
|
||||
dev_name[0] = 0;
|
||||
|
||||
opt.mode = -1;
|
||||
opt.speed = -1;
|
||||
opt.count = 0;
|
||||
opt.ASCII = 0;
|
||||
opt.binary = 0;
|
||||
opt.lsb = 0;
|
||||
opt.verbose = 0;
|
||||
opt.ncmd = 0;
|
||||
opt.pcmd = NULL;
|
||||
|
||||
while (!err && (ch = getopt(argc, argv, "f:d:m:s:c:C:AbLvih")) != -1) {
|
||||
switch (ch) {
|
||||
case 'd':
|
||||
if (optarg[0] == 'r') {
|
||||
if (optarg[1] == 'w' && optarg[2] == 0) {
|
||||
fdir = DIR_READWRITE;
|
||||
}
|
||||
else if (optarg[1] == 0) {
|
||||
fdir = DIR_READ;
|
||||
}
|
||||
}
|
||||
else if (optarg[0] == 'w' && optarg[1] == 0) {
|
||||
fdir = DIR_WRITE;
|
||||
}
|
||||
else {
|
||||
err = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'f':
|
||||
if (!optarg[0]) { /* unlikely */
|
||||
fputs("error - missing device name\n", stderr);
|
||||
err = 1;
|
||||
}
|
||||
else {
|
||||
if (optarg[0] == '/')
|
||||
strlcpy(dev_name, optarg,
|
||||
sizeof(dev_name));
|
||||
else
|
||||
snprintf(dev_name, sizeof(dev_name),
|
||||
"/dev/%s", optarg);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'm':
|
||||
opt.mode = (int)strtol(optarg, &pstr, 10);
|
||||
|
||||
if (!pstr || *pstr || opt.mode < 0 || opt.mode > 3) {
|
||||
fprintf(stderr, "Invalid mode specified: %s\n",
|
||||
optarg);
|
||||
err = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case 's':
|
||||
opt.speed = (int)strtol(optarg, &pstr, 10);
|
||||
|
||||
if (!pstr || *pstr || opt.speed < 0) {
|
||||
fprintf(stderr, "Invalid speed specified: %s\n",
|
||||
optarg);
|
||||
err = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'c':
|
||||
opt.count = (int)strtol(optarg, &pstr, 10);
|
||||
|
||||
if (!pstr || *pstr) {
|
||||
fprintf(stderr, "Invalid count specified: %s\n",
|
||||
optarg);
|
||||
err = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'C':
|
||||
if(opt.pcmd) /* specified more than once */
|
||||
err = 1;
|
||||
else {
|
||||
/* get malloc'd buffer or error */
|
||||
if (interpret_command_bytes(optarg, &opt))
|
||||
err = 1;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 'A':
|
||||
opt.ASCII = 1;
|
||||
break;
|
||||
|
||||
case 'b':
|
||||
opt.binary = 1;
|
||||
break;
|
||||
|
||||
case 'L':
|
||||
opt.lsb = 1;
|
||||
break;
|
||||
|
||||
case 'v':
|
||||
opt.verbose++;
|
||||
break;
|
||||
|
||||
case 'i':
|
||||
finfo = 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
err = 1;
|
||||
/* FALLTHROUGH */
|
||||
case 'h':
|
||||
usage();
|
||||
goto the_end;
|
||||
}
|
||||
}
|
||||
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
|
||||
if (err ||
|
||||
(fdir == DIR_NONE && !finfo && opt.mode == -1 && opt.speed == -1 && opt.count == 0)) {
|
||||
/*
|
||||
* if any of the direction, mode, speed, or count not specified,
|
||||
* print usage
|
||||
*/
|
||||
|
||||
usage();
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
if ((opt.count != 0 || opt.ncmd != 0) && fdir == DIR_NONE) {
|
||||
/*
|
||||
* count was specified, but direction was not. default is
|
||||
* read/write
|
||||
*/
|
||||
/*
|
||||
* this includes a negative count, which implies write from
|
||||
* stdin
|
||||
*/
|
||||
if (opt.count == 0)
|
||||
fdir = DIR_WRITE;
|
||||
else
|
||||
fdir = DIR_READWRITE;
|
||||
}
|
||||
|
||||
if (opt.count < 0 && fdir != DIR_READWRITE && fdir != DIR_WRITE) {
|
||||
fprintf(stderr, "Invalid length %d when not writing data\n",
|
||||
opt.count);
|
||||
|
||||
err = 1;
|
||||
usage();
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
|
||||
if (!dev_name[0]) /* no device name specified */
|
||||
strlcpy(dev_name, DEFAULT_DEVICE_NAME, sizeof(dev_name));
|
||||
|
||||
hdev = open(dev_name, O_RDWR);
|
||||
|
||||
if (hdev == -1) {
|
||||
fprintf(stderr, "Error - unable to open '%s', errno=%d\n",
|
||||
dev_name, errno);
|
||||
err = 1;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
if (finfo) {
|
||||
err = get_info(hdev, dev_name);
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
/* check and assign mode, speed */
|
||||
|
||||
if (opt.mode != -1) {
|
||||
err = set_mode(hdev, &opt);
|
||||
|
||||
if (err)
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
if (opt.speed != -1) {
|
||||
err = set_speed(hdev, &opt);
|
||||
|
||||
if (err)
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
/* do data transfer */
|
||||
|
||||
if (fdir == DIR_READ) {
|
||||
err = perform_read(hdev, &opt);
|
||||
}
|
||||
else if (fdir == DIR_WRITE) {
|
||||
err = perform_write(hdev, &opt);
|
||||
}
|
||||
else if (fdir == DIR_READWRITE) {
|
||||
err = perform_readwrite(hdev, &opt);
|
||||
}
|
||||
|
||||
the_end:
|
||||
|
||||
if (hdev != -1)
|
||||
close(hdev);
|
||||
|
||||
free(opt.pcmd);
|
||||
|
||||
return (err);
|
||||
}
|
||||
|
||||
static int
|
||||
interpret_command_bytes(const char *parg, struct spi_options *popt)
|
||||
{
|
||||
int ch, ch2, ctr, cbcmd, err;
|
||||
const char *ppos;
|
||||
void *ptemp;
|
||||
uint8_t *pcur;
|
||||
|
||||
err = 0;
|
||||
cbcmd = DEFAULT_BUFFER_SIZE; /* initial cmd buffer size */
|
||||
popt->pcmd = (uint8_t *)malloc(cbcmd);
|
||||
|
||||
if (!popt->pcmd)
|
||||
return 1;
|
||||
|
||||
pcur = popt->pcmd;
|
||||
|
||||
ctr = 0;
|
||||
ppos = parg;
|
||||
|
||||
while (*ppos) {
|
||||
while (*ppos && *ppos <= ' ') {
|
||||
ppos++; /* skip (optional) leading white space */
|
||||
}
|
||||
|
||||
if (!*ppos)
|
||||
break; /* I am done */
|
||||
|
||||
ch = hexval(*(ppos++));
|
||||
if (ch < 0 || !*ppos) { /* must be valid pair of hex characters */
|
||||
err = 1;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
ch2 = hexval(*(ppos++));
|
||||
if (ch2 < 0) {
|
||||
err = 1;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
ch = (ch * 16 + ch2) & 0xff; /* convert to byte */
|
||||
|
||||
if (ctr >= cbcmd) { /* need re-alloc buffer? (unlikely) */
|
||||
cbcmd += 8192; /* increase by additional 8k */
|
||||
ptemp = realloc(popt->pcmd, cbcmd);
|
||||
|
||||
if (!ptemp) {
|
||||
err = 1;
|
||||
fprintf(stderr,
|
||||
"Not enough memory to interpret command bytes, errno=%d\n",
|
||||
errno);
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
popt->pcmd = (uint8_t *)ptemp;
|
||||
pcur = popt->pcmd + ctr;
|
||||
}
|
||||
|
||||
if (popt->lsb)
|
||||
*pcur = reversebits[ch];
|
||||
else
|
||||
*pcur = (uint8_t)ch;
|
||||
|
||||
pcur++;
|
||||
ctr++;
|
||||
}
|
||||
|
||||
popt->ncmd = ctr; /* record num bytes in '-C' argument */
|
||||
|
||||
the_end:
|
||||
|
||||
/* at this point popt->pcmd is NULL or a valid pointer */
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
get_info(int hdev, const char *dev_name)
|
||||
{
|
||||
uint32_t fmode, fspeed;
|
||||
int err;
|
||||
char temp_buf[PATH_MAX], cpath[PATH_MAX];
|
||||
|
||||
if (!realpath(dev_name, cpath)) /* get canonical name for info purposes */
|
||||
strlcpy(cpath, temp_buf, sizeof(cpath)); /* this shouldn't happen */
|
||||
|
||||
err = ioctl(hdev, SPIGENIOC_GET_SPI_MODE, &fmode);
|
||||
|
||||
if (err == 0)
|
||||
err = ioctl(hdev, SPIGENIOC_GET_CLOCK_SPEED, &fspeed);
|
||||
|
||||
if (err == 0) {
|
||||
fprintf(stderr,
|
||||
"Device name: %s\n"
|
||||
"Device mode: %d\n"
|
||||
"Device speed: %d\n",
|
||||
cpath, fmode, fspeed);//, max_cmd, max_data, temp_buf);
|
||||
}
|
||||
else
|
||||
fprintf(stderr, "Unable to query info (err=%d), errno=%d\n",
|
||||
err, errno);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
set_mode(int hdev, struct spi_options *popt)
|
||||
{
|
||||
uint32_t fmode = popt->mode;
|
||||
|
||||
if (popt->mode < 0) /* use default? */
|
||||
return 0;
|
||||
|
||||
return ioctl(hdev, SPIGENIOC_SET_SPI_MODE, &fmode);
|
||||
}
|
||||
|
||||
static int
|
||||
set_speed(int hdev, struct spi_options *popt)
|
||||
{
|
||||
uint32_t clock_speed = popt->speed;
|
||||
|
||||
if (popt->speed < 0)
|
||||
return 0;
|
||||
|
||||
return ioctl(hdev, SPIGENIOC_SET_CLOCK_SPEED, &clock_speed);
|
||||
}
|
||||
|
||||
static int
|
||||
hexval(char c)
|
||||
{
|
||||
if (c >= '0' && c <= '9') {
|
||||
return c - '0';
|
||||
} else if (c >= 'A' && c <= 'F') {
|
||||
return c - 'A' + 10;
|
||||
} else if (c >= 'a' && c <= 'f') {
|
||||
return c - 'a' + 10;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void *
|
||||
prep_write_buffer(struct spi_options *popt)
|
||||
{
|
||||
int ch, ch2, ch3, ncmd, lsb, err;
|
||||
uint8_t *pdata, *pdat2;
|
||||
size_t cbdata, cbread;
|
||||
const char *szbytes;
|
||||
|
||||
ncmd = popt->ncmd; /* num command bytes (can be zero) */
|
||||
|
||||
if (ncmd == 0 && popt->count == 0)
|
||||
return NULL; /* always since it's an error if it happens
|
||||
* now */
|
||||
|
||||
if (popt->count < 0) {
|
||||
cbdata = DEFAULT_BUFFER_SIZE;
|
||||
}
|
||||
else {
|
||||
cbdata = popt->count;
|
||||
}
|
||||
|
||||
lsb = popt->lsb; /* non-zero if LSB order; else MSB */
|
||||
|
||||
pdata = malloc(cbdata + ncmd + 1);
|
||||
cbread = 0;
|
||||
|
||||
err = 0;
|
||||
|
||||
if (!pdata)
|
||||
return NULL;
|
||||
|
||||
if (popt->pcmd && ncmd > 0) {
|
||||
memcpy(pdata, popt->pcmd, ncmd); /* copy command bytes */
|
||||
pdat2 = pdata + ncmd;
|
||||
}
|
||||
else
|
||||
pdat2 = pdata; /* no prepended command data */
|
||||
|
||||
/*
|
||||
* read up to 'cbdata' bytes. If I get an EOF, do one of two things:
|
||||
* a) change the data count to match how many bytes I read in b) fill
|
||||
* the rest of the input buffer with zeros
|
||||
*
|
||||
* If the specified length is negative, I do 'a', else 'b'
|
||||
*/
|
||||
|
||||
while (!err && cbread < cbdata && (ch = fgetc(stdin)) != EOF) {
|
||||
if (popt->ASCII) {
|
||||
/* skip consecutive white space */
|
||||
|
||||
while (ch <= ' ') {
|
||||
if ((ch = fgetc(stdin)) == EOF)
|
||||
break;
|
||||
}
|
||||
|
||||
if (ch != EOF) {
|
||||
ch2 = hexval(ch);
|
||||
|
||||
if (ch2 < 0) {
|
||||
invalid_character:
|
||||
fprintf(stderr,
|
||||
"Invalid input character '%c'\n", ch);
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
ch = fgetc(stdin);
|
||||
|
||||
if (ch != EOF) {
|
||||
ch3 = hexval(ch);
|
||||
|
||||
if (ch3 < 0)
|
||||
goto invalid_character;
|
||||
|
||||
ch = ch2 * 16 + ch3;
|
||||
}
|
||||
}
|
||||
|
||||
if (err || ch == EOF)
|
||||
break;
|
||||
}
|
||||
|
||||
/* for LSB, flip the bits - otherwise, just copy the value */
|
||||
if (lsb)
|
||||
pdat2[cbread] = reversebits[ch];
|
||||
else
|
||||
pdat2[cbread] = (uint8_t) ch;
|
||||
|
||||
cbread++; /* increment num bytes read so far */
|
||||
}
|
||||
|
||||
/* if it was an error, not an EOF, that ended the I/O, return NULL */
|
||||
|
||||
if (err || ferror(stdin)) {
|
||||
free(pdata);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (popt->verbose > 0) {
|
||||
const char *sz_bytes;
|
||||
|
||||
if (cbread != 1)
|
||||
sz_bytes = "bytes"; /* correct plurality of 'byte|bytes' */
|
||||
else
|
||||
sz_bytes = "byte";
|
||||
|
||||
if (popt->ASCII)
|
||||
fprintf(stderr, "ASCII input of %zd %s\n", cbread,
|
||||
sz_bytes);
|
||||
else
|
||||
fprintf(stderr, "Binary input of %zd %s\n", cbread,
|
||||
sz_bytes);
|
||||
}
|
||||
|
||||
/*
|
||||
* if opt.count is negative, copy actual byte count to opt.count which does
|
||||
* not include any of the 'command' bytes that are being sent. Can be zero.
|
||||
*/
|
||||
if (popt->count < 0) {
|
||||
popt->count = cbread;
|
||||
}
|
||||
/*
|
||||
* for everything else, fill the rest of the read buffer with '0'
|
||||
* bytes, as per the standard practice for SPI
|
||||
*/
|
||||
else {
|
||||
while (cbread < cbdata)
|
||||
pdat2[cbread++] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* popt->count bytes will be sent and read from the SPI, preceded by the
|
||||
* 'popt->ncmd' command bytes (if any).
|
||||
* So we must use 'popt->count' and 'popt->ncmd' from this point on in
|
||||
* the code.
|
||||
*/
|
||||
|
||||
if (popt->verbose > 0 && popt->count + popt->ncmd) {
|
||||
if ((popt->count + popt->ncmd) == 1)
|
||||
szbytes = "byte";
|
||||
else
|
||||
szbytes = "bytes";
|
||||
|
||||
fprintf(stderr, "Writing %d %s to SPI device\n",
|
||||
popt->count + popt->ncmd, szbytes);
|
||||
|
||||
verbose_dump_buffer(pdata, popt->count + popt->ncmd, lsb);
|
||||
}
|
||||
|
||||
return pdata;
|
||||
}
|
||||
|
||||
static int
|
||||
_read_write(int hdev, void *bufw, void *bufr, int cbrw, int lsb)
|
||||
{
|
||||
int err, ctr;
|
||||
struct spigen_transfer spi;
|
||||
|
||||
if (!cbrw)
|
||||
return 0;
|
||||
|
||||
if (!bufr)
|
||||
bufr = bufw;
|
||||
else
|
||||
memcpy(bufr, bufw, cbrw); /* transaction uses bufr for
|
||||
* both R and W */
|
||||
|
||||
bzero(&spi, sizeof(spi)); /* zero structure first */
|
||||
|
||||
/* spigen code seems to suggest there must be at least 1 command byte */
|
||||
|
||||
spi.st_command.iov_base = bufr;
|
||||
spi.st_command.iov_len = cbrw;
|
||||
|
||||
/*
|
||||
* The remaining members for spi.st_data are zero - all bytes are
|
||||
* 'command' for this. The driver doesn't really do anything different
|
||||
* for 'command' vs 'data' and at least one command byte must be sent in
|
||||
* the transaction.
|
||||
*/
|
||||
|
||||
err = ioctl(hdev, SPIGENIOC_TRANSFER, &spi) < 0 ? -1 : 0;
|
||||
|
||||
if (!err && lsb) {
|
||||
/* flip the bits for 'lsb' mode */
|
||||
for (ctr = 0; ctr < cbrw; ctr++) {
|
||||
((uint8_t *) bufr)[ctr] =
|
||||
reversebits[((uint8_t *)bufr)[ctr]];
|
||||
}
|
||||
}
|
||||
|
||||
if (err)
|
||||
fprintf(stderr, "Error performing SPI transaction, errno=%d\n",
|
||||
errno);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
_do_data_output(void *pr, struct spi_options *popt)
|
||||
{
|
||||
int err, index, icount;
|
||||
const char *sz_bytes, *sz_byte2;
|
||||
const uint8_t *pbuf;
|
||||
|
||||
pbuf = (uint8_t *)pr + popt->ncmd; /* only the data we want */
|
||||
icount = popt->count;
|
||||
err = 0;
|
||||
|
||||
if (icount <= 0) {
|
||||
return -1; /* should not but could happen */
|
||||
}
|
||||
|
||||
if (icount != 1)
|
||||
sz_bytes = "bytes"; /* correct plurality of 'byte|bytes' */
|
||||
else
|
||||
sz_bytes = "byte";
|
||||
|
||||
if (popt->ncmd != 1)
|
||||
sz_byte2 = "bytes";
|
||||
else
|
||||
sz_byte2 = "byte";
|
||||
|
||||
/* binary on stdout */
|
||||
if (popt->binary || !popt->ASCII) {
|
||||
if (popt->verbose > 0)
|
||||
fprintf(stderr, "Binary output of %d %s\n", icount,
|
||||
sz_bytes);
|
||||
|
||||
err = (int)fwrite(pbuf, 1, icount, stdout) != icount;
|
||||
}
|
||||
else if (icount > 0) {
|
||||
if (popt->verbose > 0)
|
||||
fprintf(stderr, "ASCII output of %d %s\n", icount,
|
||||
sz_bytes);
|
||||
|
||||
/* ASCII output */
|
||||
for (index = 0; !err && index < icount; index++) {
|
||||
if (index) {
|
||||
/*
|
||||
* not the first time, insert separating space
|
||||
*/
|
||||
err = fputc(' ', stdout) == EOF;
|
||||
}
|
||||
|
||||
if (!err)
|
||||
err = fprintf(stdout, "%02hhx", pbuf[index]) < 0;
|
||||
}
|
||||
|
||||
if (!err)
|
||||
err = fputc('\n', stdout) == EOF;
|
||||
}
|
||||
|
||||
/* verbose text out on stderr */
|
||||
|
||||
if (err)
|
||||
fprintf(stderr, "Error writing to stdout, errno=%d\n", errno);
|
||||
else if (popt->verbose > 0 && icount) {
|
||||
fprintf(stderr,
|
||||
"%d command %s and %d data %s read from SPI device\n",
|
||||
popt->ncmd, sz_byte2, icount, sz_bytes);
|
||||
|
||||
/* verbose output will show the command bytes as well */
|
||||
verbose_dump_buffer(pr, icount + popt->ncmd, popt->lsb);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
perform_read(int hdev, struct spi_options *popt)
|
||||
{
|
||||
int icount, err;
|
||||
void *pr, *pw;
|
||||
|
||||
pr = NULL;
|
||||
icount = popt->count + popt->ncmd;
|
||||
|
||||
/* prep write buffer filled with 0 bytes */
|
||||
pw = malloc(icount);
|
||||
|
||||
if (!pw) {
|
||||
err = -1;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
bzero(pw, icount);
|
||||
|
||||
/* if I included a command sequence, copy bytes to the write buf */
|
||||
if (popt->pcmd && popt->ncmd > 0)
|
||||
memcpy(pw, popt->pcmd, popt->ncmd);
|
||||
|
||||
pr = malloc(icount + 1);
|
||||
|
||||
if (!pr) {
|
||||
err = -2;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
bzero(pr, icount);
|
||||
|
||||
err = _read_write(hdev, pw, pr, icount, popt->lsb);
|
||||
|
||||
if (!err && popt->count > 0)
|
||||
err = _do_data_output(pr, popt);
|
||||
|
||||
the_end:
|
||||
|
||||
free(pr);
|
||||
free(pw);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
perform_write(int hdev, struct spi_options *popt)
|
||||
{
|
||||
int err;
|
||||
void *pw;
|
||||
|
||||
/* read data from cmd buf and stdin and write to 'write' buffer */
|
||||
|
||||
pw = prep_write_buffer(popt);
|
||||
|
||||
if (!pw) {
|
||||
err = -1;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
err = _read_write(hdev, pw, NULL, popt->count + popt->ncmd, popt->lsb);
|
||||
|
||||
the_end:
|
||||
|
||||
free(pw);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int
|
||||
perform_readwrite(int hdev, struct spi_options *popt)
|
||||
{
|
||||
int icount, err;
|
||||
void *pr, *pw;
|
||||
|
||||
pr = NULL;
|
||||
|
||||
pw = prep_write_buffer(popt);
|
||||
icount = popt->count + popt->ncmd; /* assign after fn call */
|
||||
|
||||
if (!pw) {
|
||||
err = -1;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
pr = malloc(icount + 1);
|
||||
|
||||
if (!pr) {
|
||||
err = -2;
|
||||
goto the_end;
|
||||
}
|
||||
|
||||
bzero(pr, icount);
|
||||
|
||||
err = _read_write(hdev, pw, pr, icount, popt->lsb);
|
||||
|
||||
if (!err)
|
||||
err = _do_data_output(pr, popt);
|
||||
|
||||
the_end:
|
||||
|
||||
free(pr);
|
||||
free(pw);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
verbose_dump_buffer(void *pbuf, int icount, int lsb)
|
||||
{
|
||||
uint8_t ch;
|
||||
int ictr, ictr2, index;
|
||||
|
||||
fputs(" | 0 1 2 3 4 5 6 7 8 9 A B C D E F "
|
||||
"| |\n", stderr);
|
||||
|
||||
for (ictr = 0; ictr < icount; ictr += 16) {
|
||||
fprintf(stderr, " %6x | ", ictr & 0xfffff0);
|
||||
|
||||
for (ictr2 = 0; ictr2 < 16; ictr2++) {
|
||||
index = ictr + ictr2;
|
||||
|
||||
if (index < icount) {
|
||||
ch = ((uint8_t *) pbuf)[index];
|
||||
|
||||
if (lsb)
|
||||
ch = reversebits[ch];
|
||||
|
||||
fprintf(stderr, "%02hhx ", ch);
|
||||
}
|
||||
else {
|
||||
fputs(" ", stderr);
|
||||
}
|
||||
}
|
||||
|
||||
fputs("| ", stderr);
|
||||
|
||||
for (ictr2 = 0; ictr2 < 16; ictr2++) {
|
||||
index = ictr + ictr2;
|
||||
|
||||
if (index < icount) {
|
||||
ch = ((uint8_t *) pbuf)[index];
|
||||
|
||||
if (lsb)
|
||||
ch = reversebits[ch];
|
||||
|
||||
if (ch < ' ' || ch > 127)
|
||||
goto out_of_range;
|
||||
|
||||
fprintf(stderr, "%c", ch);
|
||||
}
|
||||
else if (index < icount) {
|
||||
out_of_range:
|
||||
fputc('.', stderr);
|
||||
}
|
||||
else {
|
||||
fputc(' ', stderr);
|
||||
}
|
||||
}
|
||||
|
||||
fputs(" |\n", stderr);
|
||||
}
|
||||
|
||||
fflush(stderr);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user