串口控制器及驱动实现

已于 2024-04-13 15:00:22 修改
阅读量1k 收藏 19
点赞数 22
分类专栏： linux驱动开发经验 FPGA 文章标签： fpga开发 驱动开发
于 2024-01-04 17:17:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37812160/article/details/135390260
版权

UART控制器及驱动的实现

verilog新手一枚～本文讲述uart控制器及驱动的实现，并在zynq7020平台进行实验验证。文中附带verilog实现的uart控制器全部源码，附带linux驱动关键部分源码

开发环境

开发板ZYNQ PI extend R2 2022A版 （zynq7020）
开发主机Win11 and ubuntu20.04
IDE版本Xilinx Vitis IDE v2021.1.0 (64-bit) Vivado v2021.1 (64-bit)
uboot源码Xilinx官方
linux源码Xilinx官方

使用verilog实现UART控制器

UART原理

在这里插入图片描述

  • 8位数据，起始位低，结束位高
  • 在中间稳定位置进行数据采样
  • 检测到下降沿记作起始开始

发送模块实现

设计状态机如下：

  • counter0为波特率计数器
  • counter1为发送位数计数器
  • 检测到send_go上升沿，开始发送数据
  • 第一个always块中进行状态切换
  • 第二个always块中执行状态动作
module uart_send_byte(
    input wire rstn,                /* 复位 */
    input wire clk,                 /* 时钟 */
    input wire[19:0] baud_rate,     /* 波特率 */
    input wire send_go,             /* 开始发送 */
    input wire[7:0] byte,           /* 发送字节 */
    output reg tx,                  /* tx信号 */
    output reg tx_down              /* 发送完成 */
    );

parameter SYS_CLK = 100_000_000;
parameter MCNT1 = 8;

parameter STATE_IDLE	= 2'b00;    /* 空闲状态 */
parameter STATE_START	= 2'b01;    /* 发送起始位 */
parameter STATE_DATA	= 2'b10;    /* 发送数据 */
parameter STATE_STOP	= 2'b11;    /* 发送结束位 */

reg[31:0] counter0;                 /* 波特率计数 */
reg[3:0] counter1;                  /* 字节计数 */
reg[1:0] state;                     /* 状态 */

initial begin
    counter0 <= 0;
    counter1 <= 0;
    state <= STATE_IDLE;
    tx <= 1;
end

reg en_data0;
reg en_data1;
wire en_posedge;
/* 检测send_go信号 */
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        en_data0 <= 0;
        en_data1 <= 0;
    end
    else begin
        en_data0 <= send_go;
        en_data1 <= en_data0;
    end
end

assign en_posedge = en_data0 & (~en_data1);

/* 波特率计数器 */
always @(posedge clk or negedge rstn) begin
    if (!rstn)
        counter0 <= 0;
    else if(counter0 == (SYS_CLK / baud_rate) - 1)
        counter0 <= 0;
    else if (state == STATE_IDLE)
        counter0 <= 0;
    else
        counter0 <= counter0 + 1;
end

/* 发送位计数器 */
always @(posedge clk or negedge rstn) begin
    if (!rstn)
        counter1 <= 0;
    else if (counter0 == (SYS_CLK / baud_rate) - 1) begin
        if(counter1 == MCNT1 - 1)
            counter1 <= 0;
        else if (state == STATE_DATA)
            counter1 <= counter1 + 1;
        else
            counter1 <= 0;
    end
    else
        counter1 <= counter1;
end

/* 切换状态 */
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        state <= STATE_IDLE;
        tx_down <= 1;
    end
    else begin
        case (state)
        STATE_IDLE:
            if (en_posedge) begin
                tx_down <= 0;
                state <= STATE_START;
            end
        STATE_START: begin
            if (counter0 == (SYS_CLK / baud_rate) - 1)
                state <= STATE_DATA;
        end
        STATE_DATA:
            if (counter1 == MCNT1 - 1 && counter0== (SYS_CLK / baud_rate) - 1)
                state <= STATE_STOP;
        STATE_STOP:
            if (counter0 == (SYS_CLK / baud_rate) - 1) begin
                state <= STATE_IDLE;
                tx_down <= 1;
            end
        endcase
    end
