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

3G开发

开发平台:

Others

  1. // The MIT License
  2. //
  3. // Copyright (c) 2006 Nirav Dave (ndave@csail.mit.edu)
  4. //
  5. // Permission is hereby granted, free of charge, to any person obtaining a copy
  6. // of this software and associated documentation files (the "Software"), to deal
  7. // in the Software without restriction, including without limitation the rights
  8. // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9. // copies of the Software, and to permit persons to whom the Software is
  10. // furnished to do so, subject to the following conditions:
  11. //
  12. // The above copyright notice and this permission notice shall be included in
  13. // all copies or substantial portions of the Software.
  14. //
  15. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16. // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17. // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18. // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19. // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20. // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21. // THE SOFTWARE.
  22. // *************************************************************************
  23. //  Mapper.bsv 
  24. // *************************************************************************
  25. import ComplexF::*;
  26. import DataTypes::*;
  27. import Interfaces::*;
  28. import LibraryFunctions::*;
  29. import FIFO::*;
  30. import RWire::*;
  31. import Vector::*;
  32. function ComplexF#(16) r1_getMappedValue(Bit#(1) b0);
  33.   return (ComplexF{
  34.     i : (b0 == 1) ?  16'h7FFF : 16'h8000,
  35.     q : 0
  36.    });   
  37. endfunction
  38. function ComplexF#(16) r2_getMappedValue(Bit#(2) b0);
  39.   return (ComplexF{
  40.     i : (b0[1] == 1) ?   16'h5A82 : 16'hA57E, 
  41.     q : (b0[0] == 1) ?   16'h5A82 : 16'hA57E
  42.    }); 
  43. endfunction
  44. function ComplexF#(16) r4_getMappedValue(Bit#(4) b0);
  45.  function f(x);
  46.    case (x)
  47.       2'b00: return(16'h8692);
  48.       2'b01: return(16'hD786);
  49.       2'b10: return(16'h796E);
  50.       2'b11: return(16'h287A);
  51.    endcase
  52.  endfunction
  53.    return (ComplexF{
  54.       i : f(b0[3:2]),
  55.       q : f(b0[1:0])
  56.       }); 
  57. endfunction
  58. function Vector#(64, ComplexF#(16)) expandCFs(Bit#(1) ppv, Vector#(48, ComplexF#(16)) x);
  59.    ComplexF#(16) zero = ComplexF{i: 0, q: 0};
  60.    Integer i =0, j = 0;
  61.    Vector#(64, ComplexF#(16)) syms = Vector::replicate(zero);
  62.    //six zeros
  63.    i = i + 6;
  64.    for(i = 6; i < 11; i = i + 1, j = j + 1) // [6:10] = 5
  65.       syms[i] = x[j];
  66.    
  67.    //pilot
  68.    syms[i] = r1_getMappedValue(ppv); // [11] = 1
  69.    i = i + 1;
  70.    
  71.    for(i = 12; i < 25; i = i + 1, j = j + 1) // [12:24] = 13
  72.       syms[i] = x[j]; 
  73.    //pilot
  74.    syms[i] = r1_getMappedValue(ppv); // [25] = 1
  75.    i = i + 1;
  76.    for(i = 26; i < 32 ; i = i + 1, j = j + 1) // [26:31] = 6
  77.       syms[i] = x[j];  
  78.    // pilot 0                        // [32] = 1
  79.    i = i + 1;  
  80.    
  81.    for(i = 33; i < 39 ; i = i + 1, j = j + 1) // [33:38] = 6
  82.       syms[i] = x[j];   
  83.    //pilot 7
  84.    syms[i] = r1_getMappedValue(ppv); // [39] = 1
  85.    i = i + 1; 
  86.    for(i = 40; i < 53 ; i = i + 1, j = j + 1) // [40:52] = 13
  87.       syms[i] = x[j];
  88.    //pilot 21 NOTICE reversed value
  89.    syms[i] = r1_getMappedValue(~ppv); // [53] = 1
  90.    i = i + 1;  
  91.    for(i = 54; i < 59 ; i = i + 1, j = j + 1) // [54:58] = 5
  92.       syms[i] = x[j];
  93.    
  94.    
  95.    return syms; // YYY: ndave this may need to be reversed
  96. endfunction
  97. (* synthesize *)
  98. module mkMapper_48_64(Mapper#(48, 64));
  99.          
  100.    Bit#(127) ppv_init = truncate(128'hF10D36FDD9D149f32b184bd505AE4700 >> 1); // shift needed for alignment
  101.    Reg#(Bit#(127)) pilotPolarityVector <- mkReg(ppv_init); // NOTE that 0s represet -1.
  102.         
  103.    Reg#(Rate)            cur_rate <- mkReg(RNone);
  104.    Reg#(Bit#(2))          inM_cnt <- mkReg(0);
  105.     
  106.    Reg#(Vector#(48,ComplexF#(16))) curM <- mkRegU();
  107.    FIFO#(MsgComplexFVec#(64)) outQ <- mkFIFO(); 
  108.    
  109.    
  110.    method Action fromInterleaver(RateData#(48) i);
  111.       Rate rate = (i.rate == RNone) ? cur_rate : i.rate;
  112.    
  113.       //update placement regs
  114.       cur_rate <= rate;
  115.       Bit#(2) new_inM_cnt = pack(tuple2(rate == R4, rate != R1)) & (inM_cnt + 1);
  116.       inM_cnt <= new_inM_cnt;
  117.    
  118.       Vector#(48,ComplexF#(16)) cfs = newVector();
  119.       //generate values
  120.       case (rate)
  121.  R1:
  122.  begin
  123.     Vector#(48, Bit#(1)) va = bitBreak(i.data);
  124.     cfs = Vector::map(r1_getMappedValue, va);
  125.  end
  126.  R2:
  127.  begin
  128.     Vector#(24, Bit#(2)) va = bitBreak(i.data);
  129.     Vector#(24 ,ComplexF#(16)) cs = Vector::map(r2_getMappedValue, va);
  130.     cfs = v_truncate(Vector::append(curM, cs));
  131.  end
  132.  R4:
  133.  begin
  134.     Vector#(12, Bit#(4)) va = bitBreak(i.data);
  135.     Vector#(12 ,ComplexF#(16)) cs = Vector::map(r4_getMappedValue, va);
  136.     cfs = v_truncate(Vector::append(curM, cs)); 
  137.  end
  138.       endcase
  139.    
  140.       if (new_inM_cnt == 2'b00)
  141.  begin
  142.             MsgComplexFVec#(64) p = MsgComplexFVec{
  143.        new_message: True,
  144.                                data:        expandCFs(pilotPolarityVector[126], cfs)
  145.     };
  146.             outQ.enq(p);
  147.     //rotate ppvs
  148.     pilotPolarityVector <= {pilotPolarityVector[125:0], pilotPolarityVector[126]};
  149.          end
  150.       
  151.    endmethod
  152.    method ActionValue#(MsgComplexFVec#(64)) toIFFT();
  153.      outQ.deq();
  154.      return (outQ.first());      
  155.    endmethod
  156.    
  157. endmodule
  158. (* synthesize *)
  159. module mkMapper_48_16(Mapper#(48, 16));
  160.          
  161.    Bit#(127) ppv_init = truncate(128'hF10D36FDD9D149f32b184bd505AE4700 >> 1); // shift needed for alignment
  162.    Reg#(Bit#(127)) pilotPolarityVector <- mkReg(ppv_init); // NOTE that 0s represet -1.
  163.         
  164.    Reg#(Rate)            cur_rate <- mkReg(RNone);
  165.    Reg#(Bit#(2))          inM_cnt <- mkReg(0);
  166.     
  167.    Reg#(Vector#(48, ComplexF#(16)))  curM <- mkRegU();
  168.    FIFO#(Vector#(64, ComplexF#(16))) outQ <- mkFIFO(); 
  169.    Reg#(Bit#(2))                  outM_cnt <- mkReg(0);   
  170.    
  171.    method Action fromInterleaver(RateData#(48) i);
  172.       Rate rate = (i.rate == RNone) ? cur_rate : i.rate;
  173.    
  174.       //update placement regs
  175.       cur_rate <= rate;
  176.       Bit#(2) new_inM_cnt = pack(tuple2(rate == R4, rate != R1)) & (inM_cnt + 1);
  177.       inM_cnt <= new_inM_cnt;
  178.    
  179.       Vector#(48,ComplexF#(16)) cfs = newVector();
  180.       //generate values
  181.       case (rate)
  182.  R1:
  183.  begin
  184.     Vector#(48, Bit#(1)) va = bitBreak(i.data);
  185.     cfs = Vector::map(r1_getMappedValue, va);
  186.  end
  187.  R2:
  188.  begin
  189.     Vector#(24, Bit#(2)) va = bitBreak(i.data);
  190.     Vector#(24 ,ComplexF#(16)) cs = Vector::map(r2_getMappedValue, va);
  191.     cfs = v_truncate(Vector::append(curM, cs));
  192.  end
  193.  R4:
  194.  begin
  195.     Vector#(12, Bit#(4)) va = bitBreak(i.data);
  196.     Vector#(12 ,ComplexF#(16)) cs = Vector::map(r4_getMappedValue, va);
  197.     cfs = v_truncate(Vector::append(curM, cs)); 
  198.  end
  199.       endcase
  200.    
  201.       if (new_inM_cnt == 2'b00)
  202.  begin
  203.             Vector#(64, ComplexF#(16)) p = expandCFs(pilotPolarityVector[126], cfs);
  204.     outQ.enq(p);
  205.     //rotate ppvs
  206.     pilotPolarityVector <= {pilotPolarityVector[125:0], pilotPolarityVector[126]};
  207.          end
  208.    endmethod
  209.    method ActionValue#(MsgComplexFVec#(16)) toIFFT();
  210.      outM_cnt <= outM_cnt + 1;
  211.     
  212.      Vector#(48, ComplexF#(16)) t1 = v_truncate(outQ.first);
  213.      Vector#(32, ComplexF#(16)) t2 = v_truncate(outQ.first);     
  214.      Vector#(16, ComplexF#(16)) v1 = v_rtruncate(outQ.first); 
  215.      Vector#(16, ComplexF#(16)) v2 = v_rtruncate(t1);    
  216.      Vector#(16, ComplexF#(16)) v3 = v_rtruncate(t2);         
  217.      Vector#(16, ComplexF#(16)) v4 = v_truncate(t2);      
  218.       
  219.      let r =  case (outM_cnt)
  220.  2'b00: return v1;
  221.  2'b01: return v2;
  222.  2'b10: return v3;
  223.  2'b11: return v4;
  224.       endcase;
  225.        
  226.      outQ.deq();
  227.      return (MsgComplexFVec{
  228.                  new_message: (outM_cnt == 2'b00),
  229.                  data:        r
  230. });
  231.   endmethod
  232.    
  233. endmodule