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

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 Complex::*;
  27. import Connectable::*;
  28. import FIFO::*;
  29. import GetPut::*;
  30. import Vector::*;
  31. import Controls::*;
  32. import DataTypes::*;
  33. import Interfaces::*;
  34. import LibraryFunctions::*;
  35. import Parameters::*;
  36. import StreamFIFO::*;
  37. typedef struct{
  38.    Rate     rate;
  39.    Bit#(12) length;
  40. } RXFeedback deriving (Bits, Eq);
  41. interface PreFFTRXController;
  42.    interface Put#(SPMesgFromSync#(UnserialOutDataSz,RXFPIPrec,RXFPFPrec)) 
  43.       inFromPreFFT;
  44.    interface Get#(FFTMesg#(RXGlobalCtrl,FFTIFFTSz,RXFPIPrec,RXFPFPrec))   
  45.       outToPreDescrambler;
  46.    interface Put#(Maybe#(RXFeedback)) inFeedback;
  47. endinterface
  48. interface PreDescramblerRXController;
  49.    interface Put#(DecoderMesg#(RXGlobalCtrl,ViterbiOutDataSz,Bit#(1)))    
  50.       inFromPreDescrambler;
  51.    interface Get#(DescramblerMesg#(RXDescramblerAndGlobalCtrl,DescramblerDataSz)) 
  52.       outToDescrambler;
  53.    interface Get#(Maybe#(RXFeedback)) outFeedback;
  54.    interface Get#(Bit#(12))   outLength;
  55. endinterface
  56. interface PostDescramblerRXController;
  57.    interface Put#(EncoderMesg#(RXDescramblerAndGlobalCtrl,DescramblerDataSz))                
  58.       inFromDescrambler;
  59.    interface Get#(Bit#(8))  outData;
  60. endinterface      
  61. interface RXController;
  62.    interface Put#(SPMesgFromSync#(UnserialOutDataSz,RXFPIPrec,RXFPFPrec)) 
  63.       inFromPreFFT;
  64.    interface Get#(FFTMesg#(RXGlobalCtrl,FFTIFFTSz,RXFPIPrec,RXFPFPrec))   
  65.       outToPreDescrambler;
  66.    interface Put#(DecoderMesg#(RXGlobalCtrl,ViterbiOutDataSz,Bit#(1)))    
  67.       inFromPreDescrambler;
  68.    interface Get#(DescramblerMesg#(RXDescramblerAndGlobalCtrl,DescramblerDataSz)) 
  69.       outToDescrambler;
  70.    interface Put#(EncoderMesg#(RXDescramblerAndGlobalCtrl,DescramblerDataSz))                
  71.       inFromDescrambler;
  72.    interface Get#(Bit#(12)) outLength;
  73.    interface Get#(Bit#(8))  outData;
  74. endinterface
  75.       
  76. typedef enum{
  77.    RX_IDLE,     // idle
  78.    RX_HEADER,   // decoding header
  79.    RX_HTAIL,    // sending zeros after header
  80.    RX_FEEDBACK, // waiting for feedback
  81.    RX_DATA,     // decoding data
  82.    RX_DTAIL     // sending zeros after data
  83. } RXCtrlState deriving(Eq,Bits);
  84. (* synthesize *)
  85. module mkPreFFTRXController(PreFFTRXController);
  86.    // state elements
  87.    FIFO#(FFTMesg#(RXGlobalCtrl,FFTIFFTSz,RXFPIPrec,RXFPFPrec)) outQ <- mkLFIFO;
  88.    Reg#(RXCtrlState) rxState <- mkReg(RX_IDLE); // the current state
  89.    Reg#(Bit#(3))     zeroCount <- mkRegU;       // count no of zeros symbol sent
  90.    Reg#(Rate)        rxRate <- mkRegU;          // the packet rate for receiving
  91.    Reg#(Bit#(16))    rxLength <- mkRegU;        // the remaining of data to be received (in terms of bits)
  92.    
  93.    // constants
  94.    // data bis per ofdm symbol 
  95.    Bit#(16) dbps = case (rxRate)
  96.       R0: 24;
  97.       R1: 36;
  98.       R2: 48;
  99.       R3: 72;
  100.       R4: 96;
  101.       R5: 144;
  102.       R6: 192;
  103.       R7: 216;
  104.    endcase;
  105.    
  106.    // rules
  107.    // send 2 extra symbol of zeros to push out data from vitebri (also reset the viterbi state)
  108.    rule sendZeros(rxState == RX_HTAIL || rxState == RX_DTAIL);
  109.       RXGlobalCtrl rxCtrl = RXGlobalCtrl{firstSymbol: False, 
  110.  rate: R0};
  111.       Symbol#(FFTIFFTSz,RXFPIPrec,RXFPFPrec) zeroSymbol = replicate(cmplx(0,0));
  112.       outQ.enq(FFTMesg{control:rxCtrl, data: zeroSymbol});
  113.       if (zeroCount < 4)
  114.  begin
  115.     zeroCount <= zeroCount + 1;
  116.  end
  117.       else
  118.  begin
  119.     rxState <= (rxState == RX_HTAIL) ? RX_FEEDBACK : RX_IDLE;
  120.  end
  121.       $display("PreFFTRXCtrllr sendZeros rxState:%d rxLength:%d",rxState,rxLength);
  122.    endrule 
  123.    
  124.    // interface methods
  125.    interface Put inFromPreFFT;
  126.       method Action put(SPMesgFromSync#(UnserialOutDataSz,RXFPIPrec,RXFPFPrec) mesg) 
  127.  if (rxState != RX_HTAIL && rxState != RX_DTAIL && rxState != RX_FEEDBACK);
  128.  case (rxState)
  129.     RX_IDLE: 
  130.     begin
  131.        if (mesg.control) // only process if it is a new packet, otherwise, drop it
  132.   begin
  133.      zeroCount <= 0;
  134.      RXGlobalCtrl rxCtrl = RXGlobalCtrl{firstSymbol: True, 
  135. rate: R0};
  136.      outQ.enq(FFTMesg{control:rxCtrl, data: mesg.data});
  137.      rxState <= RX_HTAIL;
  138.   end  
  139.        end
  140.     RX_DATA:
  141.     begin
  142.        RXGlobalCtrl rxCtrl = RXGlobalCtrl{firstSymbol: False, 
  143.   rate: rxRate};
  144.        outQ.enq(FFTMesg{control:rxCtrl, data: mesg.data});
  145.        if (rxLength <= dbps) // last symbol
  146.   begin
  147.      rxState <= RX_DTAIL;
  148.      zeroCount <= 0;
  149.   end
  150.        else
  151.   begin
  152.      rxLength <= rxLength - dbps;
  153.   end
  154.     end
  155.  endcase
  156.  $display("PreFFTRXCtrllr inFromPreFFT rxState:%d rxLength:%d",rxState,rxLength);
  157.       endmethod
  158.    endinterface
  159.  
  160.    interface Put inFeedback;
  161.       method Action put(Maybe#(RXFeedback) feedback) if (rxState == RX_FEEDBACK);
  162.  if (isValid(feedback)) // set the packet parameter
  163.     begin
  164.        let packetInfo = fromMaybe(?,feedback);
  165.        rxState <= RX_DATA;
  166.        rxRate  <= packetInfo.rate; 
  167.        rxLength <= ((zeroExtend(packetInfo.length) + 2) << 3) + 6; // no of bits to be received = (16+8*length+6) 
  168.     end
  169.  else // error in decoding package, return to idle
  170.     begin
  171.        rxState <= RX_IDLE; 
  172.     end
  173.  $display("PreFFTRXCtrllr inFeedback rxState:%d rxLength:%d",rxState,rxLength);
  174.       endmethod
  175.    endinterface
  176.    interface outToPreDescrambler = fifoToGet(outQ);
  177. endmodule
  178. (* synthesize *)
  179. module mkPreDescramblerRXController(PreDescramblerRXController);
  180.    // state elements
  181.    FIFO#(DecoderMesg#(RXGlobalCtrl,ViterbiOutDataSz,Bit#(1))) inMesgQ <- mkLFIFO;
  182.    FIFO#(DescramblerMesg#(RXDescramblerAndGlobalCtrl,DescramblerDataSz)) outMesgQ <- mkLFIFO;
  183.    FIFO#(Maybe#(RXFeedback)) outFeedbackQ <- mkLFIFO;
  184.    FIFO#(Bit#(12))           outLengthQ <- mkLFIFO;
  185.    StreamFIFO#(24,5,Bit#(1)) streamQ <- mkStreamLFIFO;
  186.    Reg#(RXCtrlState)         rxState <- mkReg(RX_DATA);
  187.    Reg#(Bit#(3))             zeroCount <- mkReg(0);
  188.    Reg#(Bool)                isGetSeed <- mkReg(False);
  189.    Reg#(Maybe#(Bit#(ScramblerShifterSz))) seed <- mkReg(tagged Invalid);
  190.    Reg#(Bit#(12))            rxLength <- mkRegU;
  191.    // constants
  192.    Bit#(5) vOutSz = fromInteger(valueOf(ViterbiOutDataSz));
  193.    Bit#(5) dInSz  = fromInteger(valueOf(DescramblerDataSz));
  194.    let streamQ_usage = streamQ.usage;
  195.    let streamQ_free  = streamQ.free;
  196.    
  197.    // functions
  198.    function Rate getRate(Bit#(24) header);
  199.       return case (header[3:0])
  200. 4'b1011: R0;
  201. 4'b1111: R1;
  202. 4'b1010: R2; 
  203. 4'b1110: R3;
  204. 4'b1001: R4;
  205. 4'b1101: R5;
  206. 4'b1000: R6;
  207. 4'b1100: R7;
  208. default: R0;
  209.      endcase;
  210.    endfunction
  211.    
  212.    function Bit#(12) getLength(Bit#(24) header);
  213.       return header[16:5];
  214.    endfunction
  215.    
  216.    function Bool checkParity(Bit#(24) header);
  217.       return header[17:17] == getParity(header[16:0]);
  218.    endfunction
  219.    
  220.    // rules
  221.    rule decodeHeader(rxState == RX_HEADER && streamQ_usage >= 24);
  222.       let header = pack(streamQ.first);
  223.       if (checkParity(header))
  224.  begin
  225.     let rate = getRate(header);
  226.     let length = getLength(header);
  227.     outFeedbackQ.enq(tagged Valid RXFeedback{rate:rate,
  228.      length:length});
  229.     outLengthQ.enq(length);
  230.     isGetSeed <= True;
  231.     rxLength <= length;
  232.  end
  233.       else
  234.  begin
  235.     outFeedbackQ.enq(tagged Invalid);
  236.  end
  237.       rxState <= RX_HTAIL;
  238.       streamQ.deq(24);
  239.       $display("PreDescramblerRXCtrllr decodeHeader rxState:%d rxLength:%d",rxState,rxLength);
  240.    endrule
  241.    
  242.    // skip 2 symbols of zeros
  243.    rule skipZeros(rxState == RX_HTAIL && streamQ_usage >= 24);
  244.       streamQ.deq(24);
  245.       if (zeroCount < 4)
  246.  begin
  247.     zeroCount <= zeroCount + 1;
  248.  end
  249.       else
  250.  begin
  251.     rxState <= RX_DATA;
  252.  end
  253.       $display("PreDescramblerRXCtrllr skipZeros rxState:%d rxLength:%d",rxState,rxLength);
  254.    endrule
  255.    
  256.    rule getSeed(rxState == RX_DATA && isGetSeed && streamQ_usage >= 12);
  257.       seed <= tagged Valid (reverseBits((pack(streamQ.first))[11:5]));
  258.       isGetSeed <= False;
  259.       streamQ.deq(12);
  260.       $display("PreDescramblerRXCtrllr getSeed rxState:%d rxLength:%d",rxState,rxLength);      
  261.    endrule
  262.    
  263.    rule sendData(rxState == RX_DATA && !isGetSeed && streamQ_usage >= dInSz);
  264.       let rxDCtrl = RXDescramblerCtrl{seed: seed, bypass: 0}; // descrambler ctrl, no bypass
  265.       let rxGCtrl = RXGlobalCtrl{firstSymbol: isValid(seed), rate: ?};
  266.       let rxCtrl = RXDescramblerAndGlobalCtrl{descramblerCtrl: rxDCtrl, length: rxLength, globalCtrl: rxGCtrl};
  267.       seed <= tagged Invalid;
  268.       outMesgQ.enq(DescramblerMesg{control: rxCtrl, data: pack(take(streamQ.first))});
  269.       streamQ.deq(dInSz);
  270.       $display("PreDescramblerRXCtrllr sendData rxState:%d rxLength:%d",rxState,rxLength);
  271.    endrule
  272.    
  273.    rule processInMesgQ(streamQ_free >= vOutSz);
  274.       let mesg = inMesgQ.first;
  275.       if (rxState == RX_DATA && mesg.control.firstSymbol)
  276.  begin
  277.     if (streamQ_usage == 0) // all date from last packet has been processed
  278.        begin
  279.   rxState <= RX_HEADER;
  280.   zeroCount <= 0;
  281.   inMesgQ.deq;
  282.   streamQ.enq(vOutSz,append(mesg.data,replicate(0)));
  283.        end
  284.  end
  285.       else
  286.  begin
  287.     inMesgQ.deq;
  288.     streamQ.enq(vOutSz,append(mesg.data,replicate(0)));
  289.  end
  290.       $display("PreDescramblerRXCtrll processInMsgQ rxState:%d rxLength:%d",rxState,rxLength);      
  291.    endrule
  292.    // interface methods
  293.    interface inFromPreDescrambler = fifoToPut(inMesgQ);     
  294.    interface outToDescrambler = fifoToGet(outMesgQ);   
  295.    interface outLength = fifoToGet(outLengthQ);   
  296.    interface outFeedback = fifoToGet(outFeedbackQ);
  297. endmodule 
  298. (* synthesize *)
  299. module mkPostDescramblerRXController(PostDescramblerRXController);
  300.    // state elements
  301.    FIFO#(EncoderMesg#(RXDescramblerAndGlobalCtrl,DescramblerDataSz)) inMesgQ <- mkLFIFO;
  302.    FIFO#(Bit#(8)) outDataQ <- mkLFIFO;
  303.    StreamFIFO#(24,5,Bit#(1)) streamQ <- mkStreamLFIFO; // descramblerdatasz must be factor of 12
  304.    Reg#(Bit#(12)) rxLength <- mkRegU; // no of bytes remains to be received
  305.    Reg#(Bool)     drop4b   <- mkRegU; // drop the first 4 bits?
  306.    Reg#(RXCtrlState) rxState <- mkReg(RX_IDLE);
  307.    
  308.    // constants
  309.    Bit#(5) dInSz = fromInteger(valueOf(DescramblerDataSz));
  310.    let streamQ_usage = streamQ.usage;
  311.    let streamQ_free  = streamQ.free;
  312.    
  313.    // rules
  314.    rule processInMesgQ(streamQ_free >= dInSz);
  315.       let mesg = inMesgQ.first;
  316.       inMesgQ.deq;
  317.       if ((rxState == RX_IDLE && mesg.control.globalCtrl.firstSymbol) || rxState != RX_IDLE)
  318.  begin
  319.     if (rxState == RX_IDLE)
  320.        begin
  321.   rxState <= RX_DATA;
  322.   drop4b <= True;
  323.   rxLength <= mesg.control.length;
  324.        end
  325.     streamQ.enq(dInSz,append(unpack(mesg.data),replicate(0)));
  326.  end
  327.       else
  328.  begin
  329.     streamQ.clear;
  330.  end
  331.       $display("PostDescramblerRXCtrllr processInMesgQ rxState:%d rxLength:%d",rxState,rxLength);      
  332.    endrule
  333.    
  334.    rule processStreamQ(streamQ_usage >= 8);
  335.       Bit#(8) outData = truncate(pack(streamQ.first));
  336.       Bit#(5) deqSz = drop4b ? 4 : 8;
  337.       drop4b <= False;
  338.       streamQ.deq(deqSz);
  339.       if (!drop4b)
  340.  begin
  341.     outDataQ.enq(outData);
  342.     if (rxLength > 1)
  343.        begin
  344.   rxLength <= rxLength - 1;
  345.        end
  346.     else
  347.        begin
  348.   rxState <= RX_IDLE;
  349.        end
  350.  end
  351.       $display("PostDescramblerRXCtrllr processStreamQ rxState:%d rxLength:%d",rxState,rxLength);      
  352.    endrule
  353.    
  354.    // interface methods
  355.    interface inFromDescrambler = fifoToPut(inMesgQ);
  356.    interface outData = fifoToGet(outDataQ);
  357. endmodule
  358. (* synthesize *)
  359. module mkRXController(RXController);
  360.    // state elements
  361.    let preFFTCtrllr          <- mkPreFFTRXController;
  362.    let preDescramblerCtrllr  <- mkPreDescramblerRXController;
  363.    let postDescramblerCtrllr <- mkPostDescramblerRXController;
  364.    
  365.    // mkConnections
  366.    mkConnection(preDescramblerCtrllr.outFeedback,preFFTCtrllr.inFeedback);
  367.    
  368.    // methods
  369.    interface inFromPreFFT = preFFTCtrllr.inFromPreFFT;
  370.    interface outToPreDescrambler = preFFTCtrllr.outToPreDescrambler;
  371.    interface inFromPreDescrambler = preDescramblerCtrllr.inFromPreDescrambler;
  372.    interface outToDescrambler = preDescramblerCtrllr.outToDescrambler;
  373.    interface inFromDescrambler = postDescramblerCtrllr.inFromDescrambler;
  374.    interface outLength = preDescramblerCtrllr.outLength;
  375.    interface outData   = postDescramblerCtrllr.outData;
  376. endmodule