end

/* 执行状态 */
always @(posedge clk or negedge rstn) begin
    if (!rstn)
        tx <= 1;
    else
        case (state)
        STATE_IDLE:
            tx <= 1;
        STATE_START: begin
            tx <= 0;
        end
        STATE_DATA:
            tx <= byte[counter1];
        STATE_STOP: begin
            tx <= 1;
        end
        endcase
end

endmodule

接收模块实现

设计状态机如下：

  • counter0为波特率计数器
  • counter1为接收字节计数器
  • DETECT_START状态下，检测到下降沿进入START_CHECK
  • START_CHECK成功进行READ_DATA，否则继续DETECT_START
  • READ_DATA完毕进入STOP_CHECK
  • STOP_CHECK成功拉高down，否则拉高err
/* 对于强干扰的环境，UART的接收需要进行16倍过采样；取中间789三次结果，两次以上为1则为1，两次以上为0则为0
 * 异步信号（使用两个时钟）容易出现亚稳态：
 * 什么是亚稳态：D触发器输入信号在数据窗口期内发生变化，会导致输出进入亚稳态，可能发送震荡，并最终随机稳定在高电平或者低电平
 * 亚稳态的存在可能会影响其他逻辑对该信号值的判断
 * 通过2级或者更多的D触发器打拍的方式，降低亚稳态的传播，让后续逻辑使用的该信号正常
 * 100MHz时钟时，第一级D触发器有出现亚稳态的可能，第二级D触发器出现亚稳态的概率很小，第三级D触发器出现亚稳态概率非常小
 */

module uart_read_byte(
    input wire rstn,                /* 复位 */
    input wire clk,                 /* 时钟 */
    input wire rx,                  /* rx信号 */
    input wire[19:0] baud_rate,     /* 波特率 */
    output reg rx_down,             /* rx一字节完成 */
    output reg[7:0] data,           /* 接收的数据 */
    output reg err                  /* 接收错误 */
    );

parameter SYS_CLK = 100_000_000;
parameter MCNT1 = 8;

parameter STATE_DETECT_START = 0;   /* 检测起始位下降沿 */
parameter STATE_START_CHECK = 1;    /* 校验起始位电平是否正确 */
parameter STATE_READ_DATA = 2;      /* 读取数据 */
parameter STATE_STOP_CHECK = 3;     /* 检验结束位 */

reg[31:0] counter0;                 /* 波特率计数 */
reg[2:0] counter1;                  /* 接收字节计数 */
reg[1:0] state;                     /* 接受状态 */
reg[7:0] temp_data;                 /* 存储接收数据 */
reg rx_temp;                        /* 存储rx的值 */

/* 波特率计数 */
always @(posedge clk or negedge rstn) begin
    if (!rstn)
        counter0 <= 0;
    else if (state == STATE_DETECT_START)
        counter0 <= 0;
    else if (counter0 == (SYS_CLK / baud_rate) - 1)
        counter0 <= 0;
    else
        counter0 <= counter0 + 1;
end

/* 接收位计数 */
always @(posedge clk or negedge rstn) begin
    if (!rstn)
        counter1 <= 0;
    else if (state == STATE_READ_DATA)
        if (counter0 == (SYS_CLK / baud_rate) - 1)
            if (counter1 == MCNT1 - 1)
                counter1 <= 0;
            else
                counter1 <= counter1 + 1;
        else
            counter1 <= counter1;
    else
        counter1 <= 0;
end

reg[2:0] start_data;
wire start_negedge;
/* 检测下降沿起始位，打2拍防止亚稳态 */
always @(posedge clk or negedge rstn) begin
    if (!rstn)
        start_data <= 0;
    else
        if (state == STATE_DETECT_START) begin
            start_data[0] <= rx;
            start_data[2:1] <= start_data[1:0];
        end
        else begin
            start_data <= 0;
        end
end

assign start_negedge = start_data[2] & (~start_data[1]);

