Welcome to verilog-ethernet Discussions!

[alexforencich]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[quyphamdev]

Hello,
I am looking for UDP/IP HDL core to add to my Quartus project with Triple-Speed Ethernet Intel FPGA IP. Does your UDP/IP work with Intel's IPs ?
Thanks.

[alexforencich]

Never tried it, but in principle there is no reason it shouldn't work. You will likely need to adapt Avalon-ST to AXI stream. Unfortunately, I do not currently have shims to do this.

[quyphamdev]

Thanks for a quick response.

[zyq-77]

Hello,
I use your example design on Xilinx KC705 and find that the design can't process fragmented network frame. Is there a problem with my usage? Where can I modify the code to achieve this function?
Thanks.

[alexforencich]

It doesn't support it because it's a gigantic pain. You have to store all of the received fragments somewhere and keep them organized until all of the other fragments come in and the frame can be assembled. And you have to handle cases where you're missing fragments and/or they don't arrive in order. And they are guaranteed to be interleaved with other traffic, so all of this has to be done as an offshoot, and then the results merged back in later on. And if block RAM isn't large enough, then you need to rope in DRAM, etc. etc. etc. If you want fragmentation support, use a software stack.

Incidentally, TCP is also not supported for a similar reason. You have to maintain a window of packets per connection on both TX and RX, handle retransmits and timeouts, handle multiple connections in parallel, etc. And you need to have some reasonable interface to the user design that can support multiple connections and separate backpressure on each connection, etc.

The current stack is basically just packet parsing and de-parsing along with some checksum computation. Very simple and straightforward compared to what you need to do to handle TCP connections, fragmentation, etc.

[Winters123]

just a random thought: Does it make sense to integrate corundum with a TCP/IP core (like this) so that corundum will be able to support TCP-based application offloading?

[alexforencich]

Well, you can put whatever you like between the DMA engine and the wire. That specific code will not be integrated as it's written in HLS and hence cannot be simulated with the current simulation framework (cocotb + icarus verilog). It's also not clear if code written for Xilinx HLS will be portable to, say, Intel devices, which are on the roadmap for corundum. The core of corundum is 100% pure verilog for the widest possible device and tool support, and that's not something I'm going to sacrifice any time soon. I'm also not sure if it makes much sense to actually offload TCP, vs a simpler segmentation offload such as LSO. I am considering implementing LSO as part of the variable-length descriptor support, which is much simpler in comparison to full TCP offload as the network stack still handles the actual protocol.

[Helix2551]

Hello,
I am quite new in the FPGA world and will use https://github.com/corundum/corundum concept with my NetFPGA sume board.
I wanna use a SFP port for CAN bus, so the PHY Modul should meet the needed requirements.
Corundum linked this Git repository regarding their PHY Moduls.
Would you please so kind, and help me how I can figure out if the PHY Modul can use CAN ?
Thanks a lot

[alexforencich]

CAN bus? I don't think you can use the transceivers for CAN. It's not compatible electrically. You'll want to use the PMODs for CAN, and use an external CAN transceiver chip.

[Helix2551]

Ok thank you for this advise :)

[ntut317]

Hello, I am currently studying at Taipei University of Technology and the grade is the master's degree.Now I am developing chips for transmission protocol conversion. Sincerely hope you can give me some suggest about the transfer protocol conversion. If you have time, please contact me. My E-mail is [email protected], Thank you.

[QuestionAccount101]

Hello Alex, your coding is amazing! I have been working with your code and I am having issues with AXIS_ADAPTER. I can expand an AXIS going from 1byte to 2 bytes but going back down to 1 byte creates an issue. The code seems to manage the first byte correctly and drops the remaining. Any advice?

[alexforencich]

I will need to see either the code or a waveform to be able to figure out what the issue is, my assumption is something is either not properly connected or not properly configured.

[QuestionAccount101]

Hello. I just grabbed the AXIS output from your eth_mac_1g_fifo instantiation and created 2 instances of axis_adapter in the RX path. The first with S_DATA_WIDTH = 8 and M_DATA_WIDTH = 16, the second with S_DATA_WIDTH = 16 and M_DATA_WIDTH = 8. Then pass that output to your eth_axis_rx and so on for the loop. Using Wireshark I discovered only every other byte was getting returned. I will play with your code and see what I come up with and will get in touch again after I have figured it out. Thank you again, you are an epic Verilog coder.

