xmzzy2012
xmzzy2012

spi驱动框架源码分析

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

spi驱动框架源码分析_第1张图片 

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

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

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

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

[cpp] view plain copy
  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);   
在Linux中用spi_driver来描述一个SPI外设驱动。
[cpp] view plain copy
  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. };  

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

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

[cpp] view plain copy
  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. };   
如下图，看这三个结构的关系，这里spi_device与spi_master是同一个父设备（挂接在同一口上），这是在spi_new_device函数中设定的，一般这个设备是一个物理设备。

spi驱动框架源码分析_第2张图片

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

[cpp] view plain copy
  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. };   
spi_bus_type对应spi中的spi bus总线，spidev的类定义如下：

[cpp] view plain copy
  1. 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中初始化。

[cpp] view plain copy
  1. struct spi_board_info { 
  2. char     modalias[32];  //设备与驱动匹配的唯一标识 
  3. constvoid    *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. };

  12. struct s3c2410_spi_info {       
  13. int     pin_cs;        //芯片选择管脚 
  14. unsignedint    num_cs;        //总线上的设备数 
  15. int        bus_num;       //总线号 
  16. void (*gpio_setup)(struct s3c2410_spi_info *spi, int enable);    //spi管脚配置函数 
  17. void (*set_cs)(struct s3c2410_spi_info *spi, int cs,int pol); 
  18. };   
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);

[cpp] view plain copy
  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. };  
s3c24xx_spi是S3C2440的SPI控制器在Linux内核中的具体描述，该结构包含spi_bitbang内嵌结构，控制器时钟频率和占用的中断资源等重要成员，其中spi_bitbang具体负责SPI数据的传输。

[cpp] view plain copy
  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 unsignedchar *tx; 
  11. unsignedchar       *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. }; 
为了解决多个不同的SPI设备共享SPI控制器而带来的访问冲突，spi_bitbang使用内核提供的工作队列(workqueue)。workqueue是Linux内核中定义的一种回调处理方式。采用这种方式需要传输数据时，不直接完成数据的传输，而是将要传输的工作分装成相应的消息(spi_message)，发送给对应的workqueue，由与workqueue关联的内核守护线程(daemon)负责具体的执行。由于workqueue会将收到的消息按时间先后顺序排列，这样就是对设备的访问严格串行化，解决了冲突。
[html] view plain copy
  1. 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. }; 

下面来看看spi_message：

[cpp] view plain copy
  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. };   
在有消息需要传递的时候，会将spi_transfer通过自己的transfer_list字段挂到spi_message的transfers链表头上。spi_message用来原子的执行spi_transfer表示的一串数组传输请求。这个传输队列是原子的，这意味着在这个消息完成之前不会有其他消息占用总线。消息的执行总是按照FIFO的顺序。

下面看一看spi_transfer：

  1. struct spi_transfer { 
  2. constvoid *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;//用来连接的双向链表节点
    }

 

这篇来分析spi子系统的建立过程。
嵌入式微处理器访问SPI设备有两种方式：使用GPIO模拟SPI接口的工作时序或者使用SPI控制器。使用GPIO模拟SPI接口的工作时序是非常容易实现的，但是会导致大量的时间耗费在模拟SPI接口的时序上，访问效率比较低。
 spi驱动框架源码分析_第3张图片
这个是由sys文件系统导出的spi子系统在内核中的视图了。
首先了解一下Linux内核中的几个文件:spi.c也就是spi子系统的核心了，spi_s3c24xx.c是s3c24xx系列芯片的SPI controller驱动，它向更上层的SPI核心层(spi.c)提供接口用来控制外设，是一个被其他驱动使用的驱动。而spidev.c是在核心层基础之上将SPI controller模拟成一个字符型的驱动，向文件系统提供标准的文件系统接口，用来操作对应的SPI controller。
下面我们来看看spi子系统是怎么注册进内核的：

[cpp] view plain copy
  1. staticint __init spi_init(void) //spi.c
  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); 
这里注册了一个spi_bus_type，也就是一个spi总线，和一个spi_master的class。分别对应上图中sys/bus/下的spi目录和sys/class/下的spi_master目录。

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

[cpp] view plain copy
  1. staticint __init s3c24xx_spi_init(void) //spi_s3c24xx.c
  2. { 
  3.        return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe); 
  4. } 
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。添加了platform_driver后会match成功后，调用s3c24xx_spi_probe，这里看其实现：
[html] view plain copy
  1. 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.     interr =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->pdatapdata = 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;//transfer里的参数设置speed和bits_per_word要调用这个setup_transfer,重新设置传输参数
  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. } 