/* 状态判断 */
always @(posedge clk or negedge rstn) begin
    /* rstn中尽量减少非必须的复位赋值，有利于综合布线 */
    if (!rstn)
        state <= STATE_DETECT_START;
    else
        case (state)
        STATE_DETECT_START:
            if (start_negedge)
                state <= STATE_START_CHECK;
        STATE_START_CHECK:
            if (counter0 == (SYS_CLK / baud_rate) / 2)
                rx_temp <= rx;
            else if (counter0 == (SYS_CLK / baud_rate) - 1) begin
                if (rx_temp == 0)
                    state <= STATE_READ_DATA;
                else
                    state <= STATE_DETECT_START;
            end
            else
                state <= STATE_START_CHECK;
        STATE_READ_DATA:
            if (counter1 == MCNT1 - 1 && counter0 == (SYS_CLK / baud_rate) - 1)
                state <= STATE_STOP_CHECK;
        STATE_STOP_CHECK:
            if (counter0 == (SYS_CLK / baud_rate) / 2)
                state <= STATE_DETECT_START;
        endcase
end

/* 状态执行 */
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        rx_down <= 0;
        data <= 0;
        err <= 0;
    end
    else
        case (state)
        STATE_DETECT_START: 
            temp_data <= 0;
        STATE_START_CHECK: begin
            rx_down <= 0;
            err <= 0;
        end
        STATE_READ_DATA:
            if (counter0 == (SYS_CLK / baud_rate) / 2)
                temp_data[counter1] <= rx;
        STATE_STOP_CHECK:
            /* 停止位只使用一半的时间，提前进行检测起始位，防止因为频率误差导致起始位未检测到 */
            if (counter0 == (SYS_CLK / baud_rate) / 2) begin
                err <= rx ? 0 : 1;
                rx_down <= 1;
                data <= temp_data;
            end
        endcase
end

endmodule

增加接收fifo

  • 增加位宽8，深度32的fifo
  • uart_read_byte的rx_down上升沿时将数据写入
module uart_read_fifo(
    input rstn,
    input clk,
    input en,
    input wire[19:0] baud_rate, /* 波特率 */
    input fifo_rd_en,
    output wire[7:0] rx_date,
    input rx,
    output wire[4:0] rx_fifo_count,
    output wire[3:0] rx_fifo_state,
    output rx_ack
    );

wire rx_down;
wire rx_err;
wire[7:0] rx_date_temp;

/* 检测rx_down上升沿 */
reg[1:0] rx_down_data;
wire read_posedge;
always @(negedge clk or negedge rstn) begin
    if (!rstn)
        rx_down_data <= 0;
    else begin
        rx_down_data[0] <= rx_down;
        rx_down_data[1] <= rx_down_data[0];
    end
end

assign read_posedge = rx_down_data[0] & (~rx_down_data[1]);

fifo_generator fifo_generator_uart_rx(
    .clk(clk),
    .srst(~rstn),
    .din(rx_date_temp),
    .wr_en(read_posedge && (~rx_err) && en),
    .rd_en(fifo_rd_en),
    .dout(rx_date),
    .full(rx_fifo_state[3]),
    .almost_full(rx_fifo_state[2]),
    .wr_ack(rx_ack),
    .empty(rx_fifo_state[1]),
    .almost_empty(rx_fifo_state[0]),
    .data_count(rx_fifo_count)
);

uart_read_byte uart_read_byte_obj0(
    .rstn(rstn),
    .clk(clk),
    .rx(rx),
    .baud_rate(baud_rate),
    .rx_down(rx_down),
    .data(rx_date_temp),
    .err(rx_err)
    );

endmodule

增加发送fifo

  • 增加位宽8，深度32的fifo
  • 通过状态机，将fifo中的数据通过uart_send_byte模块发送
module uart_send_fifo(
    input rstn,
    input clk,
    input en,
    input wire[19:0] baud_rate,     /* 波特率 */
    input fifo_wr_en,
    input wire[7:0] tx_date,
    output tx,
    output wire[4:0] tx_fifo_count,
    output wire[3:0] tx_fifo_state
    );

