Qualcomm平台的SPI驱动框架分析
  1. 一、SPI总线概述
  2. SPI是英语Serial Peripheral interface的缩写,顾名思义就是串行外围设备接口,是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在 EEPROM,FLASH,实时时钟,AD转换器,还有数字信号处理器和数字信号解码器之间。SPI是一种高速的,全双工,同步的通信总线,并且在芯片的管脚上只占用四根线,节约了芯片的管脚,同时为PCB的布局上节省空间,提供方便。
  3. SPI的通信原理很简单,它以主从方式工作,这种模式通常有一个主设备和一个或多个从设备,需要4根线,事实上3根也可以。也是所有基于SPI的设备共有的,它们是SDI(数据输入),SDO(数据输出),SCLK(时钟),CS(片选)
  4. MOSI(SDO):主器件数据输出,从器件数据输入。
  5. MISO(SDI):主器件数据输入,从器件数据输出。
  6. SCLK :时钟信号,由主器件产生。
  7. CS:从器件使能信号,由主器件控制。
  8. 其中CS是控制芯片是否被选中的,也就是说只有片选信号为预先规定的使能信号时(高电位或低电位),对此芯片的操作才有效,这就允许在同一总线上连接多个SPI设备成为可能。需要注意的是,在具体的应用中,当一条SPI总线上连接有多个设备时,SPI本身的CS有可能被其他的GPIO脚代替,即每个设备的CS脚被连接到处理器端不同的GPIO,通过操作不同的GPIO口来控制具体的需要操作的SPI设备,减少各个SPI设备间的干扰。
  9. SPI是串行通讯协议,也就是说数据是一位一位从MSB或者LSB开始传输的,这就是SCK时钟线存在的原因,由SCK提供时钟脉冲,MISO、MOSI则基于此脉冲完成数据传输。 SPI支持4-32bits的串行数据传输,支持MSB和LSB,每次数据传输时当从设备的大小端发生变化时需要重新设置SPI Master的大小端。

  10. 二、Linux SPI驱动总体架构
  11. 在2.6的linux内核中,SPI的驱动架构可以分为如下三个层次:SPI 核心层、SPI控制器驱动层和SPI设备驱动层。Linux 中SPI驱动代码位于drivers/spi目录。
  12. 1.SPI核心层
  13. SPI核心层是Linux的SPI核心部分,提供了核心数据结构的定义、SPI控制器驱动和设备驱动的注册、注销管理等API。其为硬件平台无关层,向下屏蔽了物理总线控制器的差异,定义了统一的访问策略和接口;其向上提供了统一的接口,以便SPI设备驱动通过总线控制器进行数据收发。
  14. Linux中,SPI核心层的代码位于driver/spi/spi.c。

  15. 2.SPI控制器驱动层
  16. SPI控制器驱动层,每种处理器平台都有自己的控制器驱动,属于平台移植相关层。它的职责是为系统中每条SPI总线实现相应的读写方法。在物理上,每个SPI控制器可以连接若干个SPI从设备。
  17. 在系统开机时,SPI控制器驱动被首先装载。一个控制器驱动用于支持一条特定的SPI总线的读写。一个控制器驱动可以用数据结构struct spi_master来描述。

  18. 3.SPI设备驱动层
  19. SPI设备驱动层为用户接口层,其为用户提供了通过SPI总线访问具体设备的接口。
  20. SPI设备驱动层可以用两个模块来描述,struct spi_driver和struct spi_device。
  21. Driver是为device服务的,spi_driver注册时会扫描SPI bus上的设备,进行驱动和设备的绑定,probe函数用于驱动和设备匹配时被调用。从上面的结构体注释中我们可以知道,SPI的通信是通过消息队列机制,而不是像I2C那样通过与从设备进行对话的方式。

  22. 三、spi子系统主要数据结构
  23. 1.在Linux中,使用spi_master结构来描述一个SPI主机控制器的驱动。
  24. struct spi_master { 
  25.     struct device dev; 
  26.     s16 bus_num; //为该控制器对应的SPI总线号
  27.     u16 num_chipselect; //控制器支持的片选数量,即能支持多少个spi设备,从设备的片选号不能大于这个数量
  28.     u16 dma_alignment; 
  29.     int (*setup)(struct spi_device *spi);//函数是设置SPI总线的模式,时钟等的初始化函数, 针对设备设置SPI的工作时钟及数据传输模式等。在spi_add_device函数中调用
  30.     int (*transfer)(struct spi_device *spi,struct spi_message *mesg);//实现SPI总线读写方法的函数。实现数据的双向传输,可能会睡眠 
  31.     void (*cleanup)(struct spi_device *spi); //注销时候调用
  32. };
  33. //分配,注册和注销的SPI主机的API由SPI核心提供:
  34. struct spi_master *spi_alloc_master(struct device *host, unsigned size); 
  35. int spi_register_master(struct spi_master *master); 
  36. void spi_unregister_master(struct spi_master *master); 
  37.    
  38. 2.在Linux中用spi_driver来描述一个SPI外设驱动。
  39. struct spi_driver {
  40.     const struct spi_device_id *id_table;//匹配的设备表
  41.     int            (*probe)(struct spi_device *spi);
  42.     int            (*remove)(struct spi_device *spi);
  43.     void        (*shutdown)(struct spi_device *spi);
  44.     int            (*suspend)(struct spi_device *spi, pm_message_t mesg);
  45.     int            (*resume)(struct spi_device *spi);
  46.     struct device_driver    driver;
  47. }; 

  48. 3.Linux用spi_device来描述一个SPI外设设备。
  49. struct spi_device { 
  50.     struct device        dev;
  51.     struct spi_master    *master;//对应的控制器指针
  52.     u32            max_speed_hz;//spi通信的时钟
  53.     u8            chip_select; //片选,用于区分同一总线上的不同设备
  54.     u8            mode;
  55. #define    SPI_CPHA    0x01            /* clock phase */
  56. #define    SPI_CPOL    0x02            /* clock polarity */
  57. #define    SPI_MODE_0    (0|0)            /* (original MicroWire) */
  58. #define    SPI_MODE_1    (0|SPI_CPHA)
  59. #define    SPI_MODE_2    (SPI_CPOL|0)
  60. #define    SPI_MODE_3    (SPI_CPOL|SPI_CPHA)
  61. #define    SPI_CS_HIGH    0x04            /* chipselect active high? */
  62. #define    SPI_LSB_FIRST    0x08            /* per-word bits-on-wire */
  63. #define    SPI_3WIRE    0x10            /* SI/SO signals shared */
  64. #define    SPI_LOOP    0x20            /* loopback mode */
  65. #define    SPI_NO_CS    0x40            /* 1 dev/bus, no chipselect */
  66. #define    SPI_READY    0x80            /* slave pulls low to pause */
  67.     u8            bits_per_word;//每个字长的比特数
  68.     int            irq;//使用的中断号
  69.     void            *controller_state;
  70.     void            *controller_data;
  71.     char            modalias[SPI_NAME_SIZE];//名字 
  72. }; 
  73. 看这三个结构的关系,这里spi_device与spi_master是同一个父设备,这是在spi_new_device函数中设定的,一般这个设备是一个物理设备。

  74. 4.为了解决多个不同的SPI设备共享SPI控制器而带来的访问冲突,spi_bitbang使用内核提供的工作队列(workqueue)。 workqueue是Linux内核中定义的一种回调处理方式。采用这种方式需要传输数据时,不直接完成数据的传输,而是将要传输的工作分装成相应的消息 (spi_message),发送给对应的workqueue,由与workqueue关联的内核守护线程(daemon)负责具体的执行。由于 workqueue会将收到的消息按时间先后顺序排列,这样就是对设备的访问严格串行化,解决了冲突。
  75. struct spi_bitbang { 
  76.     struct workqueue_struct *workqueue;//工作队列头 
  77.     struct work_struct work;//每一次传输都传递下来一个spi_message,都向工作队列头添加一个 
  78.     workspinlock_t lock; 
  79.     struct list_head queue;//挂接spi_message,如果上一次的spi_message还没有处理完,接下来的spi_message就挂接在queue上等待处理 
  80.     u8 busy;//忙碌标志 
  81.     u8 use_dma; 
  82.     u8 flags; 
  83.     struct spi_master *master;//指向spi控制器
  84.     int (*setup_transfer)(struct spi_device *spi,struct spi_transfer *t);//设置传输模式 
  85.     void (*chipselect)(struct spi_device *spi, int is_on);//片选 
  86. #define BITBANG_CS_ACTIVE 1 /* normally nCS, active low */ 
  87. #define BITBANG_CS_INACTIVE 0 
  88.     int (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t);//传输函数
  89.     u32 (*txrx_word[4])(struct spi_device *spi,unsigned nsecs,u32 word, u8 bits); 
  90. }; 

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

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

  117. 7.spi控制器驱动的私有数据
  118. struct davinci_spi {
  119.     struct spi_bitbang    bitbang;
  120.     struct clk        *clk;//时钟
  121.     u8            version;
  122.     resource_size_t        pbase;//spi寄存器物理地址
  123.     void __iomem        *base;//spi寄存器虚拟地址
  124.     u32            irq;//spi中断号
  125.     struct completion    done;

  126.     const void    *tx;//发送buffer
  127.     void            *rx;//读buffer
  128. #define SPI_TMP_BUFSZ    (SMP_CACHE_BYTES + 1)
  129.     u8            rx_tmp_buf[SPI_TMP_BUFSZ];
  130.     int            rcount;//读数据个数
  131.     int            wcount;//写数据个数
  132.     struct davinci_spi_dma    dma;
  133.     struct davinci_spi_platform_data *pdata;

  134.     void        (*get_rx)(u32 rx_data, struct davinci_spi *);//读数据函数
  135.     u32            (*get_tx)(struct davinci_spi *);//发送数据函数
  136.     u8            bytes_per_word[SPI_MAX_CHIPSELECT];
  137.     u32            speed;
  138.     u32            cs_num;
  139.     bool        in_use;

  140. #ifdef CONFIG_CPU_FREQ
  141.     struct notifier_block freq_transition;
  142. #endif
  143. };


  144. 四、spi驱动初始化
  145. 1.spi总线注册
  146. //spi总线结构
  147. struct bus_type spi_bus_type = {
  148.     .name        = "spi",
  149.     .dev_attrs    = spi_dev_attrs,
  150.     .match        = spi_match_device,
  151.     .uevent        = spi_uevent,
  152.     .suspend    = spi_suspend,
  153.     .resume        = spi_resume,
  154. };

  155. //spi_master类,会在sysfs文件系统创建该类
  156. static struct class spi_master_class = {
  157.     .name        = "spi_master",
  158.     .owner        = THIS_MODULE,
  159.     .dev_release    = spi_master_release,
  160. };

  161. static int __init spi_init(void)
  162. {
  163.     int    status;

  164.     buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
  165.     if (!buf) {
  166.         status = -ENOMEM;
  167.         goto err0;
  168.     }
  169.     //分别对应sysfs文件系统中的sys/bus/下的spi目录和sys/class/下的spi_master目录。
  170.     status = bus_register(&spi_bus_type);//注册spi总线
  171.     if (status < 0)
  172.         goto err1;

  173.     status = class_register(&spi_master_class);//创建spi_master的类
  174.     if (status < 0)
  175.         goto err2;
  176.     return 0;

  177. err2:
  178.     bus_unregister(&spi_bus_type);
  179. err1:
  180.     kfree(buf);
  181.     buf = NULL;
  182. err0:
  183.     return status;
  184. }

  185. 2.spi控制器管脚的复用配置
  186. const short da850_spi0_pins[] __initdata = {
  187.     DA850_SPI0_CLK,DA850_SPI0_ENA,DA850_SPI0_SOMI,DA850_SPI0_SIMO,
  188.     -1
  189. };

  190. static __init void da850_evm_init(void)
  191. {
  192.     //......
  193.     ret = davinci_cfg_reg_list(da850_spi0_pins);//复用管脚配置
  194.     if (ret)
  195.         pr_warning("da850_evm_init: spi0 mux setup failed: %d\n",    ret);
  196.     //......    
  197. }

  198. 3.注册spi的platform device设备        
  199. static struct spi_board_info da850evm_spi_info[] = {
  200.     {
  201.         .modalias = "ads7846",//设备名,与spi_driver中定义的名字相同
  202.         .bus_num = 0,
  203.         .chip_select = 0,
  204.         .max_speed_hz = 1500000,
  205.         .mode             = SPI_MODE_0,
  206.         .irq = 128,//GPIO1[11]
  207.         .platform_data = &ads7846_config,
  208.         }, 
  209. };

  210. static void __init da850evm_init_spi0(struct spi_board_info *info, unsigned len)
  211. {
  212.     int ret;
  213.     
  214.     //注册spi设备的信息到board_list链表中,待spi master注册好后扫描这些板级设备再进行注册
  215.     ret = spi_register_board_info(info, len);
  216.     if (ret)
  217.         pr_warning("failed to register board info : %d\n", ret);
  218.     
  219.     //注册spi0的platform device
  220.     ret = da8xx_register_spi(0, &da850evm_spi0_pdata);
  221.     if (ret)
  222.         pr_warning("failed to register spi 1 device : %d\n", ret);

  223.     if (!(system_rev & 0x100))
  224.         register_mtd_user(&spi_notifier);
  225. }

  226. int __init spi_register_board_info(struct spi_board_info const *info, unsigned n)
  227. {
  228.     struct boardinfo *bi;
  229.     int i;

  230.     bi = kzalloc(* sizeof(*bi), GFP_KERNEL);//分配一个boardinfo结构
  231.     if (!bi)
  232.         return -ENOMEM;

  233.     for (= 0; i < n; i++, bi++, info++) {
  234.         struct spi_master *master;
  235.         memcpy(&bi->board_info, info, sizeof(*info));//填充boardinfo结构
  236.         mutex_lock(&board_lock);
  237.         list_add_tail(&bi->list, &board_list);//挂载到全局链表board_list中
  238.         
  239.         //遍历spi_master_list链表,查看是否有spi设备在此spi控制器上,现在因为spi master尚未注册,不会注册板级设备。
  240.         //待spi控制器注册后,还会扫描链表进行匹配,来注册板级设备
  241.         list_for_each_entry(master, &spi_master_list, list)
  242.             spi_match_master_to_boardinfo(master, &bi->board_info);
  243.         mutex_unlock(&board_lock);
  244.     }
  245.     return 0;
  246. }

  247. static struct resource da8xx_spi0_resources[] = {
  248.     [0] = {
  249.         .start = 0x01c41000,
  250.         .end = 0x01c41fff,
  251.         .flags = IORESOURCE_MEM,
  252.     },
  253.     [1] = {
  254.         .start = IRQ_DA8XX_SPINT0,
  255.         .end = IRQ_DA8XX_SPINT0,
  256.         .flags = IORESOURCE_IRQ,
  257.     },
  258.     [2] = {
  259.         .start = EDMA_CTLR_CHAN(0, 14),
  260.         .end = EDMA_CTLR_CHAN(0, 14),
  261.         .flags = IORESOURCE_DMA,
  262.     },
  263.     [3] = {
  264.         .start = EDMA_CTLR_CHAN(0, 15),
  265.         .end = EDMA_CTLR_CHAN(0, 15),
  266.         .flags = IORESOURCE_DMA,
  267.     },
  268.     [4] = {
  269.         .start = 0,
  270.         .end = 0,
  271.         .flags = IORESOURCE_DMA,
  272.     },
  273. };

  274. static struct platform_device da8xx_spi_device[] = {
  275.     [0] = {
  276.         .name = "spi_davinci",
  277.         .id = 0,
  278.         .num_resources = ARRAY_SIZE(da8xx_spi0_resources),
  279.         .resource = da8xx_spi0_resources,
  280.     },
  281.     [1] = {
  282.         .name = "spi_davinci",
  283.         .id = 1,
  284.         .num_resources = ARRAY_SIZE(da8xx_spi1_resources),
  285.         .resource = da8xx_spi1_resources,
  286.     },
  287. };

  288. int __init da8xx_register_spi(int instance,struct davinci_spi_platform_data *pdata)
  289. {
  290.     struct platform_device *pdev;

  291.     if (instance == 0)
  292.         pdev = &da8xx_spi_device[0];
  293.     else if (instance == 1)
  294.         pdev = &da8xx_spi_device[1];
  295.     else
  296.         return -EINVAL;

  297.     pdev->dev.platform_data = pdata;

  298.     return platform_device_register(pdev);//注册platform device设备
  299. }

  300. 4.注册platform driver,会注册spi控制器spi_master

  301. static struct platform_driver davinci_spi_driver = {
  302.     .driver = {
  303.         .name = "spi_davinci",
  304.         .owner = THIS_MODULE,
  305.     },
  306.     .remove = __exit_p(davinci_spi_remove),
  307.     .suspend = davinci_spi_suspend,
  308.     .resume = davinci_spi_resume,
  309. };

  310. static int __init davinci_spi_init(void)
  311. {
  312.     return platform_driver_probe(&davinci_spi_driver, davinci_spi_probe);
  313. }

  314. //platform driver与platform device匹配成功后,调用davinci_spi_probe
  315. static int davinci_spi_probe(struct platform_device *pdev)
  316. {
  317.     struct spi_master *master;
  318.     struct davinci_spi *dspi;
  319.     struct davinci_spi_platform_data *pdata;
  320.     struct resource *r, *mem;
  321.     resource_size_t dma_rx_chan = SPI_NO_RESOURCE;
  322.     resource_size_t    dma_tx_chan = SPI_NO_RESOURCE;
  323.     resource_size_t    dma_eventq = SPI_NO_RESOURCE;
  324.     int i = 0, ret = 0;
  325.     u32 spipc0;

  326.     pdata = pdev->dev.platform_data;
  327.     if (pdata == NULL) {
  328.         ret = -ENODEV;
  329.         goto err;
  330.     }
  331.     
  332.     //分配一个spi控制器的spi_master结构,分配struct spi_master + struct davinci_spi大小的数据,把davinci_spi设为spi_master的私有数据
  333.     master = spi_alloc_master(&pdev->dev, sizeof(struct davinci_spi));
  334.     if (master == NULL) {
  335.         ret = -ENOMEM;
  336.         goto err;
  337.     }
  338.     
  339.     //把spi_master设置为platform_device结构中dev的私有数据
  340.     dev_set_drvdata(&pdev->dev, master);
  341.     
  342.     //从master中获得私有数据davinci_spi
  343.     dspi = spi_master_get_devdata(master);
  344.     if (dspi == NULL) {
  345.         ret = -ENOENT;
  346.         goto free_master;
  347.     }
  348.     
  349.     //从platform device的私有数据中获得spi控制器的寄存器物理地址资源
  350.     r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  351.     if (== NULL) {
  352.         ret = -ENOENT;
  353.         goto free_master;
  354.     }
  355.     dspi->pbase = r->start;//spi寄存器起始物理地址
  356.     dspi->pdata = pdata;
  357.     
  358.     //为spi控制器的物理地址申请内存空间
  359.     mem = request_mem_region(r->start, resource_size(r), pdev->name);
  360.     if (mem == NULL) {
  361.         ret = -EBUSY;
  362.         goto free_master;
  363.     }
  364.     
  365.     //将spi控制器的寄存器物理地址映射到内核空间
  366.     dspi->base = ioremap(r->start, resource_size(r));
  367.     if (dspi->base == NULL) {
  368.         ret = -ENOMEM;
  369.         goto release_region;
  370.     }
  371.     
  372.     //从platform device的私有数据中获得spi控制器的中断号
  373.     dspi->irq = platform_get_irq(pdev, 0);
  374.     if (dspi->irq <= 0) {
  375.         ret = -EINVAL;
  376.         goto unmap_io;
  377.     }
  378.     
  379.     //申请中断号
  380.     ret = request_irq(dspi->irq, davinci_spi_irq, 0, dev_name(&pdev->dev),dspi);
  381.     if (ret)
  382.         goto unmap_io;
  383.     
  384.     //spi master计数加1,且
  385.     dspi->bitbang.master = spi_master_get(master);
  386.     if (dspi->bitbang.master == NULL) {
  387.         ret = -ENODEV;
  388.         goto irq_free;
  389.     }
  390.     
  391.     //获得spi时钟
  392.     dspi->clk = clk_get(&pdev->dev, NULL);
  393.     if (IS_ERR(dspi->clk)) {
  394.         ret = -ENODEV;
  395.         goto put_master;
  396.     }
  397.     clk_enable(dspi->clk);//时钟使能

  398.     master->bus_num = pdev->id;//spi控制器所在的spi总线号
  399.     master->num_chipselect = pdata->num_chipselect;//spi控制器的片选数量
  400.     master->setup = davinci_spi_setup;//spi控制器的setup函数
  401.     
  402.     //spi_bitbang专门负责数据的传输*
  403.     dspi->bitbang.chipselect = davinci_spi_chipselect;//片选选择函数
  404.     dspi->bitbang.setup_transfer = davinci_spi_setup_transfer;//建立传输的函数

  405.     dspi->version = pdata->version;//版本号SPI_VERSION_2
  406.     //设置一些标志位
  407.     dspi->bitbang.flags = SPI_NO_CS | SPI_LSB_FIRST | SPI_LOOP;
  408.     if (dspi->version == SPI_VERSION_2)
  409.         dspi->bitbang.flags |= SPI_READY;
  410.     
  411.     //DMA操作的一些设置
  412.     r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
  413.     if (r)
  414.         dma_rx_chan = r->start;
  415.     r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
  416.     if (r)
  417.         dma_tx_chan = r->start;
  418.     r = platform_get_resource(pdev, IORESOURCE_DMA, 2);
  419.     if (r)
  420.         dma_eventq = r->start;

  421.     //数据传输函数
  422.     dspi->bitbang.txrx_bufs = davinci_spi_bufs;
  423.     //没有使用DMA
  424.     if (dma_rx_chan != SPI_NO_RESOURCE &&dma_tx_chan != SPI_NO_RESOURCE &&dma_eventq != SPI_NO_RESOURCE) {
  425.         dspi->dma.rx_channel = dma_rx_chan;
  426.         dspi->dma.tx_channel = dma_tx_chan;
  427.         dspi->dma.eventq = dma_eventq;

  428.         ret = davinci_spi_request_dma(dspi);
  429.         if (ret)
  430.             goto free_clk;

  431.         dev_info(&pdev->dev, "DMA: supported\n");
  432.         dev_info(&pdev->dev, "DMA: RX channel: %d, TX channel: %d, event queue: %d\n", dma_rx_chan, dma_tx_chan,dma_eventq);
  433.     }
  434.     
  435.     //设置spi的读写函数
  436.     dspi->get_rx = davinci_spi_rx_buf_u8;
  437.     dspi->get_tx = davinci_spi_tx_buf_u8;

  438.     init_completion(&dspi->done);
  439.     ret = davinci_spi_cpufreq_register(dspi);//cpu变频相关操作
  440.     if (ret) {
  441.         pr_info("davinci SPI contorller driver failed to register cpufreq\n");
  442.         goto free_dma;
  443.     }

  444.     iowrite32(0, dspi->base + SPIGCR0);//reset spi控制器
  445.     udelay(100);
  446.     iowrite32(1, dspi->base + SPIGCR0);//跳出spi控制器reset状态

  447.     //初始化设置寄存器,包括对SPIMOSI,SPIMISO,SPICLK引脚的设置
  448.     spipc0 = SPIPC0_DIFUN_MASK | SPIPC0_DOFUN_MASK | SPIPC0_CLKFUN_MASK;
  449.     iowrite32(spipc0, dspi->base + SPIPC0);

  450.     //GPIO作为片选管脚的初始化
  451.     if (pdata->chip_sel) {
  452.         for (= 0; i < pdata->num_chipselect; i++) {
  453.             if (pdata->chip_sel[i] != SPI_INTERN_CS)
  454.                 gpio_direction_output(pdata->chip_sel[i], 1);
  455.         }
  456.     }

  457.     if (pdata->intr_line)
  458.         iowrite32(SPI_INTLVL_1, dspi->base + SPILVL);//设置spi中断的等级
  459.     else
  460.         iowrite32(SPI_INTLVL_0, dspi->base + SPILVL);

  461.     iowrite32(CS_DEFAULT, dspi->base + SPIDEF);//设置片选寄存器,写入默认值0xFF

  462.     /* master mode default */
  463.     set_io_bits(dspi->base + SPIGCR1, SPIGCR1_CLKMOD_MASK);//设置为master模式
  464.     set_io_bits(dspi->base + SPIGCR1, SPIGCR1_MASTER_MASK);//设置为master模式
  465.     set_io_bits(dspi->base + SPIGCR1, SPIGCR1_POWERDOWN_MASK);//设置为power-down模式

  466.     //设置bitbang传输
  467.     ret = spi_bitbang_start(&dspi->bitbang);
  468.     if (ret)
  469.         goto free_dma;

  470.     dev_info(&pdev->dev, "Controller at 0x%p\n", dspi->base);

  471.     return ret;

  472. free_dma:
  473.     edma_free_channel(dspi->dma.tx_channel);
  474.     edma_free_channel(dspi->dma.rx_channel);
  475.     edma_free_slot(dspi->dma.dummy_param_slot);
  476. free_clk:
  477.     clk_disable(dspi->clk);
  478.     clk_put(dspi->clk);
  479. put_master:
  480.     spi_master_put(master);
  481. irq_free:
  482.     free_irq(dspi->irq, dspi);
  483. unmap_io:
  484.     iounmap(dspi->base);
  485. release_region:
  486.     release_mem_region(dspi->pbase, resource_size(r));
  487. free_master:
  488.     kfree(master);
  489. err:
  490.     return ret;
  491. }

  492. int spi_bitbang_start(struct spi_bitbang *bitbang)
  493. {
  494.     int    status;

  495.     if (!bitbang->master || !bitbang->chipselect)
  496.         return -EINVAL;
  497.     
  498.      /*初始化一个工作队列,后面再create_singlethread_workqueue,等到有数据要传输的时候,在spi_bitbang_transfer函数中通过调用queue_work(bitbang->workqueue, &bitbang->work),把work扔进workqueue中调度运行,这是内核的一贯做法*/
  499.     //动态创建一个work_struct结构,它的处理函数是bitbang_work
  500.     INIT_WORK(&bitbang->work, bitbang_work);
  501.     spin_lock_init(&bitbang->lock);//初始化自旋锁和链表头
  502.     INIT_LIST_HEAD(&bitbang->queue);//初始化链表头

  503.     if (!bitbang->master->mode_bits)
  504.         bitbang->master->mode_bits = SPI_CPOL | SPI_CPHA | bitbang->flags;

  505.     if (!bitbang->master->transfer)
  506.         bitbang->master->transfer = spi_bitbang_transfer;//spi数据的传输就是通过调用这个方法来实现的
  507.     
  508.     //数据传输过程:spi_bitbang_transfer-->......-->davinci_spi_bufs
  509.     if (!bitbang->txrx_bufs) {//前边已经赋值davinci_spi_bufs
  510.         bitbang->use_dma = 0;
  511.         bitbang->txrx_bufs = spi_bitbang_bufs;
  512.         if (!bitbang->master->setup) {
  513.             if (!bitbang->setup_transfer)
  514.                 bitbang->setup_transfer =
  515.                      spi_bitbang_setup_transfer;
  516.             bitbang->master->setup = spi_bitbang_setup;
  517.             bitbang->master->cleanup = spi_bitbang_cleanup;
  518.         }
  519.     } else if (!bitbang->master->setup)
  520.         return -EINVAL;

  521.     bitbang->busy = 0;
  522.     //调用create_singlethread_workqueue创建单个工作线程
  523.     bitbang->workqueue = create_singlethread_workqueue(dev_name(bitbang->master->dev.parent));
  524.     if (bitbang->workqueue == NULL) {
  525.         status = -EBUSY;
  526.         goto err1;
  527.     }

  528.     //注册spi主机控制器
  529.     status = spi_register_master(bitbang->master);
  530.     if (status < 0)
  531.         goto err2;

  532.     return status;

  533. err2:
  534.     destroy_workqueue(bitbang->workqueue);
  535. err1:
  536.     return status;
  537. }

  538. int spi_register_master(struct spi_master *master)
  539. {
  540.     static atomic_t        dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
  541.     struct device        *dev = master->dev.parent;
  542.     struct boardinfo    *bi;
  543.     int            status = -ENODEV;
  544.     int            dynamic = 0;

  545.     if (!dev)
  546.         return -ENODEV;

  547.     //spi控制器的片选数量不能为0
  548.     if (master->num_chipselect == 0)
  549.         return -EINVAL;

  550.     if (master->bus_num < 0) {//spi控制器总线号不能为0
  551.         master->bus_num = atomic_dec_return(&dyn_bus_id);
  552.         dynamic = 1;
  553.     }

  554.     spin_lock_init(&master->bus_lock_spinlock);
  555.     mutex_init(&master->bus_lock_mutex);
  556.     master->bus_lock_flag = 0;

  557.     //设置spi控制器的名称,即在sysfs文件系统中显示的名称
  558.     dev_set_name(&master->dev, "spi%u", master->bus_num);
  559.     
  560.     //设备添加到内核,会在sysfs文件系统下创建属性文件,这也是sys/class/spi_master下产生spi0,spi1的原因
  561.     status = device_add(&master->dev);
  562.     if (status < 0)
  563.         goto done;
  564.     dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),dynamic ? " (dynamic)" : "");

  565.     mutex_lock(&board_lock);
  566.     list_add_tail(&master->list, &spi_master_list);//将spi控制器的master挂载到全局链表spi_master_list
  567.     
  568.     /*在spi controller的driver注册的时候不但注册这个主机控制器的驱动,还要遍历这个主机控制器的总线上的spi_device,
  569.     将总线上的 spi_device全部注册进内核。当注册进内核并且spi_driver已经注册的时候,如果总线match成功,
  570.     则会调用spi_driver的 probe函数,这个将在后边进行分析。
  571.     */
  572.     list_for_each_entry(bi, &board_list, list)//遍历每个boardinfo管理的spi_board_info,如果设备的总线号与控制器的总线好相等,则创建新设备
  573.         spi_match_master_to_boardinfo(master, &bi->board_info);
  574.     mutex_unlock(&board_lock);

  575.     status = 0;
  576.     /* Register devices from the device tree */
  577.     of_register_spi_devices(master);
  578. done:
  579.     return status;
  580. }

  581. static void spi_match_master_to_boardinfo(struct spi_master *master,struct spi_board_info *bi)
  582. {
  583.     struct spi_device *dev;

  584.     if (master->bus_num != bi->bus_num)//要在同一个spi总线上
  585.         return;
  586.     
  587.     //向spi控制器添加spi device
  588.     dev = spi_new_device(master, bi);
  589.     if (!dev)
  590.         dev_err(master->dev.parent, "can't create new device for %s\n",bi->modalias);
  591. }

  592. struct spi_device *spi_new_device(struct spi_master *master,struct spi_board_info *chip)
  593. {
  594.     struct spi_device    *proxy;
  595.     int            status;

  596.     //分配spi_device,并初始化spi->dev的一些字段
  597.     proxy = spi_alloc_device(master);
  598.     if (!proxy)
  599.         return NULL;

  600.     WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
  601.     //初始化spi_device的各个字段
  602.     proxy->chip_select = chip->chip_select;//片选号
  603.     proxy->max_speed_hz = chip->max_speed_hz;
  604.     proxy->mode = chip->mode;
  605.     proxy->irq = chip->irq;
  606.     strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));//spi设备的名字
  607.     proxy->dev.platform_data = (void *) chip->platform_data;
  608.     proxy->controller_data = chip->controller_data;
  609.     proxy->controller_state = NULL;
  610.     
  611.     //添加spi设备
  612.     status = spi_add_device(proxy);
  613.     if (status < 0) {
  614.         spi_dev_put(proxy);
  615.         return NULL;
  616.     }

  617.     return proxy;
  618. }

  619. int spi_add_device(struct spi_device *spi)
  620. {
  621.     static DEFINE_MUTEX(spi_add_lock);
  622.     struct device *dev = spi->master->dev.parent;
  623.     struct device *d;
  624.     int status;

  625.     //spi设备的片选号不能超过spi控制器的片选数量
  626.     if (spi->chip_select >= spi->master->num_chipselect) {
  627.         dev_err(dev, "cs%d >= max %d\n",spi->chip_select,spi->master->num_chipselect);
  628.         return -EINVAL;
  629.     }

  630.     //这里设置是spi_device在Linux设备驱动模型中的name,也就是spi0.0
  631.     dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),spi->chip_select);
  632.     mutex_lock(&spi_add_lock);

  633.     //如果总线上挂的设备已经有这个名字,则设置状态忙碌,并退出
  634.     d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
  635.     if (!= NULL) {
  636.         dev_err(dev, "chipselect %d already in use\n",spi->chip_select);
  637.         put_device(d);
  638.         status = -EBUSY;
  639.         goto done;
  640.     }

  641.     //对spi_device进行设置
  642.     status = spi_setup(spi);
  643.     if (status < 0) {
  644.         dev_err(dev, "can't setup %s, status %d\n",dev_name(&spi->dev), status);
  645.         goto done;
  646.     }

  647.     //添加到内核,在sysfs文件系统下创建相应的属性文件(设备文件dev文件不会在这里创建,下边注册spi device驱动时会创建dev文件)
  648.     status = device_add(&spi->dev);
  649.     if (status < 0)
  650.         dev_err(dev, "can't add %s, status %d\n",dev_name(&spi->dev), status);
  651.     else
  652.         dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));

  653. done:
  654.     mutex_unlock(&spi_add_lock);
  655.     return status;
  656. }

  657. int spi_setup(struct spi_device *spi)
  658. {
  659.     unsigned    bad_bits;
  660.     int        status;

  661.     bad_bits = spi->mode & ~spi->master->mode_bits;
  662.     if (bad_bits) {
  663.         dev_err(&spi->dev, "setup: unsupported mode bits %x\n",bad_bits);
  664.         return -EINVAL;
  665.     }
  666.     
  667.     if (!spi->bits_per_word)
  668.         spi->bits_per_word = 8;

  669.     status = spi->master->setup(spi);//调用davinci_spi_setup

  670.     dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
  671.                 "%u bits/w, %u Hz max --> %d\n",
  672.             (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
  673.             (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
  674.             (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
  675.             (spi->mode & SPI_3WIRE) ? "3wire, " : "",
  676.             (spi->mode & SPI_LOOP) ? "loopback, " : "",
  677.             spi->bits_per_word, spi->max_speed_hz,
  678.             status);

  679.     return status;
  680. }

  681. static int davinci_spi_setup(struct spi_device *spi)
  682. {
  683.     int retval = 0;
  684.     struct davinci_spi *dspi;
  685.     struct davinci_spi_platform_data *pdata;
  686.     
  687.     //从spi master的私有数据中取出davinci_spi
  688.     dspi = spi_master_get_devdata(spi->master);
  689.     pdata = dspi->pdata;

  690.     //设置了每字长的位数,发送速度
  691.     if (!spi->bits_per_word)
  692.         spi->bits_per_word = 8;

  693.     //设置spi片选管脚
  694.     if (!(spi->mode & SPI_NO_CS)) {
  695.         if ((pdata->chip_sel == NULL) ||(pdata->chip_sel[spi->chip_select] == SPI_INTERN_CS))
  696.             set_io_bits(dspi->base + SPIPC0, 1 << spi->chip_select);
  697.     }

  698.     //使能spi控制器
  699.     if (spi->mode & SPI_READY)
  700.         set_io_bits(dspi->base + SPIPC0, SPIPC0_SPIENA_MASK);

  701.     //是否使能内部loop-back测试模式
  702.     if (spi->mode & SPI_LOOP)
  703.         set_io_bits(dspi->base + SPIGCR1, SPIGCR1_LOOPBACK_MASK);
  704.     else
  705.         clear_io_bits(dspi->base + SPIGCR1, SPIGCR1_LOOPBACK_MASK);

  706.     return retval;
  707. }

  708. 5.spi device的驱动注册,并创建设备节点
  709. static struct spi_driver ads7846_driver = {
  710.     .driver = {
  711.         .name    = "ads7846",
  712.         .bus    = &spi_bus_type,
  713.         .owner    = THIS_MODULE,
  714.     },
  715.     .probe        = ads7846_probe,
  716.     .remove        = __devexit_p(ads7846_remove),
  717.     .suspend    = ads7846_suspend,
  718.     .resume        = ads7846_resume,
  719. };

  720. static int __init ads7846_init(void)
  721. {
  722.     return spi_register_driver(&ads7846_driver);
  723. }

  724. //驱动与设备匹配成功后,会调用ads7846_probe函数,此函数会创建spi设备的字符设备,设备节点,这里创建的是/dev/input/event0
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weijory/article/details/72188687
个人分类: BSP开发
想对作者说点什么? 我来说一句

高通平台SPI显示

2017年11月09日 640KB 下载

没有更多推荐了,返回首页

不良信息举报

Qualcomm平台的SPI驱动框架分析

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