spi slave及master接口驱动及传输时序

最新推荐文章于 2024-09-28 20:05:07 发布

weixin_30909575

最新推荐文章于 2024-09-28 20:05:07 发布

阅读量743

点赞数

原文链接：http://www.cnblogs.com/wenhuisun/archive/2013/05/14/3078786.html

版权

spi slave驱动
spi slave驱动在kernel中可以主要参考spidev.c,这是一个字符驱动，可以匹配kernel中的多个名称为“spidev”的spi设备，
分析这个文件，主要有以下几个重点：
1. 如何编写多设备公用驱动
2. 如何封装读写请求到spi框架层
3. spi message请求如何分发到master

自spi_board_info或者spi master注册后，两者就已经完成了匹配的工作，spi slave驱动不关心任何匹配的细节，它只需要完成
与spi slave的匹配，就可以通过slave进而找到master。这里是通过spi_register_driver(&spidev_spi_driver);注册进
kernel，而后spi框架进行name match，再调用probe，完成关于设备的一些成员初始化操作。
下面针对上面的三个问题，进行分析这个驱动，

spi设备全局链及保护信号量：
static LIST_HEAD(device_list);
static DEFINE_MUTEX(device_list_lock);

相对与设备的驱动数据：
struct spidev_data {
   dev_t           devt;           //设备号
   spinlock_t       spi_lock;       //spi 结构体的pin锁
   struct spi_device   *spi;
   struct list_head   device_entry;//挂接到device_list

   struct mutex       buf_lock;   //保护数据的lock
   unsigned       users;           //使用者
   u8           *buffer;           //实际数据区，由open时进行动态分配，release时释放
};
spi中任何会由多个使用者访问的区域，都需要使用锁保护，如这里的users，个人觉得需要使用原子变量而不应该简单的使用整形。
在probe的时候，首先分配spidev_data,并初始化其spi/device_entry/buf_lock/spi_lock，查找一个可用的bit用作次
设备号，创建设备spidev busnum.cs,挂到全局链中，并将私有数据spidev_data放到dev->p->driver_data中。
open时，从inode中获取dev_t，然后对比整个链，找到目标数据spidev_data，放到file->private_data中，并分配缓存
读写时，直接从file中获取对应的spidev_data数据，然后通过spi device来传递spi请求。
以上主要是数据如何传递的问题。

SPI读写请求的封装很简单，如下：
static inline ssize_t spidev_sync_write(struct spidev_data *spidev, size_t len)
{
   struct spi_transfer   t = {
           .tx_buf       = spidev->buffer,
           .len       = len,
       };
   struct spi_message   m;

   spi_message_init(&m);
   spi_message_add_tail(&t, &m);
   return spidev_sync(spidev, &m);
}

static inline ssize_t spidev_sync_read(struct spidev_data *spidev, size_t len)
{
   struct spi_transfer   t = {
           .rx_buf       = spidev->buffer,
           .len       = len,
       };
   struct spi_message   m;

   spi_message_init(&m);
   spi_message_add_tail(&t, &m);
   return spidev_sync(spidev, &m);
}

封装的同步函数：
static ssize_t spidev_sync(struct spidev_data *spidev, struct spi_message *message)
{
   DECLARE_COMPLETION_ONSTACK(done);
   int status;

   message->complete = spidev_complete;
   message->context = &done;

   spin_lock_irq(&spidev->spi_lock);
   if (spidev->spi == NULL)
       status = -ESHUTDOWN;
   else
       status = spi_async(spidev->spi, message);
   spin_unlock_irq(&spidev->spi_lock);

   if (status == 0) {
       wait_for_completion(&done);
       status = message->status;
       if (status == 0)
           status = message->actual_length;
   }
   return status;
}
只需要调用spi_async就可以完成数据读取/写入的操作。
这个函数在内部真正做了什么？如何分发/回调？我们走一遍代码：
首先master内部有两个锁：
spinlock_t       bus_lock_spinlock;   【用于异步】   spi_async
struct mutex       bus_lock_mutex;   【用于同步】   spi_sync
对于不同的场景，需要对master进行不同类型的加锁，
异步：
spin_lock_irqsave(&master->bus_lock_spinlock, flags);
ret = __spi_async(spi, message);
{
   message->spi = spi;
   message->status = -EINPROGRESS;
   return master->transfer(spi, message);
}
spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);

同步：
   message->complete = spi_complete;
   message->context = &done;

   if (!bus_locked)
       mutex_lock(&master->bus_lock_mutex);

   status = spi_async_locked(spi, message);

   if (!bus_locked)
       mutex_unlock(&master->bus_lock_mutex);

   if (status == 0) {
       wait_for_completion(&done);
       status = message->status;
   }
