spi驱动框架全面分析，从master驱动到设备驱动

版权声明：欢迎转载,转载请注明出处 http://blog.csdn.net/lizuobin2/

内核版本：linux2.6.32.2 
硬件资源：s3c2440
参考：  韦东山SPI视频教程


内容概括：
    1、I2C 驱动框架回顾
    2、SPI 框架简单介绍
    3、master 驱动框架
        3.1 驱动侧
        3.2 设备侧

    4、SPI 设备驱动框架

         4.1 设备册
        4.2 驱动侧

    5、设备驱动程序实例

1、I2C 驱动框架回顾
    在前面学习 I2C 驱动程序的时候我们知道，I2C 驱动框架分为两层，一层是控制器驱动程序 i2c_adapter，它一般是由芯片厂商写好的，主要提供一个 algorithm 底层的 i2c 协议的收发函数。i2c_adapter 驱动是基于 platform 模型，在driver侧的probe函数里，取出资源信息进行设置，最后将adapter注册到i2c_bus_type，注册时会调用 i2c_scan_static_board_info，扫描并使用 i2c_new_device 创建设备（设备层的设备）。我们还提到了4种创建device的方式。

    另一层是设备驱动层，基于 i2c_bus_type ，这个就很简单了，在设备驱动层 device 只需要提供一个从设备地址和名字，在 driver 里使用 i2c_smbus_read_byte_data 等类似的函数进行收发即可了，i2c_smbus_read_byte_data 等函数最终就会调用到 我们的 i2c_adapter->algorithm 里的收发函数进行收发。

2、SPI 框架简单介绍
    对于SPI的大框架，与I2C是完全一致的，也分为两层，控制器驱动程序层叫 spi_master ，主要提供transfer函数，进行spi协议的收发。spi_master 也是基于 Platform 模型的，注册 spi_master 时也会扫描一个链表进行注册设备，简直太相似了。

    另一层是设备驱动层，基于 spi_bus_type，相比 i2c 在device中需要提供的信息多一些，需要有名字、片选、最大速率、模式、中断号等等，在driver里则使用spi_read、spi_writer 等函数，最终也会调用到 master->transfer 函数进行发送接收。

    相比 I2C ，SPI驱动的框架是要简单的，因为它少了两种注册device的方式，另外它不需要像I2C一样去发送Start信号和设备地址去探测设备，SPI只需要片选选中就行了。但是它的底层收发的控制，相对I2C要复杂一点，毕竟4根线。

3、master 驱动框架
    之前，分析的驱动程序都是 S3C2410\S3C2440 平台的，由于我的开发板 Mini2440 没有SPI设备，因此厂商带的内核里关于 SPI 驱动部分不完整，而且在s3c23xx_spi_probe函数里注册master的时候写的十分复杂，干扰信息太多，不适合分析学习，因此，我搜索了一下其他平台的代码，发现 atmel_spi.c (drivers\spi)，里 atmel 实现的底层控制器驱动简单清晰多了，因此就拿它开刀，分析Master驱动框架。

  3.1 驱动侧

    前面简介里，我提到 master 驱动框架是基于 platform 平台的（我分析的这俩都是，其它的不清楚），那么肯定就要注册platform_driver了，下面我们就开看看。

分配一个platfrom_driver结构

[cpp]  view plain  copy

 print ?

1. static struct platform_driver atmel_spi_driver = {  
2.     .driver     = {  
3.         .name   = "atmel_spi",  
4.         .owner  = THIS_MODULE,  
5.     },  
6.     .suspend    = atmel_spi_suspend,  
7.     .resume     = atmel_spi_resume,  
8.     .remove     = __exit_p(atmel_spi_remove),  
9. };  

    将 atmel_spi_driver 注册到 platform_bus_type ，匹配设备 probe

[cpp]  view plain  copy

 print ?

1. static int __init atmel_spi_init(void)  
2. {  
3.     return platform_driver_probe(&atmel_spi_driver, atmel_spi_probe);  
4. }     

    我们之前都是将 probe 函数，直接放在driver结构体里，这里不是，而是调用了 platform_driver_probe ，就不贴代码了，还看段函数介绍，大致了解下什么意思。