parameter STATE_WAIT_DATA = 0;      /* 等待FIFO中有数据 */
parameter STATE_START_SEND = 1;     /* 开始发送数据 */
parameter STATE_WAIT_SEND = 2;      /* 等待发送完成 */
parameter STATE_READ_FIFO = 3;      /* 读FIFO中的数据 */

reg[1:0] state;
wire tx_down;
reg rd_en_reg;
reg sd_go_reg;
wire[7:0] dout;

/* 判断状态 */
always @(posedge clk or negedge rstn) begin
    if (!rstn)
        state <= STATE_WAIT_DATA;
    else begin
        case (state)
        STATE_WAIT_DATA: begin
            /* fifo不为空 */
            if (tx_fifo_state[1] == 0)
                state <= STATE_READ_FIFO;
        end
        STATE_READ_FIFO:
                state <= STATE_START_SEND;
        STATE_START_SEND:
            if (tx_down == 0)
                state <= STATE_WAIT_SEND;
        STATE_WAIT_SEND:
            if (tx_down == 1)
                state <= STATE_WAIT_DATA;
        endcase
    end
end

/* 执行状态 */
always @(posedge clk or negedge rstn) begin
    if (!rstn) begin
        rd_en_reg <= 0;
        sd_go_reg <= 0;
    end
    else begin
        case (state)
        STATE_WAIT_DATA:
            ;
        STATE_READ_FIFO:
            rd_en_reg <= 1;
        STATE_START_SEND: begin
            rd_en_reg <= 0;
            sd_go_reg <= 1;
        end
        STATE_WAIT_SEND: begin
            sd_go_reg <= 0;
            rd_en_reg <= 0;
        end
        
        endcase
    end
end

fifo_generator fifo_generator_uart_tx(
    .clk(clk),
    .srst(~rstn),
    .din(tx_date),
    .wr_en(fifo_wr_en && en),
    .rd_en(rd_en_reg),
    .dout(dout),
    .full(tx_fifo_state[3]),
    .almost_full(tx_fifo_state[2]),
    .empty(tx_fifo_state[1]),
    .almost_empty(tx_fifo_state[0]),
    .data_count(tx_fifo_count)
);

uart_send_byte uart_send_byte_obj0(
    .rstn(rstn),
    .clk(clk),
    .baud_rate(baud_rate),
    .send_go(sd_go_reg),
    .byte(dout),
    .tx(tx),
    .tx_down(tx_down)
    );

endmodule

优化中断

  • 为减少CPU中断开销，当串口接收到多个包，只上报一次中断
  • 包个数不够产生中断时，上报超时中断
module interrupt(
  input rstn,
  input clk,
  input pkg_ack,
  input[14:0] item_num,
  input[15:0] time_out,
  input period,
  output irq
);

parameter SYS_CLK = 100_000_000;
reg[14:0] counter0;
reg[31:0] counter1;
reg irq_reg;

/* pkg_ack计数 */
always @(negedge clk or negedge rstn) begin
  if (!rstn)
    counter0 <= 0;
  else if (counter1 == ((SYS_CLK / 1_000_000) * time_out) - 1 || counter0 == item_num - 1)
    counter0 <= 0;
  else if (pkg_ack)
      counter0 <= counter0 + 1;
    else
      counter0 <= counter0;
end

/* 定时器，控制timeout */
always @(posedge clk or negedge rstn) begin
  if (!rstn)
    counter1 <= 0;
  else if (counter0 || period) begin
    if (counter1 == ((SYS_CLK / 1_000_000) * time_out) - 1 || counter0 == item_num - 1)
      counter1 <= 0;
    else
      counter1 <= counter1 + 1;
  end
  else
    counter1 <= 0;
end

/* 输出中断 */
always @(posedge clk) begin
  if (counter1 == ((SYS_CLK / 1_000_000) * time_out) - 1 || counter0 == item_num - 1) begin
    irq_reg <= 1;
  end
  else
    irq_reg <= 0;
end

assign irq = irq_reg;

endmodule

使用Xillybus Lite连接PL & PS

