rs_std_str.tdf

CodeVisionAVR C Library Functions Reference CodeVisionAVR C 库函数介绍 译自CodeVisionAVR C Compiler Help

-------------------------------------------------------------------------
-------------------------------------------------------------------------
--
-- Revision Control Information
--
-- $Workfile:   rs_std_str.tdf  $
-- $Archive:   P:/RS_std/units/Dec_str/ahdl/rs_std_str.tdv  $
--
-- $Revision:   1.3  $
-- $Date:   01 Sep 1999 15:51:50  $
-- $Author			:  Alejandro Diaz-Manero
--
-- Project      :  RS_std
--
-- Description	: 
--
-- Copyright 1999 (c) Altera Corporation
-- All rights reserved
--
-------------------------------------------------------------------------
-------------------------------------------------------------------------

FUNCTION chn_std_str (sysclk, reset, bd[errs..1][m..1], omega[errs..1][m..1])
	RETURNS (errloc[errs..1][size..1], errvec[errs..1][m..1], numroots[m..1], gofinal);

FUNCTION  bms_std_str_full (sysclk, reset, latchsyn, syn[check..1][m..1])
	RETURNS (bdout[errs..1][m..1], omegaout[errs..1][m..1], numerr[wide..1], done);

FUNCTION  bms_std_str_half (sysclk, reset, latchsyn, syn[check..1][m..1])
	RETURNS (bdout[errs..1][m..1], omegaout[errs..1][m..1], numerr[wide..1], done);

FUNCTION syn_std_str (sysclk, reset, r[m..1], dsin, dsout, bypass, gofinal, massdone,
			  	  errvec[errs..1][m..1], errloc[errs..1][size..1])
	RETURNS (latchstage, resetmass, resetchn, rdyin, outvalid, 
			 syn[check..1][m..1], rsout[m..1]);

PARAMETERS
(
n = 204, -- length of message
m = 8, -- field size (2^m)
irrpol = 285, -- field polynomial
check = 16, -- number of check symbols
genstart = 0, -- first root of generator polynomial
speed = "half",
wide = 5,
root1 = 1, root2 = 2,	root3 = 4, root4 = 8,	root5 = 16,	root6 = 32,	root7 = 64,	root8 = 128,
root9 = 29,	root10 = 58, root11 = 116,	root12 = 232,	root13 = 205,	root14 = 135,	root15 = 19,
root16 = 38, root17 = 76,	root18 = 152,	root19 = 45,	root20 = 90,	root21 = 180,	root22 = 117,
root23 = 234,	root24 = 201,	root25 = 143,	root26 = 3,	root27 = 6,	root28 = 12,	root29 = 24,
root30 = 48,	root31 = 96,	root32 = 192,	root33 = 157,	root34 = 39, root35 = 78, root36 = 156,
root37 = 37,	root38 = 74,	root39 = 148,	root40 = 53,	root41 = 106,	root42 = 212,	root43 = 181,
root44 = 119,	root45 = 238,	root46 = 193,	root47 = 159,	root48 = 35,	root49 = 70,	root50 = 140,
negroot0 = 1,	negroot1 = 142,	negroot2 = 71, negroot3 = 173, negroot4 = 216, negroot5 = 108,
negroot6 = 54, negroot7 = 27,	negroot8 = 131,	negroot9 = 207,	negroot10 = 233, negroot11 = 250,
negroot12 = 125, negroot13 = 176,	negroot14 = 88,	negroot15 = 44,	negroot16 = 22,	negroot17 = 11,
negroot18 = 139,	negroot19 = 203, negroot20 = 235,	negroot21 = 251, negroot22 = 243,	negroot23 = 247,
negroot24 = 245, negroot25 = 244, rootpower_seed = 9,
inv_file = "inv_8_285.hex"
);