/**
 * platform_driver_probe - register driver for non-hotpluggable device
 * @drv: platform driver structure
 * @probe: the driver probe routine, probably from an __init section
 *
 * Use this instead of platform_driver_register() when you know the device
 * is not hotpluggable and has already been registered, and you want to
 * remove its run-once probe() infrastructure from memory after the driver
 * has bound to the device.
 *
 * One typical use for this would be with drivers for controllers integrated
 * into system-on-chip processors, where the controller devices have been
 * configured as part of board setup.
 *
 * Returns zero if the driver registered and bound to a device, else returns
 * a negative error code and with the driver not registered.
 */
    1、适用于非热插拔设备
    2、通常Probe位于__init段3、当你知道device是非热拔插的，而且设备已经被注册了，而且你想在probe函数调用一次之后就销毁它节省空间，使用 platform_driver_probe 而非 platform_driver_register。
    4、一个典型的应用是，用在完整的控制器驱动，控制器设备被当作 board setup 的一部分（在板子初始化的时候，设备就已经被注册了，放在board_info里）
    5、返回0 ，如果driver注册成功且匹配到一个device ，以后再也无法被别的device probe了。
    6、否则，返回一个错误，且driver未注册。
    显然，我们写的正式一个控制器驱动程序，设备侧确实是早已注册（后边会讲）。
    疑问：有人说使用 platform_driver_probe 时 driver 只能被一个 device 匹配绑定，之后再也无法被别的device probe，难道说，我有俩spi控制器还需要写两个控制器驱动程序么？我认为这种说法是不对的，我猜大概是driver注册时，会匹配一遍device链表，把能支持的device都probe，之后再有deivce注册进来就不行了。这个有待验证。

    i2c驱动框架里，是在driver->probe 分配设置注册adapter，想必spi也是在driver->probe里分配设置注册master。

[cpp]  view plain  copy

 print ?

1. static int __init atmel_spi_probe(struct platform_device *pdev)  
2. {  
3.     struct resource     *regs;  
4.     int         irq;  
5.     struct clk      *clk;  
6.     int         ret;  
7.     struct spi_master   *master;  
8.     struct atmel_spi    *as;  
9.       
10.     /* 获取 device 侧提供的Io内存以及中断 */  
11.     regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
12.     irq = platform_get_irq(pdev, 0);  
13.       
14.     /* 获取 spi 时钟，一会好使能它 */  
15.     clk = clk_get(&pdev->dev, "spi_clk");  
16.   
17.     /* 分配一个spi_master结构 额外加上一个 atmel_spi 用来存放其它信息 */  
18.     master = spi_alloc_master(&pdev->dev, sizeof *as);  
19.   
20.     /* 设置 master  */  
21.     master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;   // 所支持的模式  
22.     master->bus_num = pdev->id;   // 控制器编号，用于分辨外围spi设备是连接在哪一个控制器上  
23.     master->num_chipselect = 4;  // 片选最大值+1,spi设备的片选值要小于它  
24.     master->setup = atmel_spi_setup; // 一个控制器上可能接有多个spi设备，它们的频率和模式是不一样的，用于设备之间切换时设置这些信息。  
25.     master->transfer = atmel_spi_transfer;   // 最重要的发送函数  
26.     master->cleanup = atmel_spi_cleanup;  
27.       
28.     /* 将 Master 放入 pdev->dev->p->driver_data 里*/  
29.     platform_set_drvdata(pdev, master);   
30.       
31.     /* as 指向 master->dev->p->driver_data ,填充多出来那个 atmel_spi 结构 */  
32.     as = spi_master_get_devdata(master);  
33.     as->buffer = dma_alloc_coherent(&pdev->dev, BUFFER_SIZE,  
34.                     &as->buffer_dma, GFP_KERNEL);  
35.     spin_lock_init(&as->lock);  
36.     INIT_LIST_HEAD(&as->queue);  
37.     as->pdev = pdev;  
38.     as->regs = ioremap(regs->start, (regs->end - regs->start) + 1);  
39.     as->irq = irq;  
40.     as->clk = clk;  
41.       
42.     /* 注册中断 使能时钟 */  
43.     ret = request_irq(irq, atmel_spi_interrupt, 0,  
44.             dev_name(&pdev->dev), master);  
45.     clk_enable(clk);  
46.       
47.     /* 设置硬件寄存器 */  
48.     spi_writel(as, CR, SPI_BIT(SWRST));  
49.     spi_writel(as, CR, SPI_BIT(SWRST)); /* AT91SAM9263 Rev B workaround */  
50.     spi_writel(as, MR, SPI_BIT(MSTR) | SPI_BIT(MODFDIS));  
51.     spi_writel(as, PTCR, SPI_BIT(RXTDIS) | SPI_BIT(TXTDIS));  
52.     spi_writel(as, CR, SPI_BIT(SPIEN));  
53.   
54.     /* 注册master */  
55.     ret = spi_register_master(master);  
56.   
57.     return 0;  
58. }  

    对于master的设置过程注释已经说的很明白了，我们还得看看分配和注册过程。

[cpp]  view plain  copy

 print ?