[alexforencich]

Sounds like you might have the width wrong on the data signal, and the upper 8 bits are getting cut off.

[hemanthr28]

Hello, I am master's student in Computer Engineering. Currently working on a DSM problem. I am using Bittware 250 SoC for my work.
I am now working on porting the design to my FPGA. I referred the porting guide, as a first step, I need to create example design for verilog-ethernet and pcie. Can anyone please guide me on how to get started to create the example designs, I am completely new to FPGA developement.
My question is, do I use the pcie IP block in Vivado or do I need to modify some existing examples? If someone can brief me on how the flow is, it will be of great help. Thank you.

[alexforencich]

Are you referring to the Corundum porting guide? Anyway, creating new example designs generally just means making a copy of an existing one and editing it to run on your device. The 250 SoC has a Zynq MPSOC part on it, so presumably it will be quite similar to the ZCU106 design, except with GTY instead of GTH transceivers. TBH, if you're porting Corundum, then you can probably just make a copy of one of the Corundum designs and go from there; porting the PCIe and Ethernet designs separately is mainly important for porting to a new FPGA family, as opposed to a new board that uses an FPGA family that's already supported.

[hemanthr28]

Thank you for the information.

[astirabaloch]

Hello, I hope you are doing great.
I am using your verilog-ethernet module to send the UDP packets from DE2-115 to PC. Example design "Echo" is working fine. Now I have edited for transmission only. Setup is like that I've a fifo which feed the packets to "udp_payload_fifo". Here I have assumed that only sending the data to this fifo will be sufficient for transmission. This fifo gets full and do not transmit to module "udp_complete" . Every other signal is exactly like in Echo example. Is there anything else that I need to control for transmission ?
I have commented "rx_udp_hdr_ready" and "tx_udp_hdr_ready" is set to 1. Module "eth_axis_rx" is also commented.
Any help would be appreciated. Thanks.

[ziyangzhang0403]

hello, I use another board but have the same question with you. I can not just transmission data from FPGA to PC.
have you solved this problem?
thank u

[v-ashwin]

Can you please share the ethernet specification, which you had referred? We need that to understand the design and test scenarios.

[alexforencich]

Ethernet spec: https://ieeexplore.ieee.org/document/9844436 . You should be able to download it for free via the IEEE GET program (https://ieeexplore.ieee.org/browse/standards/get-program/page), basically just create an IEEE login and you should be able to download it. For UDP, etc. I was mainly looking at Wikipedia and RFCs.

[v-ashwin]

Alex,
Thanks for your reply. Now we are referring to the IEEE spec and trying to add registers to the design. We are currently working with interrupts. Have you implemented interrupts in your implementation? I was trying to search for IRQ_TXE / IRQ_RXE and other required registers but could not find in the RTL, are we missing something.

[dinakaran2805]

Hello @alexforencich,

I'm going through your work and I'm very impressed with it. I'm currently working on writing a top module in Verilog with instances of MII, GMII, and RGMII modules. I would greatly appreciate it if I could gain more clarity regarding the clock and reset used in the design.

From my understanding of your code, I have identified that in GMII and RGMII, "gtx_clk" operates at 125MHZ (with a time period of 8ns) to achieve a speed of 1Gbps. Additionally, there is a clock named "logic_clk," which I assume can run at any frequency (preferably greater than 125MHZ). However, in the MII module, the "logic_clk" runs at 25MHZ for 100Mbps.

In my top module, I am planning to include a global clock "CLK," which operates at either 1GHZ or 2GHZ.

I have a few queries:

1. Could you explain the purpose of "logic_clk" in MII and GMII/GMII? Is it feasible to use the same "logic_clk" for both MII and GMII/RGMII?
2. Is it possible for me to replace the "logic_clk" with my global clock "CLK"?
3. I noticed that the MII module has a reset "rst" in addition to "logic_rst." Could you clarify the purpose of the "rst"?

Any assistance on these questions would be greatly appreciated. Thank you.

