原文:http://www.cnblogs.com/hc101/p/6703805.html
用Verilog语言实现一个简单的MII模块
项目中要求简单地测试一下基于FPGA的模拟平台的RJ45网口，也就是需要实现一个MII或者RMII模块。看了一下官方网口PHY芯片的官方文档，还是感觉上手有点障碍，想在网络上找些参考代码看看，最后只在opencores找到了一些MAC层控制模块，代码庞大且复杂，对于初学者来说阅读起来很困难。
于是在此以一个初学者的角度记录一下我实现一个简单的MII模块的过程，并且指出一些实现过程中要注意的问题。希望可以帮助有需要的朋友。
为了便于测试，我选择了和我们平台使用相同物理芯片的FPGA开发板NEXYS 3，物理芯片为MICROCHIP出品的LAN8710A芯片。在NEXYS 3的内部，PHY芯片的管脚连接如图0所示：
图0 NEXYS3内部LAN8710A芯片管脚连接（图片来自NEXYS 3官方文档截图）
在这个简单的MII模块中，主要有一下几个子模块：PHY配置模块，发送模块，接收模块；其中PHY配置模块有一个PHY控制模块，用来读写PHY中的寄存器。这些模块如图1所示：
图1 模块关系
首先，我们需要编写一个控制PHY的子模块。按照官方文档，管理PHY芯片的方式是通过SMI（Serial Management Interface）进行的；SMI用于控制芯片状态或者读取芯片状态。SMI包括两个信号:MDC和MDIO。
MDC为一个非周期性的时钟信号，由使用SMI的模块指定。LAN8710A的官方文档指出：MDC时钟信号的相邻上升沿和下降沿之间的最小间隔是160ns，最大间隔没有限制，而其周期最小为400ns，同样的，最大周期也没有限制；因此MDC的最大频率为2.5MHz。
MDIO，是一个双向端口信号，用于串行数据的传输。双向端口信号的控制方式在后面的代码中可以参考。
在PHY芯片中，根据IEEE802.3规范中的22号条款要求的0号寄存器到6号寄存器和厂商自定义的16号寄存器到31号寄存器大致如图2所示（第一列即为它们的地址）：
图2 PHY芯片中的部分寄存器
在上面这些寄存器中，寄存器0位基本的控制寄存器，对PHY芯片的控制一般通过写这个寄存器来完成，控制寄存器的各位的功能如图3所示：
图3 控制寄存器（PHY芯片中地址为0）
通过SMI读物理芯片的寄存器的时钟顺序如图4所示：
图4 SMI读物理芯片寄存器时序图（图片来自LAN8710A芯片官方文档截图）
通过SMI写物理芯片的寄存器的时钟顺序如图5所示：
图5 SMI写物理芯片寄存器时序图（图片来自LAN8710A芯片官方文档截图）
在读写过程中传输的串行数据一定不能忘记了最前面的那32个1，最初我忽略了这一点走了很多弯路。
下面的代码给出了一个简单的利用SMI管理物理芯片的模块；该模块的功能为读写PHY芯片中的寄存器，phy_addr_i为PHY芯片的地址，默认为0，一般不需要关注，但是如果涉及到多个PHY芯片，则要选择正确的芯片地址；reg_addr_i为PHY芯片中寄存器的地址，din_i为写寄存器时的16位数据；dout_o为读寄存器时获取的16位数据；rd_en_i有效时读取寄存器数据，wr_en_i有效时将din_i上的数据写入到相应的寄存器。
1 module PHY_Ctrl(
2 input clk_i,// <= 2.5MHz
3 input rst_i,
4
5 //management signals
6 input [4:0] phy_addr_i,
7 input [4:0] reg_addr_i,
8 input wr_en_i,
9 input rd_en_i,
10 input [15:0] din_i,
11 output reg [15:0] dout_o,
12
13 //PHY signals
14 output phy_nrst_o,
15 inout mdio_io,
16 output mdc_o
17 //input col_i,
18 //input crs_i,
19 );
20
21 assign mdc_o = clk_i;
22 assign mdc_n = ~clk_i;
23 assign phy_nrst_o = ~rst_i;
24
25 reg mdo_en;
26 reg mdo;
27 assign mdio_io = mdo_en ? mdo : 1'bz;
28
29 reg [6:0] bit_cnt;
30 wire [3:0] byte_sel;
31 reg [7:0] current_byte;
32 reg op_is_write;
33
34 assign byte_sel[0] = (bit_cnt == 32);
35 assign byte_sel[1] = (bit_cnt == 40);
36 assign byte_sel[2] = (bit_cnt == 48);
37 assign byte_sel[3] = (bit_cnt == 56);
38
39 always @(posedge mdc_n, posedge rst_i)
40 if (rst_i)
41 current_byte <= 0;
42 else
43 if (byte_sel)//current byte's value must be maintained
44 case (byte_sel)
45 4'b0001: current_byte <= {1'b0,1'b1,~op_is_write,op_is_write,phy_addr_i[4:1]};
46 4'b0010: current_byte <= {phy_addr_i[0],reg_addr_i[4:0],1'b1,1'b0};
47 4'b0100: current_byte <= din_i[15:8];
48 4'b1000: current_byte <= din_i[7:0];
49 endcase
50
51 always@(posedge mdc_n, posedge rst_i)
52 if (rst_i)
53 begin
54 bit_cnt <= 0;
55 op_is_write <= 0;
56 mdo_en <= 1;
57 end
58 else
59 case (bit_cnt)
60 0:
61 if (wr_en_i | rd_en_i)
62 begin
63 bit_cnt <= 1;
64 mdo_en <= 1;
65 op_is_write <= wr_en_i;
66 end
67 47:
68 begin
69 mdo_en <= op_is_write;
70 bit_cnt <= 48;
71 end
72 65:
73 begin
74 mdo_en <= 1;
75 bit_cnt <= 0;
76 end
77 default:
78 bit_cnt <= bit_cnt + 1'b1;
79 endcase
80
81 always @(posedge mdc_n, posedge rst_i)
82 if (rst_i)
83 begin
84 mdo <= 1;
85 dout_o <= 0;
86 end
87 else
88 if (1 <= bit_cnt && bit_cnt <= 32)//preamble
89 mdo <= 1;
90 else if (33 <= bit_cnt && bit_cnt <= 40)
91 mdo <= current_byte[40 - bit_cnt];
92 else if (41 <= bit_cnt && bit_cnt <= 48)
93 mdo <= current_byte[48 - bit_cnt];
94 else if (49 <= bit_cnt && bit_cnt <= 56)
95 if (op_is_write)
96 mdo <= current_byte[56 - bit_cnt];
97 else
98 dout_o[64 - bit_cnt] <= mdio_io;
99 else if (57 <= bit_cnt && bit_cnt <= 64)
100 if (op_is_write)
101 mdo <= current_byte[64 - bit_cnt];
102 else
103 dout_o[64 - bit_cnt] <= mdio_io;
104
105 endmodule
在顶层模块中要这样直接的读写寄存器还是过于麻烦，于是我将这个模块再次封装，使得在顶层模块中用一些电平信号来控制PHY的状态。目前我自己用到的只有“环回”这一个状态量，模块按照下面的代码进行了封装：
1 module PHY_Conf(
2 input clk_100m_i,
3 input rst_i,
4
5 output phy_nrst_o,
6 inout mdio_io,
7 output mdc_o,
8
9 input loopback_en_i
10 );
11
12 reg clk_1m;
13 reg [5:0] cnt;
14
15 always @(posedge clk_100m_i, posedge rst_i)
16 if (rst_i)
17 begin
18 clk_1m <= 0;
19 cnt <= 0;
20 end
21 else
22 if (cnt >= 49)
23 begin
24 clk_1m <= ~clk_1m;
25 cnt <= 0;
26 end
27 else
28 cnt <= cnt + 1'b1;
29
30 reg loopback_en_s1;
31 reg loopback_en_s2;
32
33 always @(posedge clk_1m, posedge rst_i)
34 if (rst_i)
35 begin
36 loopback_en_s1 <= 0;
37 loopback_en_s2 <= 0;
38 end
39 else
40 begin
41 loopback_en_s1 <= loopback_en_s2;
42 loopback_en_s2 <= loopback_en_i;
43 end
44
45 always @(posedge clk_1m, posedge rst_i)
46 if (rst_i)
47 begin
48 end
49 else
50 if (loopback_en_s2 != loopback_en_s1)
51 begin
52 phy_wr_en <= 1;
53 phy_din <= {1'b0, loopback_en_s2, 2'b11, 12'b0};
54 end
55 else
56 phy_wr_en <= 0;
57
58 reg phy_wr_en;
59 reg [15:0] phy_din;
60 wire [15:0] phy_dout;
61
62 PHY_Ctrl phy_ctrl(
63 .clk_i(clk_1m),
64 .rst_i(rst_i),
65 .phy_addr_i(5'b0),
66 .reg_addr_i(5'b0),
67 .din_i(phy_din),
68 .wr_en_i(phy_wr_en),
69 //.rd_en_i(phy_rd_en_i),
70 //.dout_o(phy_dout_o),
71 .phy_nrst_o(phy_nrst_o),
72 .mdio_io(mdio_io),
73 .mdc_o(mdc_o)
74 );
75
76 endmodule
在顶层模块中，我们如果需要把PHY配置为环回状态，只需要维持loopback_en_i为高电平即可，否则维持其为低电平。
在配置好PHY之后，我们要考虑发送数据和接收数据。首先为了简单起见，我们先给出最简单的发送数据的模块和接收数据的模块，然后再考虑数据的缓冲等细节。图6给出了发送数据和接收数据的时序关系以及在发送过程或接收过程中的一些特殊的标志数据：
图6 接收数据的时序以及发送过程和接收过程中的一些特殊标志数据（图片来自LAN8710A官方文档截图）
在图5中，出现了一些标志数据，其中"JK"为发送过程中的4B5B编码，不需要我们在发送模块中发送，紧随其后的"555D"则是发送数据时必须的前缀。因此，在发送数据之前要先发送"555D"；在接收数据时，真正的数据之前也有固定的前缀"55555D"，我们在接收时需要这个前缀丢弃。
在下面的代码中，我们的目标是在一个脉冲信号tx_en_i的激发下将tx_din_i上的16位数据发送出去。如上所述，在发送tx_din_i上的16位数据之前，我们发送了前缀"555d"。
1 module TX_Module(
2 input txclk_i,
3 input rst_i,
4
5 output txen_o,
6 output txer_o,
7 output reg [3:0] txd_o,
8
9 input [15:0] tx_din_i,
10 input tx_en_i,
11 output tx_busy_o
12 );
13
14 wire txclk_n;
15 assign txclk_n = ~txclk_i;
16 assign txer_o = 0;//required!
17
18 reg [3:0] cnt;
19
20 always @(posedge txclk_i, posedge rst_i)
21 if(rst_i)
22 cnt <= 0;
23 else
24 case(cnt)
25 0:
26 if(tx_en_i)
27 cnt <= 1;
28 1,2,3,4,5,6,7,8:
29 cnt <= cnt + 1'b1;
30 9:
31 cnt <= 0;
32 endcase
33
34 assign txen_o = (0 < cnt && cnt <= 9);
35 assign tx_busy_o = (cnt != 0);
36
37 always @(posedge txclk_i, posedge rst_i)
38 if(rst_i)
39 txd_o <= 0;
40 else
41 case(cnt)
42 1: txd_o <= 4'h5;//preamble
43 2: txd_o <= 4'h5;//preamble
44 3: txd_o <= 4'h5;//preamble
45 4: txd_o <= 4'hd;//preamble
46 5: txd_o <= tx_din_i[15:12];
47 6: txd_o <= tx_din_i[11:8];
48 7: txd_o <= tx_din_i[7:4];
49 8: txd_o <= tx_din_i[3:0];
50 endcase
51
52 endmodule
在上面的发送模块的代码中，txen_o信号的值是值得注意的地方，txen_o在输出数据时必须维持高电平，在数据传输完毕时立即变为低电平；另一个很重要的地方是如果暂时没有其它需求，一定要将txer_o置为低电平状态，并且连接到芯片的相应引脚，否则会导致发送模块不能正常发送数据。在这个发送模块中，每次只能发送16位数据，每次发送的前缀也占了16位，这样看来效率比较低，是一个需要改进的地方；在后续的工作中，我们在发送模块引入了FIFO，通过将模块中的cnt状态量在5、6、7、8这4个状态循环，每次会将FIFO中存在的数据全部一起发送出去，并且由于FIFO与发送模块是异步的，我们可以连续地向FIFO中写数据，发送模块连续地从FIFO取数据然后发送。
接下来的代码给出了一个简单的接收模块，该模块假设接收到的数据的大小是以16位为基本单位的，在每接收到一个完整的16位的数据后，接收模块同过将rxd_ready置位来通知上层的模块，具体代码如下：
1 module RX_Module(
2 input rxclk_i,
3 input rst_i,
4 input rxdv_i,
5 input [3:0] rxd_i,
6
7 output rx_busy_o,
8 output reg rxd_ready_o,
9 output [15:0] rx_dout_o
10 );
11
12 reg [3:0] cnt;
13 wire rxclk_n;
14
15 reg [15:0] rxd;
16 reg [15:0] rxd_buffer;
17
18 assign rxclk_n = ~rxclk_i;
19 assign rx_dout_o = rxd_buffer;
20 assign rx_busy_o = (cnt != 0);
21
22 always@(posedge rxclk_n, posedge rst_i)
23 if(rst_i)
24 cnt <= 0;
25 else
26 case(cnt)
27 0:
28 if(rxdv_i)
29 cnt <= 1;
30 1,2,3,4:
31 cnt <= cnt + 1'b1;
32 5:
33 if (rxdv_i)
34 cnt <= 6;
35 else
36 cnt <= 0;
37 6:
38 cnt <= 7;
39 7:
40 cnt <= 8;
41 8:
42 cnt <= 5;
43 endcase
44
45 always @(posedge rxclk_i, posedge rst_i)
46 if (rst_i)
47 begin
48 rxd <= 0;
49 rxd_ready_o <= 0;
50 end
51 else
52 case(cnt)
53 5: begin rxd[15:12] <= rxd_i; rxd_ready_o <= 0; end
54 6: rxd[11:8] <= rxd_i;
55 7: rxd[7:4] <= rxd_i;
56 8: begin rxd[3:0] <= rxd_i; rxd_ready_o <= 1; end
57 endcase
58
59 always @(posedge rxclk_i, posedge rst_i)
60 if (rst_i)
61 rxd_buffer <= 0;
62 else
63 if (cnt == 5 && rxd_ready_o)
64 rxd_buffer <= rxd;
65
66 endmodule
在上面的接收模块中，考虑到接收到的数据可能不止16位，因此在利用状态量cnt在5、6、7、8这几个状态循环直到接收完最后一个16位的数据，我们使用了一个16位的缓冲区，在rxd_ready有效时可以通过rx_dout信号从该缓冲区内读取上一次接收到的16位数据。
现在，我们已经实现了最基本的发送模块和接收模块，发送模块TX_Module在tx_en_i有效时将tx_din_i上的16位数据发送出去，接收模块在每次接收到16位数据后将rxd_ready置位一个时钟周期，此时上层模块可以从rx_dout_o读取这16位数据。
下面的代码给出了一个简单的顶层模块，在这个模块中，我们可以通过将tx_en_i连接到一个按键上，将tx_din_i连接到一系列的switch滑动按钮上，将rx_dout_o连接到一系列的LED灯上或者连接到七段数码管显示模块，然后使能PHY的环回功能（使loopback_en_i维持高电平），通过简单的发送数据和接收数据来验证模块功能的正确性。
1 module MII_Lite(
2 input clk_100m_i,//100Mhz
3 input rst_i,
4
5 //PHY serial management interface signals
6 output phy_nrst_o,
7 inout mdio_io,
8 output mdc_o,
9
10 //PHY configuration signals, to be extended...
11 input loopback_en_i,
12
13 input txclk_i,
14 output [3:0] txd_o,
15 output txen_o,
16 output txer_o,
17
18 input [15:0] tx_din_i,
19 input tx_en_i,
20 output tx_busy_o,
21
22 input rxclk_i,
23 input rxdv_i,
24 //input rxer_i,
25 input [3:0] rxd_i,
26
27 output rx_busy_o,
28 output rxd_ready_o,
29 output [15:0] rx_dout_o
30 );
31
32 PHY_Conf phy_conf (
33 .clk_100m_i(clk_100m_i),
34 .rst_i(rst_i),
35
36 .phy_nrst_o(phy_nrst_o),
37 .mdio_io(mdio_io),
38 .mdc_o(mdc_o),
39
40 .loopback_en_i(loopback_en_i)
41 );
42
43 reg [23:0] cnt1;
44 always @(posedge txclk_i, posedge rst_i)
45 if(rst_i)
46 cnt1 <= 0;
47 else
48 case(cnt1)
49 0:
50 if (tx_en_i)
51 begin
52 tx_en <= 1;
53 cnt1 <= 1;
54 end
55 1:
56 begin
57 tx_en <= 0;
58 cnt1 <= 2;
59 end
60 124999:
61 cnt1 <= 0;
62 default:
63 cnt1 <= cnt1 + 1'b1;
64 endcase
65
66 reg tx_en;
67
68 TX_Module tx_unit(
69 .txclk_i(txclk_i),
70 .rst_i(rst_i),
71
72 .txen_o(txen_o),
73 .txer_o(txer_o),//required!
74 .txd_o(txd_o),
75
76 .tx_din_i(tx_din_i),
77 .tx_en_i(tx_en),
78 .tx_busy_o(tx_busy_o)
79 );
80
81 RX_Module rx_unit(
82 .rxclk_i(rxclk_i),
83 .rst_i(rst_i),
84
85 .rxdv_i(rxdv_i),
86 //.rxer_i(rxer_i),
87 .rxd_i(rxd_i),
88
89 .rx_busy_o(rx_busy_o),
90 .rxd_ready_o(rxd_ready_o),
91 .rx_dout_o(rx_dout_o)
92 );
93
94 endmodule
在后续的工作中，我们在发送模块和接收模块中都加入了一个FIFO缓冲区，并且将顶层模块更仔细的封装，以提供给上层模块调用；在发送模块中，FIFO由上层模块提供的时钟信号驱动，上层模块只需要监测发送模块中的FIFO的full信号，如果full信号为低电平，则可以向FIFO中写数据，当tx_en_i有效时，发送模块周期性地检查FIFO，如果FIFO不空，则一次性地将所有数据发送出去，如果在发送过程中有数据写入FIFO，发送模块可以持续的读取并发送这些数据；在接收模块中，FIFO的时钟与接收模块的时钟相同，每当接收模块接收到一个单位（单位为FIFO的宽度）的数据后，就将这个单位的数据写入FIFO，上层模块只需要监测接收模块的FIFO的empty信号，如果empty信号为低电平，则表示接收到数据了，这是就可以将数据读取出来。
本文更新地址：http://www.cnblogs.com/hc101/p/6703805.html
##############
注:如果复位信号是低电平有效，则需将上面程序中的 if (rst_i) 语句改成 if(!rst_i) 。