ethtest.v

MII接口1转2处理

// ethtest.v
// xikang
// 2003-7-16
//

module ethtest ( reset, clk, txclken, txdat, txen, rxclken, rxdat, rxen, err );

parameter 	PREAMBLE= 8'b01010101,
			SFD		= 8'b11010101,
			MINLEN	= 46,
			MAXLEN	= 1500,
			MAXGAP	= 200000;
			
input 				reset, clk, txclken, rxclken, rxen;
output reg			txen, err;
input  [7 : 0]		rxdat;
output reg[7 : 0]	txdat;

function [7 : 0] reverse8;
	input  [7 : 0] din;
	integer i;

	for( i = 0; i < 8; i = i + 1 )
		reverse8[i] = din[7-i];

endfunction


/////////////////////////////////////////////////////////////////////////
// tx
reg [ 7 : 0]	txdat_tmp;
reg [15 : 0]	datlen;
wire [ 7 : 0]	fcs;
reg [18 : 0]	gap;
reg [15 : 0]	seccnt;
reg				frame_en;
reg				pre_en;
reg				sfd_en;
reg				dst_en;
reg				src_en;
reg				len_en;
reg				dat_en;
reg				fcs_en;
reg				fcs_en_d;

wire [31 : 0]	txcrc_reg;
wire			d_valid;
reg				txcalc, txinit, txen_d;

assign d_valid = 1;
crc32 U_TXCRC32 ( .crc_reg(txcrc_reg), .crc(fcs), .d((txdat_tmp)), .calc(txcalc), .init(txinit), .d_valid(d_valid), .clk(clk), .clken( txclken ), .reset(reset) );

always @ ( posedge clk, negedge reset )
begin
	if( ! reset )
	begin
		txdat		<= 0;
		txdat_tmp	<= 0;
		txen	<= 0;
		txen_d	<= 0;
		datlen	<= MINLEN - 1;
		seccnt	<= 0;
		gap		<= 0;
		pre_en	<= 0;
		sfd_en	<= 0;
		dst_en	<= 0;
		src_en	<= 0;
		len_en	<= 0;
		dat_en	<= 0;
		fcs_en	<= 0;
		fcs_en_d<= 0;
		txcalc	<= 0;
		txinit	<= 1;
		frame_en	<= 0;
	end
	else if( txclken )
	begin
		if( fcs_en_d )
			txdat <= reverse8( fcs );
		else
			txdat <= reverse8( txdat_tmp );

		fcs_en_d <= fcs_en;
		txen_d	<= frame_en;
		txen	<= txen_d;
		if( gap != 0 )
			gap 	<= gap - 1;

		if( ( gap == 0 ) && ( frame_en == 0 ) )
		begin
			gap 	<= MAXGAP;
			frame_en<= 1;
			if( datlen == MAXLEN )
				datlen <= MINLEN;
			else
				datlen	<= datlen + 1;
			seccnt	<= 6;

			pre_en	<= 1;
			sfd_en	<= 0;
			dst_en	<= 0;
			src_en	<= 0;
			len_en	<= 0;
			dat_en	<= 0;
			fcs_en	<= 0;
		end

		if( frame_en )
		begin
			gap	<= MAXGAP;
			//////////////////////////////////
			// PREAMBLE 
			if( pre_en )
			begin
				txinit	<= 1;
				txdat_tmp	<= PREAMBLE;
				if( seccnt == 0 )
				begin
					pre_en	<= 0;
					sfd_en 	<= 1;
				end
				else
					seccnt	<= seccnt - 1;
			end
			//////////////////////////////////
			// SFD 
			if( sfd_en )
			begin
				txdat_tmp	<= SFD;
				sfd_en		<= 0;
				seccnt		<= 5;
				dst_en 		<= 1;
			end
			//////////////////////////////////
			// DST 
			if( dst_en )
			begin
				txinit		<= 0;
				txcalc		<= 1;

				if( seccnt == 0 )
				begin
					txdat_tmp 	<= 1;
					dst_en		<= 0;
					seccnt		<= 5;
					src_en 		<= 1;
				end
				else
				begin
					txdat_tmp 	<= 0;
					seccnt		<= seccnt - 1;
				end
			end
			//////////////////////////////////
			// SRC 
			if( src_en )
			begin
				if( seccnt == 0 )
				begin
					txdat_tmp 	<= 2;
					src_en		<= 0;
					seccnt		<= 1;
					len_en 		<= 1;
				end
				else
				begin
					txdat_tmp 	<= 0;
					seccnt		<= seccnt - 1;
				end
			end
			//////////////////////////////////
			// LENGTH 
			if( len_en )
			begin
				if( seccnt == 1 )
				begin
					seccnt		<= 0;
					txdat_tmp 	<= datlen[15 : 8];
				end
				else
				begin
					txdat_tmp 	<= datlen[7 : 0];
					len_en	<= 0;
					seccnt	<= datlen - 1;
					dat_en 	<= 1;
				end
			end

			//////////////////////////////////
			// dat 
			if( dat_en )
			begin
				txdat_tmp 	<= seccnt[7 : 0];
				if( seccnt == 0 )
				begin
					seccnt		<= 3;
					dat_en 		<= 0;
					fcs_en 		<= 1;
				end
				else
					seccnt	<= seccnt - 1;
			end
			//////////////////////////////////
			// FCS 
			if( fcs_en )
			begin
				txcalc		<= 0;
				txdat_tmp 	<= reverse8( fcs );
				if( seccnt == 0 )
				begin
					fcs_en 		<= 0;
					frame_en	<= 0;
				end
				else
					seccnt	<= seccnt - 1;
			end
		end
	end
