Subversion Repositories bluespec-80211atransmitter

// The MIT License
//
// Copyright (c) 2006 Nirav Dave (ndave@csail.mit.edu)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.




// *************************************************************************
//  ConvEncoder.bsv 
// *************************************************************************
import DataTypes::*;
import Interfaces::*;

import LibraryFunctions::*;
import FIFO::*;

(* synthesize *)
module mkConvEncoder_24_48(ConvEncoder#(24, 48));
  let _c <- mkConvEncoder();
  return(_c); 
endmodule

// n has to be 24 here
module mkConvEncoder(ConvEncoder#(n, nn))
       provisos
         (Add#(n,n,nn),Add#(6,n,n6));

  //-----------------------------------------
  // State
  //-----------------------------------------
  
  // input queues
  FIFO#(Header#(n))           headerQ <- mkLFIFO();
  FIFO#(RateData#(n))           dataQ <- mkLFIFO();

  // internal state
  FIFO#(RateData#(n))        orderedQ <- mkLFIFO();
  Reg#(Bool)                getHeader <- mkReg(True);
  Reg#(Bit#(5))               timeOut <- mkReg(24);
  Reg#(Bit#(6))               histVal <- mkReg(0);
  
  // output queue
  FIFO#(RateData#(nn))               outputQ <- mkLFIFO();

  //-----------------------------------------
  // Rules
  //-----------------------------------------
  
  rule sort(True);
  
    // look at heads of header and data input queues
    Header#(n)       header = headerQ.first();
    RateData#(n)     data = dataQ.first();
  
    // if we've not started a header  and the data rate is nonzero, enq a header
    if(getHeader && data.rate != RNone)
       begin
          orderedQ.enq(RateData{
                              rate: R1,
                       data: header
                              });
          headerQ.deq();
          let ntimeOut = (timeOut - fromInteger(valueOf(n)));
          
          timeOut <= (ntimeOut > 0) ? ntimeOut : 24; // reset

          if (!(ntimeOut > 0))
             getHeader <= False;
       end
    else // otherwise, enq a data
       begin
          if (data.rate != RNone) // newpacket
             getHeader <= True;
          
          dataQ.deq();
          orderedQ.enq(data);
       end
  endrule
   
  rule compute(True);
  
    // get input out of input queues
    Bit#(n) input_data = reverseBits((orderedQ.first).data);
    Rate    input_rate  = (orderedQ.first).rate;
    orderedQ.deq();

    // if this is a new message, reset history

    Bit#(n6)       history;

    if(input_rate == RNone) // new entry
      history = {input_data, histVal};
    else
      history = {input_data, 6'b0};

    // local variables
    Bit#(nn) rev_output_data = 0;
    Bit#(1)  shared = 0; 
    Bit#(6)  newHistVal = histVal;

    // convolutionally encode data
    for(Integer i = 0; i < valueOf(n); i = i + 1)
      begin
      shared = input_data[i] ^ history[i + 4] ^ history[i + 3] ^ history[i + 0];
      rev_output_data[(2*i) + 0] = shared ^ history[i + 1];
      rev_output_data[(2*i) + 1] = shared ^ history[i + 5];
      newHistVal = {input_data[i], newHistVal[5:1]}; // only last update will be saved
      end

    // enqueue result
    RateData#(nn) retval = RateData{
                             rate: input_rate,
                             data: reverseBits(rev_output_data)
                            };
    outputQ.enq(retval);

    // setup for next cycle
    histVal <= newHistVal;
  endrule

  
  //-----------------------------------------
  // Methods
  //-----------------------------------------

  // input from controller queue method
  method Action encode_fromController(Header#(n) header);
    headerQ.enq(header);
  endmethod

  // input from scrambler queue method
  method Action encode_fromScrambler(RateData#(n) data);
    dataQ.enq(data);
  endmethod

  // output to interleaver queue method
  method ActionValue#(RateData#(nn)) getOutput();
    outputQ.deq();
    return(outputQ.first());
  endmethod

endmodule