rs_eras_str.tdf

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

-------------------------------------------------------------------------
-------------------------------------------------------------------------
--
-- Revision Control Information
--
-- $Workfile:   rs_eras_str.tdf  $
-- $Archive:   P:/RS_eras/units/Dec_str/ahdl/rs_eras_str.tdv  $
--
-- $Revision:   1.5  $
-- $Date:   01 Sep 1999 15:52:12  $
-- $Author			:  Alejandro Diaz-Manero
--
-- Project      :  RS_eras
--
-- Description	:  Top level entity for streaming RS decoder supporting
--                 erasures.
--
-- Copyright 1999 (c) Altera Corporation
-- All rights reserved
--
-------------------------------------------------------------------------
-------------------------------------------------------------------------

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

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

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

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

FUNCTION lpm_compare (dataa[LPM_WIDTH-1..0], datab[LPM_WIDTH-1..0], clock, aclr)
   RETURNS (alb, aeb, agb, ageb, aneb, aleb);

PARAMETERS
(
n = 15, -- length of message
m = 4, -- field size (2^m)
irrpol = 19, -- field polynomial
check = 4, -- number of check symbols
genstart = 2, -- first root of generator polynomial
speed = "full",
wide = 3,
root1 = 1, root2 = 2, root3 = 4, root4 = 8, root5 = 1, root6 = 3, root7 = 6, root8 = 12,
root9 = 15, root10 = 9, root11 = 13, root12 = 2, root13 = 10, root14 = 2, root15 = 11,
root16 = 3, root17 = 3, root18 = 6, root19 = 4, root20 = 8, root21 = 5, root22 = 12,
root23 = 0, root24 = 9, root25 = 8, root26 = 7, root27 = 5, root28 = 4, root29 = 9,
root30 = 8, root31 = 6, root32 = 7, root33 = 5, root34 = 3, root35 = 9, root36 = 8,
root37 = 1, root38 = 2, root39 = 9, root40 = 8, root41 = 6, root42 = 7, root43 = 5,
root44 = 3, root45 = 9, root46 = 5, root47 = 11, root48 = 12, root49 = 13, root50 = 3,
negroot0 = 1, negroot1 = 2, negroot2 = 3, negroot3 = 4, negroot4 = 5, negroot5 = 6, 
negroot6 = 7, negroot7 = 8, negroot8 = 9, negroot9 = 10, negroot10 = 11, negroot11 = 12, 
negroot12 = 13, negroot13 = 14, negroot14 = 15, negroot15 = 9, negroot16 = 10, 
negroot17 = 7, negroot18 = 8, negroot19 = 4, negroot20 = 3, negroot21 = 2, negroot22 = 3,
negroot23 = 4, negroot24 = 5, negroot25 = 6, negroot26 = 7, negroot27 = 8, negroot28 = 9,
negroot29 = 10, negroot30 = 1, negroot31 = 2, negroot32 = 3, negroot33 = 4, negroot34 = 5,
negroot35 = 6, negroot36 = 7, negroot37 = 8, negroot38 = 9, negroot39 = 10, negroot40 = 1,
negroot41 = 2, negroot42 = 3, negroot43 = 4, negroot44 = 5, negroot45 = 6, negroot46 = 7,
negroot47 = 8, negroot48 = 9, negroot49 = 10, negroot50 = 10, rootpower_seed = 1,
first_root =9, one_half = 9, inv_file = "inv_4_19.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 size = ceil(log2(n+1));


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

VARIABLE

  IF (speed == "full") GENERATE
    key : bms_eras_str_full WITH (n=n,m=m,irrpol=irrpol,check=check,inv_file=inv_file);
  ELSE GENERATE
    key : bms_eras_str_half WITH (n=n,m=m,irrpol=irrpol,check=check,inv_file=inv_file);
  END GENERATE;
  syn : syn_eras_str WITH (n=n,m=m,irrpol=irrpol,check=check,
  first_root=first_root, one_half=one_half,
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_eras_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, negroot26 = negroot26, negroot27 = negroot27, 
negroot28 = negroot28, negroot29 = negroot29, negroot30 = negroot30, negroot31 = negroot31,
negroot32 = negroot32, negroot33 = negroot33, negroot34 = negroot34, negroot35 = negroot35,
negroot36 = negroot36, negroot37 = negroot37, negroot38 = negroot38, negroot39 = negroot39,
negroot40 = negroot40, negroot41 = negroot41,
negroot42 = negroot42, negroot43 = negroot43, negroot44 = negroot44, negroot45 = negroot45,
negroot46 = negroot46, negroot47 = negroot47, negroot48 = negroot48, negroot49 = negroot49,
negroot50 = negroot50, rootpower_seed = rootpower_seed, inv_file = inv_file
  );

  bdhold[check..1][m..1], omegahold[check..1][m..1] : dffe;
  lochold[check..1][size..1], vechold[check..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 Streaming Erasure-supporting Reed-Solomon Decoder MegaCore Function"
	SEVERITY INFO;

  syn.sysclk = sysclk;
  syn.reset = reset;
  syn.r[] = rsin[];
  syn.dsin = dsin;
  syn.dsout = dsout;
	syn.eras_ind = eras_ind;
  syn.bypass = bypass # nofix;
  syn.massdone = key.done;
  syn.gofinal = chn.gofinal;
  syn.errvec[check..1][m..1] = vechold[check..1][m..1];
  syn.errloc[check..1][size..1] = lochold[check..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];
	key.num_eras[wide..1] = syn.num_eras[wide..1];
	key.eras_pos[check..1][m..1] = syn.eras_roots[check..1][m..1];


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

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

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

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

  vechold[][].clk = sysclk;
  vechold[][].ena = syn.latchstage;
  vechold[][].clrn = !reset;
  vechold[][] = chn.errvec[check..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;