FFTIFFT.bsv
上传用户:aoptech
上传日期:2014-09-22
资源大小:784k
文件大小:5k
源码类别:

3G开发

开发平台:

Others

  1. //----------------------------------------------------------------------//
  2. // The MIT License 
  3. // 
  4. // Copyright (c) 2007 Alfred Man Cheuk Ng, mcn02@mit.edu 
  5. // 
  6. // Permission is hereby granted, free of charge, to any person 
  7. // obtaining a copy of this software and associated documentation 
  8. // files (the "Software"), to deal in the Software without 
  9. // restriction, including without limitation the rights to use,
  10. // copy, modify, merge, publish, distribute, sublicense, and/or sell
  11. // copies of the Software, and to permit persons to whom the
  12. // Software is furnished to do so, subject to the following conditions:
  13. // 
  14. // The above copyright notice and this permission notice shall be
  15. // included in all copies or substantial portions of the Software.
  16. // 
  17. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  19. // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  21. // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22. // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24. // OTHER DEALINGS IN THE SOFTWARE.
  25. //----------------------------------------------------------------------//
  26. import Connectable::*;
  27. import Complex::*;
  28. import ComplexLibrary::*;
  29. import FPComplex::*;
  30. import DataTypes::*;
  31. import CORDIC::*;
  32. import FixedPoint::*;
  33. import FixedPointLibrary::*;
  34. import Vector::*;
  35. import FIFO::*;
  36. import FIFOF::*;
  37. import FParams::*;
  38. import FFTIFFT_Library::*;
  39. import GetPut::*;
  40. import LibraryFunctions::*;
  41. import Pipeline2::*;
  42. import Controls::*;
  43. import Interfaces::*;
  44. interface FFTIFFT;
  45. // input
  46. method Action putInput(Bool isIFFT, 
  47.        FFTDataVec fpcmplxVec);
  48. // output
  49. method ActionValue#(FFTDataVec) getOutput();
  50. endinterface
  51. module [Module] mkFFTIFFT(FFTIFFT);
  52.    FFTStage noStages = fromInteger(valueOf(LogFFTSz)-1);
  53.    
  54.    // state elements
  55.    Pipeline2#(FFTTuples) pipeline <- mkPipeline2_Circ(noStages,mkOneStage); 
  56.    FIFO#(Bool) isIFFTQ <- mkSizedFIFO(valueOf(LogFFTSz));
  57.    function FFTData shifting(FFTData inData);
  58.    begin
  59.       Nat shiftSz = fromInteger(valueOf(LogFFTSz));
  60.       return cmplx(inData.rel>>shiftSz,inData.img>>shiftSz);
  61.    end
  62.    endfunction
  63.    
  64.    // methods
  65.    method Action putInput(Bool isIFFT, FFTDataVec fpcmplxVec);
  66.       if (isIFFT)
  67. fpcmplxVec = map(cmplxSwap, fpcmplxVec);
  68.       isIFFTQ.enq(isIFFT);
  69.       pipeline.in.put(tuple2(0, fpcmplxVec));
  70.    endmethod
  71.    method ActionValue#(FFTDataVec) getOutput();
  72.       let mesg <- pipeline.out.get;
  73.       let outVec = fftPermuteRes(tpl_2(mesg));
  74.       let isIFFT = isIFFTQ.first;
  75.       if (isIFFT)
  76. outVec = map(cmplxSwap, map(shifting, outVec));
  77.       isIFFTQ.deq;
  78.       return outVec;
  79.    endmethod
  80. endmodule   
  81. module [Module] mkIFFT(IFFT#(ctrl_t,FFTSz,ISz,FSz))
  82.    provisos (Bits#(ctrl_t,ctrl_sz));
  83.    
  84.    FFTIFFT ifft <- mkFFTIFFT;
  85.    FIFO#(IFFTMesg#(ctrl_t,FFTSz,ISz,FSz)) inQ <- mkLFIFO;
  86.    FIFO#(CPInsertMesg#(ctrl_t,FFTSz,ISz,FSz)) outQ <- mkSizedFIFO(2);
  87.    FIFO#(ctrl_t) ctrlQ <- mkSizedFIFO(valueOf(LogFFTSz));
  88.    
  89.    // rule
  90.    rule putInput(True);
  91.       let mesg = inQ.first;
  92.       let ctrl = mesg.control;
  93.       let data = map(fpcmplxSignExtend,mesg.data);
  94.       Vector#(HalfFFTSz,FFTData) fstHalfVec = take(data);
  95.       Vector#(HalfFFTSz,FFTData) sndHalfVec = takeTail(data);
  96.       data = append(sndHalfVec,fstHalfVec);
  97.       inQ.deq;
  98.       ifft.putInput(True,data);
  99.       ctrlQ.enq(ctrl);
  100.    endrule
  101.    
  102.    rule getOutput(True);
  103.       let data <- ifft.getOutput;
  104.       let oData = map(fpcmplxTruncate,data);
  105.       let oCtrl = ctrlQ.first;
  106.       ctrlQ.deq;
  107.       outQ.enq(Mesg{control:oCtrl,data:oData});
  108.    endrule
  109.        
  110.    // methods
  111.    interface in = fifoToPut(inQ);
  112.    interface out = fifoToGet(outQ);
  113. endmodule
  114. module [Module] mkFFT(FFT#(ctrl_t,FFTSz,ISz,FSz))
  115.    provisos (Bits#(ctrl_t,ctrl_sz));
  116.    
  117.    FFTIFFT fft <- mkFFTIFFT;
  118.    FIFO#(FFTMesg#(ctrl_t,FFTSz,ISz,FSz)) inQ <- mkLFIFO;
  119.    FIFO#(ChannelEstimatorMesg#(ctrl_t,FFTSz,ISz,FSz)) outQ; 
  120.    outQ <- mkSizedFIFO(2);
  121.    FIFO#(ctrl_t) ctrlQ <- mkSizedFIFO(valueOf(LogFFTSz));
  122.    
  123.    // rule
  124.    rule putInput(True);
  125.       let mesg = inQ.first;
  126.       let ctrl = mesg.control;
  127.       let data = map(fpcmplxSignExtend,mesg.data);
  128.       inQ.deq;
  129.       fft.putInput(False,data);
  130.       ctrlQ.enq(ctrl);
  131.    endrule
  132.    
  133.    rule getOutput(True);
  134.       let data <- fft.getOutput;
  135.       Vector#(HalfFFTSz,FFTData) fstHalfVec = take(data);
  136.       Vector#(HalfFFTSz,FFTData) sndHalfVec = takeTail(data);
  137.       data = append(sndHalfVec,fstHalfVec);
  138.       let oData = map(fpcmplxTruncate,data);
  139.       let oCtrl = ctrlQ.first;
  140.       ctrlQ.deq;
  141.       outQ.enq(Mesg{control:oCtrl,data:oData});
  142.    endrule
  143.        
  144.    // methods
  145.    interface in = fifoToPut(inQ);
  146.    interface out = fifoToGet(outQ);
  147. endmodule