rs_std_dsc.tdf

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

-------------------------------------------------------------------------
-------------------------------------------------------------------------
--
-- Revision Control Information
--
-- $Workfile:   rs_std_dsc.tdf  $
-- $Archive:   P:/RS_std/units/Dec_dsc/ahdl/rs_std_dsc.tdv  $
--
-- $Revision:   1.4  $
-- $Date:   01 Sep 1999 15:52:02  $
-- $Author			:  Alejandro Diaz-Manero
--
-- Project      :  RS_std
--
-- Description	: 
--
-- Copyright 1999 (c) Altera Corporation
-- All rights reserved
--
-------------------------------------------------------------------------
-------------------------------------------------------------------------

FUNCTION chn_std_dsc (sysclk, reset, go, 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_dsc_full (sysclk, reset, go, syn[check..1][m..1])
	RETURNS (bdout[errs..1][m..1], omegaout[errs..1][m..1], numerr[wide..1], done);

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

FUNCTION syn_std_dsc (sysclk, reset, r[m..1], dsin, dsout, bypass, gofinal, 
			  	   errvec[errs..1][m..1], errloc[errs..1][size..1])
	RETURNS (rdyin, outvalid, syn[check..1][m..1], startmass, 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 = "full",
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_dsc
(
sysclk, reset, rsin[m..1], dsin, dsout, bypass : INPUT;
rsout[m..1], outvalid, rdyin, decfail, numerr[wide..1] : OUTPUT;
)

VARIABLE

  IF (speed == "full") GENERATE
    key : bms_std_dsc_full WITH (n=n,m=m,irrpol=irrpol,check=check,inv_file=inv_file);
  ELSE GENERATE
    key : bms_std_dsc_half WITH (n=n,m=m,irrpol=irrpol,check=check,inv_file=inv_file);
  END GENERATE;
  syn : syn_std_dsc 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_dsc 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,
inv_file = inv_file, rootpower_seed = rootpower_seed
  );

  errchk[wide..1] : node;

BEGIN

ASSERT
	REPORT "Compiling ALTERA's Standard Discrete 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 # errchk[wide];
  syn.gofinal = chn.gofinal;
  syn.errvec[errs..1][m..1] = chn.errvec[errs..1][m..1];
  syn.errloc[errs..1][size..1] = chn.errloc[errs..1][size..1];
 
  key.sysclk = sysclk;
  key.reset = reset;
  key.go = syn.startmass;
  key.syn[check..1][m..1] = syn.syn[check..1][m..1];

  chn.sysclk = sysclk;
  chn.reset = reset;
  chn.go = key.done;
  chn.bd[errs..1][m..1] = key.bdout[errs..1][m..1];
  chn.omega[errs..1][m..1] = key.omegaout[errs..1][m..1];

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

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

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

  decfail = errchk[wide] & syn.outvalid;

END;