Chinaunix首页 | 论坛 | 博客

wonderfulpjz的ChinaUnix博客

首页　| 　博文目录　| 　关于我

wonderfulpjz

  • 博客访问： 876822
  • 博文数量： 284
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1960
  • 用 户 组： 普通用户
  • 注册时间： 2014-05-04 16:41
文章分类

全部博文（284）

文章存档

2018年（5）

2017年（95）

2016年（69）

2015年（15）

2014年（100）

我的朋友
最近访客
推荐博文
相关博文
Linux驱动修炼之道-SPI驱动框架源码分析

分类： LINUX

2017-01-03 14:28:49

原文地址：Linux驱动修炼之道-SPI驱动框架源码分析 作者：lilysulia

努力成为linux kernel hacker的人李万鹏原创作品，为梦而战。转载请标明出处

http://blog.csdn.net/woshixingaaa/archive/2011/06/29/6574215.aspx

                               Linux驱动修炼之道-SPI驱动框架源码分析(中)

                               Linux驱动修炼之道-SPI驱动框架源码分析(下)

                                                 

SPI协议是一种同步的串行数据连接标准，由摩托罗拉公司命名，可工作于全双工模式。相关通讯设备可工作于m/s模式。主设备发起数据帧，允许多个从设备的存在。每个从设备

有独立的片选信号，SPI一般来说是四线串行总线结构。
接口：
SCLK——Serial Clock(output from master)时钟(主设备发出)
MOSI/SIMO——Master Output, Slave Input(output from master)数据信号线mosi(主设备发出)
MISO/SOMI——Master Input,Slave Outpu(output from slave)数据信号线(从设备)
SS——Slave Select(active low;output from master)片选信号

下面来看一下Linux中的SPI驱动。在Linux设备驱动框架的设计中，有一个重要的主机，外设驱动框架分离的思想，如下图。

外设a,b,c的驱动与主机控制器A,B,C的驱动不相关，主机控制器驱动不关心外设，而外设驱动也不关心主机，外设只是访问核心层的通用的API进行数据的传输，主机和外设之间可以进行任意的组合。如果我们不进行如图的主机和外设分离，外设a,b,c和主机A,B,C进行组合的时候，需要9种不同的驱动。设想一共有个主机控制器，n个外设，分离的结构是需要m+n个驱动，不分离则需要m*n个驱动。

下面介绍spi子系统的数据结构：
在Linux中，使用spi_master结构来描述一个SPI主机控制器的驱动。

  1. "font-size:18px;">struct spi_master {  
  2. struct device    dev;/*总线编号，从0开始*/  
  3. s16    bus_num;/*支持的片选的数量，从设备的片选号不能大于这个数量*/  
  4. u16 num_chipselect;  
  5. u16  dma_alignment;/*改变spi_device的特性如：传输模式，字长，时钟频率*/  
  6. int  (*setup)(struct spi_device *spi);/*添加消息到队列的方法，这个函数不可睡眠，他的任务是安排发生的传送并且调用注册的回调函数complete()*/  
  7. int (*transfer)(struct spi_device *spi,struct spi_message *mesg);  
  8. void   (*cleanup)(struct spi_device *spi);  
  9. };  
struct spi_master { struct device dev;/*总线编号，从0开始*/ s16 bus_num;/*支持的片选的数量，从设备的片选号不能大于这个数量*/ u16 num_chipselect; u16 dma_alignment;/*改变spi_device的特性如：传输模式，字长，时钟频率*/ int (*setup)(struct spi_device *spi);/*添加消息到队列的方法，这个函数不可睡眠，他的任务是安排发生的传送并且调用注册的回调函数complete()*/ int (*transfer)(struct spi_device *spi,struct spi_message *mesg); void (*cleanup)(struct spi_device *spi); };

分配，注册和注销的SPI主机的API由SPI核心提供：

  1. struct spi_master *spi_alloc_master(struct device *host, unsigned size);  
  2. int spi_register_master(struct spi_master *master);  
  3. void spi_unregister_master(struct spi_master *master);    
struct spi_master *spi_alloc_master(struct device *host, unsigned size); int spi_register_master(struct spi_master *master); void spi_unregister_master(struct spi_master *master); 在Linux中用spi_driver来描述一个SPI外设驱动。
  1. struct spi_driver {  
  2. int   (*probe)(struct spi_device *spi);  
  3. int   (*remove)(struct spi_device *spi);  
  4. void  (*shutdown)(struct spi_device *spi);  
  5. int   (*suspend)(struct spi_device *spi, pm_message_t mesg);  
  6. int   (*resume)(struct spi_device *spi);  
  7. struct device_driver  driver;  
  8. };   
struct spi_driver { int (*probe)(struct spi_device *spi); int (*remove)(struct spi_device *spi); void (*shutdown)(struct spi_device *spi); int (*suspend)(struct spi_device *spi, pm_message_t mesg); int (*resume)(struct spi_device *spi); struct device_driver driver; };

可以看出，spi_driver结构体和platform_driver结构体有极大的相似性，都有probe(),remove(),suspend(),resume()这样的接口。

Linux用spi_device来描述一个SPI外设设备。

  1. struct spi_device {  
  2. struct device        dev;  
  3. struct spi_master   *master;       //对应的控制器指针u32       
  4. max_speed_hz;  //spi通信的时钟u8          
  5. chip_select;   //片选，用于区分同一总线上的不同设备   
  6. u8  mode;  
  7. #define    SPI_CPHA    0x01            /* clock phase */   
  8. #define    SPI_CPOL    0x02            /* clock polarity */   
  9. #define SPI_MODE_0  (0|0)           /* (original MicroWire) */#define   SPI_MODE_1  (0|SPI_CPHA)   
  10. #define SPI_MODE_2  (SPI_CPOL|0)   
  11. #define SPI_MODE_3  (SPI_CPOL|SPI_CPHA)#define  SPI_CS_HIGH 0x04            /* chipselect active high? */   
  12. #define    SPI_LSB_FIRST   0x08            /* per-word bits-on-wire */   
  13. #define  SPI_3WIRE   0x10            /* SI/SO signals shared */   
  14. #define   SPI_LOOP    0x20            /* loopback mode */   
  15. u8      bits_per_word;    //每个字长的比特数   
  16. int      irq;              //使用的中断   
  17. void     *controller_state;  
  18. void     *controller_data;  
  19. char     modalias[32];    //名字   
  20. };    
struct spi_device { struct device dev; struct spi_master *master; //对应的控制器指针u32 max_speed_hz; //spi通信的时钟u8 chip_select; //片选，用于区分同一总线上的不同设备 u8 mode; #define SPI_CPHA 0x01 /* clock phase */ #define SPI_CPOL 0x02 /* clock polarity */ #define SPI_MODE_0 (0|0) /* (original MicroWire) */#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 /* chipselect active high? */ #define SPI_LSB_FIRST 0x08 /* per-word bits-on-wire */ #define SPI_3WIRE 0x10 /* SI/SO signals shared */ #define SPI_LOOP 0x20 /* loopback mode */ u8 bits_per_word; //每个字长的比特数 int irq; //使用的中断 void *controller_state; void *controller_data; char modalias[32]; //名字 }; 如下图，看这三个结构的关系，这里spi_device与spi_master是同一个父设备，这是在spi_new_device函数中设定的，一般这个设备是一个物理设备。

这里的spi_master_class,spi_bus_type又是什么呢，看下边两个结构体：

  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. };   
  9. static struct class spi_master_class = {     
  10.     .name             = "spi_master",   
  11.     .owner           = THIS_MODULE,  
  12.     .dev_release    = spi_master_release,  
  13. };    
struct bus_type spi_bus_type = { .name = "spi", .dev_attrs = spi_dev_attrs, .match = spi_match_device, .uevent = spi_uevent, .suspend = spi_suspend, .resume = spi_resume, }; static struct class spi_master_class = { .name = "spi_master", .owner = THIS_MODULE, .dev_release = spi_master_release, }; spi_bus_type对应spi中的spi bus总线，spidev的类定义如下：

  1. static struct class *spidev_class;   
static struct class *spidev_class; 创建这个类的主要目的是使mdev/udev能在/dev下创建设备节点/dev/spiB.C。B代表总线，C代表片外设备的片选号。

下边来看两个板级的结构，其中spi_board_info用来初始化spi_device，s3c2410_spi_info用来初始化spi_master。这两个板级的结构需要在移植的时候在arch/arm/mach-s3c2440/mach-smdk2440.c中初始化。

  1. struct spi_board_info {  
  2. char     modalias[32];   //设备与驱动匹配的唯一标识   
  3. const void    *platform_data;  
  4. void     *controller_data;  
  5. int        irq;  
  6. u32     max_speed_hz;  
  7. u16        bus_num;       //设备所归属的总线编号   
  8. u16      chip_select;  
  9. u8      mode;  
  10. };  
  11. struct s3c2410_spi_info {  
  12. int     pin_cs;         //芯片选择管脚   
  13. unsigned int    num_cs;         //总线上的设备数   
  14. int        bus_num;        //总线号   
  15. void (*gpio_setup)(struct s3c2410_spi_info *spi, int enable);     //spi管脚配置函数   
  16. void (*set_cs)(struct s3c2410_spi_info *spi, int cs, int pol);  
  17. };    
struct spi_board_info { char modalias[32]; //设备与驱动匹配的唯一标识 const void *platform_data; void *controller_data; int irq; u32 max_speed_hz; u16 bus_num; //设备所归属的总线编号 u16 chip_select; u8 mode; }; struct s3c2410_spi_info { int pin_cs; //芯片选择管脚 unsigned int num_cs; //总线上的设备数 int bus_num; //总线号 void (*gpio_setup)(struct s3c2410_spi_info *spi, int enable); //spi管脚配置函数 void (*set_cs)(struct s3c2410_spi_info *spi, int cs, int pol); }; boardinfo是用来管理spi_board_info的结构，spi_board_info通过spi_register_board_info(struct spi_board_info const *info, unsigned n)交由boardinfo来管理，并挂到board_list链表上，list_add_tail(&bi->list,&board_list);

  1. struct boardinfo {   
  2.  /*用于挂到链表头board_list上*/  
  3. struct list_head  list;  
  4. /*管理的spi_board_info的数量*/  
  5. unsigned  n_board_info;  
  6. /*存放结构体spi_board_info*/  
  7. struct spi_board_info    board_info[0];  
  8. };   
struct boardinfo { /*用于挂到链表头board_list上*/ struct list_head list; /*管理的spi_board_info的数量*/ unsigned n_board_info; /*存放结构体spi_board_info*/ struct spi_board_info board_info[0]; }; s3c24xx_spi是S3C2440的SPI控制器在Linux内核中的具体描述，该结构包含spi_bitbang内嵌结构，控制器时钟频率和占用的中断资源等重要成员，其中spi_bitbang具体负责SPI数据的传输。