Xillybus Lite 是一个简单的套件，用于通过在 Linux 下运行的 user space 程序轻松访问 logic fabric ( PL ) 中的 registers

Xillybus IP使用

Xillybus Lite读写时序如下：
在这里插入图片描述
Xillybus Lite连接如下：
在这里插入图片描述

xillybus读写及寄存器定义

  • 增加一个程序版本寄存器，方便核对程序版本
  • uart控制器寄存器依次为：
    • 0x00 串口使能寄存器
    • 0x04 串口读写控制寄存器
    • 0x08 串口数据寄存器
    • 0x0c 串口发送波特率寄存器
    • 0x10 串口发送fifo数据个数寄存器
    • 0x14 串口发送fifo状态寄存器
    • 0x18 串口接收波特率寄存器
    • 0x1c 串口接收fifo数据个数寄存器
    • 0x20 串口接收fifo状态寄存器
    • 0x24 串口中断控制寄存器
module xillybus_rw(
  input wire rstn,
  input wire user_clk,
  input wire [31:0]user_addr,
  input wire [31:0]user_wren,
  input wire user_rden,
  output reg [31:0]user_rd_data,
  input wire [31:0]user_wr_data,
  input wire [3:0]user_wstrb,
  output wire uart_tx,
  input wire uart_rx,
  output wire[7:0] led,
  output wire irqf2p_0,
  output wire irqf2p_1,
  output wire irqf2p_10,
  output wire irqf2p_11,
  output wire irqf2p_12,
  output wire irqf2p_13,
  output wire irqf2p_14,
  output wire irqf2p_15,
  output wire irqf2p_2,
  output wire irqf2p_3,
  output wire irqf2p_4,
  output wire irqf2p_5,
  output wire irqf2p_6,
  output wire irqf2p_7,
  output wire irqf2p_8,
  output wire irqf2p_9
);

/* OFFSET:0x00 版本信息 */
parameter VERSION = 32'h23121504; //程序版本

/* OFFSET:0x10 串口模块 */
reg uart_flag_tx_reg;
reg uart_flag_rx_reg;
reg[1:0] uart_en_reg;             /* 00:0x00 串口使能寄存器 */
reg[31:0] uart_ctr_reg;           /* 01:0x04 串口读写控制寄存器*/
reg[31:0] uart_data_reg;          /* 02:0x08 串口数据寄存器 */
wire[31:0] uart_data_rx_wire;
reg[19:0] uart_tx_baud_rate;      /* 03:0x0c 串口发送波特率寄存器 */
wire[31:0] fifo_count_tx_wire;    /* 04:0x10 串口发送fifo数据个数寄存器 */
wire[31:0] uart_state_tx_wire;    /* 05:0x14 串口发送fifo状态寄存器 */
reg[19:0] uart_rx_baud_rate;      /* 06:0x18 串口接收波特率寄存器 */
wire[31:0] fifo_count_rx_wire;    /* 07:0x1c 串口接收fifo数据个数寄存器 */
wire[31:0] uart_state_rx_wire;    /* 08:0x20 串口接收fifo状态寄存器 */
reg[31:0] uart_int_ctr_reg;       /* 09:0x24 串口中断控制寄存器 */
wire rx_pkg_ack;

