Merge tag 'drm-intel-next-2023-08-03' of git://anongit.freedesktop.org/drm/drm-intel...
[platform/kernel/linux-rpi.git] / tools / spi / spidev_test.c
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
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
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  */
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
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
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
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
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
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
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
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
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 }