1. struct spi_master *spi_alloc_master(struct device *dev, unsigned size)  
2. {  
3.     struct spi_master   *master;  
4.   
5.     master = kzalloc(size + sizeof *master, GFP_KERNEL);  
6.   
7.     device_initialize(&master->dev); // 初始化设备  
8.     master->dev.class = &spi_master_class;     
9.     master->dev.parent = get_device(dev);    // 在 sysfs 平台设备xxx目录下创建目录  
10.     spi_master_set_devdata(master, &master[1]);  
11.   
12.     return master;  
13. }  

    1、spi_alloc_master 实际申请的内存大小为一个struct master + struct atmel_spi,并用master->dev->p->driver_data 指向这个多出来的 struct atmel_spi 空间，用来存放 master 的中断 、寄存器等东西。

    2、初始化 master->dev ，设置它的父设备等。

[cpp]  view plain  copy

 print ?

1. int spi_register_master(struct spi_master *master)  
2. {  
3.     /* 将master注册到内核中去 */  
4.     dev_set_name(&master->dev, "spi%u", master->bus_num);  
5.     status = device_add(&master->dev);  
6.       
7.     /* 扫描spi设备信息，创建设备 */  
8.     scan_boardinfo(master);  
9. }  

    1、设置 master->dev 的名字，例如 spi0、spi1 ...

    2、device_add 注册设备

    3、扫描spi设备信息：scan_boardinfo(master)

[cpp]  view plain  copy

 print ?

1. static void scan_boardinfo(struct spi_master *master)  
2. {  
3.     struct boardinfo    *bi;  
4.   
5.     mutex_lock(&board_lock);  
6.     list_for_each_entry(bi, &board_list, list) {  
7.         struct spi_board_info   *chip = bi->board_info;  
8.         unsigned        n;  
9.         /* 如果说  board_info 提供的bus_num 和 master—>bus_num 一致，则调用 spi_new_device */  
10.         for (n = bi->n_board_info; n > 0; n--, chip++) {  
11.             if (chip->bus_num != master->bus_num)  
12.                 continue;  
13.   
14.             (void) spi_new_device(master, chip);    // 我们放到设备驱动层，在分析它  
15.         }  
16.     }  
17.     mutex_unlock(&board_lock);  
18. }  

    扫描 board_list ，取出每一个 boardinfo ，比对，如果 boardinfo 里的 bus_num 和 master 的 bus_num 相等，则认为这个spi设备在硬件物理连接上是接到这个控制器的，则使用 spi_new_device 创建 spi 设备。这个过程和i2c是多么的相似。至于在哪里填充的 board_list ，到后边设备层驱动框架时再说不迟。

  3.2 设备侧
    有 platform_driver 必然有 platform_device 与之对应，At91sam9260_devices.c 中定义

[cpp]  view plain  copy

 print ?

1. static struct resource spi0_resources[] = {  
2.     [0] = {  
3.         .start  = AT91SAM9260_BASE_SPI0,  
4.         .end    = AT91SAM9260_BASE_SPI0 + SZ_16K - 1,  
5.         .flags  = IORESOURCE_MEM,  
6.     },  
7.     [1] = {  
8.         .start  = AT91SAM9260_ID_SPI0,  
9.         .end    = AT91SAM9260_ID_SPI0,  
10.         .flags  = IORESOURCE_IRQ,  
11.     },  
12. };  

    资源文件，提供寄存器范围，spi中断。

[cpp]  view plain  copy

 print ?

1. static struct platform_device at91sam9260_spi0_device = {  
2.     .name       = "atmel_spi",      // 名字与driver一致  
3.     .id     = 0,  
4.     .dev        = {  
5.                 .dma_mask       = &spi_dmamask,  
6.                 .coherent_dma_mask  = DMA_BIT_MASK(32),  
7.     },  
8.     .resource   = spi0_resources,   // 资源文件  
9.     .num_resources  = ARRAY_SIZE(spi0_resources),  
10. };  

    与 driver 所配对的设备，显然名字是一样的。一般会有两个spi控制器，at91sam9260_spi1_device 和 at91sam9260_spi0_device 一样一样的，这里就不贴代码了。

    既然分配了 platform_device 那么肯定会在某个地方调用 platform_device_register 将它注册到 platform_bus_type , 就是在 at91_add_device_spi 。

[cpp]  view plain  copy

 print ?

1. void __init at91_add_device_spi(struct spi_board_info *devices, int nr_devices)  
2. {  
3.     ...  
4.     spi_register_board_info(devices, nr_devices);  
5.   
6.     /* Configure SPI bus(es) */  
7.     if (enable_spi0) {  
8.         ...  
9.         platform_device_register(&at91sam9260_spi0_device);  
10.     }  
11.     if (enable_spi1) {  
12.         ...  
13.         platform_device_register(&at91sam9260_spi1_device);  
14.     }  
15. }  

    1、添加 spi 设备信息，这应该是在设备驱动层要说的东西~就是前边的填充 Board_list 链表。

    2、将我们的 master 的设备侧 at91sam9260_spi0_device 注册到 platform_bus_type

    思考：这样做有什么好处呢？

        这样可以保证，master driver 与 device 匹配成功调用 probe 函数 scan_boardinfo 时，spi设备已经被添加到board_list中去~！如果先注册成功了 master 驱动，再添加spi设备信息就无用了。根 i2c 也是一样的。

    至此，Master 驱动的框架就分析完了，至于 master 的那些设置，我们到下篇文件写 master 驱动里细究。

