基于AM335X与FPGA的SPI通讯设计

在2013年的工作中，涉及到了AM3359与XC7K325T之间的相互通信，其目的是为了获取FPGA设计版本号，该FPGA版本号保存在FPGA的寄存器0xFFFF中，FPGA的版本值随着加载程序发生变化，当时的版本信息为0x1003.

需要说明的是，在本文中的代码风格是刚工作两年的时候的代码风格，现在回看，这些代码风格实在难以阅读。尤其是SPI的verilog程序等。并不代表现在的编程水平与代码风格。

设计框图如下：



本文主要从三个方面介绍AM3359与FPGA的通讯

第一部分：SPI通信的基础定义

第二部分：AM335x的SPI通信编程

第三部分：FPGA从机SPI设计

SPI通信基础定义

通信是怎么发生

SPI接口是一种典型的全双工接口。通过同步时钟SCLK的脉冲将数据一位一位地在主机和从机之间交换。所以在开始通信之前，Master首先需要配置接口时钟，在Master配置时钟的时候，不需要通知从机它所配置的时钟频率具体是多少，设计人员只需要确保通讯频率是从机所支持的即可。

当Master通过片选信号（SS，低电平有效）选定一个Slave的时候，每向Slave发送一个周期的SCLK信号，都会有1bit的数据从MOSI引脚发送给Slave，Slave只需要在对应的引脚接收数据即可；同时，slave每收到一个周期的SCLK信号，都会从MISO想Master发送1bit的数据。



从上段描述中可以分析出一下两点：

1.无论Master还是Slave，都是按照bit来传输的，那么对于需要发送或者接收的数据，必须在Master或Slave中有一个移位寄存器，这些是由硬件来保证的，普通的SPI接口设计者不需要考虑移位寄存器的因素。

2.在通信中，Master发送数据后，一般需要保证Slave收到数据，这样才能确定数据在收发的过程中不发生因为硬件而导致的bit丢失。在SPI中，数据传输以“位交换”的方式传输，这样能根据从机返回的数据来确定从机已经收到数据了。SPI同样与其他基础通信方式（USB,I2C，UART等）一样无法确保传输数据的正确性。

SPI是一个相对比较开放的接口，具体表现在时钟极性/相位、帧大小、传输速度、LSB/MSB等规则没有一个确定的定义，需要根据不同的通信环境由设计开发者进行定义。

SPI的接口时序

在实际开发使用SPI的时候，需要注意使Master和Slave处于相同的Mode下工作。不同mode的定义主要是针对时钟的相关特性。

SCLK极性（CPOL）：clock Polarity

SCLK相位（CPHA）：clock Phase



CPOL

在解释CPOL之前先要介绍什么是SCLK的空闲时刻。在SPI通讯传输的时候，SCLK并不是时刻都有。在SCLK发送数据之前和发送数据之后，都会回到空闲状态，这个状态下，SCLK要么保持在高电平，要么保持在低电平。这个是需要设计者来指定的，CPOL的作用就是来指定SPI在IDLE状态下的点评状态。

CPOL = 0 ：时钟空闲状态（IDLE）的电平为低电平（0）。
CPOL = 1 ：时钟空闲状态（IDLE）的点评是高电平（1）。

CPHA

CPHA表示数据采样，数据有效的时刻。对应的数据采样是在第几个边沿进行采样。

CPHA = 0 ：在时钟第一个边沿采样。
对于CPOL = 0 ：因为IDLE为低电平，那么第一个边沿就是从低电平到高电平，即为上升沿。
对于CPOL = 1 ：因为IDLE为高电平，那么第一个边沿就是从高电平到低电平，即为下降沿。

CPHA = 1 ：在时钟第二个边沿采样。
对于CPOL = 0 ：因为IDLE为低电平，那么第二个边沿就是从高电平到低电平，即为下降沿。
对于CPOL = 1 ：因为IDLE为高电平，那么第二个边沿就是从低电平到高电平，即为上升沿。



需要注意的是：采样一定是需要先准备好数据，才用时钟的有效沿将数据打到对应的引脚上。

Mode选择参考

