Subversion Repositories bluespec_md6

//----------------------------------------------------------------------//
// The MIT License 
// 
// Copyright (c) 2008 Kermin Fleming, kfleming@mit.edu 
// 
// 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.
//----------------------------------------------------------------------//

import FIFO::*;
import FIFOF::*;
import FIFOF_::*;

/***
 *
 * This module serves as a simple bluespec wrapper for
 * the verilog based BRAMFIFO.  The imported methods support
 * the standard FIFOF and FIFO classes.  It should be noted that
 * the underlying verilog implementation is gaurded.
 *
 ***/


module mkBRAMFIFO#(Integer count) (FIFO#(fifo_type))
  provisos
          (Bits#(fifo_type, fifo_size));
  FIFOF#(fifo_type) fifo <- mkBRAMFIFOF(count);
 
  method Action enq(fifo_type data);
    fifo.enq(data);
  endmethod 

  method Action deq();
    fifo.deq();
  endmethod 
  
  method fifo_type first();
    return fifo.first();  
  endmethod

  method Action clear();
    fifo.clear();
  endmethod

endmodule

module mkBRAMFIFOF#(Integer count) (FIFOF#(fifo_type))
  provisos
          (Bits#(fifo_type, fifo_size));
  `ifdef BLUESIM
     FIFOF#(fifo_type) fifo <- mkSizedFIFOF(count);
  `else 
     error("How did we get here?");
     FIFOF#(fifo_type) fifo <- mkBRAMFIFOFIndirect(count);    
  `endif
  return fifo;
endmodule

module mkBRAMFIFOFIndirect#(Integer count) (FIFOF#(fifo_type))
  provisos
          (Bits#(fifo_type, fifo_size));

  FIFOF_#(fifo_type) fifo <- mkBRAMFIFOF_(count);    

  method Action enq(fifo_type data) if(fifo.i_notFull);
    fifo.enq(data);
  endmethod 

  method Action deq() if(fifo.i_notEmpty);
    fifo.deq();
  endmethod 
  
  method fifo_type first() if(fifo.i_notEmpty);
    return fifo.first();  
  endmethod

  method Bool notFull;
    return fifo.notFull;
  endmethod

  method Bool notEmpty;
    return fifo.notEmpty;
  endmethod

  method Action clear();
    fifo.clear();
  endmethod
 

endmodule


import "BVI" BRAMFIFOF = module mkBRAMFIFOF_#(Integer count) 
  //interface:
              (FIFOF_#(fifo_type)) 
  provisos
          (Bits#(fifo_type, fifo_size));

  default_clock clk(CLK);

  parameter                   log_data_count = log2(count);
  parameter                   data_count = count;
  parameter                   data_width = valueOf(fifo_size);

  method enq((* reg *)D_IN) enable(ENQ);
  method deq() enable(DEQ);
  method (* reg *)D_OUT first;
  method FULL_N   notFull;
  method FULL_N i_notFull;
  method (* reg *)EMPTY_N   notEmpty;
  method (* reg *)EMPTY_N i_notEmpty;
  method clear() enable(CLR);
  
  schedule deq CF (enq, i_notEmpty, i_notFull) ;
  schedule enq CF (deq, first, i_notEmpty, i_notFull) ;
  schedule (first, notEmpty, notFull) CF
             (first, i_notEmpty, i_notFull, notEmpty, notFull) ;
  schedule (i_notEmpty, i_notFull) CF
              (clear, first, i_notEmpty, i_notFull, notEmpty, notFull) ;
  schedule (clear, deq, enq) SBR clear ;
  schedule first SB (clear, deq) ;
  schedule (notEmpty, notFull) SB (clear, deq, enq) ;


  /*schedule first SB (deq,enq,clear);
  schedule first CF (first,notFull,notEmpty);
   
  schedule notFull SB (deq,enq,clear);
  schedule notFull CF (first,notFull,notEmpty);  

  schedule notEmpty SB (deq,enq,clear);
  schedule notEmpty CF (first,notFull,notEmpty);
  
  schedule deq CF enq; 
  schedule deq SB clear;
  schedule deq C  deq;

  schedule enq CF deq; 
  schedule enq SB clear;
  schedule enq C  enq;
 
  schedule clear C clear;*/
  
endmodule