  1. struct s3c24xx_spi {  
  2. /* bitbang has to be first */  
  3. struct spi_bitbang  bitbang;  
  4. struct completion   done;  
  5. void __iomem      *regs;  
  6. int            irq;  
  7. int             len;  
  8. int             count;  
  9. void         (*set_cs)(struct s3c2410_spi_info *spi,  int cs, int pol);  
  10. /* data buffers */const unsigned char *tx;  
  11. unsigned char       *rx;  
  12. struct clk      *clk;  
  13. struct resource        *ioarea;  
  14. struct spi_master   *master;  
  15. struct spi_device   *curdev;  
  16. struct device       *dev;  
  17. struct s3c2410_spi_info *pdata;  
  18. };  
struct s3c24xx_spi { /* bitbang has to be first */ struct spi_bitbang bitbang; struct completion done; void __iomem *regs; int irq; int len; int count; void (*set_cs)(struct s3c2410_spi_info *spi, int cs, int pol); /* data buffers */const unsigned char *tx; unsigned char *rx; struct clk *clk; struct resource *ioarea; struct spi_master *master; struct spi_device *curdev; struct device *dev; struct s3c2410_spi_info *pdata; };为了解决多个不同的SPI设备共享SPI控制器而带来的访问冲突，spi_bitbang使用内核提供的工作队列(workqueue)。workqueue是Linux内核中定义的一种回调处理方式。采用这种方式需要传输数据时，不直接完成数据的传输，而是将要传输的工作分装成相应的消息(spi_message)，发送给对应的workqueue，由与workqueue关联的内核守护线程(daemon)负责具体的执行。由于workqueue会将收到的消息按时间先后顺序排列，这样就是对设备的访问严格串行化，解决了冲突。

  1. "font-size:18px;">struct spi_bitbang {  
  2. struct workqueue_struct *workqueue;      //工作队列头   
  3. struct work_struct  work;            //每一次传输都传递下来一个spi_message，都向工作队列头添加一个   
  4. workspinlock_t        lock;  
  5. struct list_head   queue;           //挂接spi_message，如果上一次的spi_message还没有处理完，接下来的spi_message就挂接在queue上等待处理   
  6. u8            busy;            //忙碌标志   
  7. u8           use_dma;  
  8. u8          flags;  
  9. struct spi_master *master;/*一下3个函数都是在函数s3c24xx_spi_probe()中被初始化*/  
  10. int  (*setup_transfer)(struct spi_device *spi,struct spi_transfer *t);   //设置传输模式   
  11. void    (*chipselect)(struct spi_device *spi, int is_on);                    //片选   
  12. #define    BITBANG_CS_ACTIVE   1   /* normally nCS, active low */   
  13. #define   BITBANG_CS_INACTIVE 0/*传输函数，由s3c24xx_spi_txrx来实现*/   
  14. int   (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t);  
  15. u32    (*txrx_word[4])(struct spi_device *spi,unsigned nsecs,u32 word, u8 bits);  
  16. };  
struct spi_bitbang { struct workqueue_struct *workqueue; //工作队列头 struct work_struct work; //每一次传输都传递下来一个spi_message，都向工作队列头添加一个 workspinlock_t lock; struct list_head queue; //挂接spi_message，如果上一次的spi_message还没有处理完，接下来的spi_message就挂接在queue上等待处理 u8 busy; //忙碌标志 u8 use_dma; u8 flags; struct spi_master *master;/*一下3个函数都是在函数s3c24xx_spi_probe()中被初始化*/ int (*setup_transfer)(struct spi_device *spi,struct spi_transfer *t); //设置传输模式 void (*chipselect)(struct spi_device *spi, int is_on); //片选 #define BITBANG_CS_ACTIVE 1 /* normally nCS, active low */ #define BITBANG_CS_INACTIVE 0/*传输函数，由s3c24xx_spi_txrx来实现*/ int (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t); u32 (*txrx_word[4])(struct spi_device *spi,unsigned nsecs,u32 word, u8 bits); };下面来看看spi_message：

  1. struct spi_message {  
  2. struct list_head    transfers;   //此次消息的传输队列，一个消息可以包含多个传输段   
  3. struct spi_device *spi;        //传输的目的设备   
  4. unsigned      is_dma_mapped:1;  //如果为真，此次调用提供dma和cpu虚拟地址   
  5. void          (*complete)(void *context);  //异步调用完成后的回调函数   
  6. void         *context;                    //回调函数的参数   
  7. unsigned      actual_length;               //此次传输的实际长度   
  8. int         status;                      //执行的结果，成功被置0，否则是一个负的错误码   
  9. struct list_head   queue;  
  10. void          *state;  
  11. };    
struct spi_message { struct list_head transfers; //此次消息的传输队列，一个消息可以包含多个传输段 struct spi_device *spi; //传输的目的设备 unsigned is_dma_mapped:1; //如果为真，此次调用提供dma和cpu虚拟地址 void (*complete)(void *context); //异步调用完成后的回调函数 void *context; //回调函数的参数 unsigned actual_length; //此次传输的实际长度 int status; //执行的结果，成功被置0，否则是一个负的错误码 struct list_head queue; void *state; }; 在有消息需要传递的时候，会将spi_transfer通过自己的transfer_list字段挂到spi_message的transfers链表头上。spi_message用来原子的执行spi_transfer表示的一串数组传输请求。这个传输队列是原子的，这意味着在这个消息完成之前不会有其他消息占用总线。消息的执行总是按照FIFO的顺序。

下面看一看spi_transfer：

  1. struct spi_transfer {  
  2. const void *tx_buf;  //要写入设备的数据(必须是dma_safe)，或者为NULL   
  3. void       *rx_buf;  //要读取的数据缓冲(必须是dma_safe)，或者为NULL   
  4. unsigned   len;      //tx和rx的大小(字节数),这里不是指它的和，而是各自的长度，他们总是相等的   
  5. dma_addr_t    tx_dma;   //如果spi_message.is_dma_mapped是真，这个是tx的dma地址   
  6. dma_addr_t rx_dma;   //如果spi_message.is_dma_mapped是真，这个是rx的dma地址   
  7. unsigned   cs_change:1;    //影响此次传输之后的片选，指示本次tranfer结束之后是否要重新片选并调用setup改变设置，这个标志可以较少系统开销u8       
  8. bits_per_word;  //每个字长的比特数，如果是0，使用默认值   
  9. u16        delay_usecs;    //此次传输结束和片选改变之间的延时，之后就会启动另一个传输或者结束整个消息   
  10. u32       speed_hz;       //通信时钟。如果是0，使用默认值   
  11. struct list_head transfer_list; //用来连接的双向链表节点   
  12. };  

  13. 这篇来分析spi子系统的建立过程。
    嵌入式微处理器访问SPI设备有两种方式：使用GPIO模拟SPI接口的工作时序或者使用SPI控制器。使用GPIO模拟SPI接口的工作时序是非常容易实现的，但是会导致大量的时间耗费在模拟SPI接口的时序上，访问效率比较低，容易成为系统瓶颈。这里主要分析使用SPI控制器的情况。

    这个是由sys文件系统导出的spi子系统在内核中的视图了。
    首先了解一下Linux内核中的几个文件:spi.c也就是spi子系统的核心了，spi_s3c24xx.c是s3c24xx系列芯片的SPI controller驱动，它向更上层的SPI核心层(spi.c)提供接口用来控制芯片的SPI controller，是一个被其他驱动使用的驱动。而spidev.c是在核心层基础之上将SPI controller模拟成一个字符型的驱动，向文件系统提供标准的文件系统接口，用来操作对应的SPI controller。
    下面我们来看看spi子系统是怎么注册进内核的：

    1. static int __init spi_init(void)  
    2. {  
    3.     int status;  
    4.     buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);  
    5.     if (!buf) {  
    6.         status = -ENOMEM;  
    7.         goto err0;  
    8.     }  
    9.     status = bus_register(&spi_bus_type);  
    10.     if (status < 0)  
    11.         goto err1;  
    12.     status = class_register(&spi_master_class);  
    13.     if (status < 0)  
    14.         goto err2;  
    15.     return 0;  
    16. err2:  
    17.     bus_unregister(&spi_bus_type);  
    18. err1:  
    19.     kfree(buf);  
    20.     buf = NULL;  
    21. err0:  
    22.     return status;  
    23. }  
    24. postcore_initcall(spi_init);  
    static int __init spi_init(void) { int status; buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL); if (!buf) { status = -ENOMEM; goto err0; } status = bus_register(&spi_bus_type); if (status < 0) goto err1; status = class_register(&spi_master_class); if (status < 0) goto err2; return 0; err2: bus_unregister(&spi_bus_type); err1: kfree(buf); buf = NULL; err0: return status; } postcore_initcall(spi_init);这里注册了一个spi_bus_type，也就是一个spi总线，和一个spi_master的class。分别对应上图中sys/bus/下的spi目录和sys/class/下的spi_master目录。

    下面来分析SPI controller驱动的注册与初始化过程，首先执行的是s3c24xx_spi_init。

