开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 3G开发 > 查看源码
Descrambler.bsv
资源名称：mit-ofdm-wifi.rar　[点击查看]
上传用户：aoptech
上传日期：2014-09-22
资源大小：784k
文件大小：4k
源码类别：

3G开发

开发平台：

Others

Descrambler.bsv：源码内容
  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. //----------------------------------------------------------------------//
  27. import Controls::*;
  28. import DataTypes::*;
  29. import FIFO::*;
  30. import Interfaces::*;
  31. import LibraryFunctions::*;
  32. import GetPut::*;
  33. import Scrambler::*;
  35. module mkDescrambler#(function ScramblerCtrl#(n,shifter_sz) 
  36.  mapCtrl(ctrl_t ctrl),
  37.       Bit#(shifter_sz) genPoly)
  38.    (Descrambler#(ctrl_t,n,n))
  39.    provisos(Add#(1,xxA,shifter_sz),
  40.     Bits#(ctrl_t,ctrl_sz));
  41.    
  42.    // id function
  43.    function ctrl_t 
  44.       descramblerConvertCtrl(ctrl_t ctrl);
  45.       return ctrl;
  46.    endfunction
  47.  
  48.    let descrambler <- mkScrambler(mapCtrl,
  49.   descramblerConvertCtrl,
  50.   genPoly);
  51.    return descrambler;
  52. endmodule
  54. // // auxiliary function
  55. // function Tuple2#(Bit#(n), Bit#(sRegSz)) scramble(Bit#(n) inBit, Bit#(sRegSz) sReg, Bit#(sRegSz) mask)
  56. //   provisos (Add#(1,xxA,sRegSz));
  58. //       Integer sRegSzInt = valueOf(sRegSz);
  59. //       Nat sRegSzNat = fromInteger(sRegSzInt);
  60. //       Bit#(n) res = 0;
  61. //       Bit#(sRegSz) newSReg = sReg;
  63. //       for(Integer i = 0; i < valueOf(n); i = i + 1)
  64. //  begin
  65. //     Bit#(1) temp = 0;
  66. //     for(Integer j = 0; j < sRegSzInt; j = j + 1)
  67. //       if (mask[j] == 1)
  68. //         temp = temp ^ newSReg[j];
  69. //     res[i] = inBit[i] ^ temp;
  70. //     newSReg = {newSReg[sRegSzNat-1:1],temp};
  71. //  end
  73. //       return tuple2(res, newSReg);
  75. // endfunction
  77. // // main function
  78. // module mkDescrambler#(function DescramblerCtrl genCtrl(ctrl_t ctrl),
  79. //        Bit#(sRegSz) mask,
  80. //        Bit#(sRegSz) initSeq)
  81. //   (Descrambler#(ctrl_t, n))
  82. //   provisos (Add#(1, xxA, sRegSz),
  83. //      Add#(1, xxB, n), Add#(sRegSz, xxC, n),
  84. //      Bits#(DescramblerMesg#(ctrl_t,n), xxD));
  86. //    Reg#(Bit#(sRegSz)) sReg <- mkReg(initSeq);
  87. //    FIFO#(DescramblerMesg#(ctrl_t,n)) outQ <- mkSizedFIFO(2);
  88.    
  89. //     interface Put in;
  90. //         method Action put(DescramblerMesg#(ctrl_t, n) inMsg);
  91. //       let ctrl = genCtrl(inMsg.control); 
  92. //       case (ctrl)
  93. //  Bypass: outQ.enq(inMsg);
  94. //  FixRst: 
  95. //    begin
  96. //       let res = scramble(inMsg.data, initSeq, mask);
  97. //       outQ.enq(DescramblerMesg{ control: inMsg.control,
  98. //         data: tpl_1(res)});
  99. //       sReg <= tpl_2(res);
  100. //    end
  101. //  DynRst:
  102. //    begin
  103. //       Tuple2#(Bit#(xxC),Bit#(sRegSz)) splittedData = split(inMsg.data);
  104. //       let newInitSeq = reverseBits(tpl_2(splittedData));
  105. //       let newInData = tpl_1(splittedData);
  106. //       let res = scramble(newInData, newInitSeq, mask);
  107. //       Bit#(n) outData = {tpl_1(res), newInitSeq};
  108. //       outQ.enq(DescramblerMesg{ control: inMsg.control,
  109. //         data: outData});
  110. //       sReg <= tpl_2(res);
  111. //    end
  112. //  Norm:
  113. //    begin
  114. //       let res = scramble(inMsg.data, sReg, mask);
  115. //       outQ.enq(DescramblerMesg{ control: inMsg.control,
  116. //         data:tpl_1(res)});
  117. //       sReg <= tpl_2(res);
  118. //    end
  119. //       endcase // case(inMsg.ctrl)
  120. //         endmethod
  121. //     endinterface
  123. //     interface out = fifoToGet(outQ);
  124. // endmodule // mkDescrambler