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