spi controller的register在spi_bitbang_start函数中实现：
[html] view plain copy
  1. int spi_bitbang_start(struct spi_bitbang *bitbang) 
  2. { 
  3.     int status; 
  4.  
  5.  
  6.     if (!bitbang->master || !bitbang->chipselect) 
  7.         return -EINVAL; 
  8.     /*动态创建一个work_struct结构，它的处理函数是bitbang_work*/ 
  9.     INIT_WORK(&bitbang->work, bitbang_work); 
  10.     spin_lock_init(&bitbang->lock); 
  11.     INIT_LIST_HEAD(&bitbang->queue); //链表头
  12.     /*spi的数据传输就是用这个方法*/ 
  13.     if (!bitbang->master->transfer) 
  14.         bitbang->master->transfer = spi_bitbang_transfer;
  15.     if (!bitbang->txrx_bufs) { //在s3c24xx_spi_probe里定义了txrx_bufs
  16.         bitbang->use_dma =0; 
  17.         /*spi_s3c24xx.c中有spi_bitbang_bufs方法，在bitbang_work中被调用*/ 
  18.         bitbang->txrx_bufs =spi_bitbang_bufs; 
  19.         if (!bitbang->master->setup) {  //在s3c24xx_spi_probe里定义了master->setup
  20.             if (!bitbang->setup_transfer) //在s3c24xx_spi_probe里定义了            setup_transfer=s3c24xx_spi_setupxfer
  21.                 bitbang->setup_transfer = 
  22.                     spi_bitbang_setup_transfer; 
  23.             /*在spi_s3c24xx.c中有setup的处理方法，在spi_new_device中被调用*/ 
  24.             bitbang->master->setup = spi_bitbang_setup; 
  25.             bitbang->master->cleanup = spi_bitbang_cleanup; 
  26.         } 
  27.     } else if (!bitbang->master->setup) 
  28.         return -EINVAL; 
  29.  
  30.  
  31.     /* this task is the only thing to touch the SPI bits */ 
  32.     bitbang->busy =0; 
  33.     /调用create_singlethread_workqueue创建单个工作线程/ 
  34.     bitbang->workqueue =create_singlethread_workqueue( 
  35.             dev_name(bitbang->master->dev.parent)); 
  36.     if (bitbang->workqueue == NULL) { 
  37.        status = -EBUSY; 
  38.         goto err1; 
  39.     } 
  40.    status =spi_register_master(bitbang->master); 
  41.     if (status<0) 
  42.         goto err2; 
  43.     return status; 
  44. err2: 
  45.     destroy_workqueue(bitbang->workqueue); 
  46. err1: 
  47.     return status; 
  48. } 

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

[cpp] view plain copy
  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. } 

这里跟踪scan_boardinfo函数：

[cpp] view plain copy
  1. staticvoid 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. } 
在移植的时候我们会在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函数，这个将在后边进行分析。

[html] view plain copy
  1. int __init 
  2. spi_register_board_info(struct spi_board_info const *info, unsigned n) //n=1
  3. { 
  4.     struct boardinfo    *bi; 
  5.    
  6.    bi =kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL); 
  7.     if (!bi) 
  8.         return -ENOMEM; 
  9.     bi->nn_board_info = n; 
  10.     memcpy(bi->board_info, info, n * sizeof *info); 
  11.  
  12.  
  13.     mutex_lock(&board_lock); 
  14.     list_add_tail(&bi->list, &board_list); 
  15.     mutex_unlock(&board_lock); 
  16.     return 0; 
  17. } 

看一下创建新设备的函数：

[html] view plain copy
  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.    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->chipchip_select = chip->chip_select; 
  14.     proxy->max_speed_hz =chip->max_speed_hz; 
  15.     proxy->mode =chip->mode;//设置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)); //spi_bus_type match的时候用到
  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. } 
下面来看分配spi_alloc_device的函数，主要完成了分配spi_device，并初始化spi->dev的一些字段。
[cpp] view plain copy
  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. } 
