SPI driver test

 

Linux BSP test-unittest-(C)SPI(using spidev)

There are three ways to test SPI:               1.test in loop back mode.               2.test by other drivers that use it               3.test by spidev I will show how to test spi by spidev.(make sure your board supports SPIDEV interface. ) test code: --------------------------------------spidev.h /* * include/linux/spi/spidev.h * * Copyright (C) 2006 SWAPP * Andrea Paterniani <a.paterniani@swapp-eng.it> * * 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, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef SPIDEV_H #define SPIDEV_H /* User space versions of kernel symbols for SPI clocking modes, * matching <linux/spi/spi.h> */ #define SPI_CPHA   0x01 #define SPI_CPOL   0x02 #define SPI_MODE_0   (0|0) #define SPI_MODE_1   (0|SPI_CPHA) #define SPI_MODE_2   (SPI_CPOL|0) #define SPI_MODE_3   (SPI_CPOL|SPI_CPHA) #define SPI_CS_HIGH   0x04 #define SPI_LSB_FIRST   0x08 #define SPI_3WIRE   0x10 #define SPI_LOOP   0x20 /*---------------------------------------------------------------------------*/ /* IOCTL commands */ #define SPI_IOC_MAGIC    'k' /** * struct spi_ioc_transfer - describes a single SPI transfer * @tx_buf: Holds pointer to userspace buffer with transmit data, or null. * If no data is provided, zeroes are shifted out. * @rx_buf: Holds pointer to userspace buffer for receive data, or null. * @len: Length of tx and rx buffers, in bytes. * @speed_hz: Temporary override of the device's bitrate. * @bits_per_word: Temporary override of the device's wordsize. * @delay_usecs: If nonzero, how long to delay after the last bit transfer * before optionally deselecting the device before the next transfer. * @cs_change: True to deselect device before starting the next transfer. * * This structure is mapped directly to the kernel spi_transfer structure; * the fields have the same meanings, except of course that the pointers * are in a different address space (and may be of different sizes in some * cases, such as 32-bit i386 userspace over a 64-bit x86_64 kernel). * Zero-initialize the structure, including currently unused fields, to * accomodate potential future updates. * * SPI_IOC_MESSAGE gives userspace the equivalent of kernel spi_sync(). * Pass it an array of related transfers, they'll execute together. * Each transfer may be half duplex (either direction) or full duplex. * * struct spi_ioc_transfer mesg[4]; * ... * status = ioctl(fd, SPI_IOC_MESSAGE(4), mesg); * * So for example one transfer might send a nine bit command (right aligned * in a 16-bit word), the next could read a block of 8-bit data before * terminating that command by temporarily deselecting the chip; the next * could send a different nine bit command (re-selecting the chip), and the * last transfer might write some register values. */ struct spi_ioc_transfer { __u64   tx_buf; __u64   rx_buf; __u32   len; __u32   speed_hz; __u16   delay_usecs; __u8   bits_per_word; __u8   cs_change; __u32   pad; /* If the contents of 'struct spi_ioc_transfer' ever change * incompatibly, then the ioctl number (currently 0) must change; * ioctls with constant size fields get a bit more in the way of * error checking than ones (like this) where that field varies. * * NOTE: struct layout is the same in 64bit and 32bit userspace. */ }; /* not all platforms use <asm-generic/ioctl.h> or _IOC_TYPECHECK() ... */ #define SPI_MSGSIZE(N) \ ((((N)*(sizeof (struct spi_ioc_transfer))) < (1 << _IOC_SIZEBITS)) \    ? ((N)*(sizeof (struct spi_ioc_transfer))) : 0) #define SPI_IOC_MESSAGE(N) _IOW(SPI_IOC_MAGIC, 0, char[SPI_MSGSIZE(N)]) /* Read / Write of SPI mode (SPI_MODE_0..SPI_MODE_3) */ #define SPI_IOC_RD_MODE    _IOR(SPI_IOC_MAGIC, 1, __u8) #define SPI_IOC_WR_MODE    _IOW(SPI_IOC_MAGIC, 1, __u8) /* Read / Write SPI bit justification */ #define SPI_IOC_RD_LSB_FIRST   _IOR(SPI_IOC_MAGIC, 2, __u8) #define SPI_IOC_WR_LSB_FIRST   _IOW(SPI_IOC_MAGIC, 2, __u8) /* Read / Write SPI device word length (1..N) */ #define SPI_IOC_RD_BITS_PER_WORD _IOR(SPI_IOC_MAGIC, 3, __u8) #define SPI_IOC_WR_BITS_PER_WORD _IOW(SPI_IOC_MAGIC, 3, __u8) /* Read / Write SPI device default max speed hz */ #define SPI_IOC_RD_MAX_SPEED_HZ   _IOR(SPI_IOC_MAGIC, 4, __u32) #define SPI_IOC_WR_MAX_SPEED_HZ   _IOW(SPI_IOC_MAGIC, 4, __u32) #endif /* SPIDEV_H */ --------------------------------------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 "spidev.h" #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) static void pabort(const char *s) {         perror(s);         abort(); } static 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(""); } void print_usage(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); } void parse_opts(int argc, char *argv[]) {         while (1) {                 static 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' },                         { NULL, 0, 0, 0 },                 };                 int c;                 c = getopt_long(argc, argv, "D:s:d:b:lHOLC3", 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;                 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; } Create bin file"spidev_test",then run ./spi_test + parameters in command line to test your SPI driver.