Linux下spi驱动开发

1. struct platform_device s3c_device_spi0 = {
   
2.                           .name = "s3c64xx-spi", //名称，要和Platform_driver匹配
   
3.                 .id = 0, //第0个控制器，S5PC100中有3个控制器
   
4.                 .num_resources = ARRAY_SIZE(s5pc1xx_spi0_resource), //占用资源的种类
   
5.                 .resource = s5pc1xx_spi0_resource, //指向资源结构数组的指针
   
6.                 .dev = {
   
7.                                   .dma_mask = &spi_dmamask, //dma寻址范围
   
8.                         .coherent_dma_mask = DMA_BIT_MASK(32), //可以通过关闭cache等措施保证一致性的dma寻址范围
   
9.                         .platform_data = &s5pc1xx_spi0_pdata, //特殊的平台数据，参看后文
   
10.                 },
    
11.                 };
    
12. 
    
13. static struct s3c64xx_spi_cntrlr_info s5pc1xx_spi0_pdata = {
    
14.                   .cfg_gpio = s5pc1xx_spi_cfg_gpio, //用于控制器管脚的IO配置
    
15.         .fifo_lvl_mask = 0x7f,
    
16.                   .rx_lvl_offset = 13,
    
17.                 };
    
18. 
    
19. static int s5pc1xx_spi_cfg_gpio(struct platform_device *pdev)
    
