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

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 FIFO::*;
  28. import GetPut::*;
  29. import Vector::*;
  30. import Controls::*;
  31. import DataTypes::*;
  32. import Interfaces::*;
  33. import LibraryFunctions::*;
  34. import Parameters::*;
  35. import StreamFIFO::*;
  36. typedef struct{
  37.    Bit#(11)   length;  // data to send MAC PDU
  38.    Rate       rate;    // data rate (determine by BS before)
  39.    CPSizeCtrl cpSize;  // cp size in term of symbol size
  40.    Bit#(4)    bsid;    // base station id it subscribe to
  41.    Bit#(4)    uiuc;    // uplink profile
  42.    Bit#(4)    fid;     // frame number 
  43.    Bit#(3)    power;   // transmit power level (not affecting baseband)
  44. } TXVector deriving (Eq, Bits);
  45. typedef enum{ SendData, SendPadding }
  46.         TXState deriving (Eq, Bits);
  47. interface TXController;
  48.    method Action txStart(TXVector txVec);
  49.    method Action txData(Bit#(8) inData);
  50.    method Action txEnd();
  51.    interface Get#(ScramblerMesg#(TXScramblerAndGlobalCtrl,
  52.  ScramblerDataSz)) out;
  53. endinterface
  54.       
  55. // construct scramblerSeed
  56. function Bit#(ScramblerShifterSz) makeSeed(TXVector txVec);
  57.    return reverseBits({txVec.bsid,2'b11,txVec.uiuc,1'b1,txVec.fid});
  58. endfunction   
  59. // decr txVector length
  60. function TXVector decrTXVectorLength(TXVector txVec);
  61.    return TXVector{length: txVec.length - 1,
  62.    rate: txVec.rate,
  63.    cpSize: txVec.cpSize,
  64.    bsid: txVec.bsid,
  65.    uiuc: txVec.uiuc,
  66.    fid: txVec.fid,
  67.    power: txVec.power};
  68. endfunction
  69. //get maximum number of padding (basic unit is 8 bits) required for each rate
  70. function Bit#(7) maxPadding(Rate rate);
  71.    return case (rate)
  72.      R0: 12;
  73.        R1: 24;
  74.        R2: 36; 
  75.        R3: 48;
  76.        R4: 72;
  77.        R5: 96;
  78.        R6: 108;
  79.     endcase;
  80. endfunction      
  81. // // construct scrambler mesg// get maximum number of padding (basic unit is byte) required for each rate
  82. // function Bit#(7) maxPadding(Rate rate);
  83. //    Bit#(7) scramblerDataSz = fromInteger(valueOf(ScramblerDataSz)/8);
  84. //    return case (rate)
  85. //       R0: 12 - scramblerDataSz;
  86. //       R1: 24 - scramblerDataSz;
  87. //       R2: 36 - scramblerDataSz; 
  88. //       R3: 48 - scramblerDataSz;
  89. //       R4: 72 - scramblerDataSz;
  90. //       R5: 96 - scramblerDataSz;
  91. //       R6: 108 - scramblerDataSz;
  92. //    endcase;
  93. // endfunction      
  94. function ScramblerMesg#(TXScramblerAndGlobalCtrl,ScramblerDataSz)
  95.    makeMesg(Bit#(ScramblerDataSz) bypass,
  96.     Maybe#(Bit#(ScramblerShifterSz)) seed,
  97.     Bool firstSymbol,
  98.     Rate rate,
  99.     CPSizeCtrl cpSize,
  100.     Bit#(ScramblerDataSz) data);
  101.    let sCtrl = TXScramblerCtrl{bypass: bypass,
  102.        seed: seed};
  103.    let gCtrl = TXGlobalCtrl{firstSymbol: firstSymbol,
  104.     rate: rate,
  105.     cpSize: cpSize};
  106.    let ctrl = TXScramblerAndGlobalCtrl{scramblerCtrl: sCtrl,
  107.        globalCtrl: gCtrl};
  108.    let mesg = Mesg{control:ctrl, data:data};
  109.    return mesg;
  110. endfunction
  111. (* synthesize *)
  112. module mkTXController(TXController);
  113.    
  114.    //state elements
  115.    Reg#(Bool)                 busy <- mkReg(False);
  116.    Reg#(TXState)           txState <- mkRegU;
  117.    Reg#(Bit#(7))             count <- mkRegU;
  118.    Reg#(Bit#(7))       fstSymCount <- mkRegU;
  119.    Reg#(Bool)               fstSym <- mkRegU;
  120.    Reg#(Bool)              rstSeed <- mkRegU;
  121.    Reg#(TXVector)         txVector <- mkRegU;
  122.    StreamFIFO#(32,6,Bit#(1)) sfifo <- mkStreamLFIFO; // buf at most 32
  123.    FIFO#(ScramblerMesg#(TXScramblerAndGlobalCtrl,ScramblerDataSz)) outQ;
  124.    outQ <- mkSizedFIFO(2);
  125.    
  126.    // constants
  127.    let sfifo_usage = sfifo.usage;
  128.    let sfifo_free = sfifo.free;
  129.    Bit#(6) scramblerDataSz = fromInteger(valueOf(ScramblerDataSz));
  130.    
  131.    // rules
  132.    rule sendData(busy && sfifo_usage >= scramblerDataSz);
  133.       let bypass = 0;
  134.       let seedVal = makeSeed(txVector);
  135.       let seed = rstSeed ? tagged Valid seedVal : tagged Invalid;
  136.       let fstSym = (fstSymCount > 0) ? True : False;
  137.       let rate = txVector.rate;
  138.       let cpSz = txVector.cpSize;
  139.       Bit#(ScramblerDataSz) data = pack(take(sfifo.first));
  140.       let mesg = makeMesg(bypass,seed,fstSym,rate,cpSz,data);
  141.       rstSeed <= False;
  142.       outQ.enq(mesg);
  143.       sfifo.deq(scramblerDataSz);
  144.       if (fstSymCount > 0)
  145.  fstSymCount <= fstSymCount - fromInteger(valueOf(ScramblerDataSz)/8);
  146.       $display("sendData");
  147.    endrule
  148.    
  149.    rule enqPadding(busy && txState == SendPadding && sfifo_free >= 8);
  150.       if (count == 0)
  151.  begin
  152.     if (sfifo_usage == 0)
  153.        begin
  154.   busy <= False;
  155.   $display("returnIdle");
  156.        end
  157.  end
  158.       else
  159.  begin
  160.     let data = 8'hFF;
  161.     sfifo.enq(8,append(unpack(data),replicate(0)));
  162.     count <= count - 1;
  163.     $display("enqPadding"); 
  164.  end
  165.    endrule
  166.    
  167.    // methods
  168.    method Action txStart(TXVector txVec) if (!busy);
  169.       txVector <= txVec;
  170.       busy <= True;
  171.       txState <= SendData;
  172.       count <= 0;
  173.       rstSeed <= True;
  174.       fstSym <= True;
  175.       fstSymCount <= maxPadding(txVec.rate);
  176.       $display("txStart");
  177.    endmethod
  178.    
  179.    method Action txData(Bit#(8) inData) 
  180.       if (busy && txState == SendData && txVector.length > 0 && sfifo_free >= 8);
  181.       let newTXVec = decrTXVectorLength(txVector);
  182.       sfifo.enq(8,append(unpack(inData),replicate(0)));
  183.       txVector <= newTXVec;
  184.       if (newTXVec.length == 0)
  185.  begin
  186.     txState <= SendPadding;
  187.     if (count == 0)
  188.        count <= maxPadding(txVector.rate); // need a tail
  189.  end
  190.       else
  191.  count <= (count == 0) ? maxPadding(txVector.rate)-1 : count - 1;
  192.       $display("txData");
  193.    endmethod
  194.    
  195.    method Action txEnd();
  196.       busy <= False;
  197.    endmethod
  198.     
  199.    interface out = fifoToGet(outQ);   
  200. endmodule