友善之臂 mini2440 SPI 驱动移植.docx

友善之臂 mini2440 SPI 驱动移植.docx

《友善之臂 mini2440 SPI 驱动移植.docx》由会员分享，可在线阅读，更多相关《友善之臂 mini2440 SPI 驱动移植.docx（13页珍藏版）》请在冰豆网上搜索。

友善之臂mini2440SPI驱动移植

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

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

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

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

//spi  add by shiguang 

#include  

#include  

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的开头增加下列代码

//spiaddbyshiguang

s3c_device_spi0.dev.platform_data=&s3c2410_spi0_platdata;

spi_register_board_info（s3c2410_spi0_board,ARRAY_SIZE（s3c2410_spi0_board））;

//endspi

在mini2440_devices数组的最后中添加

&s3c_device_spi0,//addbyshiguang

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

在文件开头增加下列代码

//addbyshiguang

#include

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

//addbyshiguang

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）;

//endadd

3.最后重新编译内核

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

[root@ShiGuang/]#ls/dev/spidev0.0-l

crw-rw----  1root  root  153, 0Jan 108:

00/dev/spidev0.0

[root@ShiGuang/]# 

4.应用程序测试

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

viewplaincopytoclipboardprint?

1./* 

2. * SPI testing utility （using spidev driver） 

3. * 

4. * Copyright （c） 2007  MontaVista Software, Inc. 

5. * Copyright （c） 2007  Anton Vorontsov  

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   

15.#include   

16.#include   

17.#include   

18.#include   

19.#include   

20.#include   

21.#include   

22.#include   

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的SPIrx和tx短接就可以收到数据。

结果如下图所示：

测试完毕！

OVER！