end

/////////////////////////////////////////////////////////////////////////
// rx

wire [ 7 : 0]	rxdat_tmp;
reg				rxpk_en;
reg				rxdst_en;
reg				rxsrc_en;
reg				rxlen_en;
reg				rxdat_en;
reg				rxfcs_en;
reg	[15 : 0]	rxcnt;
reg	[15 : 0]	nextpklen;
reg	[ 7 : 0]	rxlen_hi;
reg	[ 5 : 0]	watchdog;

wire[31 : 0]	rxcrc_reg;
wire[7 : 0]		rxfcs;
reg				rxcalc, rxinit, clr;
reg	[5 : 0]		cycle;

assign rxdat_tmp = reverse8(rxdat);

crc32 U_RXCRC32 ( .crc_reg(rxcrc_reg), .crc(rxfcs), .d(rxdat_tmp), .calc(rxcalc), .init(rxinit), .d_valid(d_valid), .clk(clk), .clken( rxclken ), .reset(reset) );


always @ ( posedge clk, negedge reset )
begin
	if( ! reset )
	begin
		cycle		<= 0;
		err			<= 0;
		rxdst_en	<= 0;
		rxsrc_en	<= 0;
		rxlen_en	<= 0;
		rxdat_en	<= 0;
		rxfcs_en	<= 0;
		rxpk_en		<= 0;
		rxcnt		<= 0;
		rxinit		<= 1;
		rxcalc		<= 0;
		rxlen_hi	<= 0;
		clr			<= 1;
		watchdog	<= MAXGAP + 10;
		nextpklen	<= MINLEN;
	end
	else if( rxclken )
	begin
		if( watchdog == 0 )
			err <= 1;

		if( err == 0 )
			cycle <= 1;

		clr <= 0;
		if( clr )
		begin
			cycle <= cycle + 1;
			if( cycle == 0 )
				err <= 0;
		end

		if( ! rxen )
		begin
			watchdog	<= watchdog - 1;
			rxdst_en	<= 0;
			rxsrc_en	<= 0;
			rxlen_en	<= 0;
			rxdat_en	<= 0;
			rxfcs_en	<= 0;
			rxpk_en		<= 0;
		end
		else
		begin
			watchdog	<= MAXGAP + 10;
			//////////////////////////////////////////////////////
			// SFD
			if( (! rxpk_en ) && ( rxdat_tmp == SFD ) )
			begin
				rxpk_en		<= 1;
				rxdst_en	<= 1;
				rxcnt		<= 5;
				rxcalc		<= 1;
				rxinit		<= 0;
			end

			//////////////////////////////////////////////////////
			// DST
			if( rxdst_en )
			begin
				if( rxcnt == 0 )
				begin
					rxdst_en	<= 0;
					rxsrc_en	<= 1;
					rxcnt		<= 5;
				end
				else
					rxcnt <= rxcnt - 1;
			end

			//////////////////////////////////////////////////////
			// SRC
			if( rxsrc_en )
			begin
				if( rxcnt == 0 )
				begin
					rxsrc_en	<= 0;
					rxlen_en	<= 1;
					rxcnt		<= 1;
				end
				else
					rxcnt <= rxcnt - 1;
			end

			//////////////////////////////////////////////////////
			// LEN
			if( rxlen_en )
			begin
				if( rxcnt == 0 )
				begin
					rxlen_en	<= 0;
					rxdat_en	<= 1;
					rxcnt		<= { rxlen_hi, rxdat_tmp };
					if( { rxlen_hi, rxdat_tmp } == MAXLEN )
						nextpklen	<= MINLEN;
					else
						nextpklen	<= { rxlen_hi, rxdat_tmp } + 1;

					if( { rxlen_hi, rxdat_tmp } == MINLEN )
						clr <= 1;

					if( { rxlen_hi, rxdat_tmp } != nextpklen )
						err <= 1;
				end
				else
				begin
					rxlen_hi <= rxdat_tmp;
					rxcnt <= rxcnt - 1;
				end
			end

			//////////////////////////////////////////////////////
			// DAT
			if( rxdat_en )
			begin
				if( rxcnt == 1 )
				begin
					rxcalc		<= 0;
					rxdat_en	<= 0;
					rxfcs_en	<= 1;
					rxcnt		<= 3;
				end
				else
					rxcnt <= rxcnt - 1;
			end

			//////////////////////////////////////////////////////
			// FCS
			if( rxfcs_en )
			begin
				if( rxfcs != rxdat_tmp )
					err <= 1;

				if( rxcnt == 0 )
				begin
					rxfcs_en	<= 0;
					rxpk_en		<= 0;
					rxinit		<= 1;
				end
				else
					rxcnt <= rxcnt - 1;
			end
		end

	end
end

endmodule