MII RMII RGMII GMII

heningbo

MII RMII RGMII GMII [复制链接]

最近在学习黑金的一款FPGA中的例程，其中有一个例程是一个非IP核的千兆网的例程。想把自己的学习经验教训写一下，希望大家和气的指出问题。写之前，先说一些概念，但是这些内容都来自于网络，我自己整理了一下，也忘了出处，如果不合适，留言我来删除。

MII是英文Medium Independent Interface的缩写，翻译成中文是“介质独立接口”，该接口一般应用于以太网硬件平台的MAC层和PHY层之间，MII接口的类型有很多，常用的有MII、RMII、SMII、SSMII、SSSMII、GMII、RGMII、SGMII、TBI、RTBI、XGMII、XAUI、XLAUI等。

MII接口：

RXD(Receive Data)[3:0]：数据接收信号，共4根信号线；

TX_ER(Transmit Error)：发送数据错误提示信号，同步于TX_CLK，高电平有效，表示TX_ER有效期内传输的数据无效。对于10Mbps速率下，TX_ER不起作用；

RX_ER(Receive Error)：接收数据错误提示信号，同步于RX_CLK，高电平有效，表示RX_ER有效期内传输的数据无效。对于10Mbps速率下，RX_ER不起作用；

TX_EN(Transmit Enable)：发送使能信号，只有在TX_EN有效期内传的数据才有效；

RX_DV(Reveive Data Valid)：接收数据有效信号，作用类型于发送通道的TX_EN；

TX_CLK：发送参考时钟，100Mbps速率下，时钟频率为25MHz，10Mbps速率下，时钟频率为2.5MHz。注意，TX_CLK时钟的方向是从PHY侧指向MAC侧的，因此此时钟是由PHY提供的。

RX_CLK：接收数据参考时钟，100Mbps速率下，时钟频率为25MHz，10Mbps速率下，时钟频率为2.5MHz。RX_CLK也是由PHY侧提供的。

CRS：Carrier Sense，载波侦测信号，不需要同步于参考时钟，只要有数据传输，CRS就有效，另外，CRS只有PHY在半双工模式下有效；

COL：Collision Detectd，冲突检测信号，不需要同步于参考时钟，只有PHY在半双工模式下有效。

MII接口一共有16根线。

RMII接口

RXD(Receive Data)[3:0]：数据接收信号，共4根信号线；

TX_ER(Transmit Error)：发送数据错误提示信号，同步于TX_CLK，高电平有效，表示TX_ER有效期内传输的数据无效。对于10Mbps速率下，TX_ER不起作用；

RX_ER(Receive Error)：接收数据错误提示信号，同步于RX_CLK，高电平有效，表示RX_ER有效期内传输的数据无效。对于10Mbps速率下，RX_ER不起作用；

TX_EN(Transmit Enable)：发送使能信号，只有在TX_EN有效期内传的数据才有效；

RX_DV(Reveive Data Valid)：接收数据有效信号，作用类型于发送通道的TX_EN；

TX_CLK：发送参考时钟，100Mbps速率下，时钟频率为25MHz，10Mbps速率下，时钟频率为2.5MHz。注意，TX_CLK时钟的方向是从PHY侧指向MAC侧的，因此此时钟是由PHY提供的。

RX_CLK：接收数据参考时钟，100Mbps速率下，时钟频率为25MHz，10Mbps速率下，时钟频率为2.5MHz。RX_CLK也是由PHY侧提供的。

CRS：Carrier Sense，载波侦测信号，不需要同步于参考时钟，只要有数据传输，CRS就有效，另外，CRS只有PHY在半双工模式下有效；

COL：Collision Detectd，冲突检测信号，不需要同步于参考时钟，只有PHY在半双工模式下有效。

MII接口一共有16根线。

RMII接口

与MII接口相比，GMII的数据宽度由4位变为8位，GMII接口中的控制信号如TX_ER、TX_EN、RX_ER、RX_DV、CRS和COL的作用同MII接口中的一样，发送参考时钟GTX_CLK和接收参考时钟RX_CLK的频率均为125MHz(1000Mbps/8=125MHz)。

在这里有一点需要特别说明下，那就是发送参考时钟GTX_CLK，它和MII接口中的TX_CLK是不同的，MII接口中的TX_CLK是由PHY芯片提供给MAC芯片的，而GMII接口中的GTX_CLK是由MAC芯片提供给PHY芯片的。两者方向不一样。

在实际应用中，绝大多数GMII接口都是兼容MII接口的，所以，一般的GMII接口都有两个发送参考时钟：TX_CLK和GTX_CLK(两者的方向是不一样的，前面已经说过了)，在用作MII模式时，使用TX_CLK和8根数据线中的4根。

RGMII接口

RGMII即Reduced GMII，是RGMII的简化版本，将接口信号线数量从24根减少到14根(COL/CRS端口状态指示信号，这里没有画出)，时钟频率仍旧为125MHz，TX/RX数据宽度从8为变为4位，为了保持1000Mbps的传输速率不变，RGMII接口在时钟的上升沿和下降沿都采样数据。在参考时钟的上升沿发送GMII接口中的TXD[3:0]/RXD[3:0]，在参考时钟的下降沿发送GMII接口中的TXD[7:4]/RXD[7:4]。RGMI同时也兼容100Mbps和10Mbps两种速率，此时参考时钟速率分别为25MHz和2.5MHz。