[Hweyskm]

Hello dears, I implemented a simple level-2 frame forwarding by editing fpga_core as follows:

Modified fpga_core.v:

`
eth_mac_1g_rgmii_fifo #(
.TARGET(TARGET),
.USE_CLK90("TRUE"),
.ENABLE_PADDING(1),
.MIN_FRAME_LENGTH(64),
.TX_FIFO_DEPTH(4096),
.TX_FRAME_FIFO(1),
.RX_FIFO_DEPTH(4096),
.RX_FRAME_FIFO(1)
)
eth_mac_inst_0 (
.gtx_clk(clk),
.gtx_clk90(clk90),
.gtx_rst(rst),
.logic_clk(clk),
.logic_rst(rst),

.tx_axis_tdata(tx_axis_tdata_0),
.tx_axis_tvalid(tx_axis_tvalid_0),
.tx_axis_tready(tx_axis_tready_0),
.tx_axis_tlast(tx_axis_tlast_0),
.tx_axis_tuser(tx_axis_tuser_0),

.rx_axis_tdata(rx_axis_tdata_0),
.rx_axis_tvalid(rx_axis_tvalid_0),
.rx_axis_tready(rx_axis_tready_0),
.rx_axis_tlast(rx_axis_tlast_0),
.rx_axis_tuser(rx_axis_tuser_0),

.rgmii_rx_clk(phy0_rx_clk),
.rgmii_rxd(phy0_rxd),
.rgmii_rx_ctl(phy0_rx_ctl),
.rgmii_tx_clk(phy0_tx_clk),
.rgmii_txd(phy0_txd),
.rgmii_tx_ctl(phy0_tx_ctl),

.tx_fifo_overflow(),
.tx_fifo_bad_frame(),
.tx_fifo_good_frame(),
.rx_error_bad_frame(),
.rx_error_bad_fcs(),
.rx_fifo_overflow(),
.rx_fifo_bad_frame(),
.rx_fifo_good_frame(),
.speed(),

.cfg_ifg(8'd12),
.cfg_tx_enable(1'b1),
.cfg_rx_enable(1'b1)

);

// Instantiate second Ethernet MAC (Port 1)
eth_mac_1g_rgmii_fifo #(
.TARGET(TARGET),
.USE_CLK90("TRUE"),
.ENABLE_PADDING(1),
.MIN_FRAME_LENGTH(64),
.TX_FIFO_DEPTH(4096),
.TX_FRAME_FIFO(1),
.RX_FIFO_DEPTH(4096),
.RX_FRAME_FIFO(1)
)
eth_mac_inst_1 (
.gtx_clk(clk),
.gtx_clk90(clk90),
.gtx_rst(rst),
.logic_clk(clk),
.logic_rst(rst),

.tx_axis_tdata(tx_axis_tdata_1),
.tx_axis_tvalid(tx_axis_tvalid_1),
.tx_axis_tready(tx_axis_tready_1),
.tx_axis_tlast(tx_axis_tlast_1),
.tx_axis_tuser(tx_axis_tuser_1),

.rx_axis_tdata(rx_axis_tdata_1),
.rx_axis_tvalid(rx_axis_tvalid_1),
.rx_axis_tready(rx_axis_tready_1),
.rx_axis_tlast(rx_axis_tlast_1),
.rx_axis_tuser(rx_axis_tuser_1),

.rgmii_rx_clk(phy1_rx_clk),
.rgmii_rxd(phy1_rxd),
.rgmii_rx_ctl(phy1_rx_ctl),
.rgmii_tx_clk(phy1_tx_clk),
.rgmii_txd(phy1_txd),
.rgmii_tx_ctl(phy1_tx_ctl),

.tx_fifo_overflow(),
.tx_fifo_bad_frame(),
.tx_fifo_good_frame(),
.rx_error_bad_frame(),
.rx_error_bad_fcs(),
.rx_fifo_overflow(),
.rx_fifo_bad_frame(),
.rx_fifo_good_frame(),
.speed(),

.cfg_ifg(8'd12),
.cfg_tx_enable(1'b1),
.cfg_rx_enable(1'b1)

);

// Receiver from Port 0
eth_axis_rx eth_axis_rx_0 (
.clk(clk),
.rst(rst),

.s_axis_tdata(rx_axis_tdata_0),
.s_axis_tvalid(rx_axis_tvalid_0),
.s_axis_tready(rx_axis_tready_0),
.s_axis_tlast(rx_axis_tlast_0),
.s_axis_tuser(rx_axis_tuser_0),

.m_eth_hdr_valid(rx_eth_hdr_valid_0),
.m_eth_hdr_ready(rx_eth_hdr_ready_0),
.m_eth_dest_mac(rx_eth_dest_mac_0),
.m_eth_src_mac(rx_eth_src_mac_0),
.m_eth_type(rx_eth_type_0),

.m_eth_payload_axis_tdata(rx_eth_payload_axis_tdata_0),
.m_eth_payload_axis_tvalid(rx_eth_payload_axis_tvalid_0),
.m_eth_payload_axis_tready(rx_eth_payload_axis_tready_0),
.m_eth_payload_axis_tlast(rx_eth_payload_axis_tlast_0),
.m_eth_payload_axis_tuser(rx_eth_payload_axis_tuser_0),

.busy(),
.error_header_early_termination()

);

// Receiver from Port 1
eth_axis_rx eth_axis_rx_1 (
.clk(clk),
.rst(rst),

.s_axis_tdata(rx_axis_tdata_1),
.s_axis_tvalid(rx_axis_tvalid_1),
.s_axis_tready(rx_axis_tready_1),
.s_axis_tlast(rx_axis_tlast_1),
.s_axis_tuser(rx_axis_tuser_1),

.m_eth_hdr_valid(rx_eth_hdr_valid_1),
.m_eth_hdr_ready(rx_eth_hdr_ready_1),
.m_eth_dest_mac(rx_eth_dest_mac_1),
.m_eth_src_mac(rx_eth_src_mac_1),
.m_eth_type(rx_eth_type_1),

.m_eth_payload_axis_tdata(rx_eth_payload_axis_tdata_1),
.m_eth_payload_axis_tvalid(rx_eth_payload_axis_tvalid_1),
.m_eth_payload_axis_tready(rx_eth_payload_axis_tready_1),
.m_eth_payload_axis_tlast(rx_eth_payload_axis_tlast_1),
.m_eth_payload_axis_tuser(rx_eth_payload_axis_tuser_1),

.busy(),
.error_header_early_termination()

);

// Transmitter to Port 0
eth_axis_tx eth_axis_tx_0 (
.clk(clk),
.rst(rst),

.s_eth_hdr_valid(rx_eth_hdr_valid_1),
.s_eth_hdr_ready(rx_eth_hdr_ready_1),
.s_eth_dest_mac(rx_eth_dest_mac_1),
.s_eth_src_mac(rx_eth_src_mac_1),
.s_eth_type(rx_eth_type_1),

.s_eth_payload_axis_tdata(rx_eth_payload_axis_tdata_1),
.s_eth_payload_axis_tvalid(rx_eth_payload_axis_tvalid_1),
.s_eth_payload_axis_tready(rx_eth_payload_axis_tready_1),
.s_eth_payload_axis_tlast(rx_eth_payload_axis_tlast_1),
.s_eth_payload_axis_tuser(rx_eth_payload_axis_tuser_1),

.m_axis_tdata(tx_axis_tdata_0),
.m_axis_tvalid(tx_axis_tvalid_0),
.m_axis_tready(tx_axis_tready_0),
.m_axis_tlast(tx_axis_tlast_0),
.m_axis_tuser(tx_axis_tuser_0),

.busy()

);

// Transmitter to Port 1
eth_axis_tx eth_axis_tx_1 (
.clk(clk),
.rst(rst),

.s_eth_hdr_valid(rx_eth_hdr_valid_0),
.s_eth_hdr_ready(rx_eth_hdr_ready_0),
.s_eth_dest_mac(rx_eth_dest_mac_0),
.s_eth_src_mac(rx_eth_src_mac_0),
.s_eth_type(rx_eth_type_0),

.s_eth_payload_axis_tdata(rx_eth_payload_axis_tdata_0),
.s_eth_payload_axis_tvalid(rx_eth_payload_axis_tvalid_0),
.s_eth_payload_axis_tready(rx_eth_payload_axis_tready_0),
.s_eth_payload_axis_tlast(rx_eth_payload_axis_tlast_0),
.s_eth_payload_axis_tuser(rx_eth_payload_axis_tuser_0),

.m_axis_tdata(tx_axis_tdata_1),
.m_axis_tvalid(tx_axis_tvalid_1),
.m_axis_tready(tx_axis_tready_1),
.m_axis_tlast(tx_axis_tlast_1),
.m_axis_tuser(tx_axis_tuser_1),

.busy()

);
`