always @(posedge user_clk) begin
  if (!rstn) begin
    uart_flag_rx_reg <= 0;
    uart_flag_tx_reg <= 0;
    uart_int_ctr_reg <= 32'h0010_03e8;
    uart_tx_baud_rate <= 9600;
    uart_rx_baud_rate <= 9600;
  end
  else begin
    if (user_wren) begin
      /* 15:0 共6MByte可访问 */
      case (user_addr[15:2])
      4:uart_en_reg <= user_wr_data;
      5: begin
        uart_ctr_reg <= user_wr_data;
        if (user_wr_data & (1 << 31))
          uart_flag_rx_reg <= 1;
        else if (user_wr_data & (1 << 30))
          uart_flag_tx_reg <= 1;
      end
      6:uart_data_reg <= user_wr_data;
      7:uart_tx_baud_rate <= user_wr_data;
      10:uart_rx_baud_rate <= user_wr_data;
      13:uart_int_ctr_reg <= user_wr_data;
      endcase
    end
    else begin
      uart_flag_rx_reg <= 0;
      uart_flag_tx_reg <= 0;
    end
    if (user_rden) begin
      case (user_addr[15:2])
      0:user_rd_data <= VERSION;
      4:user_rd_data <= uart_en_reg;
      5:user_rd_data <= uart_ctr_reg;
      6: begin
        user_rd_data <= uart_data_rx_wire;
      end
      7:user_rd_data <= uart_tx_baud_rate;
      8:user_rd_data <= fifo_count_tx_wire;
      9:user_rd_data <= uart_state_tx_wire;
      10:user_rd_data <= uart_rx_baud_rate;
      11:user_rd_data <= fifo_count_rx_wire;
      12:user_rd_data <= uart_state_rx_wire;
      13:user_rd_data <= uart_int_ctr_reg;
      default: user_rd_data <= 0;
      endcase
    end
  end
end

uart_send_fifo uart_send_fifo_obj0(
    .rstn(rstn),
    .clk(user_clk),
    .en(uart_en_reg[0]),
    .baud_rate(uart_tx_baud_rate),
    .fifo_wr_en(uart_flag_tx_reg),
    .tx_date(uart_data_reg),
    .tx(uart_tx),
    .tx_fifo_count(fifo_count_tx_wire),
    .tx_fifo_state(uart_state_tx_wire)
    );

uart_read_fifo uart_read_fifo_obj0(
    .rstn(rstn),
    .clk(user_clk),
    .en(uart_en_reg[1]),
    .baud_rate(uart_rx_baud_rate),
    .fifo_rd_en(uart_flag_rx_reg),
    .rx_date(uart_data_rx_wire),
    .rx(uart_rx),
    .rx_fifo_count(fifo_count_rx_wire),
    .rx_fifo_state(uart_state_rx_wire),
    .rx_ack(rx_pkg_ack)
    );

interrupt interrupt_obj0(
  .rstn(rstn),
  .clk(user_clk),
  .pkg_ack(rx_pkg_ack),
  .item_num(uart_int_ctr_reg[30:16]),
  .time_out(uart_int_ctr_reg[15:0]),
  .period(uart_int_ctr_reg[31]),
  .irq(irqf2p_0)
);

endmodule

linux下UART驱动编写

轮询发送

  • 简单起见，uart控制器未设计发送中断，所以使用轮询发送
static void uart_start_tx(struct uart_port *port)
{
	struct dev_priv *priv;
	struct peng_dev *p_pdev;
	struct circ_buf *xmit;
	struct tty_port *tport;
	u32 state, n;
	priv = container_of(port, struct dev_priv, port);
	p_pdev = &priv->pdev;
	tport = &port->state->port;
	xmit = &port->state->xmit;
	dev_dbg(priv->pdev.p_dev, "uart_start_tx\n");
	if (uart_tx_stopped(port))
		return;
	if (uart_circ_empty(&port->state->xmit))
		return;
	n = PDEV_CSR_READ(p_pdev, PREG_REG, UART_TX_FIFO_COUNT);
	state = PDEV_CSR_READ(p_pdev, PREG_REG, UART_TX_FIFO_STATE);
	/* UART_TX_FIFO_COUNT满或空时都为0，需要根据UART_TX_FIFO_STATE来判断是否满 */
	if (state & UART_FIFO_STATE_FULL)
		return;
	n = UART_FIFO_SIZE - n;
	while (n) {
		if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
			dev_dbg(p_pdev->p_dev, "uart_circ_empty\n");
			/* 发送完成 */
			break;
		} else {
			dev_dbg(p_pdev->p_dev, "T:0x%02x", xmit->buf[xmit->tail]);
			priv->txBytCnt++;
			n--;
			spin_lock(&port->lock);
			PDEV_CSR_WRITE(p_pdev, PREG_REG, UART_DATA, (u32)xmit->buf[xmit->tail]);
			PDEV_CSR_WRITE(p_pdev, PREG_REG, UART_CTL, UART_CTL_TX);
			spin_unlock(&port->lock);
			/* 调整循环缓冲的位置 */
			xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
			/* 发送的数据量加1 */
			port->icount.tx++;
		}
	}
	/* 等待发送完成 */
	while(1) {
		state = PDEV_CSR_READ(p_pdev, PREG_REG, UART_TX_FIFO_STATE);
		if(state & UART_FIFO_EMPTY)
			break;
		mdelay(1);
	}
	/* 如果循环缓冲里面的数据小于WAKEUP_CHARS(256)，则唤醒之前阻塞的发送进程 */
	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
		uart_write_wakeup(port);
}

