X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/raggedstone/blobdiff_plain/528d015aa19100f9f97b3469ab7d2aafa43b425e..40a1f26c3a09dbd1f71f4fd7f3aca74f387a09db:/ethernet/source/pci/pci_pciw_fifo_control.v diff --git a/ethernet/source/pci/pci_pciw_fifo_control.v b/ethernet/source/pci/pci_pciw_fifo_control.v new file mode 100644 index 0000000..187e4d0 --- /dev/null +++ b/ethernet/source/pci/pci_pciw_fifo_control.v @@ -0,0 +1,326 @@ +////////////////////////////////////////////////////////////////////// +//// //// +//// File name "pciw_fifo_control.v" //// +//// //// +//// This file is part of the "PCI bridge" project //// +//// http://www.opencores.org/cores/pci/ //// +//// //// +//// Author(s): //// +//// - Miha Dolenc (mihad@opencores.org) //// +//// //// +//// All additional information is avaliable in the README //// +//// file. //// +//// //// +//// //// +////////////////////////////////////////////////////////////////////// +//// //// +//// Copyright (C) 2001 Miha Dolenc, mihad@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 //// +//// //// +////////////////////////////////////////////////////////////////////// +// +// CVS Revision History +// +// $Log: pci_pciw_fifo_control.v,v $ +// Revision 1.1 2007-03-20 17:50:56 sithglan +// add shit +// +// Revision 1.5 2003/08/14 13:06:03 simons +// synchronizer_flop replaced with pci_synchronizer_flop, artisan ram instance updated. +// +// Revision 1.4 2003/08/08 16:36:33 tadejm +// Added 'three_left_out' to pci_pciw_fifo signaling three locations before full. Added comparison between current registered cbe and next unregistered cbe to signal wb_master whether it is allowed to performe burst or not. Due to this, I needed 'three_left_out' so that writing to pci_pciw_fifo can be registered, otherwise timing problems would occure. +// +// Revision 1.3 2003/07/29 08:20:11 mihad +// Found and simulated the problem in the synchronization logic. +// Repaired the synchronization logic in the FIFOs. +// +// + +/* FIFO_CONTROL module provides read/write address and status generation for + FIFOs implemented with standard dual port SRAM cells in ASIC or FPGA designs */ +`include "pci_constants.v" +// synopsys translate_off +`include "timescale.v" +// synopsys translate_on + +module pci_pciw_fifo_control +( + rclock_in, + wclock_in, + renable_in, + wenable_in, + reset_in, + almost_full_out, + full_out, + almost_empty_out, + empty_out, + waddr_out, + raddr_out, + rallow_out, + wallow_out, + three_left_out, + two_left_out +); + +parameter ADDR_LENGTH = 7 ; + +// independent clock inputs - rclock_in = read clock, wclock_in = write clock +input rclock_in, wclock_in; + +// enable inputs - read address changes on rising edge of rclock_in when reads are allowed +// write address changes on rising edge of wclock_in when writes are allowed +input renable_in, wenable_in; + +// reset input +input reset_in; + +// almost full and empy status outputs +output almost_full_out, almost_empty_out; + +// full and empty status outputs +output full_out, empty_out; + +// read and write addresses outputs +output [(ADDR_LENGTH - 1):0] waddr_out, raddr_out; + +// read and write allow outputs +output rallow_out, wallow_out ; + +// three and two locations left output indicator +output three_left_out ; +output two_left_out ; + +// read address register +reg [(ADDR_LENGTH - 1):0] raddr ; + +// write address register +reg [(ADDR_LENGTH - 1):0] waddr; +reg [(ADDR_LENGTH - 1):0] waddr_plus1; +assign waddr_out = waddr ; + +// grey code registers +// grey code pipeline for write address +reg [(ADDR_LENGTH - 1):0] wgrey_minus1 ; // previous +reg [(ADDR_LENGTH - 1):0] wgrey_addr ; // current +reg [(ADDR_LENGTH - 1):0] wgrey_next ; // next + +reg [(ADDR_LENGTH - 1):0] wgrey_next_plus1 ; // next plus 1 + + +// next write gray address calculation - bitwise xor between address and shifted address +wire [(ADDR_LENGTH - 2):0] calc_wgrey_next = waddr[(ADDR_LENGTH - 1):1] ^ waddr[(ADDR_LENGTH - 2):0] ; +wire [(ADDR_LENGTH - 2):0] calc_wgrey_next_plus1 = waddr_plus1[(ADDR_LENGTH - 1):1] ^ waddr_plus1[(ADDR_LENGTH - 2):0] ; + +// grey code pipeline for read address +reg [(ADDR_LENGTH - 1):0] rgrey_minus2 ; // two before current +reg [(ADDR_LENGTH - 1):0] rgrey_minus1 ; // one before current +reg [(ADDR_LENGTH - 1):0] rgrey_addr ; // current +reg [(ADDR_LENGTH - 1):0] rgrey_next ; // next + +// next read gray address calculation - bitwise xor between address and shifted address +wire [(ADDR_LENGTH - 2):0] calc_rgrey_next = raddr[(ADDR_LENGTH - 1):1] ^ raddr[(ADDR_LENGTH - 2):0] ; + +// write allow - writes are allowed when fifo is not full +assign wallow_out = wenable_in & ~full_out ; + +// clear generation for FFs and registers +wire clear = reset_in ; + +//rallow generation +assign rallow_out = renable_in & ~empty_out ; // reads allowed if read enable is high and FIFO is not empty + +// at any clock edge that rallow is high, this register provides next read address, so wait cycles are not necessary +// when FIFO is empty, this register provides actual read address, so first location can be read +reg [(ADDR_LENGTH - 1):0] raddr_plus_one ; + + +// read address mux - when read is performed, next address is driven, so next data is available immediately after read +// this is convenient for zero wait stait bursts +assign raddr_out = rallow_out ? raddr_plus_one : raddr ; + +always@(posedge rclock_in or posedge clear) +begin + if (clear) + begin + // initial values seem a bit odd - they are this way to allow easier grey pipeline implementation and to allow min fifo size of 8 + raddr_plus_one <= #`FF_DELAY 5 ; + raddr <= #`FF_DELAY 4 ; +// raddr_plus_one <= #`FF_DELAY 6 ; +// raddr <= #`FF_DELAY 5 ; + end + else if (rallow_out) + begin + raddr_plus_one <= #`FF_DELAY raddr_plus_one + 1'b1 ; + raddr <= #`FF_DELAY raddr_plus_one ; + end +end + +/*----------------------------------------------------------------------------------------------- +Read address control consists of Read address counter and Grey Address pipeline +There are 4 Grey addresses: + - rgrey_minus2 is Grey Code of address two before current address + - rgrey_minus1 is Grey Code of address one before current address + - rgrey_addr is Grey Code of current read address + - rgrey_next is Grey Code of next read address +--------------------------------------------------------------------------------------------------*/ +// grey coded address pipeline for status generation in read clock domain +always@(posedge rclock_in or posedge clear) +begin + if (clear) + begin + rgrey_minus2 <= #1 0 ; + rgrey_minus1 <= #`FF_DELAY 1 ; + rgrey_addr <= #1 3 ; + rgrey_next <= #`FF_DELAY 2 ; + end + else + if (rallow_out) + begin + rgrey_minus2 <= #1 rgrey_minus1 ; + rgrey_minus1 <= #`FF_DELAY rgrey_addr ; + rgrey_addr <= #1 rgrey_next ; + rgrey_next <= #`FF_DELAY {raddr[ADDR_LENGTH - 1], calc_rgrey_next} ; + end +end + +/*-------------------------------------------------------------------------------------------- +Write address control consists of write address counter and 3 Grey Code Registers: + - wgrey_minus1 represents previous Grey coded write address + - wgrey_addr represents current Grey Coded write address + - wgrey_next represents next Grey Coded write address + + - wgrey_next_plus1 represents second next Grey Coded write address + +----------------------------------------------------------------------------------------------*/ +// grey coded address pipeline for status generation in write clock domain +always@(posedge wclock_in or posedge clear) +begin + if (clear) + begin + wgrey_minus1 <= #`FF_DELAY 1 ; + wgrey_addr <= #`FF_DELAY 3 ; + wgrey_next <= #`FF_DELAY 2 ; + + wgrey_next_plus1 <= #`FF_DELAY 6; + + end + else + if (wallow_out) + begin + wgrey_minus1 <= #`FF_DELAY wgrey_addr ; + wgrey_addr <= #`FF_DELAY wgrey_next ; + + wgrey_next <= #`FF_DELAY {waddr[(ADDR_LENGTH - 1)], calc_wgrey_next} ; +// wgrey_next <= #`FF_DELAY wgrey_next_plus1 ; + wgrey_next_plus1 <= #`FF_DELAY {waddr_plus1[(ADDR_LENGTH - 1)], calc_wgrey_next_plus1} ; + + end +end + +// write address counter - nothing special except initial value +always@(posedge wclock_in or posedge clear) +begin + if (clear) + begin + // initial value 5 + + waddr <= #`FF_DELAY 4 ; + waddr_plus1 <= #`FF_DELAY 5 ; + end + else + if (wallow_out) + begin + waddr <= #`FF_DELAY waddr + 1'b1 ; + waddr_plus1 <= #`FF_DELAY waddr_plus1 + 1'b1 ; + end +end + +/*------------------------------------------------------------------------------------------------------------------------------ +Gray coded address of read address decremented by two is synchronized to write clock domain and compared to: +- previous grey coded write address - if they are equal, the fifo is full + +- gray coded write address. If they are equal, fifo is almost full. + +- grey coded next write address. If they are equal, the fifo has two free locations left. +--------------------------------------------------------------------------------------------------------------------------------*/ +wire [(ADDR_LENGTH - 1):0] wclk_sync_rgrey_minus2 ; +reg [(ADDR_LENGTH - 1):0] wclk_rgrey_minus2 ; + +pci_synchronizer_flop #(ADDR_LENGTH, 0) i_synchronizer_reg_rgrey_minus2 +( + .data_in (rgrey_minus2), + .clk_out (wclock_in), + .sync_data_out (wclk_sync_rgrey_minus2), + .async_reset (clear) +) ; + +always@(posedge wclock_in or posedge clear) +begin + if (clear) + begin + wclk_rgrey_minus2 <= #`FF_DELAY 0 ; + end + else + begin + wclk_rgrey_minus2 <= #`FF_DELAY wclk_sync_rgrey_minus2 ; + end +end + +assign full_out = (wgrey_minus1 == wclk_rgrey_minus2) ; +assign almost_full_out = (wgrey_addr == wclk_rgrey_minus2) ; +assign two_left_out = (wgrey_next == wclk_rgrey_minus2) ; + +assign three_left_out = (wgrey_next_plus1 == wclk_rgrey_minus2) ; + + +/*------------------------------------------------------------------------------------------------------------------------------ +Empty control: +Gray coded write address pointer is synchronized to read clock domain and compared to Gray coded read address pointer. +If they are equal, fifo is empty. + +Almost empty control: +Synchronized write pointer is also compared to Gray coded next read address. If these two are +equal, fifo is almost empty. +--------------------------------------------------------------------------------------------------------------------------------*/ +wire [(ADDR_LENGTH - 1):0] rclk_sync_wgrey_addr ; +reg [(ADDR_LENGTH - 1):0] rclk_wgrey_addr ; +pci_synchronizer_flop #(ADDR_LENGTH, 3) i_synchronizer_reg_wgrey_addr +( + .data_in (wgrey_addr), + .clk_out (rclock_in), + .sync_data_out (rclk_sync_wgrey_addr), + .async_reset (clear) +) ; + +always@(posedge rclock_in or posedge clear) +begin + if (clear) + rclk_wgrey_addr <= #`FF_DELAY 3 ; + else + rclk_wgrey_addr <= #`FF_DELAY rclk_sync_wgrey_addr ; +end + +assign almost_empty_out = (rgrey_next == rclk_wgrey_addr) ; +assign empty_out = (rgrey_addr == rclk_wgrey_addr) ; +endmodule