4、SPI 设备驱动框架

    设备驱动层，参考韦东山老师的 SPI Flash 驱动来分析，设备驱动层，device driver 都是注册到spi_bus_type的，因此，我们现在看看 spi_bus_type->match 函数，看看它们如何匹配。

[cpp]  view plain  copy

 print ?

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.     const struct spi_driver *sdrv = to_spi_driver(drv);  
5.   
6.     if (sdrv->id_table)  
7.         return !!spi_match_id(sdrv->id_table, spi);  
8.   
9.     return strcmp(spi->modalias, drv->name) == 0;  
10. }  

    如果，driver里有id_table，则根据id_table进行匹配，没有就根据 spi->moadlias （设备名），和 driver->name 进行比较了。一样则配对成功。

  4.1 设备层

    设备层比较简单，先来分析它吧，目的只有一个分配 spi_board_info 设置 注册。

[cpp]  view plain  copy

 print ?

1. static struct spi_board_info spi_info_jz2440[] = {  
2.     {  
3.         .modalias = "100ask_spi_flash",  /* 对应的spi_driver名字也是"oled" */  
4.         .max_speed_hz = 80000000,   /* max spi clock (SCK) speed in HZ */  
5.         .bus_num = 1,     /* jz2440里OLED接在SPI CONTROLLER 1 */  
6.         .mode    = SPI_MODE_0,  
7.         .chip_select   = S3C2410_GPG(2), /* flash_cs, 它的含义由spi_master确定 */  
8.     }  
9. };  

[cpp]  view plain  copy

 print ?

1. static int spi_info_jz2440_init(void)  
2. {  
3.     return spi_register_board_info(spi_info_jz2440, ARRAY_SIZE(spi_info_jz2440));   // list_add_tail(&bi->list, &board_list);  
4. }  

    注册 list_add_tail(&spi_info_jz2440->list, &board_list) 

    前面我们提到，master注册成功时会扫描 board_list 注册 spi 设备，现在来看看 spi 设备的注册过程,虽然没有啥重要的。

[cpp]  view plain  copy

 print ?

1. struct spi_device *spi_new_device(struct spi_master *master,  
2.                   struct spi_board_info *chip)  
3. {  
4.     struct spi_device   *proxy;  
5.     int         status;  
6.   
7.     proxy = spi_alloc_device(master);  
8.   
9.     proxy->chip_select = chip->chip_select;  
10.     proxy->max_speed_hz = chip->max_speed_hz;  
11.     proxy->mode = chip->mode;  
12.     proxy->irq = chip->irq;  
13.     strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));  
14.     proxy->dev.platform_data = (void *) chip->platform_data;  
15.     proxy->controller_data = chip->controller_data;  
16.     proxy->controller_state = NULL;  
17.   
18.     status = spi_add_device(proxy);  
19.   
20.     return proxy;  
21. }  
22.   
23. struct spi_device *spi_alloc_device(struct spi_master *master)  
24. {  
25.     struct spi_device   *spi;  
26.     struct device       *dev = master->dev.parent;  
27.   
28.     spi = kzalloc(sizeof *spi, GFP_KERNEL);  
29.   
30.     spi->master = master;  
31.     spi->dev.parent = dev;  
32.     spi->dev.bus = &spi_bus_type;  
33.     spi->dev.release = spidev_release;  
34.     device_initialize(&spi->dev);  
35.     return spi;  
36. }  
37.   
38. int spi_add_device(struct spi_device *spi)  
39. {  
40.     static DEFINE_MUTEX(spi_add_lock);  
41.     struct device *dev = spi->master->dev.parent;  
42.     int status;  
43.   
44.     /* 片选限制 */  
45.     if (spi->chip_select >= spi->master->num_chipselect) {  
46.         dev_err(dev, "cs%d >= max %d\n",  
47.             spi->chip_select,  
48.             spi->master->num_chipselect);  
49.         return -EINVAL;  
50.     }  
51.   
52.     /* Set the bus ID string */  
53.     dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),  
54.             spi->chip_select);  
55.           
56.     status = spi_setup(spi);  
57.     /* 
58.         if (!spi->bits_per_word) 
59.             spi->bits_per_word = 8; 
60.  
61.         status = spi->master->setup(spi); 
62.     */  
63.   
64.     status = device_add(&spi->dev);  
65. }  

    有一点，需要留意的吧，我们在写 master 驱动时，master->num_chipselect 要大于我们将要注册进来的spi设备的 chip_select 。

  4.2 驱动侧

