Linux下SPI驱动的移植和应用程序的测试

Linux2.6.32下SPI驱动的移植如下图所示：

下面需要修改部分内核代码，具体操作如下：

1.  修改arch/arm/mach-s3c2440/mach-mini2440.c文件

在include头文件代码行之后增加如下代码

//spi  add by shiguang 
#include <linux/spi/spi.h> 
#include <mach/spi.h> 
 
static struct spi_board_info s3c2410_spi0_board[] = { 
        [0] = { 
                 .modalias = "spidev", 
                .bus_num        = 0,  
                .chip_select        = 0, 
                .irq = IRQ_EINT9, 
                .max_speed_hz         = 500*1000, 
        }, 
}; 
 
static struct s3c2410_spi_info s3c2410_spi0_platdata = { 
        .pin_cs = S3C2410_GPG(2), 
        .num_cs = 1, 
        .bus_num = 0, 
}; 
//end add spi 

 

然后在函数__initmini2440_machine_init的开头增加下列代码

//spi add by shiguang

s3c_device_spi0.dev.platform_data=&s3c2410_spi0_platdata;

spi_register_board_info(s3c2410_spi0_board,ARRAY_SIZE(s3c2410_spi0_board));

//end spi

 

在mini2440_devices数组的最后中添加

&s3c_device_spi0,// add by shiguang

 

2.修改drivers/spi/spi_s3c24xx.c文件

在文件开头增加下列代码

//add by shiguang

#include <mach/regs-gpio.h>

 

在s3c24xx_spi_initialsetup函数结尾增加下列代码

// add by shiguang

s3c2410_gpio_cfgpin(hw->pdata->pin_cs,S3C2410_GPIO_OUTPUT);

s3c2410_gpio_cfgpin(0x8B, S3C2410_GPIO_SFN2);

s3c2410_gpio_cfgpin(0x8C, S3C2410_GPIO_SFN2);

s3c2410_gpio_cfgpin(0x8D, S3C2410_GPIO_SFN2);

// end add

3. 最后重新编译内核

重启mini2440，查看/dev下的设备文件

[root@ShiGuang /]# ls /dev/spidev0.0 -l
crw-rw----    1 root     root     153,   0 Jan  1 08:00 /dev/spidev0.0
[root@ShiGuang /]# 

4. 应用程序测试

测设程序取至Linux源码包下的/home/youshan/linux-2.6.32.2/Documentation/spi/spidev_test.c ，这里我再把它贴一遍。