中断接收

  • 通过IRQ_F2P，PL将中断发送给PS
  • 中断中将FIFO中缓存的数据提交给TTY层
static irqreturn_t dev_isr(int irq, void *dev_id)
{
	u32 n, state;
	u8 data;
	struct dev_priv *priv;
	struct peng_dev *p_pdev;
	struct uart_port *port;
	struct tty_port *tport;
	struct circ_buf *xmit;
	priv = (struct dev_priv *)dev_id;
	p_pdev = &priv->pdev;
	port = &priv->port;
	tport = &port->state->port;
	xmit = &port->state->xmit;
	
	spin_lock(&port->lock);
	priv->nRxIntCount++;
	n = PDEV_CSR_READ(p_pdev, PREG_REG, UART_RX_FIFO_COUNT);
	state = PDEV_CSR_READ(p_pdev, PREG_REG, UART_RX_FIFO_STATE);
	if (state & UART_FIFO_STATE_FULL)
		n = UART_FIFO_SIZE;
	dev_dbg(p_pdev->p_dev, "rx,n=%d\n", n);
	mb();
	/* 接收fifo中字节数 */
	priv->rxBytCnt += n;
	while (n--) {
		/* 将收到的数据提交给TTY层 */
		PDEV_CSR_WRITE(p_pdev, PREG_REG, UART_CTL, UART_CTL_RX);
		data = PDEV_CSR_READ(p_pdev, PREG_REG, UART_DATA);
		if (!uart_handle_sysrq_char(port, data))
			uart_insert_char(port, priv->intStatus, 0, data, TTY_NORMAL);
		dev_dbg(p_pdev->p_dev, "R:0x%02x", data);
	}
	tty_flip_buffer_push(tport);
	spin_unlock(&port->lock);

	return IRQ_HANDLED;
}

控制器功能测试

接收测试

输入命令查看uart数据

cat /dev/ttyFpga0

电脑串口助手发送51字节数据（超过fifo深度）
在这里插入图片描述

左侧为zynq控制台，右侧为电脑串口助手

  • 51字节产生4次中断，中断优化符合预期
  • 右侧发送数据和左侧接收一致，符合预期

发送测试

输入命令发送uart数据,（数据大小超过fifo深度）

echo asdfghjklasdfghjklasdfghjklasdfghjklasdfghjkl > /dev/ttyFpga0

在这里插入图片描述

  • 左侧发送数据和右侧接收一致，符合预期

关注博主公众号，优质文章不断更新
在这里插入图片描述

