Subversion Repositories reedsolomon

//----------------------------------------------------------------------//
// The MIT License 
// 
// Copyright (c) 2010 Abhinav Agarwal, Alfred Man Cheuk Ng
// Contact: abhiag@gmail.com
// 
// 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.
//----------------------------------------------------------------------//

import FIFO::*;
import GetPut::*;
import GFTypes::*;
import mkReedSolomon::*;

import Transfer::*;

typedef enum{ ReadN, ReadT, ReadD } FPGAState deriving (Eq, Bits);

// ---------------------------------------------------------
// FPGA Reed-Solomon Wrapper module
// ---------------------------------------------------------
(* synthesize *)
module mkfuncunit (ProcSide);
   
   Transfer transfer <- mkTransfer();
   IReedSolomon       decoder <- mkReedSolomon();
   Reg#(FPGAState)    state   <- mkReg(ReadN);
   Reg#(Byte)         n       <- mkReg(0);
   
   rule readN(state == ReadN);
      let inData <- transfer.funcSideGet.get();
      n <= truncate(inData);
      state <= ReadT;

      $display(" [mkFPGAReedSolomon] readN n : %d", inData);
   endrule
   
   rule readT(state == ReadT);
      let inData <- transfer.funcSideGet.get();
      let t = truncate(inData);
      let k = n - 2 * t;
      
      decoder.rs_t_in.put(t);
      decoder.rs_k_in.put(k);
      state <= ReadD;

      $display(" [mkFPGAReedSolomon] readT t : %d", inData);
   endrule   
   
   rule readD(state == ReadD);
      let inData <- transfer.funcSideGet.get();
      decoder.rs_input.put(truncate(inData));
      n <= n - 1;
      if (n == 1) // last element, start to ReadN again
         state <= ReadN;

      $display(" [mkFPGAReedSolomon] readD i : %d, data in : %d", n, inData);
   endrule
   
   rule discardFlag(True);
      let rs_flag <- decoder.rs_flag.get();

      $display(" [mkFPGAReedSolomon] discardFlag flag : %d", rs_flag);
   endrule

   rule enqOut(True);
      let datum <- decoder.rs_output.get();
      transfer.funcSidePut.put(zeroExtend(datum));
      
      $display(" [mkFPGAReedSolomon] enqOut data out : %d", datum);
   endrule
   
   return transfer.procSide();
   
endmodule