Subversion Repositories cryptosorter

//----------------------------------------------------------------------//
//                          Qualcomm Proprietary                        //
//                     Copyright (c) 2006 Qualcomm Inc.                 //
//                          All rights reserved.                        //
//----------------------------------------------------------------------//
//        File: $RCSfile: NewBRAMFIFO.bsv,v $
//      Author: Alfred Man Cheuk Ng, Abhinav Agarwal
//     Created: 2007-07-13
// Description: FIFO and FIFOF implemented using BRAM, default 4 elements
//
//----------------------------------------------------------------------//
// $Id: NewBRAMFIFO.bsv,v 1.1 2008-06-30 16:02:10 kfleming Exp $
//----------------------------------------------------------------------//

import BRAM::*;
import EHRReg::*;
import FIFO::*;
import FIFOF::*;

// schedule = (notEmpty = first < deq < notFull < enq) C clear 
module mkNewBRAMFIFOF(FIFOF#(a))
   provisos (Bits#(a,asz));
   
   // state elements
   UGBRAM#(Bit#(8), a) bram  <- mkBypassUGBRAM_Full; // 256 elements memory storage
   EHRReg#(2,Bit#(8))  head  <- mkEHRReg(0);         // head pointer
   EHRReg#(2,Bit#(8))  tail  <- mkEHRReg(0);         // tail pointer
   EHRReg#(2,Bool)     over  <- mkEHRReg(False);     // negate everytime either head or tail overthrow
   Wire#(a)            resp  <- mkDWire(?);          //
   
   // signals
   let canDeq = head[0] != tail[0] || over[0];
   let canEnq = head[0] != tail[0] || !over[0];      // cannot enq and deq simutaneously when full
   
   // rules
   rule prefetchHead(True);
      bram.read_req(head[1]);
   endrule
   
   rule getReadresp(True);
      resp <= bram.read_resp;
   endrule
   
   // interface methods
   method Action enq(a x) if (canEnq);
      bram.write(tail[1],x);
      if (tail[1] == maxBound) // max idx, wrap around ptr
         begin
            tail[1] <= 0;
            over[1] <= !over[1];
         end
      else
         tail[1] <= tail[1] + 1;
   endmethod
   
   method a first() if (canDeq);
      return resp;
   endmethod
   
   method Action deq() if (canDeq);
      if (head[0] == maxBound)
         begin
            head[0] <= 0;
            over[0] <= !over[0];
         end
      else
         head[0] <= head[0] + 1;
   endmethod
   
   method Bool notEmpty();
      return canDeq;
   endmethod
   
   method Bool notFull();
      return canEnq;
   endmethod
  
   method Action clear();
      head[0] <= 0;
      tail[1] <= 0;
      over[1] <= False;
   endmethod                                      
   
endmodule

// schedule = (first < deq < enq) C clear 
module mkNewBRAMFIFO(FIFO#(a))
   provisos (Bits#(a,asz));
   
   // state elements
   FIFOF#(a) fifo <- mkNewBRAMFIFOF;

   // interface methods
   method Action enq(a x) = fifo.enq(x);
   method a      first()  = fifo.first; 
   method Action deq()    = fifo.deq;
   method Action clear()  = fifo.clear;
   
endmodule