20.                   {
    
21.                   switch (pdev->id) {
    
22.                   case 0:
    
23.                           s3c_gpio_cfgpin(S5PC1XX_GPB(0), S5PC1XX_GPB0_SPI_MISO0);
    
24.                           s3c_gpio_cfgpin(S5PC1XX_GPB(1), S5PC1XX_GPB1_SPI_CLK0);
    
25.                           s3c_gpio_cfgpin(S5PC1XX_GPB(2), S5PC1XX_GPB2_SPI_MOSI0);
    
26.                           s3c_gpio_setpull(S5PC1XX_GPB(0), S3C_GPIO_PULL_UP);
    
27.                           s3c_gpio_setpull(S5PC1XX_GPB(1), S3C_GPIO_PULL_UP);
    
28.                           s3c_gpio_setpull(S5PC1XX_GPB(2), S3C_GPIO_PULL_UP);
    
29.                         break;
    
30. 
    
31. case 1:
    
32.                           s3c_gpio_cfgpin(S5PC1XX_GPB(4), S5PC1XX_GPB4_SPI_MISO1);
    
33.                           s3c_gpio_cfgpin(S5PC1XX_GPB(5), S5PC1XX_GPB5_SPI_CLK1);
    
34.                           s3c_gpio_cfgpin(S5PC1XX_GPB(6), S5PC1XX_GPB6_SPI_MOSI1);
    
35.                           s3c_gpio_setpull(S5PC1XX_GPB(4), S3C_GPIO_PULL_UP);
    
36.                           s3c_gpio_setpull(S5PC1XX_GPB(5), S3C_GPIO_PULL_UP);
    
37.                           s3c_gpio_setpull(S5PC1XX_GPB(6), S3C_GPIO_PULL_UP);
    
38.                         break;
    
39. 
    
40. case 2:
    
41.                           s3c_gpio_cfgpin(S5PC1XX_GPG3(0), S5PC1XX_GPG3_0_SPI_CLK2);
    
42.                           s3c_gpio_cfgpin(S5PC1XX_GPG3(2), S5PC1XX_GPG3_2_SPI_MISO2);
    
43.                           s3c_gpio_cfgpin(S5PC1XX_GPG3(3), S5PC1XX_GPG3_3_SPI_MOSI2);
    
44.                           s3c_gpio_setpull(S5PC1XX_GPG3(0), S3C_GPIO_PULL_UP);
    
45.                           s3c_gpio_setpull(S5PC1XX_GPG3(2), S3C_GPIO_PULL_UP);
    
46.                           s3c_gpio_setpull(S5PC1XX_GPG3(3), S3C_GPIO_PULL_UP);
    
47.                         break;
    
48. 
    
49. default:
    
50.                           dev_err(&pdev->dev, "Invalid SPI Controller number!");
    
51.                           return -EINVAL;
    
52.                   }

1. static struct platform_driver s3c64xx_spi_driver = {
   
2.                           .driver = {
   
3.                                   .name = "s3c64xx-spi", //名称，和platform_device对应
   
4.                         .owner = THIS_MODULE,
   
5.                           },
   
6.                           .remove = s3c64xx_spi_remove,
   
7.                           .suspend = s3c64xx_spi_suspend,
   
8.                           .resume = s3c64xx_spi_resume,
   
9.                 };
   
10. 
    
11. platform_driver_probe(&s3c64xx_spi_driver, s3c64xx_spi_probe)；//注册s3c64xx_spi_driver

1. struct spi_master {
   
2.                           struct device dev;
   
3.                           s16 bus_num; //表示是SPI主机控制器的编号。由平台代码决定
   
4.                 u16 num_chipselect; //控制器支持的片选数量，即能支持多少个spi设备
   
5.                 int (*setup)(struct spi_device *spi); //针对设备设置SPI的工作时钟及数据传输模式等。在spi_add_device函数中调用。
   
6.                 int (*transfer)(struct spi_device *spi,
   
7.                           struct spi_message *mesg); //实现数据的双向传输，可能会睡眠
   
8.                 void (*cleanup)(struct spi_device *spi); //注销时调用
   
9.         };

1. struct bus_type spi_bus_type = {
   
2.                           .name = "spi",
   
3.                           .dev_attrs = spi_dev_attrs,
   
4.                           .match = spi_match_device,
   
5.                           .uevent = spi_uevent,
   
6.                           .suspend = spi_suspend,
   
7.                           .resume = spi_resume,
   
8.                 };

1. static int spi_match_device(struct device *dev, struct device_driver *drv)
   
2.                   {
   
3.                           const struct spi_device *spi = to_spi_device(dev);
   
4.                           return strcmp(spi->modalias, drv->name) == 0;
   
5.                 }

1. static struct spi_board_info s3c_spi_devs[] __initdata = {
   
2.                           {
   
3.                                   .modalias = "m25p10",
   
4.                                   .mode = SPI_MODE_0, //CPOL=0, CPHA=0 此处选择具体数据传输模式
   
5.                         .max_speed_hz = 10000000, //最大的spi时钟频率
   
6.                         /* Connected to SPI-0 as 1st Slave */
   
7.                                   .bus_num = 0, //设备连接在spi控制器0上
   
8.                         .chip_select = 0, //片选线号，在S5PC100的控制器驱动中没有使用它作为片选的依据，而是选择了下文controller_data里的方法。
   
9.                         .controller_data = &smdk_spi0_csi[0],
   
10.                           },
    
11.                   };
    
12.                   static struct s3c64xx_spi_csinfo smdk_spi0_csi[] = {
    
13.                           [0] = {
    
14.                                   .set_level = smdk_m25p10_cs_set_level,
    
15.                                   .fb_delay = 0x3,
    
16.                           },
    
17.                   };
    
18.                   static void smdk_m25p10_cs_set_level(int high) //spi控制器会用这个方法设置cs
    
19.                   {
    
20.                           u32 val;
    
21.                           val = readl(S5PC1XX_GPBDAT);
    
22.                           if (high)
    
23.                                   val |= (1<<3);
    
24.                           else
    
25.                                   val &= ~(1<<3);
    
26.                           writel(val, S5PC1XX_GPBDAT);
    
27.                 }
    
28. 
    
29. spi_register_board_info(s3c_spi_devs, ARRAY_SIZE(s3c_spi_devs));//注册spi_board_info。这个代码会把spi_board_info注册要链表board_list上。

1. static void scan_boardinfo(struct spi_master *master)
   
2.                   {
   
3.                           struct boardinfo *bi;
   
4.                           mutex_lock(&board_lock);
   
5.                           list_for_each_entry(bi, &board_list, list) {
   
6.                                   struct spi_board_info *chip = bi->board_info;
   
7.                                   unsigned n;
   
8.                                   for (n = bi->n_board_info; n > 0; n--, chip++) {
   
9.                                           if (chip->bus_num != master->bus_num)
   
10.                                           continue;
    
11.                                           /* NOTE: this relies on spi_new_device to
    
12.                                           * issue diagnostics when given bogus inputs
    
13.                                           */
    
14.                                           (void) spi_new_device(master, chip); //创建并注册了spi_device
    
15.                                   }
    
16.                           }
    
17.                           mutex_unlock(&board_lock);
    
18.                 }

1. static struct spi_driver m25p80_driver = { //spi_driver的构建
   
2.                 .driver = {
   
3.                                   .name = "m25p80",
   
4.                                   .bus = &spi_bus_type,
   
5.                                   .owner = THIS_MODULE,
   
6.                           },
   
7.                           .probe = m25p_probe,
   
8.                           .remove = __devexit_p(m25p_remove),
   
9.                           */
   
10.                 };
    
11. 
    
12. spi_register_driver(&m25p80_driver);//spi driver的注册
    
13. 
    
14. 在有匹配的spi device时，会调用m25p_probe
    
15. 
    
16. static int __devinit m25p_probe(struct spi_device *spi)
    
17.                   {
    
18.                   ……
    
19.         }

1. struct spi_transfer t[2]; //定义了两个spi_transfer
   
2.                   struct spi_message m; //定义了两个spi_message
   
3.                 spi_message_init(&m); //初始化其transfers链表
   
4. 
   
5. t[0].tx_buf = flash->command;
   
6.                   t[0].len = CMD_SIZE + FAST_READ_DUMMY_BYTE; //定义第一个transfer的写指针和长度
   
7.         spi_message_add_tail(&t[0], &m); //添加到spi_message
   
8.                   t[1].rx_buf = buf;
   
9.                 t[1].len = len; //定义第二个transfer的读指针和长度
   
10. 
    
11. spi_message_add_tail(&t[1], &m); //添加到spi_message
    
12.                   flash->command[0] = OPCODE_READ;
    
13.                   flash->command[1] = from >> 16;
    
14.                   flash->command[2] = from >> 8;
    
15.                 flash->command[3] = from; //初始化前面写buf的内容
    
16. 
    
17. spi_sync(flash->spi, &m); //调用spi_master发送spi_message
    
18. 
    
19. // spi_sync为同步方式发送，还可以用spi_async异步方式，那样的话，需要设置回调完成函数。
    
20. 
    
21. 另外你也可以选择一些封装好的更容易使用的函数，这些函数可以在include/linux/spi/spi.h文件中找到，如：
    
22. 
    
23. extern int spi_write_then_read(struct spi_device *spi,
    
24.                           const u8 *txbuf, unsigned n_tx,
    
25.                           u8 *rxbuf, unsigned n_rx);

1. #include <linux/platform_device.h>
   
2.         #include <linux/spi/spi.h>
   
3.         #include <linux/init.h>
   
4.         #include <linux/module.h>
   
5.         #include <linux/device.h>
   
6.         #include <linux/interrupt.h>
   
7.         #include <linux/mutex.h>
   
8.         #include <linux/slab.h> // kzalloc
   
9.         #include <linux/delay.h>
   
10. 
    
11. #define FLASH_PAGE_SIZE 256
    
12. 
    
13. /* Flash Operating Commands */
    
14.         #define CMD_READ_ID 0x9f
    
15.         #define CMD_WRITE_ENABLE 0x06
    
16.         #define CMD_BULK_ERASE 0xc7
    
17.         #define CMD_READ_BYTES 0x03
    
18.         #define CMD_PAGE_PROGRAM 0x02
    
19.         #define CMD_RDSR 0x05
    
20. 
    
21. /* Status Register bits. */
    
22.         #define SR_WIP 1 /* Write in progress */
    
23.         #define SR_WEL 2 /* Write enable latch */
    
24. 
    
25. /* ID Numbers */
    
26.         #define MANUFACTURER_ID 0x20
    
27.         #define DEVICE_ID 0x1120
    
28. 
    
29. /* Define max times to check status register before we give up. */
    
30.         #define MAX_READY_WAIT_COUNT 100000
    
31.         #define CMD_SZ 4
    
32. 
    
33. struct m25p10a {
    
34.                 struct spi_device *spi;
    
35.                 struct mutex lock;
    
36.                 char erase_opcode;
    
37.                 char cmd[ CMD_SZ ];
    
38.         };
    
39. 
    
40. /*
    
41.         * Internal Helper functions
    
42.         */
    
43. 
    
44. /*
    
45.         * Read the status register, returning its value in the location
    
46.         * Return the status register value.
    
47.         * Returns negative if error occurred.
    
48.         */
    
49.         static int read_sr(struct m25p10a *flash)
    
50.         {
    
51.                 ssize_t retval;
    
52.                 u8 code = CMD_RDSR;
    
53.                 u8 val;
    
54. 
    
55.         retval = spi_write_then_read(flash->spi, &code, 1, &val, 1);
    
56. 
    
57.         if (retval < 0) {
    
58.                        dev_err(&flash->spi->dev, "error %d reading SR\n", (int) retval);
    
59.                        return retval;
    
60.                  }
    
61. 
    
62.         return val;
    
63.         }
    
64. 
    
65. /*
    
66.         * Service routine to read status register until ready, or timeout occurs.
    
67.         * Returns non-zero if error.
    
68.         */
    
69.         static int wait_till_ready(struct m25p10a *flash)
    
70.         {
    
71.                 int count;
    
72.                 int sr;
    
73. 
    
74.         /* one chip guarantees max 5 msec wait here after page writes,
    
75.                 * but potentially three seconds (!) after page erase.
    
76.                 */
    
77.                 for (count = 0; count < MAX_READY_WAIT_COUNT; count++) {
    
78.                         if ((sr = read_sr(flash)) < 0)
    
79.                                 break;
    
80.                         else if (!(sr & SR_WIP))
    
81.                                 return 0;
    
82. 
    
83.                 /* REVISIT sometimes sleeping would be best */
    
84.                 }
    
85.                  printk( "in (%s): count = %d\n", count );
    
86. 
    
87.         return 1;
    
88.         }
    
89. 
    
90. /*
    
91.         * Set write enable latch with Write Enable command.
    
92.         * Returns negative if error occurred.
    
93.         */
    
94.         static inline int write_enable( struct m25p10a *flash )
    
95.         {
    
96.                 flash->cmd[0] = CMD_WRITE_ENABLE;
    
97.                 return spi_write( flash->spi, flash->cmd, 1 );
    
98.         }
    
99. 
    
100. /*
     
101.         * Erase the whole flash memory
     
102.         *
     
103.         * Returns 0 if successful, non-zero otherwise.
     
104.         */
     
105.         static int erase_chip( struct m25p10a *flash )
     
106.         {
     
107.                 /* Wait until finished previous write command. */
     
108.                 if (wait_till_ready(flash))
     
109.                         return -1;
     
110. 
     
111.         /* Send write enable, then erase commands. */
     
112.                 write_enable( flash );
     
113.                 flash->cmd[0] = CMD_BULK_ERASE;
     
114.                 return spi_write( flash->spi, flash->cmd, 1 );
     
115.         }
     
116. 
     
117. /*
     
118.         * Read an address range from the flash chip. The address range
     
119.         * may be any size provided it is within the physical boundaries.
     
120.         */
     
121.         static int m25p10a_read( struct m25p10a *flash, loff_t from, size_t len, char *buf )
     
122.         {
     
123.                 int r_count = 0, i;
     
124. 
     
125.         flash->cmd[0] = CMD_READ_BYTES;
     
126.                 flash->cmd[1] = from >> 16;
     
127.                 flash->cmd[2] = from >> 8;
     
128.                 flash->cmd[3] = from;
     
129.     
     
130.         #if 1
     
131.                 struct spi_transfer st[2];
     
132.                 struct spi_message msg;
     
133.     
     
134.                 spi_message_init( &msg );
     
135.                 memset( st, 0, sizeof(st) );
     
136. 
     
137.         flash->cmd[0] = CMD_READ_BYTES;
     
138.                 flash->cmd[1] = from >> 16;
     
139.                 flash->cmd[2] = from >> 8;
     
140.                 flash->cmd[3] = from;
     
141. 
     
142.         st[ 0 ].tx_buf = flash->cmd;
     
143.                 st[ 0 ].len = CMD_SZ;
     
144.                 spi_message_add_tail( &st[0], &msg );
     
145. 
     
146.         st[ 1 ].rx_buf = buf;
     
147.                 st[ 1 ].len = len;
     
148.                 spi_message_add_tail( &st[1], &msg );
     
149. 
     
150.         mutex_lock( &flash->lock );
     
151.     
     
152.                 /* Wait until finished previous write command. */
     
153.                 if (wait_till_ready(flash)) {
     
154.                         mutex_unlock( &flash->lock );
     
155.                         return -1;
     
156.                 }
     
157. 
     
158.         spi_sync( flash->spi, &msg );
     
159.                 r_count = msg.actual_length - CMD_SZ;
     
160.                 printk( "in (%s): read %d bytes\n", __func__, r_count );
     
161.                 for( i = 0; i < r_count; i++ ) {
     
162.                         printk( "0x%02x\n", buf[ i ] );
     
163.                 }
     
164. 
     
165.         mutex_unlock( &flash->lock );
     
166.         #endif
     
167. 
     
168.         return 0;
     
169.         }
     
170. 
     
171. /*
     
172.         * Write an address range to the flash chip. Data must be written in
     
173.         * FLASH_PAGE_SIZE chunks. The address range may be any size provided
     
174.         * it is within the physical boundaries.
     
175.         */
     
176.         static int m25p10a_write( struct m25p10a *flash, loff_t to, size_t len, const char *buf )
     
177.         {
     
178.                 int w_count = 0, i, page_offset;
     
179.                 struct spi_transfer st[2];
     
180.                 struct spi_message msg;
     
181.         #if 1
     
182.                 if (wait_till_ready(flash)) { //读状态，等待ready
     
183.                 mutex_unlock( &flash->lock );
     
184.                 return -1;
     
185.                 }
     
186.         #endif
     
187.                 write_enable( flash ); //写使能
     
188.     
     
189.                 spi_message_init( &msg );
     
190.                 memset( st, 0, sizeof(st) );
     
191. 
     
192.         flash->cmd[0] = CMD_PAGE_PROGRAM;
     
193.                 flash->cmd[1] = to >> 16;
     
194.                 flash->cmd[2] = to >> 8;
     
195.                 flash->cmd[3] = to;
     
196. 
     
197.         st[ 0 ].tx_buf = flash->cmd;
     
198.                 st[ 0 ].len = CMD_SZ;
     
199.                 spi_message_add_tail( &st[0], &msg );
     
200. 
     
201.         st[ 1 ].tx_buf = buf;
     
202.                 st[ 1 ].len = len;
     
203.                 spi_message_add_tail( &st[1], &msg );
     
204. 
     
205.         mutex_lock( &flash->lock );
     
206. 
     
207.         /* get offset address inside a page */
     
208.                 page_offset = to % FLASH_PAGE_SIZE;
     
209. 
     
210.         /* do all the bytes fit onto one page? */
     
211.                 if( page_offset + len <= FLASH_PAGE_SIZE ) { // yes
     
212.                         st[ 1 ].len = len;
     
213.                         printk("%d, cmd = %d\n", st[ 1 ].len, *(char *)st[0].tx_buf);
     
214.                         //while(1)
     
215.                         {
     
216.                         spi_sync( flash->spi, &msg );
     
217.                         }
     
218.                         w_count = msg.actual_length - CMD_SZ;
     
219.                 }
     
220.                 else { // no
     
221.                 }
     
222.                 printk( "in (%s): write %d bytes to flash in total\n", __func__, w_count );
     
223.                 mutex_unlock( &flash->lock );
     
224.                 return 0;
     
225.         }
     
226. 
     
227. static int check_id( struct m25p10a *flash )
     
228.         {
     
229.                 char buf[10] = {0};
     
230.                 flash->cmd[0] = CMD_READ_ID;
     
231.                 spi_write_then_read( flash->spi, flash->cmd, 1, buf, 3 );
     
232.                 printk( "Manufacture ID: 0x%x\n", buf[0] );
     
233.                 printk( "Device ID: 0x%x\n", buf[1] | buf[2] << 8 );
     
234.                 return buf[2] << 16 | buf[1] << 8 | buf[0];
     
235.         }
     
236. 
     
237. static int m25p10a_probe(struct spi_device *spi)
     
238.         {
     
239.                 int ret = 0;
     
240.                 struct m25p10a *flash;
     
241.                 char buf[ 256 ];
     
242.                 printk( "%s was called\n", __func__ );
     
243.                 flash = kzalloc( sizeof(struct m25p10a), GFP_KERNEL );
     
244.                 if( !flash ) {
     
245.                         return -ENOMEM;
     
246.                 }
     
247.                 flash->spi = spi;
     
248.                 mutex_init( &flash->lock );
     
249.                 /* save flash as driver‘s private data */
     
250.                 spi_set_drvdata( spi, flash );
     
251.     
     
252.                 check_id( flash ); //读取ID
     
253.         #if 1
     
254.                 ret = erase_chip( flash ); //擦除
     
255.                 if( ret < 0 ) {
     
256.                         printk( "erase the entirely chip failed\n" );
     
257.                 }
     
258.                 printk( "erase the whole chip done\n" );
     
259.                 memset( buf, 0x7, 256 );
     
260.                 m25p10a_write( flash, 0, 20, buf); //0地址写入20个7
     
261.                 memset( buf, 0, 256 );
     
262.                 m25p10a_read( flash, 0, 25, buf ); //0地址读出25个数
     
263.         #endif
     
264.                 return 0;
     
265.         }
     
266. 
     
267. static int m25p10a_remove(struct spi_device *spi)
     
268.         {
     
269.                 return 0;
     
270.         }
     
271. 
     
272. static struct spi_driver m25p10a_driver = {
     
273.                 .probe = m25p10a_probe,
     
274.                 .remove = m25p10a_remove,
     
275.                 .driver = {
     
276.                         .name = "m25p10a",
     
277.                 },
     
278.         };
     
279. 
     
280. static int __init m25p10a_init(void)
     
281.         {
     
282.                 return spi_register_driver(&m25p10a_driver);
     
283.         }
     
284. 
     
285. static void __exit m25p10a_exit(void)
     
286.         {
     
287.                 spi_unregister_driver(&m25p10a_driver);
     
288.         }
     
289. 
     
290. module_init(m25p10a_init);
     
291.         module_exit(m25p10a_exit);
     
292. 
     
293. MODULE_DESCRIPTION("m25p10a driver for FS_S5PC100");
     
294. 
     
295. MODULE_LICENSE("GPL");

===========================

感谢作者的奉献,　要是能早一点看到这篇文章,　我也不用在茫茫的网页中四处寻迷,　搞得焦头烂额也不得其中真谛.

看到这样的文章,　如同拔得云雾见清天,柳岸花明又一村;　其实Ｉ２Ｃ原来是搞懂了的,　ＳＰＩ跟Ｉ２Ｃ简直

一模一样,　但就是最初的不了解,　让网上那些分析ＳＰＩ如何实现的文章带到了迷宫一样.　要说的话那些文章就

完全是在装Ｂ,　只是展示了自己理解得怎样怎样,　完全没有阅读的价值.　我要是读了这篇文章,　网上那些东西

还不是多跟踪一下代码就可以搞明白的.只能说怎一个艹字了得.最后再次感谢文章作者的无私奉献,　希望能看到更多

像这样的文章.