Subversion Repositories bluespec-h264

// The MIT License

// Copyright (c) 2006-2007 Massachusetts Institute of Technology

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

package mkSizedFIFO_fpga;

import FIFO::*;
import RWire::*;
import RegFile::*;
import IFPGA_FIFO::*;

module mkSizedFIFO_fpga (IFPGA_FIFO#(f_type, size))
  provisos(
            Bits#(f_type, f_type_length),
            Add#(TLog#(size), 0, lg_size),
            Add#(TLog#(size), 1, lg_size_plus),
            Add#(2, TLog#(size),lg_size_plus_plus), 
            Add#(1, lg_size_plus, lg_size_plus_plus)
          );
  
  RegFile#(Bit#(TLog#(size)), f_type) data <- mkRegFile(0, fromInteger(valueof(TSub#(size,1))));
  Reg#(Bit#(lg_size_plus)) number_enqueued <- mkReg(0);
  Reg#(Bit#(TLog#(size))) base_ptr <- mkReg(0);
  RWire#(Bit#(0)) deque_pending <- mkRWire();
  RWire#(Bit#(0)) clear_pending <- mkRWire();
  RWire#(f_type) enque_pending <- mkRWire();

  // We'll have problems with non-saturating additions, so we ought to add some checks
  // Strongly Recommend power of 2 sizes to simpilfy logic.

  rule update;
    if(clear_pending.wget() matches tagged Valid .v)
      begin
        //clear is occuring, we drop a pending enqueue on the floor.
        number_enqueued <= 0;
        base_ptr <= 0;
      end
    else
      begin
       if(enque_pending.wget() matches tagged Valid .new_data)
         begin
           if(deque_pending.wget() matches tagged Valid .dp)
             begin
               // enque and deque occuring.. no change to net.
               base_ptr <= (zeroExtend(base_ptr) == fromInteger(valueof(size)-1))? 0:base_ptr + 1;
               Bit#(lg_size_plus_plus) offset = zeroExtend((zeroExtend(base_ptr) + number_enqueued)); 
               data.upd((offset >= fromInteger(valueof(size)))?
                           truncate(offset - truncate(fromInteger(valueof(size)))):
                          truncate(offset),    
                       new_data);
             end
           else
             begin
               number_enqueued <= number_enqueued + 1;
               Bit#(lg_size_plus_plus) offset = zeroExtend((zeroExtend(base_ptr) + number_enqueued)); 
               data.upd((offset >= fromInteger(valueof(size)))?
                           truncate(offset - truncate(fromInteger(valueof(size)))):
                           truncate(offset),    
                        new_data);
             end
         end 
       else
         begin
           if(deque_pending.wget() matches tagged Valid .dp)
             begin
               //enque and deque occuring.. no change to net.
               base_ptr <= (zeroExtend(base_ptr) == truncate(fromInteger(valueof(size)-1)))? 0:base_ptr + 1;
               number_enqueued <= number_enqueued - 1;
             end
         end 
      end
  endrule

  interface FIFO fifo;

    method Action enq (f_type value) if(number_enqueued < fromInteger(valueof(size)));
      enque_pending.wset(value);
    endmethod

    method Action deq()  if(number_enqueued > 0);
      deque_pending.wset(0);
    endmethod 

    method f_type first() if(number_enqueued > 0);
      return data.sub(base_ptr);
    endmethod 

    method Action clear();
      clear_pending.wset(0);
    endmethod

  endinterface

endmodule
endpackage