这里即在kernel内部完成了同步的工作，不需要像spidev那样需要自己等待完成量，使用的是bus_lock_mutex
内部与异步的调用方式一致：
spin_lock_irqsave(&master->bus_lock_spinlock, flags);
ret = __spi_async(spi, message);
spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
从这里可以看出，同步与异步没有本质差别，只是多了一个完成量的操作而已。

最终调用的函数为：master->transfer(spi, message);
这个函数将在spi master中分析。

在spi slave侧需要熟悉传输的参数的每个域的功能，才能很好的完成工作
struct spi_transfer {
   const void   *tx_buf;                   //非dma 发送地址
   void       *rx_buf;                   //非dma 读取地址
   unsigned   len;                       //tx/rx bufffer size

   dma_addr_t   tx_dma;                       //若spi_message.is_dma_mapped置位，为transfer的dma address
   dma_addr_t   rx_dma;                       //若spi_message.is_dma_mapped置位，为read的dma address

   unsigned   cs_change:1;               //传输完成后，修改cs信号
   u8       bits_per_word;                   //长度，优先覆盖spi_board_info的设置（32）
   u16       delay_usecs;                   //传输后继续传输或者cs结束传输的中间时隙
   u32       speed_hz;                       //本次传输的速度，可以优先覆盖spi_board_info里的设置

   struct list_head transfer_list;           //挂接到spi_message上的连接体
};

struct spi_message {
   struct list_head   transfers;           //transfer链

   struct spi_device   *spi;               //对应的spi设备

   unsigned       is_dma_mapped:1;       //是否启动dma功能

   void           (*complete)(void *context);   //完成后回调
   void           *context;                   //回调参数
   unsigned       actual_length;               //传输的真正长度
   int           status;                           //0，成功

   struct list_head   queue;                   //driver使用
   void           *state;
};
每个域的使用方法，这里直接看起来并不明确，必须结合master的驱动。
---------------------------------------------------------------------------------------------------------
spi master驱动
---------------------------------------------------------------------------------------------------------
SPI 设备资源：
static struct resource s3c_spi0_resource[] = {
   [0] = DEFINE_RES_MEM(S3C24XX_PA_SPI, SZ_32),
   [1] = DEFINE_RES_IRQ(IRQ_SPI0),
};

struct platform_device s3c_device_spi0 = {
   .name       = "s3c2410-spi",
   .id       = 0,
   .num_resources   = ARRAY_SIZE(s3c_spi0_resource),
   .resource   = s3c_spi0_resource,
   .dev       = {
       .dma_mask       = &samsung_device_dma_mask,
       .coherent_dma_mask   = DMA_BIT_MASK(32),
   }
};

static struct resource s3c_spi1_resource[] = {
   [0] = DEFINE_RES_MEM(S3C24XX_PA_SPI1, SZ_32),
   [1] = DEFINE_RES_IRQ(IRQ_SPI1),
};

struct platform_device s3c_device_spi1 = {
   .name       = "s3c2410-spi",
   .id       = 1,
   .num_resources   = ARRAY_SIZE(s3c_spi1_resource),
   .resource   = s3c_spi1_resource,
   .dev       = {
       .dma_mask       = &samsung_device_dma_mask,
       .coherent_dma_mask   = DMA_BIT_MASK(32),
   }
};

在此之间，走过了一些弯路学了verilog/modelsim，在之前一直不明白的事情在逐渐的尝试中获得了新的认识，
硬件的ip core的工作是由clock来驱动的，而不是软件意义上的过程，在同步时钟的上升/下降沿中进行数据处理，移位等
在SPI 的ip core设计中，主要有三个模块：
1. clock generate
2. data shift
3. register control
首先通过AP过来的系统时钟及设备能够支持的最大时钟频率，计算出对应的最接近的分频系数，而模块1就是根据这个分频系数
来通过系统的源clock产生对应的目标clock。【因为对于SPI IP不需要独立的精确的晶振】
生成了与slave同步的clock之后，输出到模块2，模块2负责具体的发送数据功能。具体的采数发数时序见第三节。
而register control则负责所有的可配置接口，如：分频系数，支持位宽，FIFO深度，支持的片选数，以及相应的MSB/LSB
设置选项。
在SPI的协议中，最大的误区在于master与slave之间的私有协议：
SPI master的本生设计中并不支持具体的传输协议，而是简单的提供了一个传输数据的通路，而协议则是由实现的slave端，以及
slave端驱动来决定的。下面来总结这个数据发送与接收的具体过程：