下面来看分配的这个spi_device是怎样注册进内核的：
[cpp] view plain copy
  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) {//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), //见spi_register_master
  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); //不同的设备的频率和分频数不同，结果写在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. static int s3c24xx_spi_setup(struct spi_device *spi)
{
	struct s3c24xx_spi_devstate *cs = spi->controller_state;//<span style="color:#009900;">ｃｓ是spi_device的成员，保存成员设备信息</span>
	struct s3c24xx_spi *hw = to_hw(spi);
	int ret;

	/* allocate settings on the first call */
	if (!cs) {// NULL first 
		cs = kzalloc(sizeof(struct s3c24xx_spi_devstate), GFP_KERNEL);
		if (!cs) {
			dev_err(&spi->dev, "no memory for controller state\n");
			return -ENOMEM;
		}

		cs->spcon = SPCON_DEFAULT;
		cs->hz = -1;
		spi->controller_state = cs;//only set spcon,hz
	}

	/* initialise the state from the device */
	ret = s3c24xx_spi_update_state(spi, NULL);
	if (ret)
		return ret;

	spin_lock(&hw->bitbang.lock);
	if (!hw->bitbang.busy) {
		hw->bitbang.chipselect(spi, BITBANG_CS_INACTIVE);//cs invalid
		/* need to ndelay for 0.5 clocktick ? */
	}
	spin_unlock(&hw->bitbang.lock);

	return 0;
}


  47. static int s3c24xx_spi_update_state(struct spi_device *spi,
				    struct spi_transfer *t) // 第一次t = NULL，以后每来一个transfer都不为空
{	
	struct s3c24xx_spi *hw = to_hw(spi);
	struct s3c24xx_spi_devstate *cs = spi->controller_state;
	unsigned int bpw;
	unsigned int hz;
	unsigned int div;
	unsigned long clk;
	bpw = t ? t->bits_per_word : spi->bits_per_word;
	hz  = t ? t->speed_hz : spi->max_speed_hz;
	if (!bpw)
		bpw = 8;
	if (!hz)
		hz = spi->max_speed_hz;
	if (bpw != 8) {
		dev_err(&spi->dev, "invalid bits-per-word (%d)\n", bpw);
		return -EINVAL;
	}
	if (spi->mode != cs->mode) {
		u8 spcon = SPCON_DEFAULT | S3C2410_SPCON_ENSCK;
		if (spi->mode & SPI_CPHA)
			spcon |= S3C2410_SPCON_CPHA_FMTB;
		if (spi->mode & SPI_CPOL)
			spcon |= S3C2410_SPCON_CPOL_HIGH;
		cs->mode = spi->mode;
		cs->spcon = spcon;
	}
	if (cs->hz != hz) {//hz=spi->max_speed_hz
		clk = clk_get_rate(hw->clk);//already get hw->clk
		div = DIV_ROUND_UP(clk, hz * 2) - 1;//hz=what we want
		if (div > 255)
			div = 255;
		dev_dbg(&spi->dev, "pre-scaler=%d (wanted %d, got %ld)\n",
			div, hz, clk / (2 * (div + 1)));
		cs->hz = hz;//记录该设备的时钟频率
		cs->sppre = div;//记录该设备的分频
	}
	return 0;
}

下面来看这个spi_driver是怎样注册的，又是与spi_device怎样match上的。
在spidev.c中：
[cpp] view plain copy
  1. staticint __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. } 
注册了名为”spi”的字符驱动，然后注册了spidev_spi驱动，这个就是图中sys/Bus/Spi/Drivers/下的spidev。
[cpp] view plain copy
  1. staticstruct 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. }; 
这里来看__driver_attach(设备和驱动匹配的时候会调用此函数)这个函数，其中分别调用了driver_match_device，driver_probe_device函数。如果匹配成果调用probe函数，否则返回。
copy
  1. staticint __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 inline int driver_match_device(struct device_driver *drv,
				      struct device *dev)
{
	return drv->bus->match ? drv->bus->match(dev, drv) : 1;
}<span style="font-family:verdana,sans-serif;font-size:14px;color:#333333;margin: 0px; padding: 0px; line-height: 26px; white-space: normal; background-color: rgb(255, 255, 255);"><span style="font-size:18px;margin: 0px; padding: 0px;">匹配的时候调用的bus的match函数。</span></span><br style="margin: 0px; padding: 0px; color: rgb(51, 51, 51); line-height: 26px; font-family: Arial; font-size: 14px; white-space: normal; background-color: rgb(255, 255, 255);" />
[cpp] view plain copy
  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. staticint spi_match_device(struct device *dev,struct device_driver *drv) 
  10. { 
  11.    conststruct spi_device *spi = to_spi_device(dev); 
  12.  
  13.  
  14.    return strcmp(spi->modalias, drv->name) == 0; 
  15. } 

可以看到这里根据驱动和设备的名字进行匹配，匹配成功后最终会调用驱动的probe函数，如下。

先调用spi_drv_probe后在调用设备probe

[cpp] view plain copy
  1. staticint spi_drv_probe(struct device *dev) 
  2. { 
  3.    conststruct spi_driver     *sdrv = to_spi_driver(dev->driver); 
  4.  
  5.  
  6.    return sdrv->probe(to_spi_device(dev)); 
  7. } 
static int spidev_probe(struct spi_device *spi)
{
	struct spidev_data	*spidev;
	int			status;
	unsigned long		minor;

。。。。
	if (status == 0) {
		set_bit(minor, minors);
		list_add(&spidev->device_entry, &device_list);<span style="color:#009900;">//添加到device_list</span>
	}

。。。。
	return status;
}