[cpp] view plain copy

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 <getopt.h>  
19. #include <fcntl.h>  
20. #include <sys/ioctl.h>  
21. #include <linux/types.h>  
22. #include <linux/spi/spidev.h>  
23.   
24. #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))  
25.   
26. static void pabort(const char *s)  
27. {  
28.         perror(s);  
29.         abort();  
30. }  
31.   
32. static const char *device = "/dev/spidev1.1";  
33. static uint8_t mode;  
34. static uint8_t bits = 8;  
35. static uint32_t speed = 500000;  
36. static uint16_t delay;  
37.   
38. static void transfer(int fd)  
39. {  
40.         int ret;  
41.         uint8_t tx[] = {  
42.                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,  
43.                 0x40, 0x00, 0x00, 0x00, 0x00, 0x95,  
44.                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,  
45.                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,  
46.                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,  
47.                 0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD,  
48.                 0xF0, 0x0D,  
49.         };  
50.         uint8_t rx[ARRAY_SIZE(tx)] = {0, };  
51.         struct spi_ioc_transfer tr = {  
52.                 .tx_buf = (unsigned long)tx,  
53.                 .rx_buf = (unsigned long)rx,  
54.                 .len = ARRAY_SIZE(tx),  
55.                 .delay_usecs = delay,  
56.                 .speed_hz = speed,  
57.                 .bits_per_word = bits,  
58.         };  
59.   
60.         ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);  
61.         if (ret == 1)  
62.                 pabort("can't send spi message");  
63.   
64.         for (ret = 0; ret < ARRAY_SIZE(tx); ret++) {  
65.                 if (!(ret % 6))  
66.                         puts("");  
67.                 printf("%.2X ", rx[ret]);  
68.         }  
69.         puts("");  
70. }  
71.   
72. static void print_usage(const char *prog)  
73. {  
74.         printf("Usage: %s [-DsbdlHOLC3]\n", prog);  
75.         puts("  -D --device   device to use (default /dev/spidev1.1)\n"  
76.              "  -s --speed    max speed (Hz)\n"  
77.              "  -d --delay    delay (usec)\n"  
78.              "  -b --bpw      bits per word \n"  
79.              "  -l --loop     loopback\n"  
80.              "  -H --cpha     clock phase\n"  
81.              "  -O --cpol     clock polarity\n"  
82.              "  -L --lsb      least significant bit first\n"  
83.              "  -C --cs-high  chip select active high\n"  
84.              "  -3 --3wire    SI/SO signals shared\n");  
85.         exit(1);  
86. }  
87.   
88. static void parse_opts(int argc, char *argv[])  
89. {  
90.         while (1) {  
91.                 static const struct option lopts[] = {  
92.                         { "device",  1, 0, 'D' },  
93.                         { "speed",   1, 0, 's' },  
94.                         { "delay",   1, 0, 'd' },  
95.                         { "bpw",     1, 0, 'b' },  
96.                         { "loop",    0, 0, 'l' },  
97.                         { "cpha",    0, 0, 'H' },  
98.                         { "cpol",    0, 0, 'O' },  
99.                         { "lsb",     0, 0, 'L' },  
100.                         { "cs-high", 0, 0, 'C' },  
101.                         { "3wire",   0, 0, '3' },  
102.                         { "no-cs",   0, 0, 'N' },  
103.                         { "ready",   0, 0, 'R' },  
104.                         { NULL, 0, 0, 0 },  
105.                 };  
106.                 int c;  
107.   
108.                 c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);  
109.   
110.                 if (c == -1)  
111.                         break;  
112.   
113.                 switch (c) {  
114.                 case 'D':  
115.                         device = optarg;  
116.                         break;  
117.                 case 's':  
118.                         speed = atoi(optarg);  
119.                         break;  
120.                 case 'd':  
121.                         delay = atoi(optarg);  
122.                         break;  
123.                 case 'b':  
124.                         bits = atoi(optarg);  
125.                         break;  
126.                 case 'l':  
127.                         mode |= SPI_LOOP;  
128.                         break;  
129.                 case 'H':  
130.                         mode |= SPI_CPHA;  
131.                         break;  
132.                 case 'O':  
133.                         mode |= SPI_CPOL;  
134.                         break;  
135.                 case 'L':  
136.                         mode |= SPI_LSB_FIRST;  
137.                         break;  
138.                 case 'C':  
139.                         mode |= SPI_CS_HIGH;  
140.                         break;  
141.                 case '3':  
142.                         mode |= SPI_3WIRE;  
143.                         break;  
144.                 case 'N':  
145.                         mode |= SPI_NO_CS;  
146.                         break;  
147.                 case 'R':  
148.                         mode |= SPI_READY;  
149.                         break;  
150.                 default:  
151.                         print_usage(argv[0]);  
152.                         break;  
153.                 }  
154.         }  
155. }  
156.   
157. int main(int argc, char *argv[])  
158. {  
159.         int ret = 0;  
160.         int fd;  
161.   
162.         parse_opts(argc, argv);  
163.   
164.         fd = open(device, O_RDWR);  
165.         if (fd < 0)  
166.                 pabort("can't open device");  
167.   
168.         /* 
169.          * spi mode 
170.          */  
171.         ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);  
172.         if (ret == -1)  
173.                 pabort("can't set spi mode");  
174.   
175.         ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);  
176.         if (ret == -1)  
177.                 pabort("can't get spi mode");  
178.   
179.         /* 
180.          * bits per word 
181.          */  
182.         ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);  
183.         if (ret == -1)  
184.                 pabort("can't set bits per word");  
185.   
186.         ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);  
187.         if (ret == -1)  
188.                 pabort("can't get bits per word");  
189.   
190.         /* 
191.          * max speed hz 
192.          */  
193.         ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);  
194.         if (ret == -1)  
195.                 pabort("can't set max speed hz");  
196.   
197.         ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);  
198.         if (ret == -1)  
199.                 pabort("can't get max speed hz");  
200.   
201.         printf("spi mode: %d\n", mode);  
202.         printf("bits per word: %d\n", bits);  
203.         printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);  
204.   
205.         transfer(fd);  
206.   
207.         close(fd);  
208.   
209.         return ret;  
210. }  

只需将mini2440的SPI rx和tx短接就可以收到数据。结果如下图所示：

测试完毕！OVER！