I'm trying to see the effects of manipulating data and how is CRC is being calculated, so I modified axis_gmii_tx.v such that I Xor the payload (excluding the first 400 bytes so that layer-3 header details and some payload bytes are passed as is ) with 10101010b. However, all frames are being dropped ( I think due to incorrect CRC). Any ideas on why my logic fails ?? Many thanks

Modified axis_gmii_tx.v:

`
// rest of logic
STATE_PAYLOAD: begin
// send payload

            update_crc = 1'b1;
            s_axis_tready_next = 1'b1;

            mii_odd_next = 1'b1;

            if (frame_min_count_reg) begin
                frame_min_count_next = frame_min_count_reg - 1;
            end
					
					gmii_txd_next = s_tdata_reg;          
					                gmii_tx_en_next = 1'b1;
					//////////////////////////////////////////////////////////
							if (byte_counter >= 400) begin
								 s_tdata_next = s_axis_tdata ^ 8'h55;  // Apply XOR after byte 400
							end else begin
							s_tdata_next = s_axis_tdata;          // Forward unchanged for first 400 bytes
					end
					/////////////////////////////////////////////////////////


            if (!s_axis_tvalid || s_axis_tlast) begin
                s_axis_tready_next = frame_next; // drop frame
                frame_error_next = !s_axis_tvalid || s_axis_tuser[0];
                error_underflow_next = !s_axis_tvalid;

                state_next = STATE_LAST;
            end else begin
                state_next = STATE_PAYLOAD;
            end
        end

// rest of logic

if (state_reg == STATE_IDLE) begin
byte_counter <= 0;
end else if (state_reg == STATE_PAYLOAD && s_axis_tvalid && s_axis_tready) begin
byte_counter <= byte_counter + 1;
end

state_reg <= state_next;

// rest of logic
`