[cpp]  view plain  copy

 print ?

1. static struct spi_driver spi_flash_drv = {  
2.     .driver = {  
3.         .name   = "100ask_spi_flash",  
4.         .owner  = THIS_MODULE,  
5.     },  
6.     .probe      = spi_flash_probe,  
7.     .remove     = __devexit_p(spi_flash_remove),  
8. };  

    分配一个 spi_driver ，没有 id_table ，要根据名字进行匹配了，显然跟前面的设备是一样的。

[cpp]  view plain  copy

 print ?

1. static int spi_flash_init(void)  
2. {  
3.     return spi_register_driver(&spi_flash_drv);  
4. }  

    注册到 spi_bus_type ,匹配成功好调用 probe 函数，韦东山老师是将spi flash 作为一个mtd设备来使用的，因此在probe函数中分配、设置、注册 mtd_info 

[cpp]  view plain  copy

 print ?

1. static int __devinit spi_flash_probe(struct spi_device *spi)  
2. {  
3.     int mid, did;  
4.       
5.     spi_flash = spi;  
6.   
7.     s3c2410_gpio_cfgpin(spi->chip_select, S3C2410_GPIO_OUTPUT);  
8.     SPIFlashInit();  
9.     SPIFlashReadID(&mid, &did);  
10.     printk("SPI Flash ID: %02x %02x\n", mid, did);  
11.         memset(&spi_flash_dev, 0, sizeof(spi_flash_dev));  
12.     /* 构造注册一个mtd_info 
13.      * mtd_device_register(master, parts, nr_parts) 
14.      * 
15.      */  
16.   
17.     /* Setup the MTD structure */  
18.     spi_flash_dev.name = "100ask_spi_flash";  
19.     spi_flash_dev.type = MTD_NORFLASH;  
20.     spi_flash_dev.flags = MTD_CAP_NORFLASH;  
21.     spi_flash_dev.size = 0x200000;  /* 2M */  
22.     spi_flash_dev.writesize = 1;  
23.     spi_flash_dev.writebufsize = 4096; /* 没有用到 */  
24.     spi_flash_dev.erasesize = 4096;  /* 擦除的最小单位 */  
25.   
26.     spi_flash_dev.owner = THIS_MODULE;  
27.     spi_flash_dev._erase = spi_flash_erase;  
28.     spi_flash_dev._read  = spi_flash_read;  
29.     spi_flash_dev._write = spi_flash_write;  
30.   
31.     mtd_device_register(&spi_flash_dev, NULL, 0);  
32.        
33.     return 0;  
34. }  

    在 i2c 设备驱动程序中，我们使用 i2c_read 等函数调用 adapter 里的底层收发函数进行与i2c设备通信，spi肯定也有相应的函数，例如 spi_read、spi_write ，下面我们来仔细看看，这个很重要~不然我们怎么写设备驱动呢，光写个框架不能收发那不白扯么。

[cpp]  view plain  copy

 print ?

1. static inline int spi_write(struct spi_device *spi, const u8 *buf, size_t len)  
2. {  
3.     struct spi_transfer t = {  
4.             .tx_buf     = buf,  
5.             .len        = len,  
6.         };  
7.     struct spi_message  m;  
8.   
9.     spi_message_init(&m);  
10.     spi_message_add_tail(&t, &m);  
11.     return spi_sync(spi, &m);  
12. }  

    以 spi_write 为例，看看它是如何调用到底层收发函数的。它构造了一个 spi_message 并由 spi_transfer组成，然后调用 spi_sync(spi, &m)->spi_async(spi,&m)->master->transfer(spi, &m).过程我们了解了，那么如何组织 spi_messgae ，它对应于时序图怎样的一个过程我们还不明白。

    还记得，i2c 是通过构造 i2c_msg ，然后传递多个 i2c_msg 给底层的发送函数，多个i2c_msg 组成start信号和p信号之间的发送过程，每一个i2c_msg 都有一个start信号。大概 i2c_msg 就类比于spi里的 spi_transfer ，但是通常情况下，整个 spi_messgae 传输过程我们只片选一次就够了。下面看个实例分析。

    上图是 spi flash 读取任意字节的时序图，片选选中之后，我们要先发送一个0x03 命令（1字节），再发送24bit（3字节）地址（先发送高位），然后读取len，最后取消片选。

[cpp]  view plain  copy

 print ?