TX_EN信号线上传送TX_EN和TX_ER两种信息，在TX_CLK的上升沿发送TX_EN，下降沿发送TX_ER；同样的，RX_DV信号线上也传送RX_DV和RX_ER两种信息，在RX_CLK的上升沿发送RX_DV，下降沿发送RX_ER。

heningbo

本帖最后由 heningbo 于 2019-5-22 10:19 编辑

我自己整理的文档中有一些图片，但是论坛中无法直接粘贴，一格式上传有太麻烦，还不会操作，所以讲一个很重要图片没有传上来。即RMII转MII的图片。
管理员这块是否可优化。@管理员

heningbo

以太网的顶层文件如下：
`timescale 1ns/1ns
module ethernet_2port(
input sys_clk_p,
input sys_clk_n,
input key,
output [3:0] led,
input rst_n,
output e1_reset,
output e1_mdc,
inout e1_mdio,
output [3:0] rgmii1_txd,
output rgmii1_txctl,
output rgmii1_txc,
input [3:0] rgmii1_rxd,
input rgmii1_rxctl,
input rgmii1_rxc,
output e2_reset,
output e2_mdc,
inout e2_mdio,
output [3:0] rgmii2_txd,
output rgmii2_txctl,
output rgmii2_txc,
input [3:0] rgmii2_rxd,
input rgmii2_rxctl,
input rgmii2_rxc,
);
wire sys_clk_200m;
wire sys_clk;
wire [3:0] led_r1;
wire [3:0] led_r2;

assign led = led_r1 & led_r2;

clk_ref refclk
(
// Clock out ports
.clk_out1(sys_clk_200m),      // output clk_out1
.clk_out2(sys_clk),      // output clk_out2
// Status and control signals
.reset(1'b0), // input reset
.locked(),    // output locked
// Clock in ports
.clk_in1_p(sys_clk_p), // input clk_in1_p
.clk_in1_n(sys_clk_n) // input clk_in1_n
);

ethernet_test u1(
.sys_clk_50m (sys_clk ),
.sys_clk (sys_clk_200m ),
.key_in (key ),
.rst_n (rst_n ),
.led (led_r1 ),
.e_reset (e1_reset ),
.e_mdc (e1_mdc ),
.e_mdio (e1_mdio ),

.rgmii_txd (rgmii1_txd ),
.rgmii_txctl (rgmii1_txctl ),
.rgmii_txc (rgmii1_txc ),
.rgmii_rxd (rgmii1_rxd ),
.rgmii_rxctl (rgmii1_rxctl ),
.rgmii_rxc (rgmii1_rxc )

);

ethernet_test u2(
.sys_clk_50m (sys_clk ),
.sys_clk (sys_clk_200m ),
.key_in (key ),
.rst_n (rst_n ),
.led (led_r2 ),
.e_reset (e2_reset ),
.e_mdc (e2_mdc ),
.e_mdio (e2_mdio ),

.rgmii_txd (rgmii2_txd ),
.rgmii_txctl (rgmii2_txctl ),
.rgmii_txc (rgmii2_txc ),
.rgmii_rxd (rgmii2_rxd ),
.rgmii_rxctl (rgmii2_rxctl ),
.rgmii_rxc (rgmii2_rxc )

);
endmodule

说明：1、查分输入，经过内部PLL之类的核转成单端及频率改变。
      2、复位等信号就不说了。
      3、指示灯，用于显示link、网络速率等信息。
      4、MDIO接口（由于使用2个相同的千兆网接口，所以分为1和2）
      5、与phy的连接接口为EGMII

heningbo

`timescale 1ns/1ns
module ethernet_test(
input sys_clk_50m ,
input sys_clk ,
input key_in ,
input rst_n ,
output [3:0] led ,
output e_reset ,
output e_mdc ,
output e_mdio ,
output [3:0] rgmii_txd ,
output rgmii_txctl ,
output rgmii_txc ,
input [3:0] rgmii_rxd ,
input rgmii_rxctl ,
input rgmii_rxc
);
wire reset_n ;
wire [07:0] gmii_txd ;
wire gmii_tx_en ;
wire gmii_tx_er ;
wire gmii_tx_clk ;
wire gmii_crs ;
wire gmii_col ;
wire [07:0] gmii_rxd ;
wire gmii_rx_dv ;
wire gmii_rx_er ;
wire gmii_rx_clk ;
wire [01:0] speed_selection ;
wire duplex_mode ;
wire rgmii_rxcpll ;
wire [31:0] pack_total_len ;
wire [01:0] speed ;
wire link ;
wire e_rx_dv ;
wire [07:0] e_rxd ;
wire e_tx_en ;
wire [07:0] e_txd ;
wire e_rst_n ;
assign speed_selection = 2'b10 ;
assign duplex_mode = 1'b1 ;
//MDIO config
smi_config smi_config_inst
(
.clk (sys_clk_50m ),
.rst_n (e_reset ),
.mdc (e_mdc ),
.mdio (e_mdio ),
.speed (speed ),
.link (link ),
.led (led )
);
util_gmii_to_rgmii util_gmii_to_rgmii_m0(
.reset (1'b0 ),
.rgmii_td (rgmii_txd ),
.rgmii_tx_ctl (rgmii_txctl ),
.rgmii_txc (rgmii_txc ),
.rgmii_rd (rgmii_rxd ),
.rgmii_rx_ctl (rgmii_rxctl ),
.gmii_rx_clk (gmii_rx_clk ),
.gmii_txd (e_txd ),
.gmii_tx_en (e_tx_en ),
.gmii_tx_er (1'b0 ),
.gmii_tx_clk (gmii_tx_clk ),
.gmii_crs (gmii_crs ),
.gmii_col (gmii_col ),
.gmii_rxd (gmii_rxd ),
.rgmii_rxc (rgmii_rxc ),
.gmii_rx_dv (gmii_rx_dv ),
.gmii_rx_er (gmii_rx_er ),
.speed_selection (speed ),
.duplex_mode (duplex_mode )
);
gmii_arbi arbi_inst
(
.clk (gmii_tx_clk ),
.rst_n (rst_n ),
.speed (speed ),
.link (link ),
.pack_total_len (pack_total_len ),
.e_rst_n (e_rst_n ),
.gmii_rx_dv (gmii_rx_dv ),
.gmii_rxd (gmii_rxd ),
.gmii_tx_en (gmii_tx_en ),
.gmii_txd (gmii_txd ),
.e_rx_dv (e_rx_dv ),
.e_rxd (e_rxd ),
.e_tx_en (e_tx_en ),
.e_txd (e_txd )
);
mac_test mac_test0
(
.gmii_tx_clk (gmii_tx_clk ),
.gmii_rx_clk (gmii_rx_clk ) ,
.rst_n (e_rst_n ),
.push_button (key_in ),
.pack_total_len (pack_total_len ),
.gmii_rx_dv (e_rx_dv ),
.gmii_rxd (e_rxd ),
.gmii_tx_en (gmii_tx_en ),
.gmii_txd (gmii_txd )
);
reset reset_m0
(
.clk (sys_clk ),
.key1 (rst_n ),
.rst_n (e_reset )
);
endmodule

复制代码

这部分代码其实也可以作为顶层文件，只是设计中需要两个硬件接口，所以在他的上一层增加了一个文件。
该段代码包括RGMII与GMII互转、MDIO、MAC几个文件的映射。具体看下面

heningbo

util_gmii_to_rgmii是GMII与RGMII转换代码
那问题来了，为什么要进行转换呢，原因是RGMII是在时钟上升和下降沿均采集数据的，所以对于一般编写代码的人来说，实现比较困难，所以转换成GMII。具体转换时序图如下：

[url=]具体实现代[/url][url=]码如下：[/url]
[url=]

复制代码

module util_gmii_to_rgmii (
reset,
rgmii_td,
rgmii_tx_ctl,
rgmii_txc,
rgmii_rd,
rgmii_rx_ctl,
gmii_rx_clk,
rgmii_rxc,
gmii_txd,
gmii_tx_en,
gmii_tx_er,
gmii_tx_clk,
gmii_crs,
gmii_col,
gmii_rxd,
gmii_rx_dv,
gmii_rx_er,
speed_selection,
duplex_mode
);
input rgmii_rxc;//add
input reset;
output [ 3:0] rgmii_td;
output rgmii_tx_ctl;
output rgmii_txc;
input [ 3:0] rgmii_rd;
input rgmii_rx_ctl;
output gmii_rx_clk;
input [ 7:0] gmii_txd;
input gmii_tx_en;
input gmii_tx_er;
output gmii_tx_clk;
output gmii_crs;
output gmii_col;
output [ 7:0] gmii_rxd;
output gmii_rx_dv;
output gmii_rx_er;
input [ 1:0] speed_selection; // 1x gigabit, 01 100Mbps, 00 10mbps
input duplex_mode; // 1 full, 0 half
wire gigabit;
wire gmii_tx_clk_s;
wire gmii_rx_dv_s;
wire [ 7:0] gmii_rxd_s;
wire rgmii_rx_ctl_delay;
wire rgmii_rx_ctl_s;
// registers
reg tx_reset_d1;
reg tx_reset_sync;
reg rx_reset_d1;
reg [ 7:0] gmii_txd_r;
reg gmii_tx_en_r;
reg gmii_tx_er_r;
reg [ 7:0] gmii_txd_r_d1;
reg gmii_tx_en_r_d1;
reg gmii_tx_er_r_d1;
reg rgmii_tx_ctl_r;
reg [ 3:0] gmii_txd_low;
reg gmii_col;
reg gmii_crs;
reg [ 7:0] gmii_rxd;
reg gmii_rx_dv;
reg gmii_rx_er;
assign gigabit = speed_selection [1];
assign gmii_tx_clk = gmii_tx_clk_s;
assign gmii_tx_clk_s = gmii_rx_clk;
BUFG bufmr_rgmii_rxc(
.I(rgmii_rxc),
.O(gmii_rx_clk)
);
always @(posedge gmii_rx_clk)
begin
gmii_rxd = gmii_rxd_s;
gmii_rx_dv = gmii_rx_dv_s;
gmii_rx_er = gmii_rx_dv_s ^ rgmii_rx_ctl_s;
end
always @(posedge gmii_tx_clk_s) begin
tx_reset_d1 <= reset;
tx_reset_sync <= tx_reset_d1;
end
always @(posedge gmii_tx_clk_s)
begin
rgmii_tx_ctl_r = gmii_tx_en_r ^ gmii_tx_er_r;
gmii_txd_low = gigabit ? gmii_txd_r[7:4] : gmii_txd_r[3:0];
gmii_col = duplex_mode ? 1'b0 : (gmii_tx_en_r| gmii_tx_er_r) & ( gmii_rx_dv | gmii_rx_er) ;
gmii_crs = duplex_mode ? 1'b0 : (gmii_tx_en_r| gmii_tx_er_r| gmii_rx_dv | gmii_rx_er);
end
always @(posedge gmii_tx_clk_s) begin
if (tx_reset_sync == 1'b1) begin
gmii_txd_r <= 8'h0;
gmii_tx_en_r <= 1'b0;
gmii_tx_er_r <= 1'b0;
end
else
begin
gmii_txd_r <= gmii_txd;
gmii_tx_en_r <= gmii_tx_en;
gmii_tx_er_r <= gmii_tx_er;
gmii_txd_r_d1 <= gmii_txd_r;
gmii_tx_en_r_d1 <= gmii_tx_en_r;
gmii_tx_er_r_d1 <= gmii_tx_er_r;
end
end
ODDR #(
.DDR_CLK_EDGE("SAME_EDGE")
) rgmii_txc_out (
.Q (rgmii_txc),
.C (gmii_tx_clk_s),
.CE(1),
.D1(1),
.D2(0),
.R(tx_reset_sync),
.S(0));
generate
genvar i;
for (i = 0; i < 4; i = i + 1) begin : gen_tx_data
ODDR #(
.DDR_CLK_EDGE("SAME_EDGE")
) rgmii_td_out (
.Q (rgmii_td[i]),
.C (gmii_tx_clk_s),
.CE(1),
.D1(gmii_txd_r_d1[i]),
.D2(gmii_txd_low[i]),
.R(tx_reset_sync),
.S(0));
end
endgenerate
ODDR #(
.DDR_CLK_EDGE("SAME_EDGE")
) rgmii_tx_ctl_out (
.Q (rgmii_tx_ctl),
.C (gmii_tx_clk_s),
.CE(1),
.D1(gmii_tx_en_r_d1),
.D2(rgmii_tx_ctl_r),
.R(tx_reset_sync),
.S(0));
generate
for (i = 0; i < 4; i = i + 1) begin
IDDR #(
.DDR_CLK_EDGE("SAME_EDGE_PIPELINED")
) rgmii_rx_iddr (
.Q1(gmii_rxd_s[i]),
.Q2(gmii_rxd_s[i+4]),
.C(gmii_rx_clk),
.CE(1),
.D(rgmii_rd[i]),
.R(0),
.S(0));
end
endgenerate
IDDR #(
.DDR_CLK_EDGE("SAME_EDGE_PIPELINED")
) rgmii_rx_ctl_iddr (
.Q1(gmii_rx_dv_s),
.Q2(rgmii_rx_ctl_s),
.C(gmii_rx_clk),
.CE(1),
.D(rgmii_rx_ctl),
.R(0),
.S(0));
endmodule