SPI没有一个通用的推荐模式，但是基于工程设计的时候是否有一个推荐的Mode选择呢？在CSDN博友的一篇《SPI接口扫盲 SPI定义/SPI时序（CPHA CPOL）》中，作者从功耗的角度分析，建议应该多选择SCLK在空闲状态下处于低电平，即CPOL保持在IDLE状态下为0。这是一个很好的分析方法。对于CPHA的选择分析，我更赞成根据实际的应用来做设计，而不是根据习惯来设计。

AM335x的SPI通信编程

在本工程中所使用的SPI为AM335x的SPI外设，即在Linux下，只需要对spidev进行文件操作。所用到的文件操作函数有以下四个：

open()

write()

read()

close()

相关的函数说明，请参考网络，在此不赘述。

在编写SPI驱动的时候，还需用到ioctl()函数，下面对ioctl做一些简要介绍。

什么是ioctl

ioctl是设备驱动程序中对设备的IO通道进行管理的函数。即是对设备的一些特性进行控制，例如对串口设备设置波特率，对SPI设备设置字长，通讯速率等。函数的调用方式如下：

int ioctl(int fd,unsigned long cmd,...);
/*
fd:文件描述符
cmd:控制命令
fecc
...:可选参数:插入*argp，具体内容依赖于cmd
*/

其中fd是用户程序打开设备是使用open()函数返回的文件标识符（句柄），cmd是用户程序对设备的控制命令，后面的省略号，表示该函数可能还有其他参数，该参数与cmd相关。

对于ioctl的详细描述，可以参考文末链接1来详细阅读。

AM335x驱动程序源码设计

static uint8_t  mode  = 0;
static uint8_t  bits  = 8;
static uint32_t speed = 16000000;
static uint8_t  cs    = 1;

int fpga_fd = 0;
uint8_t  file_name_buf[FILE_NAME_MAX] = "/dev/spidev2.1";
//==
int fpga_config(uint8_t  *file_name)
{
if (strlen(file_name) > FILE_NAME_MAX)
{
printf("File name length error\r\n");
return 0;
}
strcpy(file_name_buf, file_name);
return 1;
}