[apriya-ram]

Do we have a top level design document so that we can use this module completely

[AjSharma-5]

Hi,

I'm working with a Vivado block design that includes a custom AXI4-Lite peripheral called muxm_pattern_generator_multi, connected to the ZYNQ7 Processing System via the M_AXI_GP0 port.

As a beginner in FPGA development, I'm trying to understand how the ZYNQ PS communicates with the IP core. Specifically, I want to clarify:

• How the AXI4-Lite interface allows the PS to send control/data to the custom peripheral.
• What kind of software read/write operations are expected (e.g., using Xil_Out32 in Vitis or SDK).
• How the IP core internally maps those AXI transactions to control logic or registers.
• If there’s an example register map or simple read/write test available.

Any pointers or documentation/examples would be really helpful.

Thanks!

[alexforencich]

This is completely irrelevant to this repo, but:

• AXI lite is just a bus for memory operations. This means that it can encode operations of the form "read from address XYZ" or "write ABC to address XYZ". If you want details on how this information is encoded, read the AXI spec from ARM. On the PS end, there is a region of address space that corresponds to each M_AXI_ port, so any memory read/write operation against that address space will result in the corresponding AXI operation on that port. So the CPU just runs an ldr or str instruction with the appropriate address.
• Nothing special is required in software, as all you need is a memory read/write. You can do that with plain C via pointer manipulation, no libraries required. Although, some extra work may be required to handle caching (disable, flush, etc.).
• The core looks at the address to determine what to do with the transaction. The address space has to be uniquely mapped, so every control register will have its own address, etc. Note that the core will probably get the full address as seen by the PS, so it should probably mask off the MSBs and just look at some number of LSBs, otherwise things probably won't work correctly.
• Xilinx probably has some examples.