复制代码

[/url]

heningbo

`timescale 1 ns/1 ns
module mac_test
(
input rst_n ,
input push_button,
input [31:0] pack_total_len,
input gmii_tx_clk ,
input gmii_rx_clk ,
input gmii_rx_dv,
input [7:0] gmii_rxd,
output reg gmii_tx_en,
output reg [7:0] gmii_txd
);
localparam UDP_WIDTH = 32 ;
localparam UDP_DEPTH = 5 ;
reg gmii_rx_dv_d0 ;
reg [7:0] gmii_rxd_d0 ;
wire gmii_tx_en_tmp ;
wire [7:0] gmii_txd_tmp ;
reg [7:0] ram_wr_data ;
reg ram_wr_en ;
wire udp_ram_data_req ;
reg [15:0] udp_send_data_length ;
wire [7:0] tx_ram_wr_data ;
wire tx_ram_wr_en ;
wire udp_tx_req ;
wire arp_request_req ;
wire mac_send_end ;
reg write_end ;
wire [7:0] udp_rec_ram_rdata ;
reg [10:0] udp_rec_ram_read_addr ;
wire [15:0] udp_rec_data_length ;
wire udp_rec_data_valid ;
wire udp_tx_end ;
wire almost_full ;
reg udp_ram_wr_en ;
reg udp_write_end ;
wire write_ram_end ;
reg [31:0] wait_cnt ;
reg [UDP_WIDTH-1:0] udp_data [UDP_DEPTH-1:0];
reg [4:0] i;
reg [1:0] j ;
reg write_sel ;
wire button_negedge ;
wire mac_not_exist ;
wire arp_found ;
parameter IDLE = 9'b000_000_001 ;
parameter ARP_REQ = 9'b000_000_010 ;
parameter ARP_SEND = 9'b000_000_100 ;
parameter ARP_WAIT = 9'b000_001_000 ;
parameter GEN_REQ = 9'b000_010_000 ;
parameter WRITE_RAM = 9'b000_100_000 ;
parameter SEND = 9'b001_000_000 ;
parameter WAIT = 9'b010_000_000 ;
parameter CHECK_ARP = 9'b100_000_000 ;
reg [8:0] state ;
reg [8:0] next_state ;
reg [15:0] ram_cnt ;
reg almost_full_d0 ;
reg almost_full_d1 ;
always @(posedge gmii_tx_clk or negedge rst_n)
begin
if (~rst_n)
state <= IDLE ;
else
state <= next_state ;
end
always @(*)
begin
case(state)
IDLE :
begin
if (wait_cnt == pack_total_len)
next_state <= ARP_REQ ;
else
next_state <= IDLE ;
end
ARP_REQ :
next_state <= ARP_SEND ;
ARP_SEND :
begin
if (mac_send_end)
next_state <= ARP_WAIT ;
else
next_state <= ARP_SEND ;
end
ARP_WAIT :
begin
if (arp_found)
next_state <= WAIT ;
else if (wait_cnt == pack_total_len)
next_state <= ARP_REQ ;
else
next_state <= ARP_WAIT ;
end
GEN_REQ :
begin
if (udp_ram_data_req)
next_state <= WRITE_RAM ;
else
next_state <= GEN_REQ ;
end
WRITE_RAM :
begin
`ifdef TEST_SPEED
if (ram_cnt == udp_send_data_length - 1)
`else
if (write_ram_end)
`endif
next_state <= WAIT ;
else
next_state <= WRITE_RAM ;
end
SEND :
begin
if (udp_tx_end)
next_state <= WAIT ;
else
next_state <= SEND ;
end
WAIT :
begin
`ifdef TEST_SPEED
if (wait_cnt == 32'd90) //frame gap
`else
if (wait_cnt == pack_total_len)
`endif
next_state <= CHECK_ARP ;
else
next_state <= WAIT ;
end
CHECK_ARP :
begin
if (mac_not_exist)
next_state <= ARP_REQ ;
else if (almost_full_d1)
next_state <= CHECK_ARP ;
else
next_state <= GEN_REQ ;
end
default :
next_state <= IDLE ;
endcase
end
assign write_ram_end = (write_sel)? udp_write_end : write_end ;
assign tx_ram_wr_data = (write_sel)? udp_rec_ram_rdata : ram_wr_data ;
assign tx_ram_wr_en = (write_sel)? udp_ram_wr_en : ram_wr_en ;
always@(posedge gmii_rx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
begin
gmii_rx_dv_d0 <= 1'b0 ;
gmii_rxd_d0 <= 8'd0 ;
end
else
begin
gmii_rx_dv_d0 <= gmii_rx_dv ;
gmii_rxd_d0 <= gmii_rxd ;
end
end
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
begin
gmii_tx_en <= 1'b0 ;
gmii_txd <= 8'd0 ;
end
else
begin
gmii_tx_en <= gmii_tx_en_tmp ;
gmii_txd <= gmii_txd_tmp ;
end
end
mac_top mac_top0
(
.gmii_tx_clk (gmii_tx_clk) ,
.gmii_rx_clk (gmii_rx_clk) ,
.rst_n (rst_n) ,
.source_mac_addr (48'h00_0a_35_01_fe_c0) , //source mac address
.TTL (8'h80),
.source_ip_addr (32'hc0a80002),
.destination_ip_addr (32'hc0a80003),
.udp_send_source_port (16'h1f90),
.udp_send_destination_port (16'h1f90),
.ram_wr_data (tx_ram_wr_data) ,
.ram_wr_en (tx_ram_wr_en),
.udp_ram_data_req (udp_ram_data_req),
.udp_send_data_length (udp_send_data_length),
.udp_tx_end (udp_tx_end ),
.almost_full (almost_full ),
.udp_tx_req (udp_tx_req),
.arp_request_req (arp_request_req ),
.mac_send_end (mac_send_end),
.mac_data_valid (gmii_tx_en_tmp),
.mac_tx_data (gmii_txd_tmp),
.rx_dv (gmii_rx_dv_d0 ),
.mac_rx_datain (gmii_rxd_d0 ),
.udp_rec_ram_rdata (udp_rec_ram_rdata),
.udp_rec_ram_read_addr (udp_rec_ram_read_addr),
.udp_rec_data_length (udp_rec_data_length ),
.udp_rec_data_valid (udp_rec_data_valid),
.arp_found (arp_found ),
.mac_not_exist (mac_not_exist )
) ;
ax_debounce ax0
(
.clk(gmii_rx_clk),
.rst_n(rst_n),
.button_in(push_button),
.button_posedge(),
.button_negedge(button_negedge),
.button_out()
);
always @(*)
begin
udp_data[0] <={"H","E","L","L"};
udp_data[1] <={"O"," ","A","L"};
udp_data[2] <={"I","N","X"," "};
udp_data[3] <={"H","E","I","J"};
udp_data[4] <={"I","N","\r","\n"};
end
//reg almost_full_d0 ;
//reg almost_full_d1 ;
always@(posedge gmii_rx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
begin
almost_full_d0 <= 1'b0 ;
almost_full_d1 <= 1'b0 ;
end
else
begin
almost_full_d0 <= almost_full ;
almost_full_d1 <= almost_full_d0 ;
end
end
always@(posedge gmii_rx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
udp_send_data_length <= 16'd0 ;
else if (write_sel)
udp_send_data_length <= udp_rec_data_length - 8 ;
else
`ifdef TEST_SPEED
udp_send_data_length <= 16'd1000 ;
`else
udp_send_data_length <= 4*UDP_DEPTH ;
`endif
end
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
write_sel <= 1'b0 ;
else if (state == WAIT)
begin
if (udp_rec_data_valid)
write_sel <= 1'b1 ;
else
write_sel <= 1'b0 ;
end
end
assign udp_tx_req = (state == GEN_REQ) ;
assign arp_request_req = (state == ARP_REQ) ;
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
wait_cnt <= 0 ;
else if ((state==IDLE||state == WAIT || state == ARP_WAIT) && state != next_state)
wait_cnt <= 0 ;
else if (state==IDLE||state == WAIT || state == ARP_WAIT)
wait_cnt <= wait_cnt + 1'b1 ;
else
wait_cnt <= 0 ;
end
`ifdef TEST_SPEED
/*************************************************************/
//Test ethernet speed
//reg [15:0] ram_cnt ;
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
ram_cnt <= 11'd0 ;
else if (state == WRITE_RAM)
ram_cnt <= ram_cnt + 1'b1 ;
else
ram_cnt <= 11'd0 ;
end
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
ram_wr_en <= 1'b0 ;
else if (state == WRITE_RAM)
ram_wr_en <= 1'b1 ;
else
ram_wr_en <= 1'b0 ;
end
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
ram_wr_data <= 8'd0 ;
else if (state == WRITE_RAM)
ram_wr_data <= ram_cnt[7:0] ;
else
ram_wr_data <= 8'd0 ;
end
/*************************************************************/
`else
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
begin
write_end <= 1'b0;
ram_wr_data <= 0;
ram_wr_en <= 0 ;
i <= 0 ;
j <= 0 ;
end
else if (state == WRITE_RAM)
begin
if(i == 5)
begin
ram_wr_en <=1'b0;
write_end <= 1'b1;
end
else
begin
ram_wr_en <= 1'b1 ;
write_end <= 1'b0 ;
j <= j + 1'b1 ;
case(j)
2'd0 : ram_wr_data <= udp_data[i][31:24] ;
2'd1 : ram_wr_data <= udp_data[i][23:16] ;
2'd2 : ram_wr_data <= udp_data[i][15:8] ;
2'd3 : ram_wr_data <= udp_data[i][7:0] ;
default : ram_wr_data <= 8'h00 ;
endcase
if (j == 3)
begin
j <= 0 ;
i <= i + 1'b1;
end
end
end
else
begin
write_end <= 1'b0;
ram_wr_data <= 0;
ram_wr_en <= 0 ;
i <= 0 ;
j <= 0 ;
end
end
`endif
//send udp received data to udp tx ram
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
udp_rec_ram_read_addr <= 11'd0 ;
else if (state == WRITE_RAM)
udp_rec_ram_read_addr <= udp_rec_ram_read_addr + 1'b1 ;
else
udp_rec_ram_read_addr <= 11'd0 ;
end
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
udp_ram_wr_en <= 1'b0 ;
else if (state == WRITE_RAM && udp_rec_ram_read_addr < udp_rec_data_length - 8)
udp_ram_wr_en <= 1'b1 ;
else
udp_ram_wr_en <= 1'b0 ;
end
always@(posedge gmii_tx_clk or negedge rst_n)
begin
if(rst_n == 1'b0)
udp_write_end <= 1'b0 ;
else if (state == WRITE_RAM && udp_rec_ram_read_addr == udp_rec_data_length - 8)
udp_write_end <= 1'b1 ;
else
udp_write_end <= 1'b0 ;
end
endmodule

复制代码

英尚微电子

heningbo

//////////////////////////////////////////////////////////////////////////////////////
//Module Name : mac_rx
//Description : This module is used to receive MAC layer data and verify CRC
//
//////////////////////////////////////////////////////////////////////////////////////
`timescale 1 ns/1 ns
module mac_rx
(
input clk,
input rst_n,
input rx_dv,
input [7:0] mac_rx_datain,
input [31:0] crc_result ,
output reg crcen,
output reg crcre,
output reg [7:0] crc_din,
input checksum_err, //checksum error from IP layer
input ip_rx_end, //ip receive end
input arp_rx_end, //arp receive end
output reg ip_rx_req, //ip rx request
output reg arp_rx_req, //arp rx request
output [7:0] mac_rx_dataout,
output reg mac_rec_error ,
output reg [47:0] mac_rx_destination_mac_addr,
output reg [47:0] mac_rx_source_mac_addr
);
reg [4:0] mac_rx_cnt ;
reg [15:0] mac_crc_cnt ;
reg [63:0] preamble ;
reg [3:0] preamble_cnt ;
reg [15:0] frame_type ; //type 16'h0800 IP; 16'h0806 ARP
wire rx_dv_posedge ;
reg rx_dv_d0 ;
reg rx_dv_d1 ;
reg [7:0] mac_rx_data_d0 ;
reg [7:0] mac_rx_data_d1 ;
reg [7:0] mac_rx_data_d2 ;
wire mac_rx_head_end ;
reg [15:0] timeout ;
reg [31:0] crc ;
reg [31:0] crc_check ;
reg crc_error ;
reg [31:0] crc_rec ;
reg [31:0] crc_result_d0 ;
//MAC receive FSM
parameter IDLE = 8'b0000_0001 ;
parameter REC_PREAMBLE = 8'b0000_0010 ;
parameter REC_MAC_HEAD = 8'b0000_0100 ;
parameter REC_IDENTIFY = 8'b0000_1000 ;
parameter REC_DATA = 8'b0001_0000 ;
parameter REC_CRC = 8'b0010_0000 ;
parameter REC_ERROR = 8'b0100_0000 ;
parameter REC_END = 8'b1000_0000 ;
reg [7:0] rec_state ;
reg [7:0] rec_next_state ;
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
rec_state <= IDLE ;
else
rec_state <= rec_next_state ;
end
always @(*)
begin
case(rec_state)
IDLE : begin
if (rx_dv_posedge == 1'b1)
rec_next_state <= REC_PREAMBLE ;
else
rec_next_state <= IDLE ;
end
REC_PREAMBLE : begin
if (mac_rx_cnt == 7)
rec_next_state <= REC_MAC_HEAD ;
else
rec_next_state <= REC_PREAMBLE ;
end
REC_MAC_HEAD : begin
if (preamble != 64'h55_55_55_55_55_55_55_d5)
rec_next_state <= REC_ERROR ;
else if ( mac_rx_cnt == 16'd21)
rec_next_state <= REC_IDENTIFY ;
else
rec_next_state <= REC_MAC_HEAD ;
end
REC_IDENTIFY : begin
if (frame_type == 16'h0800 || frame_type == 16'h0806)
rec_next_state <= REC_DATA ;
else
rec_next_state <= REC_ERROR ;
end
REC_DATA : begin
if (checksum_err)
rec_next_state <= REC_ERROR ;
else if (ip_rx_end|arp_rx_end)
rec_next_state <= REC_CRC ;
else if (timeout == 16'hffff)
rec_next_state <= REC_ERROR ;
else
rec_next_state <= REC_DATA ;
end
REC_CRC : begin
if (crc_error)
rec_next_state <= REC_ERROR ;
else if (mac_rx_cnt == 7)
rec_next_state <= REC_END ;
else
rec_next_state <= REC_CRC ;
end
REC_ERROR : rec_next_state <= IDLE ;
REC_END : rec_next_state <= IDLE ;
default : rec_next_state <= IDLE ;
endcase
end
assign mac_rx_dataout = mac_rx_data_d2 ; //
assign rx_dv_posedge = ~rx_dv_d0 & rx_dv ;
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
begin
crcen <= 1'b0 ;
crcre <= 1'b1 ;
crc_din <= 8'd0 ;
end
else if (rec_state == REC_MAC_HEAD || rec_state == REC_IDENTIFY || rec_state == REC_DATA)
begin
crcen <= 1'b1 ;
crcre <= 1'b0 ;
crc_din <= mac_rx_data_d0 ;
end
else
begin
crcen <= 1'b0 ;
crcre <= 1'b1 ;
crc_din <= 8'd0 ;
end
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
ip_rx_req <= 1'b0 ;
else if (rec_state == REC_IDENTIFY && frame_type == 16'h0800)
ip_rx_req <= 1'b1 ;
else
ip_rx_req <= 1'b0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
arp_rx_req <= 1'b0 ;
else if (rec_state == REC_IDENTIFY && frame_type == 16'h0806)
arp_rx_req <= 1'b1 ;
else
arp_rx_req <= 1'b0 ;
end
//rx dv and rx data resigster
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
begin
rx_dv_d0 <= 1'b0 ;
rx_dv_d1 <= 1'b0 ;
mac_rx_data_d0 <= 8'd0 ;
mac_rx_data_d1 <= 8'd0 ;
mac_rx_data_d2 <= 8'd0 ;
end
else
begin
rx_dv_d0 <= rx_dv ;
rx_dv_d1 <= rx_dv_d0 ;
mac_rx_data_d0 <= mac_rx_datain ;
mac_rx_data_d1 <= mac_rx_data_d0 ;
mac_rx_data_d2 <= mac_rx_data_d1 ;
end
end
//timeout
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
timeout <= 16'd0 ;
else if (rec_state == REC_DATA)
timeout <= timeout + 1'b1 ;
else
timeout <= 16'd0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
mac_rx_cnt <= 5'd0 ;
else if (rec_state == REC_PREAMBLE || rec_state == REC_MAC_HEAD || rec_state == REC_CRC)
mac_rx_cnt <= mac_rx_cnt + 1'b1 ;
else
mac_rx_cnt <= 5'd0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
mac_crc_cnt <= 16'd0 ;
else if (rx_dv_d1)
mac_crc_cnt <= mac_crc_cnt + 1'b1 ;
else
mac_crc_cnt <= 16'd0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
mac_rec_error <= 1'b0 ;
else if (rx_dv_posedge)
mac_rec_error <= 1'b0 ;
else if (rec_state == REC_ERROR)
mac_rec_error <= 1'b1 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
crc <= 32'd0 ;
else if (crcen)
crc <= crc_result_d0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
crc_result_d0 <= 32'd0 ;
else
crc_result_d0 <= crc_result ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
crc_check <= 32'd0 ;
else if (rec_state == REC_CRC)
begin
case(mac_rx_cnt)
5'd1 : crc_check[31:24] <= {~crc[24], ~crc[25], ~crc[26], ~crc[27], ~crc[28], ~crc[29], ~crc[30], ~crc[31]} ;
5'd2 : crc_check[23:16] <= {~crc[16], ~crc[17], ~crc[18], ~crc[19], ~crc[20], ~crc[21], ~crc[22], ~crc[23]} ;
5'd3 : crc_check[15:8] <= {~crc[8], ~crc[9], ~crc[10], ~crc[11], ~crc[12], ~crc[13], ~crc[14], ~crc[15]} ;
5'd4 : crc_check[7:0] <= {~crc[0], ~crc[1], ~crc[2], ~crc[3], ~crc[4], ~crc[5], ~crc[6], ~crc[7]} ;
default : crc_check <= crc_check ;
endcase
end
else
crc_check <= 32'd0 ;
end
//received crc data
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
crc_rec <= 48'd0 ;
else if (rec_state == REC_CRC)
begin
case(mac_rx_cnt)
5'd0 : crc_rec[31:24] <= mac_rx_data_d2 ;
5'd1 : crc_rec[23:16] <= mac_rx_data_d2 ;
5'd2 : crc_rec[15:8] <= mac_rx_data_d2 ;
5'd3 : crc_rec[7:0] <= mac_rx_data_d2 ;
default : crc_rec <= crc_rec ;
endcase
end
else
crc_rec <= crc_rec ;
end
//check crc
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
crc_error <= 1'b0 ;
else if (rec_state == REC_CRC && mac_rx_cnt == 5)
begin
if (crc_check == crc_rec)
crc_error <= 1'b0 ;
else
crc_error <= 1'b1 ;
end
else
crc_error <= 1'b0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
preamble_cnt <= 4'd0 ;
else if (rx_dv)
begin
if (preamble_cnt < 8)
preamble_cnt <= preamble_cnt + 1'b1 ;
end
else
preamble_cnt <= 4'd0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
preamble <= 64'd0 ;
else if (rx_dv)
begin
if (preamble_cnt == 4'd0)
preamble[63:56] <= mac_rx_datain ;
if (preamble_cnt == 4'd1)
preamble[55:48] <= mac_rx_datain ;
if (preamble_cnt == 4'd2)
preamble[47:40] <= mac_rx_datain ;
if (preamble_cnt == 4'd3)
preamble[39:32] <= mac_rx_datain ;
if (preamble_cnt == 4'd4)
preamble[31:24] <= mac_rx_datain ;
if (preamble_cnt == 4'd5)
preamble[23:16] <= mac_rx_datain ;
if (preamble_cnt == 4'd6)
preamble[15:8] <= mac_rx_datain ;
if (preamble_cnt == 4'd7)
preamble[7:0] <= mac_rx_datain ;
end
else
preamble <= 64'd0 ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
mac_rx_destination_mac_addr <= 48'd0 ;
else if (rec_state == REC_MAC_HEAD)
begin
case(mac_rx_cnt)
5'd8 : mac_rx_destination_mac_addr[47:40] <= mac_rx_data_d0 ;
5'd9 : mac_rx_destination_mac_addr[39:32] <= mac_rx_data_d0 ;
5'd10 : mac_rx_destination_mac_addr[31:24] <= mac_rx_data_d0 ;
5'd11 : mac_rx_destination_mac_addr[23:16] <= mac_rx_data_d0 ;
5'd12 : mac_rx_destination_mac_addr[15:8] <= mac_rx_data_d0 ;
5'd13 : mac_rx_destination_mac_addr[7:0] <= mac_rx_data_d0 ;
default : mac_rx_destination_mac_addr <= mac_rx_destination_mac_addr ;
endcase
end
else
mac_rx_destination_mac_addr <= mac_rx_destination_mac_addr ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
mac_rx_source_mac_addr <= 48'd0 ;
else if (rec_state == REC_MAC_HEAD)
begin
case(mac_rx_cnt)
5'd14 : mac_rx_source_mac_addr[47:40] <= mac_rx_data_d0 ;
5'd15 : mac_rx_source_mac_addr[39:32] <= mac_rx_data_d0 ;
5'd16 : mac_rx_source_mac_addr[31:24] <= mac_rx_data_d0 ;
5'd17 : mac_rx_source_mac_addr[23:16] <= mac_rx_data_d0 ;
5'd18 : mac_rx_source_mac_addr[15:8] <= mac_rx_data_d0 ;
5'd19 : mac_rx_source_mac_addr[7:0] <= mac_rx_data_d0 ;
default : mac_rx_source_mac_addr <= mac_rx_source_mac_addr ;
endcase
end
else
mac_rx_source_mac_addr <= mac_rx_source_mac_addr ;
end
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
frame_type <= 16'd0 ;
else if (rec_state == REC_MAC_HEAD)
begin
case(mac_rx_cnt)
5'd20 : frame_type[15:8] <= mac_rx_data_d0 ;
5'd21 : frame_type[7:0] <= mac_rx_data_d0 ;
default : frame_type <= frame_type ;
endcase
end
else
frame_type <= frame_type ;
end
ila_0 I_ila_0(
.clk (clk ), // 01 bit
.probe0 (rx_dv ), // 01 bit
.probe1 (mac_rx_datain ), // 08 bit
.probe2 (crc_result ), // 32 bit
.probe3 (ip_rx_end ), // 01 bit
.probe4 (ip_rx_req ), // 01 bit
.probe5 (arp_rx_end ), // 01 bit
.probe6 (arp_rx_req ), // 01 bit
.probe7 (mac_rx_dataout ), // 08 bit
.probe8 (mac_rx_destination_mac_addr ), // 48 bit
.probe9 (mac_rx_source_mac_addr ), // 48 bit
.probe10 (preamble ), // 64 bit
.probe11 (rx_dv_d0 ), // 01 bit
.probe12 (rx_dv_d1 ), // 01 bit
.probe13 (mac_rx_data_d0 ), // 08 bit
.probe14 (mac_rx_data_d1 ), // 08 bit
.probe15 (mac_rx_cnt ), // 05 bit
.probe16 (rec_state ) // 08 bit
);
endmodule

复制代码

heningbo

这是通过ILA进行跟踪的波形图

studyqu309

很牛逼，受教了

heningbo

studyqu309 发表于 2019-6-20 10:21 很牛逼，受教了

后边可能就不更新了，如果想了解，而且有条件，就自己买个板子吧！

杨星河

您好我想向您咨询一下千兆网代码的事情非常着急可以加一下联系方式么我的Q 635775767 万分感谢

BHang03

您好，我想请问一下这是黑金哪个例程？最近在做gmii和rgmii相关的试验

heningbo

BHang03 发表于 2019-12-2 00:42 您好，我想请问一下这是黑金哪个例程？最近在做gmii和rgmii相关的试验

网络测试

MII RMII RGMII GMII [复制链接]

最新回复

点评

点评

荣誉会员勋章