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