读指定地址： read(addr, &value, len);
1. 配置相关读取操作的寄存器
2. slave驱动封装协议CMD【描述base + addr + len + flags】
3. 拉下slave对应在master上的cs【低电平有效】
4. 发送指定位宽cmd到slave端【由master来驱动，而slave只需要发送数据到对应fifo并启动发送即可】
5. slave端接收到指定的cmd，在MISO线上回应对应的数据
6. slave驱动从master 的fifo中等待数据，当master 读取到对应的线上数据，并放于FIFO中
7. 读取到数据，拉高CS

/*make sure len is word units*/
int gps_spi_read_bytes_test3( u32 len,u32 addr,u32 *data, bool sys, u32 base){
   u32 read_cmd[2];
   local_spi_init();
   read_cmd[0] = SPI_READ_CMD(len,addr >> 2 + base);
   spi_assert_function(0);
   local_spi_write((u8*)read_cmd, 4);
   local_spi_read((u8 *)data, 4);
   spi_assert_function(1);
   return 0;
}

写指定地址： write(addr, &value, len);
int gps_spi_write_bytes_test2( u32 len,u32 addr,u32 data){
    u32 write_cmd[2],one_read;
   local_spi_init();
   write_cmd[0] = SPI_WRITE_SYS_CMD(len*1,addr >> 2);
   write_cmd[1] = data;
   spi_assert_function(0);
   local_spi_write((u8 *)write_cmd, 8);
   spi_assert_function(1);
    return 0;
}

一些读写的实现细节：
int local_spi_read(u8 *buf, u32 size){
   while (cnt < size){
       /*wait for data*/
       while (reg->sts2 & (0x1 << 5)){
           if (time_out++ > READ_TIME_OUT){
               goto read_exit;
           }
       }
       *p = (u32)reg->txd;
       p++;
       cnt += 4;
   }
   return 0;
}

int local_spi_write(u8 *buf, u32 size){
   while (cnt < size){
       /*if tx fifo is not full*/
       while (reg->sts2 & (0x1 << 6));
       writel(*p, SPRD_SPI1_BASE);
       p++;
       /*bitlen is 4*/
       cnt += 4;
   }
}
以上为master 驱动需要实现传输的一些流程
---------------------------------------------------------------------------------------------------------
spi传输时序问题
---------------------------------------------------------------------------------------------------------
主要关注两个参数：
CPOL： Clock初始电平（0：低电平，1：高电平）
CPHA：采样位置（0：第一个跳变边沿，1：第二个跳变边沿）

0/0：上升沿采样，下降沿发送
0/1：下降沿采样，上升沿发送
1/0：下降沿采样，上升沿发送
1/1：上升沿采样，下降沿发送

这里需要注意，在双工状态下，不可同沿采样及发送，必须错开。
采样的基本原理如下：
master与slave保持时钟同步，master每输出一个时钟，master输出一个数据（MOSI线），slave便响应一个数据（MISO线），在示波器上
可以看到三条线的数据交互过程。
setup time 与 hold time【假设上升沿采样】
建立时间:是指在时钟信号上升沿到来以前，数据稳定不变的时间，如果建立时间不够，数据将不能在这个时钟上升沿被打入触发器；
保持时间:是指在时钟信号上升沿到来以后，数据稳定不变的时间，如果保持时间不够，数据同样不能被打入触发器。
首先当第一个数据发送时master的寄存器首先锁住这个值，当第一个上升沿到来时,master获取数据，slave收到并Hold住固定时间，
同理如slave的数据接收.

相关问题
---------------------------------------------------------------------------------------------------------
一个由时钟倍频引起的SPI同步思考：
assign cnt_zero = cnt == {`SPI_DIVIDER_LEN{1'b0}};
assign cnt_one = cnt == {{`SPI_DIVIDER_LEN-1{1'b0}}, 1'b1};

// Counter counts half period
always @(posedge clk_in or posedge rst)
begin
    if(rst)
      cnt <= #Tp {`SPI_DIVIDER_LEN{1'b1}};
    else
      begin
        if(!enable || cnt_zero)
          cnt <= #Tp divider;
        else
          cnt <= #Tp cnt - {{`SPI_DIVIDER_LEN-1{1'b0}}, 1'b1};
      end
end

// clk_out is asserted every other half period
always @(posedge clk_in or posedge rst)
begin
    if(rst)
      clk_out <= #Tp 1'b0;
    else
      clk_out <= #Tp (enable && cnt_zero && (!last_clk || clk_out)) ? ~clk_out : clk_out;
end

当divider为3时，计算的过程为：
   |     |    |   |    |    |    |    |    |    |    |    |
-> 2 -> 1 -> 0 -> 3                    -> 2 -> 1 -> 0 -> 3
                      -> 2 -> 1 -> 0 -> 3

三线模式SPI：
用一个data线，来代替MOSI/MISO两根线,使用分时复用