1. void SPIFlashRead(unsigned int addr, unsigned char *buf, int len)  
2. {     
3.     unsigned char tx_buf[4];     
4.     struct spi_transfer t[] = {  
5.             {  
6.                 .tx_buf     = tx_buf,  
7.                 .len        = 4,  
8.             },  
9.             {  
10.                 .rx_buf     = buf,  
11.                 .len        = len,  
12.             },  
13.         };  
14.     struct spi_message  m;  
15.   
16.     tx_buf[0] = 0x03;  
17.     tx_buf[1] = addr >> 16;  
18.     tx_buf[2] = addr >> 8;  
19.     tx_buf[3] = addr & 0xff;  
20.   
21.     spi_message_init(&m);  
22.     spi_message_add_tail(&t[0], &m);  
23.     spi_message_add_tail(&t[1], &m);  
24.     spi_sync(spi_flash, &m);      
25. }  

    韦老大的程序里，构造一个 struct spi_transfer 类型的数组，两个成员，第一个有一个tx_buf（表示写），长度为4，用来发送1字节命令和3字节地址。第二个成员 有一个rx_buf（表示读），长度由参数决定，用来读取长度len字节的内容。然后分配一个struct spi_message 并使用 spi_message_init 进行初始化，然后将 spi_transfer 数组成员依次添加到 spi_message 中去，最后 spi_sync(spi_flash, &m)

    纸上谈兵一大堆，现在来看看，我们在写一个spi设备驱动的时候需要做哪些工作。
    设备侧：
      1、分配一个 spi_board_info 结构体
      2、设置 spi_board_info 里的名字、最大频率、控制器编号、模式、片选
      3、注册 spi_register_board_info 
    驱动侧：
      1、分配一个 spi_driver 结构
      2、设置名字、probe等函数
      3、注册 spi_register_driver
      4、使用spi_write等系统调用，搞明白 spi_transfer spi_message ，会使用它们进行收发
   一个 spi_message 对应于一个不可打断的spi传输过程，可以理解为片选选中直到取消选中的过程（特殊情况下，一个spi_message里面是可以取消片选再选中的），而 spi_message 由 spi_transfer 组成，根据 tx_buf  rx_buf 是否为空来判断是 写还是读 操作。

    至此，整个 spi 的框架分析完毕

5、设备驱动程序实例

[cpp]  view plain  copy

 print ?