最好有梦想～
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
串口设备驱动
xingfuyisheng的专栏
07-29 1762
uart_port 中最主要的就是第 235 行的 ops，ops 包含了串口的具体驱动函数，UART 驱动编写人员需要实现 uart_ops，因为 uart_ops 是最底层的 UART 驱动接口，是实实在在的和 UART 寄存器打交道的。串口全称叫做串行接口，通常也叫做 COM 接口，串行接口指的是数据一个一个的顺序传输，通信线路简单。这一套接口并不是针对串口开发的，而是针对所有的终端设备，串口是一种终端设备，计算机系统本地连接的鼠标、键盘也是终端设备，通过 ssh 远程登录连接的伪终端也是终端设备。
ARM串口驱动程序源代码！！！
03-23
ARM的串口COM1、COM2、COM3的驱动程序
串口通信入门
最新发布
2302_81176524的博客
06-02 807
当每个码元只代表一个比特信息时，例如在简单的异步串行通信中，波特率和比特率是相等的。波特率表示单位时间内传送的码元（Symbol）符号的个数，它是对符号传输速率的一种度量，它用单位时间内载波调制状态改变的次数来表示，波特率即指一个单位时间内传输符号的个数。串口可以将接收来自CPU的并行数据字符转换为连续的串行数据流发送出去，同时可将接收的串行数据流转换为并行的数据字符供给CPU的器件。在这种情况下，码元就是最简单的电平信号，比如低电压表示数字0，高电压表示数字1。简言之，波特率一秒传输高低电平的数量。
串口驱动（三）
xp_super的专栏
09-21 478
一、终端概述： tty设备设备是指一类字符设备的统称，包括控制台、串口、伪终端。 为终端：双向管道 控制台：只输出的设备，必须与实际的设备联系 二、终端体系     三、数据流： 四、串口驱动函数调用流程 五、串口驱动程序的原理： 1.发送：循环buffer->发送fifo 2.接收：接收fifo->filp_buffer 产生中断的条件：当发送fifo中的数据低于
串口驱动程序
06-28
串口驱动程序，RS422_485内附很好的使用说明，window各系统都可以用
串口驱动
03-13
USB转串口驱动 PL2303_Prolific_DriverInstaller_v1180.zip PL2303_XP2KME98Driver_Setup.zip
串口驱动程序设计
qq_45236840的博客
09-17 973
一.tty架构导入 tty架构分为：tty核心，线路规程，tty驱动。 二.串口驱动 2.1 初始化 三.打开串口
Linux串口驱动
qq_42049394的博客
08-29 1001
正点原子Linux驱动学习
Linux 串口驱动
weixin_41424783的博客
07-22 3952
  1 串口本质上也是字符设备 !!!!!!!!!!!!串口是不支持热拔插的。如果强行热拔插，容易损坏串口芯片!!!!!!!!!!!!!!!!!!!!! 名词解释：流控 "软件”流控制 :帧头帧尾                           “硬件”流控制：信号线 一。流程                                           个人建议只要能够读...
串口调试驱动及软件
01-19
里面是驱动程序和调试串口软件，，用于调试串口
串口服务器驱动
03-23
中金串口服务器驱动包，适用于32位系统，64位系统暂不支持，偶尔出现不兼容现象。
串口线驱动
01-23
win系统232串口线驱动，串口线驱动程序，串口线驱动程序
linux串口驱动
01-25
解决单片机驱动问题，里面含有各种版本的驱动，可以解决代码10的问题
电脑串口驱动程序
02-02
com串口驱动，路由器与电脑相连接使用的方便快捷。
linux 串口驱动
qq_42632460的博客
09-06 730
串口源码
串口驱动概述
石头的专栏
12-25 5754
1． 启动顺序在usrConfig.c 中，usrInit()调用sysHwInit(), 对系统硬件进行基本的初始化，使其处于安静状态。sysHwInit()[在sysLib.c 中]调用sysSerial.c 中的sysSerialHwInit()对BSP 串行器件进行初始化，使其处于静态；sysSerialHwInit()再通过xxDevInit()复位串行通道。在usrInit()函数的最
串口驱动及架构
kylin_fire_zeng的专栏
09-12 4795
原创kylin_zeng:http://blog.csdn.net/kylin_fire_zeng  本文参考国嵌视频教程，再此感谢国嵌教育。 一、重点概述： 在Linux中，TTY(终端)是一类字符设备的统称，包括了3种类型：控制台，串口和伪终端。 1）控制台：供内核使用的终端为控制台。控制台在Linux启动时，通过命令 console=…指定，如果没有指定控制台，系统把第一个注册的
Linux环境下USB主机控制器驱动开发指南
在Linux系统中，主机控制器驱动是连接操作系统与硬件设备的关键部分，特别是对于USB（通用串行总线）设备来说。本文将深入探讨如何编写Linux下的USB主机控制器驱动，并分享一些常见的实践经验和理解。 首先，我们来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

最好有梦想～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值