URL https://opencores.org/ocsvn/amber/amber/trunk

Subversion Repositories amber

[/] [amber/] [trunk/] [hw/] [vlog/] [tb/] [eth_test.v] - Blame information for rev 61

Go to most recent revision | Details | Compare with Previous | View Log


//////////////////////////////////////////////////////////////////
//                                                              //
//  Top-level module instantiating the entire Amber 2 system.   //
//                                                              //
//  This file is part of the Amber project                      //
//  http://www.opencores.org/project,amber                      //
//                                                              //
//  Description                                                 //
//  This is the highest level synthesizable module in the       //
//  project. The ports in this module represent pins on the     //
//  FPGA.                                                       //
//                                                              //
//  Author(s):                                                  //
//      - Conor Santifort, csantifort.amber@gmail.com           //
//                                                              //
//////////////////////////////////////////////////////////////////
//                                                              //
// Copyright (C) 2012 Authors and OPENCORES.ORG                 //
//                                                              //
// This source file may be used and distributed without         //
// restriction provided that this copyright statement is not    //
// removed from the file and that any derivative work contains  //
// the original copyright notice and the associated disclaimer. //
//                                                              //
// This source file is free software; you can redistribute it   //
// and/or modify it under the terms of the GNU Lesser General   //
// Public License as published by the Free Software Foundation; //
// either version 2.1 of the License, or (at your option) any   //
// later version.                                               //
//                                                              //
// This source is distributed in the hope that it will be       //
// useful, but WITHOUT ANY WARRANTY; without even the implied   //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      //
// PURPOSE.  See the GNU Lesser General Public License for more //
// details.                                                     //
//                                                              //
// You should have received a copy of the GNU Lesser General    //
// Public License along with this source; if not, download it   //
// from http://www.opencores.org/lgpl.shtml                     //
//                                                              //
//////////////////////////////////////////////////////////////////
`timescale  1 ps / 1 ps
 
 
module eth_test
(
// MD interface - serial configuration of PHY
inout                       md_io,
input                       mdc_i,
 
// MAC interface - packet to DUT
input                       mtx_clk_i,
output reg [3:0]            mtxd_o,
output reg                  mtxdv_o,
output reg                  mtxerr_o,
 
 
// MAC interface - packet from DUT
input      [3:0]            mrxd_i,
input                       mrxdv_i
);
 
`include "debug_functions.v"
`include "system_functions.v"
 
// mxt state machine
localparam IDLE = 4'd0;
localparam TX_0 = 4'd1;
localparam TX_1 = 4'd2;
localparam WAIT = 4'd3;
localparam PREA = 4'd4;
localparam PREB = 4'd5;
localparam GAP  = 4'd6;
localparam CRC0 = 4'd7;
localparam CRCN = 4'd8;
localparam POLL = 4'd9;
 
 
// rx state machine
localparam RX_IDLE = 4'd0;
localparam RX_0    = 4'd1;
localparam RX_1    = 4'd2;
localparam RX_PRE  = 4'd3;
localparam RX_DONE = 4'd4;
 
 
// md state machine
localparam MD_REGADDR = 4'd0;
localparam MD_PHYADDR = 4'd1;
localparam MD_WRITE0  = 4'd2;
localparam MD_READ0   = 4'd3;
localparam MD_START1  = 4'd4;
localparam MD_START0  = 4'd5;
localparam MD_IDLE    = 4'd6;
localparam MD_TURN0   = 4'd7;
localparam MD_TURN1   = 4'd8;
localparam MD_RDATA   = 4'd9;
localparam MD_WDATA   = 4'd10;
localparam MD_WXFR    = 4'd11;
 
localparam MDREAD  = 1'd0;
localparam MDWRITE = 1'd1;
 
 
// MD register addresses        
localparam MII_BMCR     = 5'd0;        /* Basic mode control register */
localparam MII_BMSR     = 5'd1;        /* Basic mode status register  */
localparam MII_CTRL1000 = 5'd9;        /* 1000BASE-T control          */
 
 
reg [7:0]   mem [2**16-1:0];
reg [7:0]   eth [13:0];
 
reg [7:0]   rxm [2047:0];
 
reg [15:0]  line_r  = 16'd0;
reg [15:0]  rx_line_r;
 
reg [3:0]   state_r = IDLE;
reg [3:0]   md_state_r = MD_IDLE;
reg [3:0]   rx_state_r = RX_IDLE;
reg [15:0]  pkt_len_r;
reg [31:0]  wcount_r;
reg [15:0]  pkt_pos_r;
reg [3:0]   pcount_r;
 
reg         md_op_r = MDREAD;
reg [4:0]   md_count_r;
reg [4:0]   md_phy_addr_r;
reg [4:0]   md_reg_addr_r;
reg [15:0]  md_rdata_r;
reg [15:0]  md_wdata_r;
reg [15:0]  md_bmcr_r = 'd0;
reg [15:0]  md_ctrl1000_r = 16'hffff;
wire        init;
wire [31:0] crc;
wire [3:0]  crc_dinx;
reg  [3:0]  crc_din;
wire        enable;
reg  [3:0]  mrxd_r;
 
reg  [7:0]  last_pkt_num_r = 'd0;
 
 
integer             pkt_to_amber_file;
integer             pkt_to_amber_ack_file;
integer             pkt_from_amber_file;
 
reg [8*20-1:0]      pkt_to_amber     = "pkt_to_amber.mem";
reg [8*20-1:0]      pkt_to_amber_ack = "pkt_to_amber_ack.txt";
reg [8*20-1:0]      pkt_from_amber   = "pkt_from_amber.mem";
 
reg     [4*8-1:0]   line;
integer             fgets_return;
integer             pkt_to_amber_address;
reg [7:0]           pkt_to_amber_data;
 
integer             x;
reg [7:0]           pkt_from_amber_num = 8'd1;
 
 
// initializwe the ack file to 0
// this allows sim_socket to write the first packet
initial
    begin
    pkt_to_amber_ack_file = $fopen(pkt_to_amber_ack, "w");
    $fwrite(pkt_to_amber_ack_file, "0\n");
    $fclose(pkt_to_amber_ack_file);
    end
 
 
// ============================
// packet tx state machine
// ============================
always@(posedge mtx_clk_i)
    begin
    case (state_r)
        IDLE:
            begin
            mtxd_o    <= 'd0;
            mtxdv_o   <= 'd0;
            mtxerr_o  <= 'd0;
            wcount_r  <= 'd0;
 
            if (md_bmcr_r[9])  // autoneg bit set by software
                begin
                wcount_r  <= wcount_r + 1'd1;
                if (wcount_r == 32'd10000)
                    begin
                    state_r   <= POLL;
                    wcount_r  <= 'd0;
                    $display("Start polling for packets to send to amber");
                    end
                end
            end
 
 
 
        WAIT:
            begin
            wcount_r <= wcount_r + 1'd1;
            if (wcount_r == 32'd100)
                begin
                wcount_r <= 'd0;
                state_r  <= POLL;
                end
            end
 
 
        POLL: // scan for new packets
            begin
            mtxd_o    <= 'd0;
            mtxdv_o   <= 'd0;
            mtxerr_o  <= 'd0;
 
 
            pkt_to_amber_file               = $fopen(pkt_to_amber, "r");
            fgets_return                    = $fgets(line, pkt_to_amber_file);
            pkt_to_amber_address = 0;
            while (fgets_return)
                begin
                pkt_to_amber_data           = hex_chars_to_8bits (line[23:8]);
                mem[pkt_to_amber_address]   = pkt_to_amber_data[7:0];
                pkt_to_amber_address        = pkt_to_amber_address + 1;
                fgets_return                = $fgets(line, pkt_to_amber_file);
                end
            $fclose(pkt_to_amber_file);
 
 
            if (mem[0] != last_pkt_num_r)
                begin
                state_r         <= PREA;
                pkt_len_r       <= {mem[1], mem[2]} + 16'd14;
                last_pkt_num_r  <= mem[0];
                line_r          <= 'd0;
                pkt_pos_r       <= 'd0;
                pcount_r        <= 'd0;
                wcount_r        <= 'd0;
 
                pkt_to_amber_ack_file = $fopen(pkt_to_amber_ack, "w");
                $fwrite(pkt_to_amber_ack_file, "%d\n", mem[0]);
                $fclose(pkt_to_amber_ack_file);
                end
            else begin
                state_r   <= WAIT;
                end
 
            end
 
 
 
        PREA: // Preamble
            begin
            mtxd_o    <= 4'b0101;
            mtxdv_o   <= 1'd1;
            pcount_r  <= pcount_r + 1'd1;
            if (pcount_r == 4'd6)
                begin
                pcount_r  <= 'd0;
                state_r   <= PREB;
                end
            end
 
 
        PREB:
            begin
            mtxd_o    <= 4'b1101;
            mtxdv_o   <= 1'd1;
            state_r   <= TX_0;
 
            print_pkt(1'd1, line_r);
            end
 
 
        TX_0:  // low 4 bits
            begin
            mtxd_o    <= mem[line_r+3][3:0];
            mtxdv_o   <= 1'd1;
            state_r   <= TX_1;
            end
 
 
        TX_1:  // high 4 bits
            begin
            mtxd_o    <= mem[line_r+3][7:4];
            mtxdv_o   <= 1'd1;
            line_r    <= line_r + 1'd1;
 
            if (pkt_pos_r + 1'd1 == pkt_len_r)
                state_r     <= CRC0;
            else
                begin
                state_r     <= TX_0;
                pkt_pos_r   <= pkt_pos_r + 1'd1;
                end
            end
 
 
        CRC0:
            begin
            mtxd_o    <= {~crc[28], ~crc[29], ~crc[30], ~crc[31]};
            mtxdv_o   <= 1'd1;
            state_r   <= POLL;
            end
 
    endcase
    end
 
 
 
assign init    = state_r == PREB;
assign enable  = state_r != CRC0;
 
always @*
    begin
        crc_din = state_r == TX_0 ? mem[line_r+3][3:0] :
                  state_r == TX_1 ? mem[line_r+3][7:4] :
                                   32'd0               ;
    end
 
 
assign crc_dinx = {crc_din[0], crc_din[1], crc_din[2], crc_din[3]};
 
 
// Gen CRC, using the EthMac CRC generator
eth_crc eth_crc (
    .Clk        ( mtx_clk_i ),
    .Reset      ( 1'd0      ),
    .Data       ( crc_dinx  ),
    .Enable     ( enable    ),
    .Initialize ( init      ),
 
    .Crc        ( crc       ),
    .CrcError   (           )
);
 
 
// ============================
// packet rx state machine
// ============================
always@(posedge mtx_clk_i)
    begin
    case (rx_state_r)
        RX_IDLE:
            begin
            rx_line_r  <= 'd0;
            if (mrxdv_i)  // autoneg bit set by software
                begin
                rx_state_r   <= RX_PRE;
                end
            end
 
        RX_PRE:
            begin
            if (mrxd_i == 4'hd)
                rx_state_r   <= RX_0;
            end
 
        RX_0:  // low 4 bits
            begin
            mrxd_r <= mrxd_i;
 
            if (mrxdv_i)
                rx_state_r     <= RX_1;
            else
                rx_state_r     <= RX_DONE;
            end
 
 
        RX_1:  // high 4 bits
            begin
            rxm[rx_line_r]      <= {mrxd_i, mrxd_r};
            rx_line_r           <= rx_line_r + 1'd1;
 
            if (mrxdv_i)
                rx_state_r     <= RX_0;
            else
                rx_state_r     <= RX_DONE;
            end
 
 
        RX_DONE:
            begin
            print_pkt(1'd0, 16'd0);
            rx_state_r     <= RX_IDLE;
 
 
            pkt_from_amber_file     = $fopen(pkt_from_amber, "w");
            $fwrite(pkt_from_amber_file, "%02h\n", pkt_from_amber_num);
 
            for (x=0;x<rx_line_r;x=x+1)
                $fwrite(pkt_from_amber_file, "%02h\n", rxm[x]);
            $fclose(pkt_from_amber_file);
 
 
            if (pkt_from_amber_num == 8'd255)
                pkt_from_amber_num  <= 8'd1;
            else
                pkt_from_amber_num  <=  pkt_from_amber_num + 1'd1;
            end
 
 
    endcase
    end
 
 
 
 
// ============================
// management data state machine
// ============================
always@(posedge mdc_i)
    begin
    case (md_state_r)
 
        MD_IDLE:
            begin
            md_count_r <= 'd0;
            if (md_io == 1'd0)
                md_state_r   <= MD_START0;
            end
 
 
        MD_START0:
            begin
            if (md_io == 1'd1)
                md_state_r   <= MD_START1;
            else
                md_state_r   <= MD_IDLE;
            end
 
 
        MD_START1:
            begin
            if (md_io == 1'd1)
                md_state_r  <= MD_READ0;
            else
                md_state_r  <= MD_WRITE0;
            end
 
 
       MD_READ0:
            begin
            if (md_io == 1'd0)
                begin
                md_state_r  <= MD_PHYADDR;
                md_op_r     <= MDREAD;
                end
            else
                md_state_r  <= MD_IDLE;
            end
 
 
       MD_WRITE0:
            begin
            if (md_io == 1'd1)
                begin
                md_state_r  <= MD_PHYADDR;
                md_op_r     <= MDWRITE;
                end
            else
                md_state_r  <= MD_IDLE;
            end
 
        MD_PHYADDR:
            begin
            md_count_r      <= md_count_r + 1'd1;
            md_phy_addr_r   <= {md_phy_addr_r[3:0], md_io};
 
            if (md_count_r == 5'd4)
                begin
                md_state_r  <= MD_REGADDR;
                md_count_r  <= 'd0;
                end
            end
 
        MD_REGADDR:
            begin
            md_count_r      <= md_count_r + 1'd1;
            md_reg_addr_r   <= {md_reg_addr_r[3:0], md_io};
 
            if (md_count_r == 5'd4)
                begin
                md_count_r  <= 'd0;
                md_state_r  <= MD_TURN0;
                end
            end
 
 
        MD_TURN0:
            md_state_r  <= MD_TURN1;
 
        MD_TURN1:
            begin
            if (md_op_r == MDREAD)
                md_state_r  <= MD_RDATA;
            else
                md_state_r  <= MD_WDATA;
 
            case (md_reg_addr_r)
                MII_BMCR        : md_rdata_r <= md_bmcr_r;
                MII_BMSR        : md_rdata_r <= 16'hfe04;
                MII_CTRL1000    : md_rdata_r <= md_ctrl1000_r;
                default         : md_rdata_r <= 'd0;
            endcase
            end
 
 
        MD_RDATA:
            begin
            md_count_r  <= md_count_r + 1'd1;
            md_rdata_r  <= {md_rdata_r[14:0], 1'd0};
 
            if (md_count_r == 5'd15)
                md_state_r  <= MD_IDLE;
 
            end
 
 
        MD_WDATA:
            begin
            md_count_r  <= md_count_r + 1'd1;
            md_wdata_r  <= {md_wdata_r[14:0], md_io};
 
            if (md_count_r == 5'd15)
                begin
                md_state_r  <= MD_WXFR;
                md_count_r  <= 'd0;
                end
            end
 
 
        MD_WXFR:
            begin
            case (md_reg_addr_r)
                MII_BMCR        : md_bmcr_r     <= md_wdata_r;
                MII_CTRL1000    : md_ctrl1000_r <= md_wdata_r;
            endcase
            md_state_r  <= MD_IDLE;
            end
 
 
    endcase
    end
 
 
assign md_io = md_state_r == MD_RDATA ? md_rdata_r[15] : 1'bz;
 
 
 
task print_pkt;
input        tx;   /* 1 for tx, 0 for rx */
input [31:0] start;
reg   [15:0] eth_type;
reg   [7:0]  proto;
reg   [31:0] frame;
reg   [3:0]  ip_hdr_len;
reg   [15:0] ip_len;
reg   [3:0]  tcp_hdr_len;
reg   [15:0] tcp_bdy_len;
reg   [7:0]  tmp;
reg   [15:0] arp_op;
 
integer      i;
begin
    frame = start;
 
    if (tx) $write("%6d pkt to   amber ", tb.clk_count);
    else    $write("%6d pkt from amber ", tb.clk_count);
 
    $display("mac-dst %h:%h:%h:%h:%h:%h, mac-src %h:%h:%h:%h:%h:%h, type %h%h",
        rmem(tx,frame+0), rmem(tx,frame+1),rmem(tx,frame+2),rmem(tx,frame+3),rmem(tx,frame+4),rmem(tx,frame+5),
        rmem(tx,frame+6), rmem(tx,frame+7),rmem(tx,frame+8),rmem(tx,frame+9),rmem(tx,frame+10),rmem(tx,frame+11),
        rmem(tx,frame+12),rmem(tx,frame+13));
 
    eth_type = {rmem(tx,frame+12),rmem(tx,frame+13)};
 
    if (eth_type == 16'h0806) // arp
        begin
        frame       = frame + 14;
        arp_op      = rmem(tx,frame+6) << 8 | rmem(tx,frame+7);
 
        $write("ARP operation %0d", arp_op);
 
        if (arp_op == 16'd1)
            $write(" look for ip %0d.%0d.%0d.%0d",
                rmem(tx,frame+24), rmem(tx,frame+25),rmem(tx,frame+26),rmem(tx,frame+27));
        $write("\n");
        end
 
    if (eth_type == 16'h0800) // ip
        begin
        frame       = frame + 14;
        proto       = rmem(tx,frame+9);
        tmp         = rmem(tx,frame+0);
        ip_hdr_len  = tmp[3:0];
        ip_len      = {rmem(tx,frame+2), rmem(tx,frame+3)};
 
        $display("   ip-dst %0d.%0d.%0d.%0d, ip-src %0d.%0d.%0d.%0d, proto %0d, ip_len %0d, ihl %0d",
            rmem(tx,frame+16), rmem(tx,frame+17),rmem(tx,frame+18),rmem(tx,frame+19),
            rmem(tx,frame+12), rmem(tx,frame+13),rmem(tx,frame+14),rmem(tx,frame+15),
            proto, ip_len, ip_hdr_len*4);
 
        if (proto == 8'd6) // TCP
            begin
            frame       = frame + ip_hdr_len*4;
            tmp         = rmem(tx,frame+12);
            tcp_hdr_len = tmp[7:4];
            tcp_bdy_len = ip_len - ({ip_hdr_len,2'd0} + {tcp_hdr_len,2'd0});
 
            $display("   tcp-dst %0d, tcp-src %0d, tcp hdr len %0d, tcp bdy len %0d",
                {rmem(tx,frame+2), rmem(tx,frame+3)},
                {rmem(tx,frame+0), rmem(tx,frame+1)}, tcp_hdr_len*4, tcp_bdy_len);
            $display("   tcp-seq %0d, tcp-ack %0d",
                {rmem(tx,frame+4), rmem(tx,frame+5), rmem(tx,frame+6), rmem(tx,frame+7)},
                {rmem(tx,frame+8), rmem(tx,frame+9), rmem(tx,frame+10), rmem(tx,frame+11)});
 
            if (tcp_bdy_len != 16'd0)
                begin
                for (i=0;i<tcp_bdy_len;i=i+1)
                    if ((rmem(tx,frame+tcp_hdr_len*4+i) > 31 && rmem(tx,frame+tcp_hdr_len*4+i) < 128) ||
                        (rmem(tx,frame+tcp_hdr_len*4+i) == "\n"))
                        $write("%c",  rmem(tx,frame+tcp_hdr_len*4+i));
                end
 
            end
        end
    $display("----");
end
endtask
 
 
function [7:0] rmem;
input        tx;   /* 1 for tx, 0 for rx */
input [31:0] addr;
begin
    if (tx)
        rmem = mem[addr+3];
    else
        rmem = rxm[addr];
end
endfunction
 
 
wire [8*6-1:0] XSTATE =
    state_r == IDLE ? "IDLE"    :
    state_r == WAIT ? "WAIT"    :
    state_r == TX_0 ? "TX_0"    :
    state_r == TX_1 ? "TX_1"    :
    state_r == PREA ? "PREA"    :
    state_r == PREB ? "PREB"    :
    state_r == GAP  ? "GAP"     :
    state_r == CRC0 ? "CRC0"    :
    state_r == CRCN ? "CRCN"    :
    state_r == POLL ? "POLL"    :
                      "UNKNOWN" ;
 
wire [8*12-1:0] XRXSTATE =
    state_r == RX_IDLE  ? "RX_IDLE" :
    state_r == RX_0     ? "RX_0"    :
    state_r == RX_1     ? "RX_1"    :
    state_r == RX_PRE   ? "RX_PRE"  :
    state_r == RX_DONE  ? "RX_DONE" :
                          "UNKNOWN" ;
 
wire [8*12-1:0] XMDSTATE =
    md_state_r == MD_WXFR    ?  "MD_WXFR"    :
    md_state_r == MD_WDATA   ?  "MD_WDATA"   :
    md_state_r == MD_RDATA   ?  "MD_RDATA"   :
    md_state_r == MD_TURN1   ?  "MD_TURN1"   :
    md_state_r == MD_TURN0   ?  "MD_TURN0"   :
    md_state_r == MD_REGADDR ?  "MD_REGADDR" :
    md_state_r == MD_PHYADDR ?  "MD_PHYADDR" :
    md_state_r == MD_WRITE0  ?  "MD_WRITE0"  :
    md_state_r == MD_READ0   ?  "MD_READ0"   :
    md_state_r == MD_START1  ?  "MD_START1"  :
    md_state_r == MD_START0  ?  "MD_START0"  :
    md_state_r == MD_IDLE    ?  "MD_IDLE"    :
                                "UNKNOWN"    ;
 
endmodule
 
 

Browse

Tools

Subversion Repositories amber

[/] [amber/] [trunk/] [hw/] [vlog/] [tb/] [eth_test.v] - Blame information for rev 61

Line No.	Rev	Author	Line
1	61	csantifort	`//////////////////////////////////////////////////////////////////`
2			`// //`
3			`// Top-level module instantiating the entire Amber 2 system. //`
4			`// //`
5			`// This file is part of the Amber project //`
6			`// http://www.opencores.org/project,amber //`
7			`// //`
8			`// Description //`
9			`// This is the highest level synthesizable module in the //`
10			`// project. The ports in this module represent pins on the //`
11			`// FPGA. //`
12			`// //`
13			`// Author(s): //`
14			`// - Conor Santifort, csantifort.amber@gmail.com //`
15			`// //`
16			`//////////////////////////////////////////////////////////////////`
17			`// //`
18			`// Copyright (C) 2012 Authors and OPENCORES.ORG //`
19			`// //`
20			`// This source file may be used and distributed without //`
21			`// restriction provided that this copyright statement is not //`
22			`// removed from the file and that any derivative work contains //`
23			`// the original copyright notice and the associated disclaimer. //`
24			`// //`
25			`// This source file is free software; you can redistribute it //`
26			`// and/or modify it under the terms of the GNU Lesser General //`
27			`// Public License as published by the Free Software Foundation; //`
28			`// either version 2.1 of the License, or (at your option) any //`
29			`// later version. //`
30			`// //`
31			`// This source is distributed in the hope that it will be //`
32			`// useful, but WITHOUT ANY WARRANTY; without even the implied //`
33			`// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //`
34			`// PURPOSE. See the GNU Lesser General Public License for more //`
35			`// details. //`
36			`// //`
37			`// You should have received a copy of the GNU Lesser General //`
38			`// Public License along with this source; if not, download it //`
39			`// from http://www.opencores.org/lgpl.shtml //`
40			`// //`
41			`//////////////////////////////////////////////////////////////////`
42			`timescale 1 ps / 1 ps
43
44
45			`module eth_test`
46			`(`
47			`// MD interface - serial configuration of PHY`
48			`inout md_io,`
49			`input mdc_i,`
50
51			`// MAC interface - packet to DUT`
52			`input mtx_clk_i,`
53			`output reg [3:0] mtxd_o,`
54			`output reg mtxdv_o,`
55			`output reg mtxerr_o,`
56
57
58			`// MAC interface - packet from DUT`
59			`input [3:0] mrxd_i,`
60			`input mrxdv_i`
61			`);`
62
63			`include "debug_functions.v"
64			`include "system_functions.v"
65
66			`// mxt state machine`
67			`localparam IDLE = 4'd0;`
68			`localparam TX_0 = 4'd1;`
69			`localparam TX_1 = 4'd2;`
70			`localparam WAIT = 4'd3;`
71			`localparam PREA = 4'd4;`
72			`localparam PREB = 4'd5;`
73			`localparam GAP = 4'd6;`
74			`localparam CRC0 = 4'd7;`
75			`localparam CRCN = 4'd8;`
76			`localparam POLL = 4'd9;`
77
78
79			`// rx state machine`
80			`localparam RX_IDLE = 4'd0;`
81			`localparam RX_0 = 4'd1;`
82			`localparam RX_1 = 4'd2;`
83			`localparam RX_PRE = 4'd3;`
84			`localparam RX_DONE = 4'd4;`
85
86
87			`// md state machine`
88			`localparam MD_REGADDR = 4'd0;`
89			`localparam MD_PHYADDR = 4'd1;`
90			`localparam MD_WRITE0 = 4'd2;`
91			`localparam MD_READ0 = 4'd3;`
92			`localparam MD_START1 = 4'd4;`
93			`localparam MD_START0 = 4'd5;`
94			`localparam MD_IDLE = 4'd6;`
95			`localparam MD_TURN0 = 4'd7;`
96			`localparam MD_TURN1 = 4'd8;`
97			`localparam MD_RDATA = 4'd9;`
98			`localparam MD_WDATA = 4'd10;`
99			`localparam MD_WXFR = 4'd11;`
100
101			`localparam MDREAD = 1'd0;`
102			`localparam MDWRITE = 1'd1;`
103
104
105			`// MD register addresses`
106			`localparam MII_BMCR = 5'd0; /* Basic mode control register */`
107			`localparam MII_BMSR = 5'd1; /* Basic mode status register */`
108			`localparam MII_CTRL1000 = 5'd9; /* 1000BASE-T control */`
109
110
111			`reg [7:0] mem [2**16-1:0];`
112			`reg [7:0] eth [13:0];`
113
114			`reg [7:0] rxm [2047:0];`
115
116			`reg [15:0] line_r = 16'd0;`
117			`reg [15:0] rx_line_r;`
118
119			`reg [3:0] state_r = IDLE;`
120			`reg [3:0] md_state_r = MD_IDLE;`
121			`reg [3:0] rx_state_r = RX_IDLE;`
122			`reg [15:0] pkt_len_r;`
123			`reg [31:0] wcount_r;`
124			`reg [15:0] pkt_pos_r;`
125			`reg [3:0] pcount_r;`
126
127			`reg md_op_r = MDREAD;`
128			`reg [4:0] md_count_r;`
129			`reg [4:0] md_phy_addr_r;`
130			`reg [4:0] md_reg_addr_r;`
131			`reg [15:0] md_rdata_r;`
132			`reg [15:0] md_wdata_r;`
133			`reg [15:0] md_bmcr_r = 'd0;`
134			`reg [15:0] md_ctrl1000_r = 16'hffff;`
135			`wire init;`
136			`wire [31:0] crc;`
137			`wire [3:0] crc_dinx;`
138			`reg [3:0] crc_din;`
139			`wire enable;`
140			`reg [3:0] mrxd_r;`
141
142			`reg [7:0] last_pkt_num_r = 'd0;`
143
144
145			`integer pkt_to_amber_file;`
146			`integer pkt_to_amber_ack_file;`
147			`integer pkt_from_amber_file;`
148
149			`reg [8*20-1:0] pkt_to_amber = "pkt_to_amber.mem";`
150			`reg [8*20-1:0] pkt_to_amber_ack = "pkt_to_amber_ack.txt";`
151			`reg [8*20-1:0] pkt_from_amber = "pkt_from_amber.mem";`
152
153			`reg [4*8-1:0] line;`
154			`integer fgets_return;`
155			`integer pkt_to_amber_address;`
156			`reg [7:0] pkt_to_amber_data;`
157
158			`integer x;`
159			`reg [7:0] pkt_from_amber_num = 8'd1;`
160
161
162			`// initializwe the ack file to 0`
163			`// this allows sim_socket to write the first packet`
164			`initial`
165			`begin`
166			`pkt_to_amber_ack_file = $fopen(pkt_to_amber_ack, "w");`
167			`$fwrite(pkt_to_amber_ack_file, "0\n");`
168			`$fclose(pkt_to_amber_ack_file);`
169			`end`
170
171
172			`// ============================`
173			`// packet tx state machine`
174			`// ============================`
175			`always@(posedge mtx_clk_i)`
176			`begin`
177			`case (state_r)`
178			`IDLE:`
179			`begin`
180			`mtxd_o <= 'd0;`
181			`mtxdv_o <= 'd0;`
182			`mtxerr_o <= 'd0;`
183			`wcount_r <= 'd0;`
184
185			`if (md_bmcr_r[9]) // autoneg bit set by software`
186			`begin`
187			`wcount_r <= wcount_r + 1'd1;`
188			`if (wcount_r == 32'd10000)`
189			`begin`
190			`state_r <= POLL;`
191			`wcount_r <= 'd0;`
192			`$display("Start polling for packets to send to amber");`
193			`end`
194			`end`
195			`end`
196
197
198
199			`WAIT:`
200			`begin`
201			`wcount_r <= wcount_r + 1'd1;`
202			`if (wcount_r == 32'd100)`
203			`begin`
204			`wcount_r <= 'd0;`
205			`state_r <= POLL;`
206			`end`
207			`end`
208
209
210			`POLL: // scan for new packets`
211			`begin`
212			`mtxd_o <= 'd0;`
213			`mtxdv_o <= 'd0;`
214			`mtxerr_o <= 'd0;`
215
216
217			`pkt_to_amber_file = $fopen(pkt_to_amber, "r");`
218			`fgets_return = $fgets(line, pkt_to_amber_file);`
219			`pkt_to_amber_address = 0;`
220			`while (fgets_return)`
221			`begin`
222			`pkt_to_amber_data = hex_chars_to_8bits (line[23:8]);`
223			`mem[pkt_to_amber_address] = pkt_to_amber_data[7:0];`
224			`pkt_to_amber_address = pkt_to_amber_address + 1;`
225			`fgets_return = $fgets(line, pkt_to_amber_file);`
226			`end`
227			`$fclose(pkt_to_amber_file);`
228
229
230			`if (mem[0] != last_pkt_num_r)`
231			`begin`
232			`state_r <= PREA;`
233			`pkt_len_r <= {mem[1], mem[2]} + 16'd14;`
234			`last_pkt_num_r <= mem[0];`
235			`line_r <= 'd0;`
236			`pkt_pos_r <= 'd0;`
237			`pcount_r <= 'd0;`
238			`wcount_r <= 'd0;`
239
240			`pkt_to_amber_ack_file = $fopen(pkt_to_amber_ack, "w");`
241			`$fwrite(pkt_to_amber_ack_file, "%d\n", mem[0]);`
242			`$fclose(pkt_to_amber_ack_file);`
243			`end`
244			`else begin`
245			`state_r <= WAIT;`
246			`end`
247
248			`end`
249
250
251
252			`PREA: // Preamble`
253			`begin`
254			`mtxd_o <= 4'b0101;`
255			`mtxdv_o <= 1'd1;`
256			`pcount_r <= pcount_r + 1'd1;`
257			`if (pcount_r == 4'd6)`
258			`begin`
259			`pcount_r <= 'd0;`
260			`state_r <= PREB;`
261			`end`
262			`end`
263
264
265			`PREB:`
266			`begin`
267			`mtxd_o <= 4'b1101;`
268			`mtxdv_o <= 1'd1;`
269			`state_r <= TX_0;`
270
271			`print_pkt(1'd1, line_r);`
272			`end`
273
274
275			`TX_0: // low 4 bits`
276			`begin`
277			`mtxd_o <= mem[line_r+3][3:0];`
278			`mtxdv_o <= 1'd1;`
279			`state_r <= TX_1;`
280			`end`
281
282
283			`TX_1: // high 4 bits`
284			`begin`
285			`mtxd_o <= mem[line_r+3][7:4];`
286			`mtxdv_o <= 1'd1;`
287			`line_r <= line_r + 1'd1;`
288
289			`if (pkt_pos_r + 1'd1 == pkt_len_r)`
290			`state_r <= CRC0;`
291			`else`
292			`begin`
293			`state_r <= TX_0;`
294			`pkt_pos_r <= pkt_pos_r + 1'd1;`
295			`end`
296			`end`
297
298
299			`CRC0:`
300			`begin`
301			`mtxd_o <= {~crc[28], ~crc[29], ~crc[30], ~crc[31]};`
302			`mtxdv_o <= 1'd1;`
303			`state_r <= POLL;`
304			`end`
305
306			`endcase`
307			`end`
308
309
310
311			`assign init = state_r == PREB;`
312			`assign enable = state_r != CRC0;`
313
314			`always @*`
315			`begin`
316			`crc_din = state_r == TX_0 ? mem[line_r+3][3:0] :`
317			`state_r == TX_1 ? mem[line_r+3][7:4] :`
318			`32'd0 ;`
319			`end`
320
321
322			`assign crc_dinx = {crc_din[0], crc_din[1], crc_din[2], crc_din[3]};`
323
324
325			`// Gen CRC, using the EthMac CRC generator`
326			`eth_crc eth_crc (`
327			`.Clk ( mtx_clk_i ),`
328			`.Reset ( 1'd0 ),`
329			`.Data ( crc_dinx ),`
330			`.Enable ( enable ),`
331			`.Initialize ( init ),`
332
333			`.Crc ( crc ),`
334			`.CrcError ( )`
335			`);`
336
337
338			`// ============================`
339			`// packet rx state machine`
340			`// ============================`
341			`always@(posedge mtx_clk_i)`
342			`begin`
343			`case (rx_state_r)`
344			`RX_IDLE:`
345			`begin`
346			`rx_line_r <= 'd0;`
347			`if (mrxdv_i) // autoneg bit set by software`
348			`begin`
349			`rx_state_r <= RX_PRE;`
350			`end`
351			`end`
352
353			`RX_PRE:`
354			`begin`
355			`if (mrxd_i == 4'hd)`
356			`rx_state_r <= RX_0;`
357			`end`
358
359			`RX_0: // low 4 bits`
360			`begin`
361			`mrxd_r <= mrxd_i;`
362
363			`if (mrxdv_i)`
364			`rx_state_r <= RX_1;`
365			`else`
366			`rx_state_r <= RX_DONE;`
367			`end`
368
369
370			`RX_1: // high 4 bits`
371			`begin`
372			`rxm[rx_line_r] <= {mrxd_i, mrxd_r};`
373			`rx_line_r <= rx_line_r + 1'd1;`
374
375			`if (mrxdv_i)`
376			`rx_state_r <= RX_0;`
377			`else`
378			`rx_state_r <= RX_DONE;`
379			`end`
380
381
382			`RX_DONE:`
383			`begin`
384			`print_pkt(1'd0, 16'd0);`
385			`rx_state_r <= RX_IDLE;`
386
387
388			`pkt_from_amber_file = $fopen(pkt_from_amber, "w");`
389			`$fwrite(pkt_from_amber_file, "%02h\n", pkt_from_amber_num);`
390
391			`for (x=0;x<rx_line_r;x=x+1)`
392			`$fwrite(pkt_from_amber_file, "%02h\n", rxm[x]);`
393			`$fclose(pkt_from_amber_file);`
394
395
396			`if (pkt_from_amber_num == 8'd255)`
397			`pkt_from_amber_num <= 8'd1;`
398			`else`
399			`pkt_from_amber_num <= pkt_from_amber_num + 1'd1;`
400			`end`
401
402
403			`endcase`
404			`end`
405
406
407
408
409			`// ============================`
410			`// management data state machine`
411			`// ============================`
412			`always@(posedge mdc_i)`
413			`begin`
414			`case (md_state_r)`
415
416			`MD_IDLE:`
417			`begin`
418			`md_count_r <= 'd0;`
419			`if (md_io == 1'd0)`
420			`md_state_r <= MD_START0;`
421			`end`
422
423
424			`MD_START0:`
425			`begin`
426			`if (md_io == 1'd1)`
427			`md_state_r <= MD_START1;`
428			`else`
429			`md_state_r <= MD_IDLE;`
430			`end`
431
432
433			`MD_START1:`
434			`begin`
435			`if (md_io == 1'd1)`
436			`md_state_r <= MD_READ0;`
437			`else`
438			`md_state_r <= MD_WRITE0;`
439			`end`
440
441
442			`MD_READ0:`
443			`begin`
444			`if (md_io == 1'd0)`
445			`begin`
446			`md_state_r <= MD_PHYADDR;`
447			`md_op_r <= MDREAD;`
448			`end`
449			`else`
450			`md_state_r <= MD_IDLE;`
451			`end`
452
453
454			`MD_WRITE0:`
455			`begin`
456			`if (md_io == 1'd1)`
457			`begin`
458			`md_state_r <= MD_PHYADDR;`
459			`md_op_r <= MDWRITE;`
460			`end`
461			`else`
462			`md_state_r <= MD_IDLE;`
463			`end`
464
465			`MD_PHYADDR:`
466			`begin`
467			`md_count_r <= md_count_r + 1'd1;`
468			`md_phy_addr_r <= {md_phy_addr_r[3:0], md_io};`
469
470			`if (md_count_r == 5'd4)`
471			`begin`
472			`md_state_r <= MD_REGADDR;`
473			`md_count_r <= 'd0;`
474			`end`
475			`end`
476
477			`MD_REGADDR:`
478			`begin`
479			`md_count_r <= md_count_r + 1'd1;`
480			`md_reg_addr_r <= {md_reg_addr_r[3:0], md_io};`
481
482			`if (md_count_r == 5'd4)`
483			`begin`
484			`md_count_r <= 'd0;`
485			`md_state_r <= MD_TURN0;`
486			`end`
487			`end`
488
489
490			`MD_TURN0:`
491			`md_state_r <= MD_TURN1;`
492
493			`MD_TURN1:`
494			`begin`
495			`if (md_op_r == MDREAD)`
496			`md_state_r <= MD_RDATA;`
497			`else`
498			`md_state_r <= MD_WDATA;`
499
500			`case (md_reg_addr_r)`
501			`MII_BMCR : md_rdata_r <= md_bmcr_r;`
502			`MII_BMSR : md_rdata_r <= 16'hfe04;`
503			`MII_CTRL1000 : md_rdata_r <= md_ctrl1000_r;`
504			`default : md_rdata_r <= 'd0;`
505			`endcase`
506			`end`
507
508
509			`MD_RDATA:`
510			`begin`
511			`md_count_r <= md_count_r + 1'd1;`
512			`md_rdata_r <= {md_rdata_r[14:0], 1'd0};`
513
514			`if (md_count_r == 5'd15)`
515			`md_state_r <= MD_IDLE;`
516
517			`end`
518
519
520			`MD_WDATA:`
521			`begin`
522			`md_count_r <= md_count_r + 1'd1;`
523			`md_wdata_r <= {md_wdata_r[14:0], md_io};`
524
525			`if (md_count_r == 5'd15)`
526			`begin`
527			`md_state_r <= MD_WXFR;`
528			`md_count_r <= 'd0;`
529			`end`
530			`end`
531
532
533			`MD_WXFR:`
534			`begin`
535			`case (md_reg_addr_r)`
536			`MII_BMCR : md_bmcr_r <= md_wdata_r;`
537			`MII_CTRL1000 : md_ctrl1000_r <= md_wdata_r;`
538			`endcase`
539			`md_state_r <= MD_IDLE;`
540			`end`
541
542
543			`endcase`
544			`end`
545
546
547			`assign md_io = md_state_r == MD_RDATA ? md_rdata_r[15] : 1'bz;`
548
549
550
551			`task print_pkt;`
552			`input tx; /* 1 for tx, 0 for rx */`
553			`input [31:0] start;`
554			`reg [15:0] eth_type;`
555			`reg [7:0] proto;`
556			`reg [31:0] frame;`
557			`reg [3:0] ip_hdr_len;`
558			`reg [15:0] ip_len;`
559			`reg [3:0] tcp_hdr_len;`
560			`reg [15:0] tcp_bdy_len;`
561			`reg [7:0] tmp;`
562			`reg [15:0] arp_op;`
563
564			`integer i;`
565			`begin`
566			`frame = start;`
567
568			`if (tx) $write("%6d pkt to amber ", tb.clk_count);`
569			`else $write("%6d pkt from amber ", tb.clk_count);`
570
571			`$display("mac-dst %h:%h:%h:%h:%h:%h, mac-src %h:%h:%h:%h:%h:%h, type %h%h",`
572			`rmem(tx,frame+0), rmem(tx,frame+1),rmem(tx,frame+2),rmem(tx,frame+3),rmem(tx,frame+4),rmem(tx,frame+5),`
573			`rmem(tx,frame+6), rmem(tx,frame+7),rmem(tx,frame+8),rmem(tx,frame+9),rmem(tx,frame+10),rmem(tx,frame+11),`
574			`rmem(tx,frame+12),rmem(tx,frame+13));`
575
576			`eth_type = {rmem(tx,frame+12),rmem(tx,frame+13)};`
577
578			`if (eth_type == 16'h0806) // arp`
579			`begin`
580			`frame = frame + 14;`
581			`arp_op = rmem(tx,frame+6) << 8 \| rmem(tx,frame+7);`
582
583			`$write("ARP operation %0d", arp_op);`
584
585			`if (arp_op == 16'd1)`
586			`$write(" look for ip %0d.%0d.%0d.%0d",`
587			`rmem(tx,frame+24), rmem(tx,frame+25),rmem(tx,frame+26),rmem(tx,frame+27));`
588			`$write("\n");`
589			`end`
590
591			`if (eth_type == 16'h0800) // ip`
592			`begin`
593			`frame = frame + 14;`
594			`proto = rmem(tx,frame+9);`
595			`tmp = rmem(tx,frame+0);`
596			`ip_hdr_len = tmp[3:0];`
597			`ip_len = {rmem(tx,frame+2), rmem(tx,frame+3)};`
598
599			`$display(" ip-dst %0d.%0d.%0d.%0d, ip-src %0d.%0d.%0d.%0d, proto %0d, ip_len %0d, ihl %0d",`
600			`rmem(tx,frame+16), rmem(tx,frame+17),rmem(tx,frame+18),rmem(tx,frame+19),`
601			`rmem(tx,frame+12), rmem(tx,frame+13),rmem(tx,frame+14),rmem(tx,frame+15),`
602			`proto, ip_len, ip_hdr_len*4);`
603
604			`if (proto == 8'd6) // TCP`
605			`begin`
606			`frame = frame + ip_hdr_len*4;`
607			`tmp = rmem(tx,frame+12);`
608			`tcp_hdr_len = tmp[7:4];`
609			`tcp_bdy_len = ip_len - ({ip_hdr_len,2'd0} + {tcp_hdr_len,2'd0});`
610
611			`$display(" tcp-dst %0d, tcp-src %0d, tcp hdr len %0d, tcp bdy len %0d",`
612			`{rmem(tx,frame+2), rmem(tx,frame+3)},`
613			`{rmem(tx,frame+0), rmem(tx,frame+1)}, tcp_hdr_len*4, tcp_bdy_len);`
614			`$display(" tcp-seq %0d, tcp-ack %0d",`
615			`{rmem(tx,frame+4), rmem(tx,frame+5), rmem(tx,frame+6), rmem(tx,frame+7)},`
616			`{rmem(tx,frame+8), rmem(tx,frame+9), rmem(tx,frame+10), rmem(tx,frame+11)});`
617
618			`if (tcp_bdy_len != 16'd0)`
619			`begin`
620			`for (i=0;i<tcp_bdy_len;i=i+1)`
621			`if ((rmem(tx,frame+tcp_hdr_len4+i) > 31 && rmem(tx,frame+tcp_hdr_len4+i) < 128) \|\|`
622			`(rmem(tx,frame+tcp_hdr_len*4+i) == "\n"))`
623			`$write("%c", rmem(tx,frame+tcp_hdr_len*4+i));`
624			`end`
625
626			`end`
627			`end`
628			`$display("----");`
629			`end`
630			`endtask`
631
632
633			`function [7:0] rmem;`
634			`input tx; /* 1 for tx, 0 for rx */`
635			`input [31:0] addr;`
636			`begin`
637			`if (tx)`
638			`rmem = mem[addr+3];`
639			`else`
640			`rmem = rxm[addr];`
641			`end`
642			`endfunction`
643
644
645			`wire [8*6-1:0] XSTATE =`
646			`state_r == IDLE ? "IDLE" :`
647			`state_r == WAIT ? "WAIT" :`
648			`state_r == TX_0 ? "TX_0" :`
649			`state_r == TX_1 ? "TX_1" :`
650			`state_r == PREA ? "PREA" :`
651			`state_r == PREB ? "PREB" :`
652			`state_r == GAP ? "GAP" :`
653			`state_r == CRC0 ? "CRC0" :`
654			`state_r == CRCN ? "CRCN" :`
655			`state_r == POLL ? "POLL" :`
656			`"UNKNOWN" ;`
657
658			`wire [8*12-1:0] XRXSTATE =`
659			`state_r == RX_IDLE ? "RX_IDLE" :`
660			`state_r == RX_0 ? "RX_0" :`
661			`state_r == RX_1 ? "RX_1" :`
662			`state_r == RX_PRE ? "RX_PRE" :`
663			`state_r == RX_DONE ? "RX_DONE" :`
664			`"UNKNOWN" ;`
665
666			`wire [8*12-1:0] XMDSTATE =`
667			`md_state_r == MD_WXFR ? "MD_WXFR" :`
668			`md_state_r == MD_WDATA ? "MD_WDATA" :`
669			`md_state_r == MD_RDATA ? "MD_RDATA" :`
670			`md_state_r == MD_TURN1 ? "MD_TURN1" :`
671			`md_state_r == MD_TURN0 ? "MD_TURN0" :`
672			`md_state_r == MD_REGADDR ? "MD_REGADDR" :`
673			`md_state_r == MD_PHYADDR ? "MD_PHYADDR" :`
674			`md_state_r == MD_WRITE0 ? "MD_WRITE0" :`
675			`md_state_r == MD_READ0 ? "MD_READ0" :`
676			`md_state_r == MD_START1 ? "MD_START1" :`
677			`md_state_r == MD_START0 ? "MD_START0" :`
678			`md_state_r == MD_IDLE ? "MD_IDLE" :`
679			`"UNKNOWN" ;`
680
681			`endmodule`
682
683