可以看到调用了具体的probe函数，这里实现了把spidev添加到device_list，这样这个虚拟的字符驱动就注册并初始化完毕。

[cpp] view plain copy
  1. staticint 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. } 
在spidev的注册函数中注册了文件操作集合file_operations，为用户空间提供了操作SPI controller的接口。
[cpp] view plain copy
  1. staticstruct 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. }; 

到此为止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传到底半部排队，实现串行化传输。


spi_transfer->spi_message->queue_work传输


spi驱动框架源码分析_第4张图片


 

在spidev.c中实现了file_operations：

[cpp] view plain copy
  1. staticstruct 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. }; 
这里看spidev_ioctl的实现：

[cpp] view plain copy
  1. staticlong 
  2. spidev_ioctl(struct file *filp, unsignedint cmd, unsignedlong 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.        retval = spidev_message(spidev, ioc, n_ioc); //spidev_message(spidev,struct spi_io_transfer ioc,int no);
  157.         kfree(ioc); 
  158.        break; 
  159.     } 
  160.  
  161.     mutex_unlock(&spidev->buf_lock); 
  162.     spi_dev_put(spi); 
  163.    return retval; 
  164. } 
  165.  

下面跟踪spidev_message看看：

[cpp] view plain copy
  1. staticint 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); //将一个spi_transfer 添加到msg链表上，将所有任务添加到msg中
  60.     } 
  61.    /*调用底层的传输函数*/ 
  62.    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.  

看spidev_sync的实现：

[cpp] view plain copy
  1. 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.    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.  
spi_async在spi.h中定义的：
[cpp] view plain copy
  1. staticinlineint 
  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.  
这里的master->transfer是在spi_bitbang_start中进行赋值的:

bitbang->master->transfer= spi_bitbang_transfer;

看spi_bitbang_transfer的实现：

[cpp] view plain copy
  1. int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m) 
  2. { 
  3.    struct spi_bitbang  *bitbang; 
  4.     unsignedlong       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.  

分析工作队列的处理函数：

spi驱动框架源码分析_第5张图片
 
[cpp] view plain copy
  1. staticvoid bitbang_work(struct work_struct *work) 
  2. { 
  3.    struct spi_bitbang  *bitbang = 
  4.         container_of(work,struct spi_bitbang, work); 
  5.     unsignedlong       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.         

               /* override speed or wordsize? */
               if (t->speed_hz || t->bits_per_word)
                  do_setup = 1;//重新设置

              /* init (-1) or override (1) transfer params */
                  if (do_setup != 0) {
                      status = bitbang->setup_transfer(spi, t);//如果transfer里设置了speed_hz或者bits_per_word要重新设置传输参数=s3c24xx_spi_setupxfer
                  if (status < 0)
                         break;
                   if (do_setup == -1)
                       do_setup = 0;
                  }

       /* set up default clock polarity, and activate chip;
        * this implicitly updates clock and spi modes as
        * previously recorded for this device via setup().
        * (and also deselects any other chip that might be
        * selected ...)
        */
       if (cs_change) {//最初本代码里cs_change=1,
        bitbang->chipselect(spi, BITBANG_CS_ACTIVE);
        ndelay(nsecs);
       }
       cs_change = t->cs_change;//cs_change=本次处理cs的设定值。通常1至n-1的cs=0，n的cs=1，即执行最后一个transfer后要取消片选

     
  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.                status = bitbang->txrx_bufs(spi, t); //一次所有传输完毕，才会结束
  43.           }
  44.        。。。。。。。。

  45.     /* protocol tweaks before next transfer */
        if (t->delay_usecs)
         udelay(t->delay_usecs);

        if (cs_change && !list_is_last(&t->transfer_list, &m->transfers)) {
        /* sometimes a short mid-message deselect of the chip
         * may be needed to terminate a mode or command
         */
         ndelay(nsecs);
         bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
         ndelay(nsecs);
         }

  46.    } //一个transfer执行完毕，循环下一个
  47.         。。。。。。。。。。。。。。。。 
  48.  
  49.         m->status = status; 
  50.        /*传输完成，唤醒刚才的那个完成变量*/ 
  51.         m->complete(m->context); //同步机制，唤醒对象见上面
  52.  
  53.        /* restore speed and wordsize */ 
  54.        if (setup_transfer) 
  55.             setup_transfer(spi, NULL); 
  56.        //假设transfer[0].cs_chagen=0,[1]..[n-1]=0,[n]=1，这里判断的cs_transfer是最后一个transfer
  57.        if (!(status == 0 && cs_change)) { 
  58.             ndelay(nsecs); 
  59.             bitbang->chipselect(spi, BITBANG_CS_INACTIVE); 
  60.             ndelay(nsecs); 
  61.         } 
  62.  
  63.         spin_lock_irqsave(&bitbang->lock, flags); 
  64.     } 
  65.     bitbang->busy = 0; 
  66.     spin_unlock_irqrestore(&bitbang->lock, flags); 
  67. } 
  68.  