    1. static int __init s3c24xx_spi_init(void)  
    2. {  
    3.         return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe);  
    4. }  
    static int __init s3c24xx_spi_init(void) { return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe); }platform_driver_probe中完成了s3c24xx_spi_driver这个平台驱动的注册，相应的平台设备在devs.c中定义，在smdk2440_devices中添加&s3c_device_spi0，&s3c_device_spi1，这就生成了图中所示的s3c24xx-spi.0与s3c24xx-spi.1，当然了这图是在网上找的，不是我画的，所以是6410的。这里s3c24xx-spi.0表示s3c2440的spi controller的0号接口，s3c24xx-spi.1表示s3c2440的spi controller的1号接口。注册了s3c24xx_spi_driver后，赋值了平台驱动的probe函数为s3c24xx_spi_probe。所以当match成功后，调用s3c24xx_spi_probe，这里看其实现：

    1. "font-size:18px;">static int __init s3c24xx_spi_probe(struct platform_device *pdev)  
    2. {  
    3.     struct s3c2410_spi_info *pdata;  
    4.     struct s3c24xx_spi *hw;  
    5.     struct spi_master *master;  
    6.     struct resource *res;  
    7.     int err = 0;  
    8.     /*分配struct spi_master+struct s3c24xx_spi大小的数据，把s3c24xx_spi设为spi_master的私有数据*/  
    9.     master = spi_alloc_master(&pdev->dev, sizeof(struct s3c24xx_spi));  
    10.     if (master == NULL) {  
    11.         dev_err(&pdev->dev, "No memory for spi_master\n");  
    12.         err = -ENOMEM;  
    13.         goto err_nomem;  
    14.     }  
    15.     /*从master中获得s3c24xx_spi*/  
    16.     hw = spi_master_get_devdata(master);  
    17.     memset(hw, 0, sizeof(struct s3c24xx_spi));  
    18.   
    19.   
    20.     hw->master = spi_master_get(master);  
    21.     /*驱动移植的时候需要实现的重要结构，初始化为&s3c2410_spi0_platdata*/  
    22.     hw->pdata = pdata = pdev->dev.platform_data;  
    23.     hw->dev = &pdev->dev;  
    24.   
    25.   
    26.     if (pdata == NULL) {  
    27.         dev_err(&pdev->dev, "No platform data supplied\n");  
    28.         err = -ENOENT;  
    29.         goto err_no_pdata;  
    30.     }  
    31.     /*设置平台的私有数据为s3c24xx_spi*/  
    32.     platform_set_drvdata(pdev, hw);  
    33.     init_completion(&hw->done);  
    34.   
    35.   
    36.     /* setup the master state. */  
    37.     /*该总线上的设备数*/  
    38.     master->num_chipselect = hw->pdata->num_cs;  
    39.     /*总线号*/    
    40.     master->bus_num = pdata->bus_num;  
    41.   
    42.   
    43.     /* setup the state for the bitbang driver */  
    44.     /*spi_bitbang专门负责数据的传输*/  
    45.     hw->bitbang.master         = hw->master;  
    46.     hw->bitbang.setup_transfer = s3c24xx_spi_setupxfer;  
    47.     hw->bitbang.chipselect     = s3c24xx_spi_chipsel;  
    48.     hw->bitbang.txrx_bufs      = s3c24xx_spi_txrx;  
    49.     hw->bitbang.master->setup  = s3c24xx_spi_setup;  
    50.   
    51.   
    52.     dev_dbg(hw->dev, "bitbang at %p\n", &hw->bitbang);  
    53.        
    54.     。。。。。。。。。。。。。。。。。。。。。。。。  
    55.       
    56.     /*初始化设置寄存器，包括对SPIMOSI,SPIMISO,SPICLK引脚的设置*/  
    57.     s3c24xx_spi_initialsetup(hw);  
    58.   
    59.   
    60.     /* register our spi controller */  
    61.   
    62.   
    63.     err = spi_bitbang_start(&hw->bitbang);  
    64.         。。。。。。。。。。。。。。。。。。。。。  
    65. }  
    66. spi controller的register在spi_bitbang_start函数中实现：  
    67. int spi_bitbang_start(struct spi_bitbang *bitbang)  
    68. {  
    69.     int status;  
    70.   
    71.   
    72.     if (!bitbang->master || !bitbang->chipselect)  
    73.         return -EINVAL;  
    74.     /*动态创建一个work_struct结构，它的处理函数是bitbang_work*/  
    75.     INIT_WORK(&bitbang->work, bitbang_work);  
    76.     spin_lock_init(&bitbang->lock);  
    77.     INIT_LIST_HEAD(&bitbang->queue);  
    78.     /*spi的数据传输就是用这个方法*/  
    79.     if (!bitbang->master->transfer)  
    80.         bitbang->master->transfer = spi_bitbang_transfer;  
    81.     if (!bitbang->txrx_bufs) {  
    82.         bitbang->use_dma = 0;  
    83.         /*spi_s3c24xx.c中有spi_bitbang_bufs方法，在bitbang_work中被调用*/  
    84.         bitbang->txrx_bufs = spi_bitbang_bufs;  
    85.         if (!bitbang->master->setup) {  
    86.             if (!bitbang->setup_transfer)  
    87.                 bitbang->setup_transfer =  
    88.                      spi_bitbang_setup_transfer;  
    89.             /*在spi_s3c24xx.c中有setup的处理方法，在spi_new_device中被调用*/  
    90.             bitbang->master->setup = spi_bitbang_setup;  
    91.             bitbang->master->cleanup = spi_bitbang_cleanup;  
    92.         }  
    93.     } else if (!bitbang->master->setup)  
    94.         return -EINVAL;  
    95.   
    96.   
    97.     /* this task is the only thing to touch the SPI bits */  
    98.     bitbang->busy = 0;  
    99.     /调用create_singlethread_workqueue创建单个工作线程/  
    100.     bitbang->workqueue = create_singlethread_workqueue(  
    101.             dev_name(bitbang->master->dev.parent));  
    102.     if (bitbang->workqueue == NULL) {  
    103.         status = -EBUSY;  
    104.         goto err1;  
    105.     }  
    106.     status = spi_register_master(bitbang->master);  
    107.     if (status < 0)  
    108.         goto err2;  
    109.     return status;  
    110. err2:  
    111.     destroy_workqueue(bitbang->workqueue);  
    112. err1:  
    113.     return status;  
    114. }  
    static int __init s3c24xx_spi_probe(struct platform_device *pdev) { struct s3c2410_spi_info *pdata; struct s3c24xx_spi *hw; struct spi_master *master; struct resource *res; int err = 0; /*分配struct spi_master+struct s3c24xx_spi大小的数据，把s3c24xx_spi设为spi_master的私有数据*/ master = spi_alloc_master(&pdev->dev, sizeof(struct s3c24xx_spi)); if (master == NULL) { dev_err(&pdev->dev, "No memory for spi_master\n"); err = -ENOMEM; goto err_nomem; } /*从master中获得s3c24xx_spi*/ hw = spi_master_get_devdata(master); memset(hw, 0, sizeof(struct s3c24xx_spi)); hw->master = spi_master_get(master); /*驱动移植的时候需要实现的重要结构，初始化为&s3c2410_spi0_platdata*/ hw->pdata = pdata = pdev->dev.platform_data; hw->dev = &pdev->dev; if (pdata == NULL) { dev_err(&pdev->dev, "No platform data supplied\n"); err = -ENOENT; goto err_no_pdata; } /*设置平台的私有数据为s3c24xx_spi*/ platform_set_drvdata(pdev, hw); init_completion(&hw->done); /* setup the master state. */ /*该总线上的设备数*/ master->num_chipselect = hw->pdata->num_cs; /*总线号*/ master->bus_num = pdata->bus_num; /* setup the state for the bitbang driver */ /*spi_bitbang专门负责数据的传输*/ hw->bitbang.master = hw->master; hw->bitbang.setup_transfer = s3c24xx_spi_setupxfer; hw->bitbang.chipselect = s3c24xx_spi_chipsel; hw->bitbang.txrx_bufs = s3c24xx_spi_txrx; hw->bitbang.master->setup = s3c24xx_spi_setup; dev_dbg(hw->dev, "bitbang at %p\n", &hw->bitbang); 。。。。。。。。。。。。。。。。。。。。。。。。 /*初始化设置寄存器，包括对SPIMOSI,SPIMISO,SPICLK引脚的设置*/ s3c24xx_spi_initialsetup(hw); /* register our spi controller */ err = spi_bitbang_start(&hw->bitbang); 。。。。。。。。。。。。。。。。。。。。。 } spi controller的register在spi_bitbang_start函数中实现： int spi_bitbang_start(struct spi_bitbang *bitbang) { int status; if (!bitbang->master || !bitbang->chipselect) return -EINVAL; /*动态创建一个work_struct结构，它的处理函数是bitbang_work*/ INIT_WORK(&bitbang->work, bitbang_work); spin_lock_init(&bitbang->lock); INIT_LIST_HEAD(&bitbang->queue); /*spi的数据传输就是用这个方法*/ if (!bitbang->master->transfer) bitbang->master->transfer = spi_bitbang_transfer; if (!bitbang->txrx_bufs) { bitbang->use_dma = 0; /*spi_s3c24xx.c中有spi_bitbang_bufs方法，在bitbang_work中被调用*/ bitbang->txrx_bufs = spi_bitbang_bufs; if (!bitbang->master->setup) { if (!bitbang->setup_transfer) bitbang->setup_transfer = spi_bitbang_setup_transfer; /*在spi_s3c24xx.c中有setup的处理方法，在spi_new_device中被调用*/ bitbang->master->setup = spi_bitbang_setup; bitbang->master->cleanup = spi_bitbang_cleanup; } } else if (!bitbang->master->setup) return -EINVAL; /* this task is the only thing to touch the SPI bits */ bitbang->busy = 0; /调用create_singlethread_workqueue创建单个工作线程/ bitbang->workqueue = create_singlethread_workqueue( dev_name(bitbang->master->dev.parent)); if (bitbang->workqueue == NULL) { status = -EBUSY; goto err1; } status = spi_register_master(bitbang->master); if (status < 0) goto err2; return status; err2: destroy_workqueue(bitbang->workqueue); err1: return status; }

    然后看这里是怎样注册spi主机控制器驱动的:

    1. int spi_register_master(struct spi_master *master)  
    2. {  
    3.     。。。。。。。。。。。。。。。。  
    4.     /*将spi添加到内核，这也是sys/class/Spi_master下产生Spi0，Spi1的原因*/  
    5.     dev_set_name(&master->dev, "spi%u", master->bus_num);  
    6.     status = device_add(&master->dev);  
    7.     scan_boardinfo(master);  
    8. }  
    int spi_register_master(struct spi_master *master) { 。。。。。。。。。。。。。。。。 /*将spi添加到内核，这也是sys/class/Spi_master下产生Spi0，Spi1的原因*/ dev_set_name(&master->dev, "spi%u", master->bus_num); status = device_add(&master->dev); scan_boardinfo(master); }

    这里跟踪scan_boardinfo函数：

    1. static void scan_boardinfo(struct spi_master *master)  
    2. {  
    3.     struct boardinfo    *bi;  
    4. mutex_lock(&board_lock);  
    5.     /*遍历所有挂在board_list上的struct boardinfo*/  
    6.     list_for_each_entry(bi, &board_list, list) {  
    7.         struct spi_board_info   *chip = bi->board_info;  
    8.         unsigned    n;  
    9.         /*遍历每个boardinfo管理的spi_board_info，如果设备的总线号与控制器的总线好相等，则创建新设备*/  
    10.         for (n = bi->n_board_info; n > 0; n--, chip++) {  
    11.             if (chip->bus_num != master->bus_num)  
    12.                 continue;  
    13.             (void) spi_new_device(master, chip);  
    14.         }  
    15.     }  
    16.     mutex_unlock(&board_lock);  
    17. }  
    static void scan_boardinfo(struct spi_master *master) { struct boardinfo *bi; mutex_lock(&board_lock); /*遍历所有挂在board_list上的struct boardinfo*/ list_for_each_entry(bi, &board_list, list) { struct spi_board_info *chip = bi->board_info; unsigned n; /*遍历每个boardinfo管理的spi_board_info，如果设备的总线号与控制器的总线好相等，则创建新设备*/ for (n = bi->n_board_info; n > 0; n--, chip++) { if (chip->bus_num != master->bus_num) continue; (void) spi_new_device(master, chip); } } mutex_unlock(&board_lock); }在移植的时候我们会在mach-smdk2440.c中的smdk2440_machine_init中添加spi_register_board_info

    这个函数完成了将spi_board_info交由boardinfo管理，并把boardinfo挂载到board_list链表上。也就是说在系统初始化的时候将spi_device交由到挂在board_list上的boardinfo管理，在spi controller的driver注册的时候不但注册这个主机控制器的驱动，还要遍历这个主机控制器的总线上的spi_device，将总线上的spi_device全部注册进内核。当注册进内核并且spi_driver已经注册的时候，如果总线match成功，则会调用spi_driver的probe函数，这个将在后边进行分析。

    1. "font-size:18px;">int __init  
    2. spi_register_board_info(struct spi_board_info const *info, unsigned n)  
    3. {  
    4.     struct boardinfo    *bi;  
    5.   
    6.   
    7.     bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);  
    8.     if (!bi)  
    9.         return -ENOMEM;  
    10.     bi->n_board_info = n;  
    11.     memcpy(bi->board_info, info, n * sizeof *info);  
    12.   
    13.   
    14.     mutex_lock(&board_lock);  
    15.     list_add_tail(&bi->list, &board_list);  
    16.     mutex_unlock(&board_lock);  
    17.     return 0;  
    18. }  
    int __init spi_register_board_info(struct spi_board_info const *info, unsigned n) { struct boardinfo *bi; bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL); if (!bi) return -ENOMEM; bi->n_board_info = n; memcpy(bi->board_info, info, n * sizeof *info); mutex_lock(&board_lock); list_add_tail(&bi->list, &board_list); mutex_unlock(&board_lock); return 0; }看一下创建新设备的函数：
    1. "font-size:18px;">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.     proxy = spi_alloc_device(master);  
    7.     if (!proxy)  
    8.         return NULL;  
    9.   
    10.   
    11.     WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));  
    12.     /*初始化spi_device的各个字段*/  
    13.     proxy->chip_select = chip->chip_select;  
    14.     proxy->max_speed_hz = chip->max_speed_hz;  
    15.     proxy->mode = chip->mode;  
    16.     proxy->irq = chip->irq;  
    17.     /*这里获得了spi_device的名字，这个modalias也是在我们移植时在mach-smdk2440.c中的s3c2410_spi0_board中设定的*/  
    18.     strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));  
    19.     proxy->dev.platform_data = (void *) chip->platform_data;  
    20.     proxy->controller_data = chip->controller_data;  
    21.     proxy->controller_state = NULL;  
    22.     /*主要完成将spi_device添加到内核*/  
    23.     status = spi_add_device(proxy);  
    24.     if (status < 0) {  
    25.         spi_dev_put(proxy);  
    26.         return NULL;  
    27.     }  
    28.   
    29.   
    30.     return proxy;  
    31. }  
    struct spi_device *spi_new_device(struct spi_master *master, struct spi_board_info *chip) { struct spi_device *proxy; int status; proxy = spi_alloc_device(master); if (!proxy) return NULL; WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias)); /*初始化spi_device的各个字段*/ proxy->chip_select = chip->chip_select; proxy->max_speed_hz = chip->max_speed_hz; proxy->mode = chip->mode; proxy->irq = chip->irq; /*这里获得了spi_device的名字，这个modalias也是在我们移植时在mach-smdk2440.c中的s3c2410_spi0_board中设定的*/ strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias)); proxy->dev.platform_data = (void *) chip->platform_data; proxy->controller_data = chip->controller_data; proxy->controller_state = NULL; /*主要完成将spi_device添加到内核*/ status = spi_add_device(proxy); if (status < 0) { spi_dev_put(proxy); return NULL; } return proxy; }下面来看分配spi_alloc_device的函数，主要完成了分配spi_device，并初始化spi->dev的一些字段。
    1. struct spi_device *spi_alloc_device(struct spi_master *master)  
    2. {  
    3.     struct spi_device   *spi;  
    4.     struct device       *dev = master->dev.parent;  
    5.     if (!spi_master_get(master))  
    6.         return NULL;  
    7.     spi = kzalloc(sizeof *spi, GFP_KERNEL);  
    8.     if (!spi) {  
    9.         dev_err(dev, "cannot alloc spi_device\n");  
    10.         spi_master_put(master);  
    11.         return NULL;  
    12.     }  
    13.     spi->master = master;  
    14.     spi->dev.parent = dev;  
    15.     /*设置总线是spi_bus_type，下面会讲到spi_device与spi_driver是怎样match上的*/  
    16.     spi->dev.bus = &spi_bus_type;  
    17.     spi->dev.release = spidev_release;  
    18.     device_initialize(&spi->dev);  
    19.     return spi;  
    20. }  
    struct spi_device *spi_alloc_device(struct spi_master *master) { struct spi_device *spi; struct device *dev = master->dev.parent; if (!spi_master_get(master)) return NULL; spi = kzalloc(sizeof *spi, GFP_KERNEL); if (!spi) { dev_err(dev, "cannot alloc spi_device\n"); spi_master_put(master); return NULL; } spi->master = master; spi->dev.parent = dev; /*设置总线是spi_bus_type，下面会讲到spi_device与spi_driver是怎样match上的*/ spi->dev.bus = &spi_bus_type; spi->dev.release = spidev_release; device_initialize(&spi->dev); return spi; }下面来看分配的这个spi_device是怎样注册进内核的：
    1. int spi_add_device(struct spi_device *spi)  
    2. {  
    3.     static DEFINE_MUTEX(spi_add_lock);  
    4.     struct device *dev = spi->master->dev.parent;  
    5.     int status;  
    6.     /*spi_device的片选号不能大于spi控制器的片选数*/  
    7.     if (spi->chip_select >= spi->master->num_chipselect) {  
    8.         dev_err(dev, "cs%d >= max %d\n",  
    9.             spi->chip_select,  
    10.             spi->master->num_chipselect);  
    11.         return -EINVAL;  
    12.     }  
    13.     /*这里设置是spi_device在Linux设备驱动模型中的name，也就是图中的spi0.0，而在/dev/下设备节点的名字是proxy->modalias中的名字*/  
    14.     dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),  
    15.             spi->chip_select);  
    16.     mutex_lock(&spi_add_lock);  
    17.     /*如果总线上挂的设备已经有这个名字，则设置状态忙碌，并退出*/  
    18.     if (bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev))  
    19.             != NULL) {  
    20.         dev_err(dev, "chipselect %d already in use\n",  
    21.                 spi->chip_select);  
    22.         status = -EBUSY;  
    23.         goto done;  
    24.     }  
    25.     /对spi_device的时钟等进行设置/  
    26.     status = spi->master->setup(spi);  
    27.     if (status < 0) {  
    28.         dev_err(dev, "can't %s %s, status %d\n",  
    29.                 "setup", dev_name(&spi->dev), status);  
    30.         goto done;  
    31.     }  
    32.     /*添加到内核*/  
    33.     status = device_add(&spi->dev);  
    34.     if (status < 0)  
    35.         dev_err(dev, "can't %s %s, status %d\n",  
    36.                 "add", dev_name(&spi->dev), status);  
    37.     else  
    38.         dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));  
    39.   
    40.   
    41. done:  
    42.     mutex_unlock(&spi_add_lock);  
    43.     return status;  
    44. }  
    45.   
    46.   
    47. static int s3c24xx_spi_setup(struct spi_device *spi)  
    48. {  
    49.     。。。。。。。。。。。。。。  
    50.     ret = s3c24xx_spi_setupxfer(spi, NULL);  
    51.     。。。。。。。。。。。。。。  
    52. }  
    53.   
    54.   
    55. static int s3c24xx_spi_setupxfer(struct spi_device *spi,  
    56.                  struct spi_transfer *t)  
    57. {  
    58.     struct s3c24xx_spi *hw = to_hw(spi);  
    59.     unsigned int bpw;  
    60.     unsigned int hz;  
    61.     unsigned int div;  
    62.     /*设置了每字长的位数，发送速度*/  
    63.     bpw = t ? t->bits_per_word : spi->bits_per_word;  
    64.     hz  = t ? t->speed_hz : spi->max_speed_hz;  
    65.   
    66.   
    67.     if (bpw != 8) {  
    68.         dev_err(&spi->dev, "invalid bits-per-word (%d)\n", bpw);  
    69.         return -EINVAL;  
    70.     }  
    71.     /*色黄志分频值*/  
    72.     div = clk_get_rate(hw->clk) / hz;  
    73.   
    74.   
    75.     /* is clk = pclk / (2 * (pre+1)), or is it 
    76.      *    clk = (pclk * 2) / ( pre + 1) */  
    77.   
    78.   
    79.     div /= 2;  
    80.   
    81.   
    82.     if (div > 0)  
    83.         div -= 1;  
    84.   
    85.   
    86.     if (div > 255)  
    87.         div = 255;  
    88.   
    89.   
    90.     dev_dbg(&spi->dev, "setting pre-scaler to %d (hz %d)\n", div, hz);  
    91.     writeb(div, hw->regs + S3C2410_SPPRE);  
    92.   
    93.   
    94.     spin_lock(&hw->bitbang.lock);  
    95.     if (!hw->bitbang.busy) {  
    96.         hw->bitbang.chipselect(spi, BITBANG_CS_INACTIVE);  
    97.         /* need to ndelay for 0.5 clocktick ? */  
    98.     }  
    99.     spin_unlock(&hw->bitbang.lock);  
    100.   
    101.   
    102.     return 0;  
    103. }  
    int spi_add_device(struct spi_device *spi) { static DEFINE_MUTEX(spi_add_lock); struct device *dev = spi->master->dev.parent; int status; /*spi_device的片选号不能大于spi控制器的片选数*/ if (spi->chip_select >= spi->master->num_chipselect) { dev_err(dev, "cs%d >= max %d\n", spi->chip_select, spi->master->num_chipselect); return -EINVAL; } /*这里设置是spi_device在Linux设备驱动模型中的name，也就是图中的spi0.0，而在/dev/下设备节点的名字是proxy->modalias中的名字*/ dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev), spi->chip_select); mutex_lock(&spi_add_lock); /*如果总线上挂的设备已经有这个名字，则设置状态忙碌，并退出*/ if (bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev)) != NULL) { dev_err(dev, "chipselect %d already in use\n", spi->chip_select); status = -EBUSY; goto done; } /对spi_device的时钟等进行设置/ status = spi->master->setup(spi); if (status < 0) { dev_err(dev, "can't %s %s, status %d\n", "setup", dev_name(&spi->dev), status); goto done; } /*添加到内核*/ status = device_add(&spi->dev); if (status < 0) dev_err(dev, "can't %s %s, status %d\n", "add", dev_name(&spi->dev), status); else dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev)); done: mutex_unlock(&spi_add_lock); return status; } static int s3c24xx_spi_setup(struct spi_device *spi) { 。。。。。。。。。。。。。。 ret = s3c24xx_spi_setupxfer(spi, NULL); 。。。。。。。。。。。。。。 } static int s3c24xx_spi_setupxfer(struct spi_device *spi, struct spi_transfer *t) { struct s3c24xx_spi *hw = to_hw(spi); unsigned int bpw; unsigned int hz; unsigned int div; /*设置了每字长的位数，发送速度*/ bpw = t ? t->bits_per_word : spi->bits_per_word; hz = t ? t->speed_hz : spi->max_speed_hz; if (bpw != 8) { dev_err(&spi->dev, "invalid bits-per-word (%d)\n", bpw); return -EINVAL; } /*色黄志分频值*/ div = clk_get_rate(hw->clk) / hz; /* is clk = pclk / (2 * (pre+1)), or is it * clk = (pclk * 2) / ( pre + 1) */ div /= 2; if (div > 0) div -= 1; if (div > 255) div = 255; dev_dbg(&spi->dev, "setting pre-scaler to %d (hz %d)\n", div, hz); writeb(div, hw->regs + S3C2410_SPPRE); spin_lock(&hw->bitbang.lock); if (!hw->bitbang.busy) { hw->bitbang.chipselect(spi, BITBANG_CS_INACTIVE); /* need to ndelay for 0.5 clocktick ? */ } spin_unlock(&hw->bitbang.lock); return 0; }下面来看这个spi_driver是怎样注册的，又是与spi_device怎样match上的。
    在spidev.c中：
    1. static int __init spidev_init(void)  
    2. {  
    3.     int status;  
    4.     BUILD_BUG_ON(N_SPI_MINORS > 256);  
    5.     status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);  
    6.     if (status < 0)  
    7.         return status;  
    8.     spidev_class = class_create(THIS_MODULE, "spidev");  
    9.     if (IS_ERR(spidev_class)) {  
    10.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);  
    11.         return PTR_ERR(spidev_class);  
    12.     }  
    13.     status = spi_register_driver(&spidev_spi);  
    14.     if (status < 0) {  
    15.         class_destroy(spidev_class);  
    16.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);  
    17.     }  
    18.     return status;  
    19. }  
    static int __init spidev_init(void) { int status; BUILD_BUG_ON(N_SPI_MINORS > 256); status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops); if (status < 0) return status; spidev_class = class_create(THIS_MODULE, "spidev"); if (IS_ERR(spidev_class)) { unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name); return PTR_ERR(spidev_class); } status = spi_register_driver(&spidev_spi); if (status < 0) { class_destroy(spidev_class); unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name); } return status; }注册了名为”spi”的字符驱动，然后注册了spidev_spi驱动，这个就是图中sys/Bus/Spi/Drivers/下的spidev。
    1. static struct spi_driver spidev_spi = {  
    2.     .driver = {  
    3.         .name =     "spidev",  
    4.         .owner =    THIS_MODULE,  
    5.     },  
    6.     .probe =    spidev_probe,  
    7.     .remove =   __devexit_p(spidev_remove),  
    8. };  
    static struct spi_driver spidev_spi = { .driver = { .name = "spidev", .owner = THIS_MODULE, }, .probe = spidev_probe, .remove = __devexit_p(spidev_remove), };
    1. static struct spi_driver spidev_spi = {  
    2.     .driver = {  
    3.         .name =     "spidev",  
    4.         .owner =    THIS_MODULE,  
    5.     },  
    6.     .probe =    spidev_probe,  
    7.     .remove =   __devexit_p(spidev_remove),  
    8. };  
    static struct spi_driver spidev_spi = { .driver = { .name = "spidev", .owner = THIS_MODULE, }, .probe = spidev_probe, .remove = __devexit_p(spidev_remove), };这里来看__driver_attach这个函数，其中分别调用了driver_match_device，driver_probe_device函数。如果匹配成果调用probe函数，否则返回。
    1. static int __driver_attach(struct device *dev, void *data)    
    2. {    
    3.     struct device_driver *drv = data;    
    4.     if (!driver_match_device(drv, dev))    
    5.         return 0;    
    6.     
    7.     if (dev->parent) /* Needed for USB */    
    8.         down(&dev->parent->sem);    
    9.     down(&dev->sem);    
    10.     if (!dev->driver)    
    11.         driver_probe_device(drv, dev);    
    12.     up(&dev->sem);    
    13.     if (dev->parent)    
    14.         up(&dev->parent->sem);    
    15.     
    16.     return 0;    
    17. }    
    static int __driver_attach(struct device *dev, void *data) { struct device_driver *drv = data; if (!driver_match_device(drv, dev)) return 0; if (dev->parent) /* Needed for USB */ down(&dev->parent->sem); down(&dev->sem); if (!dev->driver) driver_probe_device(drv, dev); up(&dev->sem); if (dev->parent) up(&dev->parent->sem); return 0; } 匹配的时候调用的bus的match函数。
    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. };  
    9. static int spi_match_device(struct device *dev, struct device_driver *drv)  
    10. {  
    11.     const struct spi_device *spi = to_spi_device(dev);  
    12.   
    13.   
    14.     return strcmp(spi->modalias, drv->name) == 0;  
    15. }  
    struct bus_type spi_bus_type = { .name = "spi", .dev_attrs = spi_dev_attrs, .match = spi_match_device, .uevent = spi_uevent, .suspend = spi_suspend, .resume = spi_resume, }; static int spi_match_device(struct device *dev, struct device_driver *drv) { const struct spi_device *spi = to_spi_device(dev); return strcmp(spi->modalias, drv->name) == 0; }可以看到这里根据驱动和设备的名字进行匹配，匹配成功后调用驱动的probe函数。
    1. static int spi_drv_probe(struct device *dev)  
    2. {  
    3.     const struct spi_driver     *sdrv = to_spi_driver(dev->driver);  
    4.   
    5.   
    6.     return sdrv->probe(to_spi_device(dev));  
    7. }  
    static int spi_drv_probe(struct device *dev) { const struct spi_driver *sdrv = to_spi_driver(dev->driver); return sdrv->probe(to_spi_device(dev)); }可以看大调用了具体的probe函数，这里实现了把spidev添加到device_list，这样这个虚拟的字符驱动就注册并初始化完毕。
    1. static int spidev_remove(struct spi_device *spi)  
    2. {  
    3.     struct spidev_data  *spidev = spi_get_drvdata(spi);  
    4.   
    5.   
    6.     /* make sure ops on existing fds can abort cleanly */  
    7.     spin_lock_irq(&spidev->spi_lock);  
    8.     spidev->spi = NULL;  
    9.     spi_set_drvdata(spi, NULL);  
    10.     spin_unlock_irq(&spidev->spi_lock);  
    11.   
    12.   
    13.     /* prevent new opens */  
    14.     mutex_lock(&device_list_lock);  
    15.     list_del(&spidev->device_entry);  
    16.     device_destroy(spidev_class, spidev->devt);  
    17.     clear_bit(MINOR(spidev->devt), minors);  
    18.     if (spidev->users == 0)  
    19.         kfree(spidev);  
    20.     mutex_unlock(&device_list_lock);  
    21.   
    22.   
    23.     return 0;  
    24. }  
    static int spidev_remove(struct spi_device *spi) { struct spidev_data *spidev = spi_get_drvdata(spi); /* make sure ops on existing fds can abort cleanly */ spin_lock_irq(&spidev->spi_lock); spidev->spi = NULL; spi_set_drvdata(spi, NULL); spin_unlock_irq(&spidev->spi_lock); /* prevent new opens */ mutex_lock(&device_list_lock); list_del(&spidev->device_entry); device_destroy(spidev_class, spidev->devt); clear_bit(MINOR(spidev->devt), minors); if (spidev->users == 0) kfree(spidev); mutex_unlock(&device_list_lock); return 0; }在spidev的注册函数中注册了文件操作集合file_operations，为用户空间提供了操作SPI controller的接口。
    1. static struct file_operations spidev_fops = {  
    2.     .owner =    THIS_MODULE,  
    3.     /* REVISIT switch to aio primitives, so that userspace 
    4.      * gets more complete API coverage.  It'll simplify things 
    5.      * too, except for the locking. 
    6.      */  
    7.     .write =    spidev_write,  
    8.     .read =     spidev_read,  
    9.     .unlocked_ioctl = spidev_ioctl,  
    10.     .open =     spidev_open,  
    11.     .release =  spidev_release,  
    12. };  
    static struct file_operations spidev_fops = { .owner = THIS_MODULE, /* REVISIT switch to aio primitives, so that userspace * gets more complete API coverage. It'll simplify things * too, except for the locking. */ .write = spidev_write, .read = spidev_read, .unlocked_ioctl = spidev_ioctl, .open = spidev_open, .release = spidev_release, };到此为止spi子系统与spi_master,spi_device,spi_driver这个Linux设备驱动模型已经建立完了。

    这篇文档主要介绍spi数据传输过程。

    当应用层要向设备传输数据的时候，会通过ioctl向设备驱动发送传输数据的命令。如图，向SPI从设备发送读写命令，实际的读写操作还是调用了主机控制器驱动的数据传输函数。transfer函数用于spi的IO传输。但是，transfer函数一般不会执行真正的传输操作，而是把要传输的内容放到一个队列里，然后调用一种类似底半部的机制进行真正的传输。这是因为,spi总线一般会连多个spi设备，而spi设备间的访问可能会并发。如果直接在transfer函数中实现传输，那么会产生竞态，spi设备互相间会干扰。所以，真正的spi传输与具体的spi控制器的实现有关，spi的框架代码中没有涉及。像spi设备的片选，根据具体设备进行时钟调整等等都在实现传输的代码中被调用。spi的传输命令都是通过结构spi_message定义，设备程序调用transfer函数将spi_message交给spi总线驱动，总线驱动再将message传到底半部排队，实现串行化传输。



    在spidev.c中实现了file_operations：

    1. "font-size:18px;">static struct file_operations spidev_fops = {  
    2.     .owner =    THIS_MODULE,  
    3.     .write =    spidev_write,  
    4.     .read =     spidev_read,  
    5.     .unlocked_ioctl = spidev_ioctl,  
    6.     .open =     spidev_open,  
    7.     .release =  spidev_release,  
    8. };  
    static struct file_operations spidev_fops = { .owner = THIS_MODULE, .write = spidev_write, .read = spidev_read, .unlocked_ioctl = spidev_ioctl, .open = spidev_open, .release = spidev_release, };这里看spidev_ioctl的实现：

    1. "font-size:18px;">static long  
    2. spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)  
    3. {  
    4.     int         err = 0;  
    5.     int         retval = 0;  
    6.     struct spidev_data  *spidev;  
    7.     struct spi_device   *spi;  
    8.     u32         tmp;  
    9.     unsigned        n_ioc;  
    10.     struct spi_ioc_transfer *ioc;  
    11.   
    12.     /*查看这个命令的幻数字段是否为'k'*/  
    13.     if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)  
    14.         return -ENOTTY;  
    15.   
    16.     /*如果方向是用户空间从内核读，即内核向用户空间写，则检查用户空间的地址是否有效*/  
    17.     if (_IOC_DIR(cmd) & _IOC_READ)  
    18.         err = !access_ok(VERIFY_WRITE,  
    19.                 (void __user *)arg, _IOC_SIZE(cmd));  
    20.     /*如果方向是用户空间向内核写，即内核读用户空间，则检查用户空间的地址是否有效*/  
    21.     if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)  
    22.         err = !access_ok(VERIFY_READ,  
    23.                 (void __user *)arg, _IOC_SIZE(cmd));  
    24.     if (err)  
    25.         return -EFAULT;  
    26.   
    27.     /* guard against device removal before, or while, 
    28.      * we issue this ioctl. 
    29.      */  
    30.     spidev = filp->private_data;  
    31.     spin_lock_irq(&spidev->spi_lock);  
    32.     spi = spi_dev_get(spidev->spi);  
    33.     spin_unlock_irq(&spidev->spi_lock);  
    34.   
    35.     if (spi == NULL)  
    36.         return -ESHUTDOWN;  
    37.   
    38.     mutex_lock(&spidev->buf_lock);  
    39.   
    40.     switch (cmd) {  
    41.     /* read requests */  
    42.     case SPI_IOC_RD_MODE:  
    43.         /*因为已经进行了地址是否有效的检查，所以这里使用__put_user,__get_user,__copy_from_user可以节省几个时钟周期呢*/  
    44.         retval = __put_user(spi->mode & SPI_MODE_MASK,  
    45.                     (__u8 __user *)arg);  
    46.         break;  
    47.     case SPI_IOC_RD_LSB_FIRST:  
    48.         retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,  
    49.                     (__u8 __user *)arg);  
    50.         break;  
    51.     case SPI_IOC_RD_BITS_PER_WORD:  
    52.         retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);  
    53.         break;  
    54.     case SPI_IOC_RD_MAX_SPEED_HZ:  
    55.         retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);  
    56.         break;  
    57.   
    58.     /*设置SPI模式*/  
    59.     case SPI_IOC_WR_MODE:  
    60.         retval = __get_user(tmp, (u8 __user *)arg);  
    61.         if (retval == 0) {  
    62.             /*先将之前的模式保存起来，一旦设置失败进行回复*/  
    63.             u8  save = spi->mode;  
    64.   
    65.             if (tmp & ~SPI_MODE_MASK) {  
    66.                 retval = -EINVAL;  
    67.                 break;  
    68.             }  
    69.   
    70.             tmp |= spi->mode & ~SPI_MODE_MASK;  
    71.             spi->mode = (u8)tmp;  
    72.             retval = spi_setup(spi);  
    73.             if (retval < 0)  
    74.                 spi->mode = save;  
    75.             else  
    76.                 dev_dbg(&spi->dev, "spi mode %02x\n", tmp);  
    77.         }  
    78.         break;  
    79.     case SPI_IOC_WR_LSB_FIRST:  
    80.         retval = __get_user(tmp, (__u8 __user *)arg);  
    81.         if (retval == 0) {  
    82.             u8  save = spi->mode;  
    83.   
    84.             if (tmp)  
    85.                 spi->mode |= SPI_LSB_FIRST;  
    86.             else  
    87.                 spi->mode &= ~SPI_LSB_FIRST;  
    88.             retval = spi_setup(spi);  
    89.             if (retval < 0)  
    90.                 spi->mode = save;  
    91.             else  
    92.                 dev_dbg(&spi->dev, "%csb first\n",  
    93.                         tmp ? 'l' : 'm');  
    94.         }  
    95.         break;  
    96.     case SPI_IOC_WR_BITS_PER_WORD:  
    97.         retval = __get_user(tmp, (__u8 __user *)arg);  
    98.         if (retval == 0) {  
    99.             u8  save = spi->bits_per_word;  
    100.   
    101.             spi->bits_per_word = tmp;  
    102.             retval = spi_setup(spi);  
    103.             if (retval < 0)  
    104.                 spi->bits_per_word = save;  
    105.             else  
    106.                 dev_dbg(&spi->dev, "%d bits per word\n", tmp);  
    107.         }  
    108.         break;  
    109.     case SPI_IOC_WR_MAX_SPEED_HZ:  
    110.         retval = __get_user(tmp, (__u32 __user *)arg);  
    111.         if (retval == 0) {  
    112.             u32 save = spi->max_speed_hz;  
    113.   
    114.             spi->max_speed_hz = tmp;  
    115.             retval = spi_setup(spi);  
    116.             if (retval < 0)  
    117.                 spi->max_speed_hz = save;  
    118.             else  
    119.                 dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);  
    120.         }  
    121.         break;  
    122.   
    123.     default:  
    124.         /* segmented and/or full-duplex I/O request */  
    125.         if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))  
    126.                 || _IOC_DIR(cmd) != _IOC_WRITE) {  
    127.             retval = -ENOTTY;  
    128.             break;  
    129.         }  
    130.         /*得到用户空间数据的大小*/  
    131.         tmp = _IOC_SIZE(cmd);  
    132.         /*如果这些数据不能分成spi_ioc_transfer的整数倍，则不能进行传输，spi_io_transfer是对spi_transfer的映射*/  
    133.         if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {  
    134.             retval = -EINVAL;  
    135.             break;  
    136.         }  
    137.         /*计算出能分多少个spi_ioc_transfer*/  
    138.         n_ioc = tmp / sizeof(struct spi_ioc_transfer);  
    139.         if (n_ioc == 0)  
    140.             break;  
    141.   
    142.         /*在内核中分配装载这些数据的内存空间*/  
    143.         ioc = kmalloc(tmp, GFP_KERNEL);  
    144.         if (!ioc) {  
    145.             retval = -ENOMEM;  
    146.             break;  
    147.         }  
    148.         /*把用户空间的数据拷贝过来*/  
    149.         if (__copy_from_user(ioc, (void __user *)arg, tmp)) {  
    150.             kfree(ioc);  
    151.             retval = -EFAULT;  
    152.             break;  
    153.         }  
    154.   
    155.         /*进行数据传输*/  
    156.         "color:#ff0000;">retval = spidev_message(spidev, ioc, n_ioc);  
    157.         kfree(ioc);  
    158.         break;  
    159.     }  
    160.   
    161.     mutex_unlock(&spidev->buf_lock);  
    162.     spi_dev_put(spi);  
    163.     return retval;  
    164. }  
    165.   
    static long spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { int err = 0; int retval = 0; struct spidev_data *spidev; struct spi_device *spi; u32 tmp; unsigned n_ioc; struct spi_ioc_transfer *ioc; /*查看这个命令的幻数字段是否为'k'*/ if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC) return -ENOTTY; /*如果方向是用户空间从内核读，即内核向用户空间写，则检查用户空间的地址是否有效*/ if (_IOC_DIR(cmd) & _IOC_READ) err = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd)); /*如果方向是用户空间向内核写，即内核读用户空间，则检查用户空间的地址是否有效*/ if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE) err = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd)); if (err) return -EFAULT; /* guard against device removal before, or while, * we issue this ioctl. */ spidev = filp->private_data; spin_lock_irq(&spidev->spi_lock); spi = spi_dev_get(spidev->spi); spin_unlock_irq(&spidev->spi_lock); if (spi == NULL) return -ESHUTDOWN; mutex_lock(&spidev->buf_lock); switch (cmd) { /* read requests */ case SPI_IOC_RD_MODE: /*因为已经进行了地址是否有效的检查，所以这里使用__put_user,__get_user,__copy_from_user可以节省几个时钟周期呢*/ retval = __put_user(spi->mode & SPI_MODE_MASK, (__u8 __user *)arg); break; case SPI_IOC_RD_LSB_FIRST: retval = __put_user((spi->mode & SPI_LSB_FIRST) ? 1 : 0, (__u8 __user *)arg); break; case SPI_IOC_RD_BITS_PER_WORD: retval = __put_user(spi->bits_per_word, (__u8 __user *)arg); break; case SPI_IOC_RD_MAX_SPEED_HZ: retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg); break; /*设置SPI模式*/ case SPI_IOC_WR_MODE: retval = __get_user(tmp, (u8 __user *)arg); if (retval == 0) { /*先将之前的模式保存起来，一旦设置失败进行回复*/ u8 save = spi->mode; if (tmp & ~SPI_MODE_MASK) { retval = -EINVAL; break; } tmp |= spi->mode & ~SPI_MODE_MASK; spi->mode = (u8)tmp; retval = spi_setup(spi); if (retval < 0) spi->mode = save; else dev_dbg(&spi->dev, "spi mode %02x\n", tmp); } break; case SPI_IOC_WR_LSB_FIRST: retval = __get_user(tmp, (__u8 __user *)arg); if (retval == 0) { u8 save = spi->mode; if (tmp) spi->mode |= SPI_LSB_FIRST; else spi->mode &= ~SPI_LSB_FIRST; retval = spi_setup(spi); if (retval < 0) spi->mode = save; else dev_dbg(&spi->dev, "%csb first\n", tmp ? 'l' : 'm'); } break; case SPI_IOC_WR_BITS_PER_WORD: retval = __get_user(tmp, (__u8 __user *)arg); if (retval == 0) { u8 save = spi->bits_per_word; spi->bits_per_word = tmp; retval = spi_setup(spi); if (retval < 0) spi->bits_per_word = save; else dev_dbg(&spi->dev, "%d bits per word\n", tmp); } break; case SPI_IOC_WR_MAX_SPEED_HZ: retval = __get_user(tmp, (__u32 __user *)arg); if (retval == 0) { u32 save = spi->max_speed_hz; spi->max_speed_hz = tmp; retval = spi_setup(spi); if (retval < 0) spi->max_speed_hz = save; else dev_dbg(&spi->dev, "%d Hz (max)\n", tmp); } break; default: /* segmented and/or full-duplex I/O request */ if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0)) || _IOC_DIR(cmd) != _IOC_WRITE) { retval = -ENOTTY; break; } /*得到用户空间数据的大小*/ tmp = _IOC_SIZE(cmd); /*如果这些数据不能分成spi_ioc_transfer的整数倍，则不能进行传输，spi_io_transfer是对spi_transfer的映射*/ if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) { retval = -EINVAL; break; } /*计算出能分多少个spi_ioc_transfer*/ n_ioc = tmp / sizeof(struct spi_ioc_transfer); if (n_ioc == 0) break; /*在内核中分配装载这些数据的内存空间*/ ioc = kmalloc(tmp, GFP_KERNEL); if (!ioc) { retval = -ENOMEM; break; } /*把用户空间的数据拷贝过来*/ if (__copy_from_user(ioc, (void __user *)arg, tmp)) { kfree(ioc); retval = -EFAULT; break; } /*进行数据传输*/ retval = spidev_message(spidev, ioc, n_ioc); kfree(ioc); break; } mutex_unlock(&spidev->buf_lock); spi_dev_put(spi); return retval; }

    下面跟踪spidev_message看看：

    1. "font-size:18px;">static int spidev_message(struct spidev_data *spidev,  
    2.         struct spi_ioc_transfer *u_xfers, unsigned n_xfers)  
    3. {  
    4.     struct spi_message  msg;  
    5.     struct spi_transfer *k_xfers;  
    6.     struct spi_transfer *k_tmp;  
    7.     struct spi_ioc_transfer *u_tmp;  
    8.     unsigned        n, total;  
    9.     u8          *buf;  
    10.     int         status = -EFAULT;  
    11.     /*初始化spi_message的tranfers链表头*/  
    12.     spi_message_init(&msg);  
    13.     /*分配n个spi_transfer的内存空间，一个spi_message由多个数据段spi_message组成*/  
    14.     k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);  
    15.     if (k_xfers == NULL)  
    16.         return -ENOMEM;  
    17.   
    18.     buf = spidev->buffer;  
    19.     total = 0;  
    20.     /*这个for循环的主要任务是将所有的spi_transfer组装成一个spi_message*/  
    21.     for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;  
    22.             n;  
    23.             n--, k_tmp++, u_tmp++) {  
    24.         /*u_tmp是从用户空间传下来的spi_ioc_message的大小，spi_ioc_message是对spi_message的映射*/  
    25.         k_tmp->len = u_tmp->len;  
    26.         /*统计要传输数据的总量*/  
    27.         total += k_tmp->len;  
    28.         if (total > bufsiz) {  
    29.             status = -EMSGSIZE;  
    30.             goto done;  
    31.         }  
    32.         /*spi_transfer是一个读写的buffer对，如果是要接收则把buffer给接收的rx_buf*/  
    33.         if (u_tmp->rx_buf) {  
    34.             k_tmp->rx_buf = buf;  
    35.             if (!access_ok(VERIFY_WRITE, (u8 __user *)  
    36.                         (uintptr_t) u_tmp->rx_buf,  
    37.                         u_tmp->len))  
    38.                 goto done;  
    39.         }  
    40.         /*如果要传输，这个buffer给tx_buf使用，从用户空间拷过来要传输的数据*/  
    41.         if (u_tmp->tx_buf) {  
    42.             k_tmp->tx_buf = buf;  
    43.             if (copy_from_user(buf, (const u8 __user *)  
    44.                         (uintptr_t) u_tmp->tx_buf,  
    45.                     u_tmp->len))  
    46.                 goto done;  
    47.         }  
    48.         /*指向下一段内存*/  
    49.         buf += k_tmp->len;  
    50.         /*最后一个transfer传输完毕是否会影响片选*/  
    51.         k_tmp->cs_change = !!u_tmp->cs_change;  
    52.         /*每字长的字节数*/  
    53.         k_tmp->bits_per_word = u_tmp->bits_per_word;  
    54.         /*一段数据传输完需要一定的时间等待*/  
    55.         k_tmp->delay_usecs = u_tmp->delay_usecs;  
    56.         /*初始化传输速度*/  
    57.         k_tmp->speed_hz = u_tmp->speed_hz;  
    58.         /*将spi_transfer通过它的transfer_list字段挂到spi_message的transfer队列上*/  
    59.         spi_message_add_tail(k_tmp, &msg);  
    60.     }  
    61.     /*调用底层的传输函数*/  
    62.     "color:#ff0000;">status = spidev_sync(spidev, &msg);  
    63.     if (status < 0)  
    64.         goto done;  
    65.   
    66.     /* copy any rx data out of bounce buffer */  
    67.     buf = spidev->buffer;  
    68.     /*把传输数据拷贝到用户空间打印出来，可以查看是否传输成功*/  
    69.     for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {  
    70.         if (u_tmp->rx_buf) {  
    71.             if (__copy_to_user((u8 __user *)  
    72.                     (uintptr_t) u_tmp->rx_buf, buf,  
    73.                     u_tmp->len)) {  
    74.                 status = -EFAULT;  
    75.                 goto done;  
    76.             }  
    77.         }  
    78.         buf += u_tmp->len;  
    79.     }  
    80.     status = total;  
    81.   
    82. done:  
    83.     kfree(k_xfers);  
    84.     return status;  
    85. }  
    86.   
    static int spidev_message(struct spidev_data *spidev, struct spi_ioc_transfer *u_xfers, unsigned n_xfers) { struct spi_message msg; struct spi_transfer *k_xfers; struct spi_transfer *k_tmp; struct spi_ioc_transfer *u_tmp; unsigned n, total; u8 *buf; int status = -EFAULT; /*初始化spi_message的tranfers链表头*/ spi_message_init(&msg); /*分配n个spi_transfer的内存空间，一个spi_message由多个数据段spi_message组成*/ k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL); if (k_xfers == NULL) return -ENOMEM; buf = spidev->buffer; total = 0; /*这个for循环的主要任务是将所有的spi_transfer组装成一个spi_message*/ for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers; n; n--, k_tmp++, u_tmp++) { /*u_tmp是从用户空间传下来的spi_ioc_message的大小，spi_ioc_message是对spi_message的映射*/ k_tmp->len = u_tmp->len; /*统计要传输数据的总量*/ total += k_tmp->len; if (total > bufsiz) { status = -EMSGSIZE; goto done; } /*spi_transfer是一个读写的buffer对，如果是要接收则把buffer给接收的rx_buf*/ if (u_tmp->rx_buf) { k_tmp->rx_buf = buf; if (!access_ok(VERIFY_WRITE, (u8 __user *) (uintptr_t) u_tmp->rx_buf, u_tmp->len)) goto done; } /*如果要传输，这个buffer给tx_buf使用，从用户空间拷过来要传输的数据*/ if (u_tmp->tx_buf) { k_tmp->tx_buf = buf; if (copy_from_user(buf, (const u8 __user *) (uintptr_t) u_tmp->tx_buf, u_tmp->len)) goto done; } /*指向下一段内存*/ buf += k_tmp->len; /*最后一个transfer传输完毕是否会影响片选*/ k_tmp->cs_change = !!u_tmp->cs_change; /*每字长的字节数*/ k_tmp->bits_per_word = u_tmp->bits_per_word; /*一段数据传输完需要一定的时间等待*/ k_tmp->delay_usecs = u_tmp->delay_usecs; /*初始化传输速度*/ k_tmp->speed_hz = u_tmp->speed_hz; /*将spi_transfer通过它的transfer_list字段挂到spi_message的transfer队列上*/ spi_message_add_tail(k_tmp, &msg); } /*调用底层的传输函数*/ status = spidev_sync(spidev, &msg); if (status < 0) goto done; /* copy any rx data out of bounce buffer */ buf = spidev->buffer; /*把传输数据拷贝到用户空间打印出来，可以查看是否传输成功*/ for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) { if (u_tmp->rx_buf) { if (__copy_to_user((u8 __user *) (uintptr_t) u_tmp->rx_buf, buf, u_tmp->len)) { status = -EFAULT; goto done; } } buf += u_tmp->len; } status = total; done: kfree(k_xfers); return status; }

    看spidev_sync的实现：

    1. "font-size:18px;">static ssize_t  
    2. spidev_sync(struct spidev_data *spidev, struct spi_message *message)  
    3. {  
    4.     /*声明并初始化一个完成量*/  
    5.     DECLARE_COMPLETION_ONSTACK(done);  
    6.     int status;  
    7.     /*指定spi_message使用的唤醒完成量函数*/  
    8.     message->complete = spidev_complete;  
    9.     message->context = &done;  
    10.   
    11.     spin_lock_irq(&spidev->spi_lock);  
    12.     if (spidev->spi == NULL)  
    13.         status = -ESHUTDOWN;  
    14.     else  
    15.         /*调用spi核心中的函数进行数据传输*/  
    16.     "color:#ff0000;"> status = spi_async(spidev->spi, message);  
    17.     spin_unlock_irq(&spidev->spi_lock);  
    18.   
    19.     if (status == 0) {  
    20.         /*等待完成量被唤醒*/  
    21.         wait_for_completion(&done);  
    22.         status = message->status;  
    23.         if (status == 0)  
    24.             status = message->actual_length;  
    25.     }  
    26.     return status;  
    27. }  
    28.   
    static ssize_t spidev_sync(struct spidev_data *spidev, struct spi_message *message) { /*声明并初始化一个完成量*/ DECLARE_COMPLETION_ONSTACK(done); int status; /*指定spi_message使用的唤醒完成量函数*/ message->complete = spidev_complete; message->context = &done; spin_lock_irq(&spidev->spi_lock); if (spidev->spi == NULL) status = -ESHUTDOWN; else /*调用spi核心中的函数进行数据传输*/ status = spi_async(spidev->spi, message); spin_unlock_irq(&spidev->spi_lock); if (status == 0) { /*等待完成量被唤醒*/ wait_for_completion(&done); status = message->status; if (status == 0) status = message->actual_length; } return status; } spi_async在spi.h中定义的：

    1. "font-size:18px;">static inline int  
    2. spi_async(struct spi_device *spi, struct spi_message *message)  
    3. {  
    4.     message->spi = spi;  
    5.     return spi->master->transfer(spi, message);  
    6. }  
    7.   
    static inline int spi_async(struct spi_device *spi, struct spi_message *message) { message->spi = spi; return spi->master->transfer(spi, message); } 这里的master->transfer是在spi_bitbang_start中进行赋值的:

    bitbang->master->transfer= spi_bitbang_transfer;

    看spi_bitbang_transfer的实现：

    1. "font-size:18px;">int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m)  
    2. {  
    3.     struct spi_bitbang  *bitbang;  
    4.     unsigned long       flags;  
    5.     int         status = 0;  
    6.   
    7.     m->actual_length = 0;  
    8.     m->status = -EINPROGRESS;  
    9.     /*在spi_alloc_master函数中调用spi_master_set_devdata把struct s3c24xx_spi结构存放起来，而struct spi_bitbang正是struct s3c24xx_spi结构所包含的第一个结构*/  
    10.     bitbang = spi_master_get_devdata(spi->master);  
    11.   
    12.     spin_lock_irqsave(&bitbang->lock, flags);  
    13.     if (!spi->max_speed_hz)  
    14.         status = -ENETDOWN;  
    15.     else {  
    16.         /*把message加入到bitbang的等待队列中*/  
    17.         list_add_tail(&m->queue, &bitbang->queue);  
    18.         /*把bitbang-work加入bitbang->workqueue中，调度运行*/  
    19.         queue_work(bitbang->workqueue, &bitbang->work);  
    20.     }  
    21.     spin_unlock_irqrestore(&bitbang->lock, flags);  
    22.   
    23.     return status;  
    24. }  
    25. EXPORT_SYMBOL_GPL(spi_bitbang_transfer);  
    26.   
    int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m) { struct spi_bitbang *bitbang; unsigned long flags; int status = 0; m->actual_length = 0; m->status = -EINPROGRESS; /*在spi_alloc_master函数中调用spi_master_set_devdata把struct s3c24xx_spi结构存放起来，而struct spi_bitbang正是struct s3c24xx_spi结构所包含的第一个结构*/ bitbang = spi_master_get_devdata(spi->master); spin_lock_irqsave(&bitbang->lock, flags); if (!spi->max_speed_hz) status = -ENETDOWN; else { /*把message加入到bitbang的等待队列中*/ list_add_tail(&m->queue, &bitbang->queue); /*把bitbang-work加入bitbang->workqueue中，调度运行*/ queue_work(bitbang->workqueue, &bitbang->work); } spin_unlock_irqrestore(&bitbang->lock, flags); return status; } EXPORT_SYMBOL_GPL(spi_bitbang_transfer);

    分析工作队列的处理函数：
    1. "font-size:18px;">static void bitbang_work(struct work_struct *work)  
    2. {  
    3.     struct spi_bitbang  *bitbang =  
    4.         container_of(work, struct spi_bitbang, work);  
    5.     unsigned long       flags;  
    6.   
    7.     spin_lock_irqsave(&bitbang->lock, flags);  
    8.     /*设置成忙状态*/  
    9.     bitbang->busy = 1;  
    10.     /*对bitqueue中的每一个spi_message进行处理*/  
    11.     while (!list_empty(&bitbang->queue)) {  
    12.         struct spi_message  *m;  
    13.         struct spi_device   *spi;  
    14.         unsigned        nsecs;  
    15.         struct spi_transfer *t = NULL;  
    16.         unsigned        tmp;  
    17.         unsigned        cs_change;  
    18.         int         status;  
    19.         int         (*setup_transfer)(struct spi_device *,  
    20.                         struct spi_transfer *);  
    21.   
    22.         m = container_of(bitbang->queue.next, struct spi_message,  
    23.                 queue);  
    24.         /*从队列中驱动这个spi_message*/  
    25.         list_del_init(&m->queue);  
    26.         spin_unlock_irqrestore(&bitbang->lock, flags);  
    27.   
    28.         nsecs = 100;  
    29.   
    30.         spi = m->spi;  
    31.         tmp = 0;  
    32.         cs_change = 1;  
    33.         status = 0;  
    34.         setup_transfer = NULL;  
    35.         /*对spi_message的transfers上的每个spi_transfer进行处理*/  
    36.         list_for_each_entry (t, &m->transfers, transfer_list) {  
    37.         。。。。。。。。。。。。。。。。。  
    38.             if (t->len) {                  
    39.                 if (!m->is_dma_mapped)  
    40.                     t->rx_dma = t->tx_dma = 0;  
    41.                 /*调用bitbang->txrx_bufs进行数据的传输，bitbang->txrx_bufs = s3c24xx_spi_txrx;这个在s3c24xx_spi_probe中进行赋值的*/  
    42.                 "color:#ff0000;">status = bitbang->txrx_bufs(spi, t);  
    43.             }  
    44.         。。。。。。。。。。。。。。。。  
    45.   
    46.         m->status = status;  
    47.         /*传输完成，唤醒刚才的那个完成变量*/  
    48.         m->complete(m->context);  
    49.   
    50.         /* restore speed and wordsize */  
    51.         if (setup_transfer)  
    52.             setup_transfer(spi, NULL);  
    53.         if (!(status == 0 && cs_change)) {  
    54.             ndelay(nsecs);  
    55.             bitbang->chipselect(spi, BITBANG_CS_INACTIVE);  
    56.             ndelay(nsecs);  
    57.         }  
    58.   
    59.         spin_lock_irqsave(&bitbang->lock, flags);  
    60.     }  
    61.     bitbang->busy = 0;  
    62.     spin_unlock_irqrestore(&bitbang->lock, flags);  
    63. }  
    64.   
    static void bitbang_work(struct work_struct *work) { struct spi_bitbang *bitbang = container_of(work, struct spi_bitbang, work); unsigned long flags; spin_lock_irqsave(&bitbang->lock, flags); /*设置成忙状态*/ bitbang->busy = 1; /*对bitqueue中的每一个spi_message进行处理*/ while (!list_empty(&bitbang->queue)) { struct spi_message *m; struct spi_device *spi; unsigned nsecs; struct spi_transfer *t = NULL; unsigned tmp; unsigned cs_change; int status; int (*setup_transfer)(struct spi_device *, struct spi_transfer *); m = container_of(bitbang->queue.next, struct spi_message, queue); /*从队列中驱动这个spi_message*/ list_del_init(&m->queue); spin_unlock_irqrestore(&bitbang->lock, flags); nsecs = 100; spi = m->spi; tmp = 0; cs_change = 1; status = 0; setup_transfer = NULL; /*对spi_message的transfers上的每个spi_transfer进行处理*/ list_for_each_entry (t, &m->transfers, transfer_list) { 。。。。。。。。。。。。。。。。。 if (t->len) { if (!m->is_dma_mapped) t->rx_dma = t->tx_dma = 0; /*调用bitbang->txrx_bufs进行数据的传输，bitbang->txrx_bufs = s3c24xx_spi_txrx;这个在s3c24xx_spi_probe中进行赋值的*/ status = bitbang->txrx_bufs(spi, t); } 。。。。。。。。。。。。。。。。 m->status = status; /*传输完成，唤醒刚才的那个完成变量*/ m->complete(m->context); /* restore speed and wordsize */ if (setup_transfer) setup_transfer(spi, NULL); if (!(status == 0 && cs_change)) { ndelay(nsecs); bitbang->chipselect(spi, BITBANG_CS_INACTIVE); ndelay(nsecs); } spin_lock_irqsave(&bitbang->lock, flags); } bitbang->busy = 0; spin_unlock_irqrestore(&bitbang->lock, flags); } 这个工作队列的处理函数中调用了spi controller driver中的传输函数：

    1. "font-size:18px;">static int s3c24xx_spi_txrx(struct spi_device *spi, struct spi_transfer *t)  
    2. {  
    3.     struct s3c24xx_spi *hw = to_hw(spi);  
    4.   
    5.     dev_dbg(&spi->dev, "txrx: tx %p, rx %p, len %d\n",  
    6.         t->tx_buf, t->rx_buf, t->len);  
    7.   
    8.     hw->tx = t->tx_buf;  //发送指针   
    9.     hw->rx = t->rx_buf;  //接收指针   
    10.     hw->len = t->len;    //需要发送/接收的数目   
    11.     hw->count = 0;       //存放实际spi传输的数据数目   
    12.     /*初始化了完成量*/  
    13.     init_completion(&hw->done);  
    14.       
    15.     /* 
    16.      *只需发送第一个字节(如果发送为空，则发送0xff)，中断中就会自动发送完其他字节(并接受数据) 
    17.      *直到所有数据发送完毕且所有数据接收完毕才返回 
    18.      */  
    19.     writeb(hw_txbyte(hw, 0), hw->regs + S3C2410_SPTDAT);  
    20.     /*等待完成量被唤醒*/  
    21.     wait_for_completion(&hw->done);  
    22.     return hw->count;  
    23. }  
    24. static inline unsigned int hw_txbyte(struct s3c24xx_spi *hw, int count)  
    25. {  
    26.         return hw->tx ? hw->tx[count] : 0xff;  
    27.         //如果还有数据没接收完且要发送的数据经已发送完毕，发送空数据0xFF   
    28. }  
    29.   
    static int s3c24xx_spi_txrx(struct spi_device *spi, struct spi_transfer *t) { struct s3c24xx_spi *hw = to_hw(spi); dev_dbg(&spi->dev, "txrx: tx %p, rx %p, len %d\n", t->tx_buf, t->rx_buf, t->len); hw->tx = t->tx_buf; //发送指针 hw->rx = t->rx_buf; //接收指针 hw->len = t->len; //需要发送/接收的数目 hw->count = 0; //存放实际spi传输的数据数目 /*初始化了完成量*/ init_completion(&hw->done); /* *只需发送第一个字节(如果发送为空，则发送0xff)，中断中就会自动发送完其他字节(并接受数据) *直到所有数据发送完毕且所有数据接收完毕才返回 */ writeb(hw_txbyte(hw, 0), hw->regs + S3C2410_SPTDAT); /*等待完成量被唤醒*/ wait_for_completion(&hw->done); return hw->count; } static inline unsigned int hw_txbyte(struct s3c24xx_spi *hw, int count) { return hw->tx ? hw->tx[count] : 0xff; //如果还有数据没接收完且要发送的数据经已发送完毕，发送空数据0xFF } 下面来分析中断函数：

    1. "font-size:18px;">static irqreturn_t s3c24xx_spi_irq(int irq, void *dev)  
    2. {  
    3.     struct s3c24xx_spi *hw = dev;  
    4.     /*读取spi的状态寄存器*/  
    5.     unsigned int spsta = readb(hw->regs + S3C2410_SPSTA);  
    6.     unsigned int count = hw->count;  
    7.     /*检测冲突*/  
    8.     if (spsta & S3C2410_SPSTA_DCOL) {               
    9.         dev_dbg(hw->dev, "data-collision\n");   
    10.         /*唤醒完成量*/  
    11.         complete(&hw->done);  
    12.         goto irq_done;  
    13.     }  
    14.     /*设备忙*/  
    15.     if (!(spsta & S3C2410_SPSTA_READY)) {  
    16.         dev_dbg(hw->dev, "spi not ready for tx?\n");  
    17.         /*唤醒完成量*/  
    18.         complete(&hw->done);  
    19.         goto irq_done;  
    20.     }  
    21.   
    22.     hw->count++;  
    23.     /*接收数据*/  
    24.     if (hw->rx)  
    25.         hw->rx[count] = readb(hw->regs + S3C2410_SPRDAT);  
    26.   
    27.     count++;  
    28.     /*如果count小于需要发送或接收数据的数目，发送其他数据*/  
    29.     if (count < hw->len)  
    30.         writeb(hw_txbyte(hw, count), hw->regs + S3C2410_SPTDAT);  
    31.     else  
    32.         /*唤醒完成量，通知s3c24xx_spi_txrx函数*/  
    33.         complete(&hw->done);  
    34.   
    35.  irq_done:  
    36.     return IRQ_HANDLED;  
    37. }  
    38.   
    static irqreturn_t s3c24xx_spi_irq(int irq, void *dev) { struct s3c24xx_spi *hw = dev; /*读取spi的状态寄存器*/ unsigned int spsta = readb(hw->regs + S3C2410_SPSTA); unsigned int count = hw->count; /*检测冲突*/ if (spsta & S3C2410_SPSTA_DCOL) { dev_dbg(hw->dev, "data-collision\n"); /*唤醒完成量*/ complete(&hw->done); goto irq_done; } /*设备忙*/ if (!(spsta & S3C2410_SPSTA_READY)) { dev_dbg(hw->dev, "spi not ready for tx?\n"); /*唤醒完成量*/ complete(&hw->done); goto irq_done; } hw->count++; /*接收数据*/ if (hw->rx) hw->rx[count] = readb(hw->regs + S3C2410_SPRDAT); count++; /*如果count小于需要发送或接收数据的数目，发送其他数据*/ if (count < hw->len) writeb(hw_txbyte(hw, count), hw->regs + S3C2410_SPTDAT); else /*唤醒完成量，通知s3c24xx_spi_txrx函数*/ complete(&hw->done); irq_done: return IRQ_HANDLED; } 至此spi数据传输过程完成，如果不想为自己的SPI设备写驱动，那么可以用Linux自带的spidev.c提供的驱动程序，只要在登记时，把设备名设置成spidev就可以了。spidev.c会在device目录下自动为每一个匹配的SPI设备创建设备节点，节点名"spi%d"。之后，用户程序可以通过字符型设备的通用接口控制SPI设备。需要注意的是，spidev创建的设备在设备模型中属于虚拟设备，他的class是spidev_class，他的父设备是在boardinfo中定义的spi设备。
阅读(594) | 评论(0) | 转发(0) |
0

上一篇：SPI四种模式

下一篇：linux中man使用技巧

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6