-- system parameters
-- n  (length of code)
-- m  (GF size (2^m)
-- irrpol (field polynomial)
-- check (number of check symbols (= # of syndromes))
-- genstart (first root of generator polynomial)

constant errs = floor(check DIV 2);
constant size = ceil(log2(n+1));


subdesign rs_std_str
(
sysclk, reset, rsin[m..1], dsin, dsout, bypass : INPUT;
rsout[m..1], outvalid, numerr[wide..1], rdyin, decfail : OUTPUT;
)

VARIABLE

  IF (speed == "full") GENERATE
    key : bms_std_str_full WITH (n=n,m=m,irrpol=irrpol,check=check,inv_file=inv_file);
  ELSE GENERATE
    key : bms_std_str_half WITH (n=n,m=m,irrpol=irrpol,check=check,inv_file=inv_file);
  END GENERATE;
  syn : syn_std_str WITH (n=n,m=m,irrpol=irrpol,check=check,
root1 = root1, root2 = root2, root3 = root3, root4 = root4, root5 = root5,
root6 = root6, root7 = root7, root8 = root8, root9 = root9, root10 = root10,
root11 = root11, root12 = root12, root13 = root13, root14 = root14, root15 = root15,
root16 = root16, root17 = root17, root18 = root18, root19 = root19, root20 = root20,
root21 = root21, root22 = root22, root23 = root23, root24 = root24, root25 = root25,
root26 = root26, root27 = root27, root28 = root28, root29 = root29, root30 = root30,
root31 = root31, root32 = root32, root33 = root33, root34 = root34, root35 = root35,
root36 = root36, root37 = root37, root38 = root38, root39 = root39, root40 = root40,
root41 = root41, root42 = root42, root43 = root43, root44 = root44, root45 = root45,
root46 = root46, root47 = root47, root48 = root48, root49 = root49, root50 = root50
);
  chn : chn_std_str WITH (n=n,m=m,irrpol=irrpol,check=check,genstart=genstart,
negroot0 = negroot0, negroot1 = negroot1, negroot2 = negroot2, negroot3 = negroot3,
negroot4 = negroot4, negroot5 = negroot5, negroot6 = negroot6, negroot7 = negroot7, 
negroot8 = negroot8, negroot9 = negroot9, negroot10 = negroot10, negroot11 = negroot11, 
negroot12 = negroot12, negroot13 = negroot13, negroot14 = negroot14, negroot15 = negroot15, 
negroot16 = negroot16, negroot17 = negroot17, negroot18 = negroot18, negroot19 = negroot19, 
negroot20 = negroot20, negroot21 = negroot21, negroot22 = negroot22, negroot23 = negroot23,
negroot24 = negroot24, negroot25 = negroot25, rootpower_seed = rootpower_seed,
inv_file = inv_file
  );

  bdhold[errs..1][m..1], omegahold[errs..1][m..1] : dffe;
  lochold[errs..1][size..1], vechold[errs..1][m..1] : dffe;
  numholda[wide..1], numholdb[wide..1], numroots[wide..1] : dffe;
  nofix : dffe;

  errchk[wide..1] : node;

BEGIN

ASSERT
	REPORT "Compiling ALTERA's Standard Streaming Reed-Solomon Decoder MegaCore Function"
	SEVERITY INFO;

  syn.sysclk = sysclk;
  syn.reset = reset;
  syn.r[] = rsin[];
  syn.dsin = dsin;
  syn.dsout = dsout;
  syn.bypass = bypass # nofix;
  syn.massdone = key.done;
  syn.gofinal = chn.gofinal;
  syn.errvec[errs..1][m..1] = vechold[errs..1][m..1];
  syn.errloc[errs..1][size..1] = lochold[errs..1][size..1];

  key.sysclk = sysclk;
  key.reset = syn.resetmass;
  key.latchsyn = syn.latchstage;
  key.syn[check..1][m..1] = syn.syn[check..1][m..1];

  bdhold[][].clk = sysclk;
  bdhold[][].ena = syn.latchstage;
  bdhold[][].clrn = !reset;
  bdhold[errs..1][] = key.bdout[errs..1][];

  omegahold[][].clk = sysclk;
  omegahold[][].ena = syn.latchstage;
  omegahold[][].clrn = !reset;
  omegahold[][] = key.omegaout[][];

  chn.sysclk = sysclk;
  chn.reset = syn.resetchn;
  chn.bd[errs..1][m..1] = bdhold[errs..1][m..1];
  chn.omega[errs..1][m..1] = omegahold[errs..1][m..1];

  lochold[][].clk = sysclk;
  lochold[][].ena = syn.latchstage;
  lochold[][].clrn = !reset;
  lochold[][] = chn.errloc[errs..1][size..1];

  vechold[][].clk = sysclk;
  vechold[][].ena = syn.latchstage;
  vechold[][].clrn = !reset;
  vechold[][] = chn.errvec[errs..1][m..1];

  numholda[] = key.numerr[];
  numholda[].clk = sysclk;
  numholda[].clrn = !reset;
  numholda[].ena = syn.latchstage;
  numholdb[] = numholda[];
  numholdb[].clk = sysclk;
  numholdb[].clrn = !reset;
  numholdb[].ena = syn.latchstage;

  numroots[] = chn.numroots[wide..1];
  numroots[].clk = sysclk;
  numroots[].clrn = !reset;
  numroots[].ena = syn.latchstage;

  rsout[] = syn.rsout[];
  outvalid = syn.outvalid;
  numerr[] = numholdb[];
  rdyin = syn.rdyin;

  -- calculate decoding failure (numroots[] <> numerr[])

  errchk[1] = numroots[1] $ numholdb[1];
  FOR k IN 2 TO wide GENERATE
    errchk[k] = errchk[k-1] # (numroots[k] $ numholdb[k]);
  END GENERATE;

  decfail = errchk[wide] & syn.outvalid;

  -- if decfail, don't correct
  nofix = errchk[wide];
  nofix.clk = sysclk;
  nofix.clrn = !reset;

END;