这个工作队列的处理函数中调用了spi controller driver中的传输函数：
[cpp] view plain copy
  1. 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.     writeb(hw_txbyte(hw, 0), hw->regs + S3C2410_SPTDAT);//发送结束即接收结束
  19.    /*等待完成量被唤醒*/ 
  20.     wait_for_completion(&hw->done); //等待该次transfer传输完毕（被唤醒2）
  21.    return hw->count; 
  22. } 
  23. staticinline unsignedint hw_txbyte(struct s3c24xx_spi *hw, int count) 
  24. { 
  25.        return hw->tx ? hw->tx[count] : 0xff; 
  26.        //如果还有数据没接收完且要发送的数据经已发送完毕，发送空数据0xFF 
  27. } 
  28.  
下面来分析中断函数：
[cpp] view plain copy
  1. static irqreturn_t s3c24xx_spi_irq(int irq, void *dev) 
  2. { 
  3.    struct s3c24xx_spi *hw = dev; 
  4.    /*读取spi的状态寄存器*/ 
  5.     unsignedint spsta = readb(hw->regs + S3C2410_SPSTA); 
  6.     unsignedint 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++; //count对于发送和接受都可以用
  28.              //对于接收已经接收到一字节，要存储下一字节，自加1
  29.              //对于发送，进入到中断时已经发送完毕一字节，可以发送下一字节了，所以自加1
  30.    /*如果count小于需要发送或接收数据的数目，继续发送其他数据*/ 
  31.    if (count < hw->len) 
  32.         writeb(hw_txbyte(hw, count), hw->regs + S3C2410_SPTDAT); 
  33.    else 
  34.        /*唤醒完成量，通知s3c24xx_spi_txrx函数*/ 
  35.         complete(&hw->done); //该次transfer传输完毕（唤醒2）
  36.  
  37. irq_done: 
  38.    return IRQ_HANDLED; 
  39. } 
  40.  