int fpga_spi_open(uint8_t  *file_name)
{
int ret = 0;
fpga_fd = open(file_name, O_RDWR);
if (fpga_fd < 0)
{
printf("in fpga_spi_open, can't open device\r\n");
return nQAM_ERROR_CAS_SPI_OPEN;
}
else
{
printf("in fpga_spi_open, open device success\r\n");
}
/*
* spi mode
*/
ret = ioctl(fpga_fd, SPI_IOC_WR_MODE, &mode);
if (ret == -1)
{
printf("in fpga_spi_open, can't set spi mode\r\n");
return nQAM_ERROR_CAS_SPI_CONFIG;
}
else
{
printf("in fpga_spi_open, set spi mode success\r\n");
}
/*
* bits per word
*/
ret = ioctl(fpga_fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
if (ret == -1)
{
printf("in fpga_spi_open, can't set bits per word\r\n");
return nQAM_ERROR_CAS_SPI_CONFIG;
}
else
{
printf("in fpga_spi_open, set bits per word success\r\n");
}
/*
* max speed hz
*/
ret = ioctl(fpga_fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
if (ret == -1)
{
printf("in fpga_spi_open, can't set max speed hz\r\n");
return nQAM_ERROR_CAS_SPI_CONFIG;
}
else
{
printf("in fpga_spi_open, set max speed success\r\n");
}
/*
* chip select
*/
ret = ioctl(fpga_fd,SPI_IOC_WR_CHIP_SELECT,&cs);
if(ret == -1)
{
printf("in fpga_spi_configure,can't set chip  select\r\n");
return nQAM_ERROR_CAS_SPI_CONFIG;
}
return nQAM_ERROR_NOERROR;
}

int fpga_spi_close()
{
return close(fpga_fd);	// close device
}
//数据交换
uint8_t transfer(uint8_t data)
{
uint8_t sbuf = data;
if(write(fpga_fd,&sbuf,1) != -1)
{
if(read(fpga_fd, &sbuf, 1) != -1)
{
printf("In transfer, transfer data over\r\n");
return sbuf;
}
else
{
printf("In transfer, read data from spi device failed!\r\n");
}
}
else
{
printf("In transfer, write data to spi device failed!\r\n");
}
return 0;
}
//通过SPI获取版本号
uint8_t get_fpga_version()
{
uint8_t buf;
if(fpga_spi_open(file_name_buf) != nQAM_ERROR_NOERROR)
{
printf("in get_fpga_vesion, fpga spi open failed\r\n");
return 0;
}
buf = transfer(READ_VESION);
fpga_spi_close();
printf("Read version done.\r\n");
return buf;
}
//测试物理连接状态
uint8_t test_fpga_connect()
{
uint8_t buf;
if(fpga_spi_open(file_name_buf) != nQAM_ERROR_NOERROR)
{
printf("in test_spi_open, fpga spi open failed\r\n");
return 0;
}
buf = transfer(TEST_CONNECT);
fpga_spi_close();
printf("FPGA spi test connect done.\r\n");
return buf;
}

附：spidev的ioctl命令。

SPI_IOC_RD_MODE：               读取spi_device的mode。

SPI_IOC_RD_LSB_FIRST：            如果是SPI_LSB_FIRST的方式则返回1。

SPI_IOC_RD_BITS_PER_WORD：         读取spi_device的bits_per_word.

SPI_IOC_RD_MAX_SPEED_HZ：          读取spi_device的max_speed_hz.

SPI_IOC_WR_MODE：               设置spi_device的mode，并调用spi_setup立即使设置生效。

SPI_IOC_WR_LSB_FIRST：            设置spi使用SPI_LSB_FIRST的传输模式。立即生效。

SPI_IOC_WR_BITS_PER_WORD：         读取字长。

SPI_IOC_WR_MAX_SPEED_HZ：          设置时钟速率。

AM335x应用程序设计

int main(int argc, char *argv )
{
uint8_t connect;
uint8_t version;
connect = test_fpga_connect();
printf("Test Value is %02X\r\n", connect); //测试连接状态

version = get_fpga_version();
printf("the fpga version is %02X\r\n", version);

printf("****fpga app test run over!****\r\n");
return 1;
}

FPGA从机SPI设计

SPI从机的Verilog实现

module spi_slave(clk,rst,data_i,wr_en_i,data_o,tx_valid,valid_o,start_o,end_o,we_ack_o,ss_i,sclk_i,mosi_i,miso_o
);

input                 clk;          // master clock input
input                 rst;          // synchronous active high reset
input   [7:0]         data_i;       // data bus input
input                 wr_en_i;      // write enable input
output  [7:0]         data_o;       // data bus output

output                valid_o;      // request signal output
output                tx_valid;
output                start_o;
output                end_o;
output  reg           we_ack_o;

//spi signals
input                 ss_i;         // slave select
input                 sclk_i;       // serial clock
input                 mosi_i;
output                miso_o;

reg     [7:0]         tx_data;
reg     [7:0]         rx_data;

reg                   tx_tip;       //tx in progress
reg                   rx_tip;       //rx in progress

wire                  rx_negedge;   //miso is sampled on negative edge
wire                  tx_negedge;   //mosi is driven on nesedge edge
wire    [2:0]         len;          //char length
wire                  lsb;          //lsb first on line

wire                  pos_edge;     //recognize posedge of sclk
wire                  neg_edge;     //recognize negdege of sclk

reg                   s_out;
reg                   s_in;
reg     [2:0]         s_sel;
reg     [2:0]         s_clk;

assign    rx_negedge  = 0;            // decided by CPOL and CPHA
assign    tx_negedge  = 1;            // means mode == 00
assign    len         = 7;
assign    lsb         = 0;

assign    miso_o      = s_out;
assign    valid_o     = rst?  1'b0  : (!rx_tip);
assign    data_o      = rst?  8'h00 : rx_data;

//sync SCK to the FPGA clock using a 3-bits shift register
always @ (posedge clk)
begin
s_clk <= {s_clk[1:0], sclk_i};  //sample the sclk_i using clk,when finding the first posedge the value is 001,when finding the first negedge the value is 110 or 010
end

assign pos_edge       =   (s_clk[1:0] == 2'b01);      // posedge when s_clk[1:0] == 2'b01 or s_clk[2:0] = 3'b001
assign neg_edge       =   (s_clk[1:0] == 2'b10);      // negedge when s_clk[1:0] == 2'b10 or s_clk[2:0] = 3'b110

//SSEL
always @ (posedge clk)
begin
s_sel <= {s_sel[1:0], ss_i};    //sample the ss signal
end

wire                  sel_active;                     // from start_o is high to end_o is high sel_active is active
assign sel_active     =   ~s_sel[1];                  // sel[2:0] = 000 001 011 111 110 100 000 when 100 000 001 .0 is high
assign start_o        =   (s_sel[1:0] == 2'b10);      // start_o when s_sel[1:0] = 2'b10 or s_sel[2:0]= 3'b110
assign end_o          =   (s_sel[2:1] == 2'b01);      // end_o when s_sel[2:1] = 2'b01 or s_sel[2:0] = 3'b011

//---------------------receiving bits from line---------------------
wire                  rx_clk;
wire                  rx_lst_bit;
reg   [2:0]           rx_cnt;                         // rx data bit count

assign rx_clk         =   rx_negedge? neg_edge : pos_edge;    // question is the beginning value is "X"
assign rx_lst_bit     = !(|rx_cnt);

always @(posedge clk)
begin
s_in  <=  mosi_i;
end

always @(posedge clk or posedge rst)
begin
if (rst)
rx_cnt <= len;
else begin
if(!rx_tip || end_o || start_o)
rx_cnt  <=  len;
else
rx_cnt  <=  rx_clk ? (rx_cnt - 1'b1) : rx_cnt;        //question is the rx_cnt always is 7?
end
end

//Transfer in process
always @(posedge clk or posedge rst)
begin
if(rst)
rx_tip  <= 1'b0;
else if(!rx_tip)
rx_tip  <= 1'b1;
else if(rx_tip && rx_lst_bit && rx_clk)
rx_tip  <= 1'b0;
end

always @(posedge clk or posedge rst)
begin
if(rst)
rx_data <= {8{1'b0}};
else begin
if(sel_active && rx_clk)
rx_data <= lsb ? {s_in,rx_data[7:1]} : {rx_data[6:0],s_in}; // if lsb = 0 rx_data = {rx_data[6:0],s_in}
// if lsb = 1 rx_data = {s_in,rx_data[7:1]}
end                                           // {s_in,rx_data[7:1]} shift right
end                                             // {rx_data[6:0],s_in} shift left

//---------------------sending bits to line---------------------
wire                  tx_clk;
wire                  tx_lsb_bit;
reg [2:0]             tx_cnt;
assign tx_clk         =   tx_negedge? neg_edge : pos_edge;        // tx_negedge = 1 negedge transfer data
assign tx_lsb_bit     = !(|tx_cnt);
assign tx_valid       = ((s_sel[2:0] == 3'b111) && (tx_tip == 1'b0)) ? 1'b1 : 1'b0;

//  always @(posedge clk or posedge rst)
//  begin
//    if(rst)
//      tx_valid  <=  1'b0;
//    else if((s_sel[2:0] == 3'b111) && (tx_tip == 1'b0))
//      tx_valid  <=  1'b1;
//    else
//      tx_valid  <=  1'b0;
//  end
// character bit counter
always @(posedge clk or posedge rst)
begin
if(rst)
tx_cnt  <= len;
else begin
if(!tx_tip || end_o || start_o)
tx_cnt  <= len;
else
tx_cnt  <= tx_clk? (tx_cnt-1'b1):tx_cnt;
end
end

//transfer in process
always @(posedge clk or posedge rst)
begin
if(rst) begin
tx_tip  <= 1'b0;
end
else if(wr_en_i && (!tx_tip)) begin               //wr_en_i is high when transfer the data
tx_tip  <= 1'b1;
end
else if(tx_tip && tx_lsb_bit && tx_clk) begin
tx_tip  <= 1'b0;
end
end

always @(posedge clk or posedge rst)
begin
if(rst) begin
tx_data <= 8'hff;
we_ack_o  <=  1'b0;
end
else begin
we_ack_o <= 1'b0;
if(wr_en_i && (!tx_tip)) begin
tx_data[7:0]  <=  data_i[7:0];
we_ack_o  <= 1'b1;
end
else begin
if(sel_active && rx_clk) begin
s_out <=  lsb?  tx_data[0] : tx_data[7];
tx_data <= lsb? {1'b1,tx_data[7:1]} : {tx_data[6:0],1'b1};
end
end
end
end
endmodule

FPGA的SPI command verilog设计

`timescale 1 ns / 1 ps
module spi_cmd #(
parameter   BUS_DATA_WIDTH            = 8,
parameter   BUS_ADDR_WIDTH            = 16
)(
input                                 clk,
input                                 rst,
input       [BUS_DATA_WIDTH-1:0]      rx_data,
input                                 rx_valid,
input                                 rx_start,
input                                 rx_end,
input                                 tx_valid,

input                                 tx_ack,
output  reg [BUS_DATA_WIDTH-1:0]      tx_data,
output  reg                           tx_req
);

localparam    CON_WR_REG              = 8'h51;
localparam    CON_RD_REG              = 8'h52;
localparam    RD_DATA_REG             = 8'h96;
localparam    RST_CMD                 = 8'h55;

localparam    ADDR_FPGA_VERSION       = 16'hFFFF;
localparam    ADDR_SPI_TEST           = 16'hF000;
localparam    FPGA_VERSION            = 16'h1003;

localparam    REC_NO_ERR              = 8'h90;
localparam    REC_INS_ERR             = 8'hF1;
localparam    REC_LEN_ERR             = 8'hF2;
localparam    REC_BUSY_ERR            = 8'hF3;
localparam    REC_WR_ERR              = 8'hF4;

localparam    REC_START               = 1;
localparam    REC_TYPE_REG            = 2;
localparam    REC_ADDR_REGH           = 3;
localparam    REC_ADDR_REGL           = 4;
localparam    REC_ADDR_LEN            = 5;
localparam    REC_CON_WRH             = 6;
localparam    REC_CON_WRL             = 7;
localparam    RSP_STATUS              = 8;
localparam    RSP_LEN                 = 9;
localparam    RSP_DIN                 = 10;
localparam    RSP_DOUT                = 11;
localparam    READ_DATAH              = 12;
localparam    READ_DATAL              = 13;
localparam    READ_DONE               = 14;

reg   [7:0]                           rec_type;
reg   [15:0]                          rec_addr;
reg   [7:0]                           addr_len;
reg   [7:0]                           len_count;
reg   [3:0]                           cmd_state;
reg   [7:0]                           err_code;
reg   [15:0]                          rsp_dout;
reg                                   rsp_rd;
reg   [15:0]                          spi_test;
reg   [3:0]                           test_flag;

always@(posedge clk or posedge rst)
begin
if(rst) begin
rec_type          <=  0;
rec_addr          <=  0;
addr_len          <=  0;
len_count         <=  0;
err_code          <=  REC_NO_ERR;
tx_data           <=  0;
tx_req            <=  0;
rsp_rd            <= 1'b0;
cmd_state         <=  REC_START;
test_flag         <=  4'h0;
end
else begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
case(cmd_state)
REC_START : begin
len_count   <=  0;
if(rx_start) begin
cmd_state <=  REC_TYPE_REG;
test_flag <=  4'h1;
end
end
REC_TYPE_REG : begin
if(rx_valid) begin
case(rx_data)
CON_WR_REG, CON_RD_REG : begin
err_code    <=  REC_NO_ERR;
rec_type    <=  rx_data;
cmd_state   <=  REC_ADDR_REGH;
test_flag   <=  4'h2;
end
RD_DATA_REG : begin
cmd_state   <=  RSP_STATUS;
test_flag   <=  4'h6;
end
default : cmd_state <=  REC_START;
endcase
end
end

REC_ADDR_REGH : begin
if(rx_valid) begin
rec_addr[15:8]  <=  rx_data;
cmd_state   <=  REC_ADDR_REGL;
test_flag   <=  4'h3;
end
end
REC_ADDR_REGL : begin
if(rx_valid) begin
rec_addr[7:0] <=  rx_data;
cmd_state   <=  REC_ADDR_LEN;
test_flag   <=  4'h4;
end
end

REC_ADDR_LEN : begin
if(rx_valid) begin
if(rx_data != 0) begin
addr_len    <=  rx_data;
test_flag <=  4'h5;
case(rec_type)
CON_WR_REG : cmd_state  <=  REC_CON_WRH;
CON_RD_REG : cmd_state  <=  REC_START;
default : cmd_state <=  REC_START;
endcase
end
else begin
err_code  <=  REC_LEN_ERR;
cmd_state <=  REC_START;
end
end
end
REC_CON_WRH : begin
if(len_count == addr_len) begin
cmd_state <=  REC_START;
end
else begin
if(rx_valid) begin
if(rec_addr == ADDR_FPGA_VERSION) begin
err_code  <=  REC_WR_ERR;
cmd_state <=  REC_START;
end
else if(rec_addr == ADDR_SPI_TEST) begin
spi_test[15:8]  <=  rx_data;
end
//              else begin
//                rec_buf_data[15:8]  <=   rx_data;
//              end
cmd_state <=  REC_CON_WRL;
end
end
end
REC_CON_WRL : begin
if(rx_valid) begin
if(rec_addr == ADDR_SPI_TEST) begin
spi_test[7:0] <=  rx_data;
end
//            else begin
//              rec_buf_data[7:0] <=  rx_data;
//              rec_addr  <=  rec_addr + 1'b1;
//            end
len_count <=  len_count + 1'b1;
end
end

RSP_STATUS : begin
if(tx_valid) begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
else begin
tx_req  <=  1'b1;
end
rsp_rd    <=  1'b1;
tx_data   <=  err_code;
cmd_state <=  RSP_LEN;
test_flag <=  4'h7;
end
end

RSP_LEN : begin
if(tx_valid) begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
else begin
tx_req  <=  1'b1;
end
case(rec_type)
CON_WR_REG : begin
tx_data   <=  0;
cmd_state <=  REC_START;
end
CON_RD_REG : begin
tx_data   <=  addr_len;
cmd_state <=  RSP_DIN;
end
default : begin
tx_data   <=  0;
cmd_state <=  REC_START;
end
endcase
test_flag <=  4'h8;
end
end

RSP_DIN : begin
if(tx_valid) begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
else begin
tx_req  <=  1'b1;
end
if(len_count == addr_len) begin
cmd_state <=  READ_DONE;
end
else begin
cmd_state <=  RSP_DOUT;
rsp_rd    <=  1'b0;
end
test_flag <=  4'h9;
end
end

RSP_DOUT : begin
if(tx_valid) begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
else begin
tx_req  <=  1'b1;
end
cmd_state <=  READ_DATAH;
end
end

READ_DATAH : begin
if(tx_valid) begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
else begin
tx_req  <=  1'b1;
end
tx_data   <=  rsp_dout[15:8];
cmd_state <=  READ_DATAL;
test_flag <=  4'hA;
end
end
READ_DATAL : begin
if(tx_valid) begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
else begin
tx_req  <=  1'b1;
end
tx_data   <=  rsp_dout[7:0];
len_count <=  len_count + 1'b1;
cmd_state <=  RSP_DIN;
test_flag <=  4'hB;
end
end

READ_DONE : begin
if(tx_valid) begin
if(tx_ack) begin
tx_req  <=  1'b0;
end
else begin
tx_req  <=  1'b1;
end
tx_req    <= 1'b0;
len_count <=  0;
tx_data   <=  0;
rec_type    <=  0;
cmd_state <=  REC_START;
end
end
endcase
end
end

always @(posedge clk or posedge rst)
begin
if(rst == 1'b1)
begin
rsp_dout  <=  {16{1'b0}};
end
else if((rsp_rd == 1'b1) && (test_flag  ==  4'h7)) begin
case(rec_addr)
ADDR_FPGA_VERSION : rsp_dout  <=  FPGA_VERSION;
ADDR_SPI_TEST :   rsp_dout  <=  ~spi_test;
default : ;
endcase
end
end

endmodule

以上项目总结仅作参考，适用于本公司后继者对此工程的修改参考。

链接1 ：点击打开链接