1. #include <linux/init.h>  
2. #include <linux/fs.h>  
3. #include <linux/slab.h>  
4. #include <linux/module.h>  
5. #include <linux/kernel.h>  
6. #include <linux/device.h>  
7. #include <sound/core.h>  
8. #include <linux/spi/spi.h>  
9. #include <asm/uaccess.h>  
10. #include <linux/timer.h>  
11.   
12. #include <mach/hardware.h>  
13. #include <mach/regs-gpio.h>  
14.   
15. #include <linux/gpio.h>  
16. #include <plat/gpio-cfg.h>  
17.   
18. #include <linux/mtd/cfi.h>  
19. #include <linux/mtd/mtd.h>  
20. #include <linux/mtd/partitions.h>  
21.   
22. /* 参考: 
23.  * drivers\mtd\devices\mtdram.c 
24.  * drivers/mtd/devices/m25p80.c 
25.  */  
26.   
27. static struct spi_device *spi_flash;  
28.   
29. /*  
30.  *  
31.  */  
32. void SPIFlashReadID(int *pMID, int *pDID)  
33. {  
34.     unsigned char tx_buf[4];  
35.     unsigned char rx_buf[2];  
36.       
37.     tx_buf[0] = 0x90;  
38.     tx_buf[1] = 0;  
39.     tx_buf[2] = 0;  
40.     tx_buf[3] = 0;  
41.   
42.     spi_write_then_read(spi_flash, tx_buf, 4, rx_buf, 2);  
43.   
44.     *pMID = rx_buf[0];  
45.     *pDID = rx_buf[1];  
46. }  
47.   
48. static void SPIFlashWriteEnable(int enable)  
49. {  
50.     unsigned char val = enable ? 0x06 : 0x04;  
51.     spi_write(spi_flash, &val, 1);      
52. }  
53.   
54. static unsigned char SPIFlashReadStatusReg1(void)  
55. {  
56.     unsigned char val;  
57.     unsigned char cmd = 0x05;  
58.   
59.     spi_write_then_read(spi_flash, &cmd, 1, &val, 1);  
60.       
61.     return val;  
62. }  
63.   
64. static unsigned char SPIFlashReadStatusReg2(void)  
65. {  
66.     unsigned char val;  
67.     unsigned char cmd = 0x35;  
68.   
69.     spi_write_then_read(spi_flash, &cmd, 1, &val, 1);  
70.       
71.     return val;  
72. }  
73.   
74. static void SPIFlashWaitWhenBusy(void)  
75. {  
76.     while (SPIFlashReadStatusReg1() & 1)  
77.     {  
78.         /* 休眠一段时间 */  
79.         /* Sector erase time : 60ms 
80.          * Page program time : 0.7ms 
81.          * Write status reg time : 10ms 
82.          */  
83.         set_current_state(TASK_INTERRUPTIBLE);  
84.         schedule_timeout(HZ/100);  /* 休眠10MS后再次判断 */  
85.     }  
86. }  
87.   
88. static void SPIFlashWriteStatusReg(unsigned char reg1, unsigned char reg2)  
89. {      
90.     unsigned char tx_buf[4];  
91.   
92.     SPIFlashWriteEnable(1);    
93.       
94.     tx_buf[0] = 0x01;  
95.     tx_buf[1] = reg1;  
96.     tx_buf[2] = reg2;  
97.   
98.     spi_write(spi_flash, tx_buf, 3);     
99.   
100.     SPIFlashWaitWhenBusy();  
101. }  
102.   
103. static void SPIFlashClearProtectForStatusReg(void)  
104. {  
105.     unsigned char reg1, reg2;  
106.   
107.     reg1 = SPIFlashReadStatusReg1();  
108.     reg2 = SPIFlashReadStatusReg2();  
109.   
110.     reg1 &= ~(1<<7);  
111.     reg2 &= ~(1<<0);  
112.   
113.     SPIFlashWriteStatusReg(reg1, reg2);  
114. }  
115.   
116. static void SPIFlashClearProtectForData(void)  
117. {  
118.     /* cmp=0,bp2,1,0=0b000 */  
119.     unsigned char reg1, reg2;  
120.   
121.     reg1 = SPIFlashReadStatusReg1();  
122.     reg2 = SPIFlashReadStatusReg2();  
123.   
124.     reg1 &= ~(7<<2);  
125.     reg2 &= ~(1<<6);  
126.   
127.     SPIFlashWriteStatusReg(reg1, reg2);  
128. }  
129.   
130. /* erase 4K */  
131. void SPIFlashEraseSector(unsigned int addr)  
132. {  
133.     unsigned char tx_buf[4];  
134.     tx_buf[0] = 0x20;  
135.     tx_buf[1] = addr >> 16;  
136.     tx_buf[2] = addr >> 8;  
137.     tx_buf[3] = addr & 0xff;  
138.   
139.     SPIFlashWriteEnable(1);    
140.   
141.     spi_write(spi_flash, tx_buf, 4);  
142.   
143.     SPIFlashWaitWhenBusy();  
144. }  
145.   
146. /* program */  
147. void SPIFlashProgram(unsigned int addr, unsigned char *buf, int len)  
148. {  
149.     unsigned char tx_buf[4];     
150.     struct spi_transfer t[] = {  
151.             {  
152.                 .tx_buf     = tx_buf,  
153.                 .len        = 4,  
154.             },  
155.             {  
156.                 .tx_buf     = buf,  
157.                 .len        = len,  
158.             },  
159.         };  
160.     struct spi_message  m;  
161.   
162.     tx_buf[0] = 0x02;  
163.     tx_buf[1] = addr >> 16;  
164.     tx_buf[2] = addr >> 8;  
165.     tx_buf[3] = addr & 0xff;  
166.   
167.     SPIFlashWriteEnable(1);    
168.   
169.     spi_message_init(&m);  
170.     spi_message_add_tail(&t[0], &m);  
171.     spi_message_add_tail(&t[1], &m);  
172.     spi_sync(spi_flash, &m);  
173.   
174.     SPIFlashWaitWhenBusy();      
175. }  
176.   
177. void SPIFlashRead(unsigned int addr, unsigned char *buf, int len)  
178. {  
179.     /* spi_write_then_read规定了tx_cnt+rx_cnt < 32 
180.      * 所以对于大量数据的读取，不能使用该函数 
181.      */  
182.        
183.     unsigned char tx_buf[4];     
184.     struct spi_transfer t[] = {  
185.             {  
186.                 .tx_buf     = tx_buf,  
187.                 .len        = 4,  
188.             },  
189.             {  
190.                 .rx_buf     = buf,  
191.                 .len        = len,  
192.             },  
193.         };  
194.     struct spi_message  m;  
195.   
196.     tx_buf[0] = 0x03;  
197.     tx_buf[1] = addr >> 16;  
198.     tx_buf[2] = addr >> 8;  
199.     tx_buf[3] = addr & 0xff;  
200.   
201.     spi_message_init(&m);  
202.     spi_message_add_tail(&t[0], &m);  
203.     spi_message_add_tail(&t[1], &m);  
204.     spi_sync(spi_flash, &m);      
205. }  
206.   
207. static void SPIFlashInit(void)  
208. {  
209.     SPIFlashClearProtectForStatusReg();  
210.     SPIFlashClearProtectForData();  
211. }  
212.   
213. /* 构造注册一个mtd_info 
214.  * mtd_device_register(master, parts, nr_parts) 
215.  * 
216.  */  
217.   
218. /* 首先: 构造注册spi_driver 
219.  * 然后: 在spi_driver的probe函数里构造注册mtd_info 
220.  */  
221.   
222. static struct mtd_info spi_flash_dev;  
223.   
224. static int spi_flash_erase(struct mtd_info *mtd, struct erase_info *instr)  
225. {  
226.     unsigned int addr = instr->addr;  
227.     unsigned int len  = 0;  
228.   
229.     /* 判断参数 */  
230.     if ((addr & (spi_flash_dev.erasesize - 1)) || (instr->len & (spi_flash_dev.erasesize - 1)))  
231.     {  
232.         printk("addr/len is not aligned\n");  
233.         return -EINVAL;  
234.     }  
235.   
236.     for (len = 0; len < instr->len; len += 4096)  
237.     {  
238.         SPIFlashEraseSector(addr);  
239.         addr += 4096;  
240.     }  
241.       
242.     instr->state = MTD_ERASE_DONE;  
243.     mtd_erase_callback(instr);  
244.     return 0;  
245. }  
246.   
247. static int spi_flash_read(struct mtd_info *mtd, loff_t from, size_t len,  
248.         size_t *retlen, u_char *buf)  
249. {  
250.     SPIFlashRead(from, buf, len);  
251.     *retlen = len;  
252.     return 0;  
253. }  
254.   
255. static int spi_flash_write(struct mtd_info *mtd, loff_t to, size_t len,  
256.         size_t *retlen, const u_char *buf)  
257. {  
258.     unsigned int addr = to;  
259.     unsigned int wlen  = 0;  
260.   
261.     /* 判断参数 */  
262.     if ((to & (spi_flash_dev.erasesize - 1)) || (len & (spi_flash_dev.erasesize - 1)))  
263.     {  
264.         printk("addr/len is not aligned\n");  
265.         return -EINVAL;  
266.     }  
267.   
268.     for (wlen = 0; wlen < len; wlen += 256)  
269.     {  
270.         SPIFlashProgram(addr, (unsigned char *)buf, 256);  
271.         addr += 256;  
272.         buf += 256;  
273.     }  
274.   
275.     *retlen = len;  
276.     return 0;  
277. }  
278.   
279. static int __devinit spi_flash_probe(struct spi_device *spi)  
280. {  
281.     int mid, did;  
282.       
283.     spi_flash = spi;  
284.   
285.     s3c2410_gpio_cfgpin(spi->chip_select, S3C2410_GPIO_OUTPUT);  
286.     SPIFlashInit();  
287.     SPIFlashReadID(&mid, &did);  
288.     printk("SPI Flash ID: %02x %02x\n", mid, did);  
289.         memset(&spi_flash_dev, 0, sizeof(spi_flash_dev));  
290.     /* 构造注册一个mtd_info 
291.      * mtd_device_register(master, parts, nr_parts) 
292.      * 
293.      */  
294.   
295.     /* Setup the MTD structure */  
296.     spi_flash_dev.name = "100ask_spi_flash";  
297.     spi_flash_dev.type = MTD_NORFLASH;  
298.     spi_flash_dev.flags = MTD_CAP_NORFLASH;  
299.     spi_flash_dev.size = 0x200000;  /* 2M */  
300.     spi_flash_dev.writesize = 1;  
301.     spi_flash_dev.writebufsize = 4096; /* 没有用到 */  
302.     spi_flash_dev.erasesize = 4096;  /* 擦除的最小单位 */  
303.   
304.     spi_flash_dev.owner = THIS_MODULE;  
305.     spi_flash_dev._erase = spi_flash_erase;  
306.     spi_flash_dev._read  = spi_flash_read;  
307.     spi_flash_dev._write = spi_flash_write;  
308.   
309.     mtd_device_register(&spi_flash_dev, NULL, 0);  
310.        
311.     return 0;  
312. }  
313.   
314. static int __devexit spi_flash_remove(struct spi_device *spi)  
315. {  
316.     mtd_device_unregister(&spi_flash_dev);  
317.     return 0;  
318. }  
319.   
320. static struct spi_driver spi_flash_drv = {  
321.     .driver = {  
322.         .name   = "100ask_spi_flash",  
323.         .owner  = THIS_MODULE,  
324.     },  
325.     .probe      = spi_flash_probe,  
326.     .remove     = __devexit_p(spi_flash_remove),  
327. };  
328.   
329. static int spi_flash_init(void)  
330. {  
331.     return spi_register_driver(&spi_flash_drv);  
332. }  
333.   
334. static void spi_flash_exit(void)  
335. {  
336.     spi_unregister_driver(&spi_flash_drv);  
337. }  
338.   
339. module_init(spi_flash_init);  
340. module_exit(spi_flash_exit);  
341. MODULE_DESCRIPTION("Flash SPI Driver");  
342. MODULE_AUTHOR("weidongshan@qq.com,www.100ask.net");  
343. MODULE_LICENSE("GPL");  
344.   
345.   
346. <strong style="color: rgb(255, 0, 0);">  
347. </strong>