至此spi数据传输过程完成，如果不想为自己的SPI设备写驱动，那么可以用Linux自带的spidev.c提供的驱动程序，只要在登记时，把设备名设置成spidev就可以了。spidev.c会在device目录下自动为每一个匹配的SPI设备创建设备节点，节点名"spi%d"。之后，用户程序可以通过字符型设备的通用接口控制SPI设备。需要注意的是，spidev创建的设备在设备模型中属于虚拟设备，他的class是spidev_class，他的父设备是在boardinfo中定义的spi设备。
  • if (!bitbang->txrx_bufs) { //在s3c24xx_spi_probe里定义了txrx_bufs
  •         bitbang->use_dma =0; 
  •         /*spi_s3c24xx.c中有spi_bitbang_bufs方法，在bitbang_work中被调用*/ 
  •         bitbang->txrx_bufs =spi_bitbang_bufs; 

    • 你可能感兴趣的:(spi驱动框架源码分析)

    • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
      一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
      扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
      在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
      腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
      Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
    • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
      ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
      ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
      ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    • MongoDB知识概括 GeorgeLin98 持久层mongodb
      MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
      前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
    • python爬取微信小程序数据,python爬取小程序数据 2301_81900439 前端
      大家好，小编来为大家解答以下问题，python爬取微信小程序数据，python爬取小程序数据，现在让我们一起来看看吧！Python爬虫系列之微信小程序实战基于Scrapy爬虫框架实现对微信小程序数据的爬取首先，你得需要安装抓包工具，这里推荐使用Charles，至于怎么使用后期有时间我会出一个事例最重要的步骤之一就是分析接口，理清楚每一个接口功能，然后连接起来形成接口串思路,再通过Spider的回调
    • 学写作的第四天 石声藤
      第四节如何坚持长期写下去？①摘要学好写作，重要的是持续性。如何坚持，就从淡化“坚持”这个词开始。做很多事，根本不是用坚持来驱动的，而是你清晰的认识，这件事很重要，你才坚持。②从本质认识写作的重要性意识决定人的行动。如果你从本质认识到某件事的重要性，即使没人逼你，你也会去坚持做，比如赚钱。认识写作的重要性，不认识，重新多学几遍第一节。③要让自己不断从写作中收益一件事能不断给你带来回报，是驱动你坚持做
    • APQP，ASPICE，敏捷，功能安全，预期安全，这些汽车行业的一堆标准 二大宝贝 安全架构
      前言APQP,ASPICE,敏捷，功能安全，预期安全，PMP，PRICE2汽车行业的有这样一堆标准。我是半路出家来到汽车行业做项目经理的，对几个标准的感觉是，看了文档和各种解析之后还是一头雾水，不知道到底说了个啥，别人问我还是一脸懵逼。APQP（TS16949的最重要工具），ASPICE（软件）这些是质量标准，是优化整个公司体系的，但这套体系对项目管理有要求；敏捷，PMP这些是项目管理的标准；项目
    • 探索ASPICE V3.1：汽车行业软件开发的中文指南 阮懿同
      探索ASPICEV3.1：汽车行业软件开发的中文指南ASPICE_V3.1中文版.pdf.zip项目地址:https://gitcode.com/open-source-toolkit/422a2在汽车软件工程领域，高质量的标准对于确保行车安全和提升用户体验至关重要。今天，我们为您介绍一个珍贵的开源宝藏——ASPICEV3.1中文版资源。这是一篇专为国内汽车行业开发者、质量管理者准备的深度解读，旨
    • 以研发创新为驱动力，黄山谷捷助力新能源汽车产业高质量发展 L913197600 黄山谷捷制造科技
      在新能源汽车产业蓬勃发展的浪潮中，车规级功率半导体作为驱动电机控制系统的核心部件，其性能与稳定性直接关系到汽车的动力输出、能效转化及安全性能。在这一关键领域，黄山谷捷股份有限公司（以下简称“黄山谷捷”或“公司”）以卓越的研发实力、精湛的生产工艺和严格的质量控制体系，成为行业内的佼佼者，特别是在功率半导体散热基板领域，更是树立了新的标杆。自2012年成立以来，黄山谷捷便深谙“科技是第一生产力”的真谛
    • 《算法》四学习——1.1节 进阶的Farmer 算法算法笔记
      前言买了一本算法4，每天看一点，对每个小结来个学习总结，输出驱动输入。本篇笔记针对第一章基础1.1基础编程模型1.1节总结了相关的语法、语言特性和书中将会用到的库。笔记自己在编码中容易遗漏的点&&优先级比||高在开发中习惯了加括号，所以没注意到这点，教材上也有但是忘记了二分查找中计算mid=left+(right-left)/2这样计算可以有效避免(left+right)/2溢出答疑java无穷大
    • macOs mojave 添加hp laserjet 1020 打印机方法。 Coder_Zh
      1.设置--》打印机与扫描仪。2.点击“+”选择IP3.输入地址：（写网络IP），协议选择：hpjetdirect-socket4.使用选项：选择hplaserjet10221.6（没有1020的驱动，但是1022的驱动兼容1020可以使用。）测试OK，可以使用。
    • sunxi-fel 的相关命令 蓝黑墨水 单片机
      文章目录简介常用命令说明获取flash的相关信息列出所有的FEL设备显示BROM信息烧写程序到内存烧写程序到flash简介这个命令是全志芯片的烧写程序。有很多写法。例如:F1C100S、F1C200S这个命令有很多隐藏的相关问题（这里不讨论）常用命令说明获取flash的相关信息$./sunxi-fel.exe-pspiflash-infoManufacturer:Winbond(EFh),mode
    • SPI机制 我们仍未知道那天所看见的猫的名
      1、SPI机制：ServiceProviderInterface：服务提供发现机制，类型IOCJavaSPI实现：ServiceLoader定义接口A；实现接口A的实现类，B和C；在/META-INF/services/下创建文件，文件名为A类的全名称，内容为B和C的类全名调用：ServiceLoaderload=ServiceLoader.load(A.class);Interatori=loa
    • 小米嵌入式面试题目RTOS面试题目 嵌入式面试题目 好家伙VCC 面试杂谈杂谈面试职场和发展
      第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
    • Linux使用mjpg-streamer进行图像传输 —你的鼬先生 Linux驱动linux树莓派图像传输
      图像传输是一项在Linux操作系统中比较常见的一个操作，在视频图传时，一般是采用MJPG-streamer来进行图像传输，本文就以树莓派为例子，来示范一个图像传输。1.树莓派的摄像头激活首先更新树莓派sudoapt-getupdatesudoapt-getupgrade随后打开树莓派的配置界面，选择InterfaceOptionsudoraspi-config在InterfaceOption选择C
    • 《刘润商业洞察力》：结构性张力 飘皓宇
      结构性张力是发现理想与现实的差距后忍不住缩小期望与现实之间差距的力量，它是增强回路系统里的“元动力”。这个原动力通常要靠我们自己的努力和奋斗来填平，也就是自驱动。自驱动除了使命以外，还可以靠外力吗？按照弗鲁姆的“期望理论”是可以建立员工个体的自驱力的。如果你用找“结构性张力”的视角找“元动力”，世界就不一样了。比如，美丽，是女孩子买漂亮衣服的元动力吗？准确地说，不是。和美丽之间的“差距”，才是。成
    • python图片匹配 给麦兜吃芒果 pythonpython
      #方法一，可以直接用importpyautogui,timeclassPic():def__init__(self):passself.w,self.h=pyautogui.size()defget_win(self,number_x=32,number_y=24):#读取页面，记录rgb数据tx=int(self.w/number_x)ty=int(self.h/number_y)img=pya
    • 目标和问题驱动 blue_panda
      持续成长，实践起来会有各种坑，虽然目标是很好的，但执行的过程中，确会有这样和那样的问题，现在就碰到了一些问题，目标，起点和路径不是那么清晰。出了问题，不怕。只要能发现问题，分析问题，制定方案，再执行对照目标和结果的偏差，肯定能够逐步的去解决的。
    • 究竟是什么决定了你的自驱动力 Aichris
      人所拥有的任何东西，都可以被剥夺，唯独人性最后的自由——也就是在任何境遇中选择一己态度和生活方式的自由——不能被剥夺。奥地利维克多-弗兰克你现在的状况，是由你之前的每一次选择和历史的积累决定的。我很相信这点，每次遇到事情不开心的时候，看看弗兰克这段话，深呼吸，让自己平静下来。昨天早上做飞机回上海开会，旁边做了一个外国妹子，很想和她沟通一下，但是不是很自信。她和同伴沟通的时候，我尝试听了一下，还是能
    • 24营2组锋妈11月13日作业及阅读笔记 锋妈
      第一部分，听课心得在《时间管理目标模型课程》中，主要学到了如下四点：一、为什么要制定目标二、怎么样制定目标三、制定目标后要做些什么四、立刻行动起来听完后，对照讲课提纲，是自身的存在的弱点，觉着最大的绊脚石是第四点立刻行动起来。因为再宏伟的目标，再强大的驱动力下，如果没有行动去执行，一切都是空谈。为了避免执行力弱化，结合自己目前实际情况，觉着尽量把目标制定的简单明了、可执行、可衡量、可反馈回顾的。只
    • 深入理解AOP（面向切面编程）及其应用 自身就是太阳 java开发语言spring
      目录AOP的核心概念AOP的实现方式1.定义DAO接口和实现类2.定义通知类3.开启AOP注解驱动切入点表达式通配符的使用：AOP通知类型案例分析：测量业务层接口的执行效率结论概述：AOP（Aspect-OrientedProgramming，面向切面编程）是一种编程范式，主要用于将共性功能从具体的业务逻辑中分离出来，实现松耦合的代码设计。其作用是在不修改原始代码的情况下，对现有方法进行增强，广泛
    • Java集合类框架源码分析 之 RoleList源码解析 【6】 yunzhonghefei Java集合类源码分析RoleList源码解析
      该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    • 我们在读书会尝试OKR，结果成了PDCA 湖边的阿曦
      “读书要玩味，好玩又有味。”前面有了不成熟的理解——《OKR的优势是什么？它的实践原则有哪些？》，现在又有了不成熟的实践——在读书会尝试OKR。我们的现状我们读书会是个小组织，每个月一次线下活动，每次参加人数在10位左右。也是个自组织，没有管理员，没有固定组织者，只有每次活动时的临时主持者。我们也没有任何规定，一切基于个人的自我驱动及相互尊重。活动的内容，可能是一本书，也可能是一个主题。在活动前，
    • 【仿RabbitMQ消息队列项目day2】使用muduo库中基于protobuf的应用层协议进行通信 月夜星辉雪 rabbitmq网络分布式c++后端服务器linux
      一.什么是muduo?muduo库是⼀个基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。简单来理解，它就是对原生的TCP套接字的封装，是一个比socket编程接口更好用的编程库。二.使用muduo库完成一个英译汉翻译服务TranslateServer.hpp:#pragmaonce#include#include#include#include#include"muduo/net/TcpC
    • 用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类） AdyZhang POJOeclipseHibernateMiddleGenIDE
      推荐:MiddlegenIDE插件,   是一个Eclipse   插件.     用它可以直接连接到数据库,   根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件!     今天开始试着使用
    • .9.png Cb123456 android
        “点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。 　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
    • 算法的效率 天子之骄 算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
      算法的效率 效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。   以下是我的学习笔记：   1.求值与霍纳法则，即为秦九韶公式。   2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。
    • java数据结构 何必如此 java数据结构
      Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类： 枚举（Enumeration） 位集合（BitSet） 向量（Vector） 栈（Stack） 字典（Dictionary） 哈希表（Hashtable） 属性（Properties） 以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
    • MybatisHelloWorld 3213213333332132
      //测试入口TestMyBatis package com.base.helloworld.test; import java.io.IOException; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibat
    • Java|urlrewrite|URL重写|多个参数 7454103 javaxmlWeb工作
       个人工作经验！ 如有不当之处，敬请指点 1.0  web -info 目录下建立     urlrewrite.xml  文件 类似如下： <?xml version="1.0" encoding="UTF-8" ?>   <!DOCTYPE u
    • 达梦数据库+ibatis darkranger sqlmysqlibatisSQL Server
      --插入数据方面 如果您需要数据库自增... 那么在插入的时候不需要指定自增列. 如果想自己指定ID列的值, 那么要设置 set identity_insert  数据库名.模式名.表名; ----然后插入数据; example: create table zhabei.test( id bigint identity(1,1) primary key, nam
    • XML 解析 四种方式 aijuans android
      XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。 XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object
    • spring中配置文件占位符的使用 avords
      1.类 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
    • 前端工程化-公共模块的依赖和常用的工作流 bee1314 webpack
      题记： 一个人的项目，还有工程化的问题嘛？   我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？ 你真的想这样嘛？   var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。  
    • 上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？ bijian1013 项目管理沟通IT职业规划
      问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应         正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。   Eno-Bea回答，注重感受，不一定是别人的         虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
    • TortoiseSVN，过滤文件 征客丶 SVN
      环境： TortoiseSVN 1.8 配置： 在文件夹空白处右键 选择  TortoiseSVN -> Settings 在 Global ignote pattern 中添加要过滤的文件： 多类型用英文空格分开 *name ： 过滤所有名称为 name 的文件或文件夹 *.name ： 过滤所有后缀为 name 的文件或文件夹 --------
    • 【Flume二】HDFS sink细说 bit1129 Flume
      1. Flume配置   a1.sources=r1 a1.channels=c1 a1.sinks=k1 ###Flume负责启动44444端口 a1.sources.r1.type=avro a1.sources.r1.bind=0.0.0.0 a1.sources.r1.port=44444 a1.sources.r1.chan
    • The Eight Myths of Erlang Performance bookjovi erlang
      erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html   Myth: Funs are sl
    • java多线程网络传输文件(非同步)-2008-08-17 ljy325 java多线程socket
      利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。 使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 客户端: 修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
    • 读《研磨设计模式》-代码笔记-模板方法模式 bylijinnan java设计模式
      声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;
    • 配置心得 chenyu19891124 配置
      时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。 作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。 做了一年的配置管理给自总结下： 1.改变 从一个以前对配置毫无
    • 对“带条件选择的并行汇聚路由问题”的再思考 comsci 算法工作软件测试嵌入式领域模型
      2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
    • Oracle 10g 的clusterware 32位 下载地址 daizj oracle
      Oracle 10g 的clusterware 32位 下载地址 http://pan.baidu.com/share/link?shareid=531580&uk=421021908 http://pan.baidu.com/share/link?shareid=137223&uk=321552738 http://pan.baidu.com/share/l
    • 非常好的介绍：Linux定时执行工具cron dongwei_6688 linux
      Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。 新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
    • Yii assets目录生成及修改 dcj3sjt126com yii
      assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 assets设置对应的方法位置 \framework\web\CAssetManager.php   assets配置方法 在m
    • mac工作软件推荐 dcj3sjt126com mac
      mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。 我为什么要要iterm2 切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： * 兼容性好，远程服务器 vi 什么的低版本能很好兼
    • Memcached(三)、封装Memcached和Ehcache frank1234 memcachedehcachespring ioc
      本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 cache.xml <?xml version="1.0" encoding="UTF-8"?>
    • Remove Duplicates from Sorted List II hcx2013 remove
      Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5,
    • Spring4新特性——注解、脚本、任务、MVC等其他特性改进 jinnianshilongnian spring4
      Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
    • MySQL安装文档 liyong0802 mysql
        工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。   安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。   Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
    • 使用VS2010构建HotSpot工程 p2p2500 HotSpotOpenJDKVS2010
      1. 下载OpenJDK7的源码：      http://download.java.net/openjdk/jdk7      http://download.java.net/openjdk/      2. 环境配置     ▶
    • Oracle实用功能之分组后列合并 seandeng888 oracle分组实用功能合并
      1       实例解析 由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下： 表test 数据如下： ID,SUBJECTCODE,DIMCODE,VALUE 1&nbs
    • Java定时任务注解方式实现 tuoni javaspringjvmxmljni
      Spring 注解的定时任务，有如下两种方式： 第一种： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"  xmlns:xsi="http
    • 11大Java开源中文分词器的使用方法和分词效果对比 yangshangchuan word分词器ansj分词器Stanford分词器FudanNLP分词器HanLP分词器
      本文的目标有两个： 1、学会使用11大Java开源中文分词器 2、对比分析11大Java开源中文分词器的分词效果 本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比
    按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他