chn_std_str.tdf

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

-------------------------------------------------------------------------
-------------------------------------------------------------------------
--
-- Revision Control Information
--
-- $Workfile:   chn_std_str.tdf  $
-- $Archive:   P:/RS_std/units/Dec_str/ahdl/chn_std_str.tdv  $
--
-- $Revision:   1.2  $
-- $Date:   20 Aug 1999 08:48:22  $
-- $Author			:  Alejandro Diaz-Manero
--
-- Project      :  RS_std
--
-- Description	: 
--
-- Copyright 1999 (c) Altera Corporation
-- All rights reserved
--
-------------------------------------------------------------------------
-------------------------------------------------------------------------

FUNCTION lpm_counter (data[LPM_WIDTH-1..0], clock, clk_en, cnt_en, updown, aclr, 
					  aset, aconst, aload, sclr, sset, sconst, sload)
   RETURNS (q[LPM_WIDTH-1..0], eq[15..0]);

FUNCTION gfmul (a[m..1], b[m..1]) 
   RETURNS (c[m..1]);

FUNCTION gfdiv (a[m..1], d[m..1]) 
   RETURNS (c[m..1]);

FUNCTION select1 (selin[inwidth..1]) -- 0=1
	RETURNS (selout[outwidth..1]);


PARAMETERS
(
n = 204,		-- length of code
m = 8,			-- GF size (2^m)
irrpol = 285,	-- field polynomial
check = 16,  	-- number of check symbols (= # of syndromes)
genstart = 0,	-- 1st root of generator polynomial
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"
);

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


subdesign chn_std_str
(
sysclk, reset : INPUT; 
bd[errs..1][m..1] : INPUT;
omega[errs..1][m..1] : INPUT;
errloc[errs..1][size..1] : OUTPUT;
errvec[errs..1][m..1] : OUTPUT;
numroots[m..1] : OUTPUT;
gofinal : OUTPUT;
)

VARIABLE

-- search variables
reg[errs..1][m..1] : dffe;
locreg[errs..1][size..1] : dffe;
deladd[size..1], deldrv[m..1] : dffe;

mulout[errs..1][m..1], alpha[errs..1][m..1] : node;
evadder[even..1][m..1], drvadder[drv..1][m..1], halfadd[m..1] : node;
rootcnt[m..1], dftadd[m..1] : node;
cmpcnt[m..1], cntchk[m..1], poly[m..1], polyzero[m..1] : node;
load[errs..1], one[m..1] : node;

lcnta, lcntb : lpm_counter WITH (LPM_WIDTH = m);

-- eval variables
omreg[(errs-1)..1][m..1], vecreg[errs..1][m..1] : dffe;
delom[m..1] : dffe;
omegamul[(errs-1)..1][m..1] : node;
omadder[(errs-1)..1][m..1] : node;
divfield[m..1] : dffe; 
vecfield[m..1] : node;
IF (genstart > 0) GENERATE
  rootreg[m..1], delroot[2..1][m..1] : dffe;
  rootmul[m..1], rootpower[m..1] : node;
END GENERATE;

init, counten, loadloc, loadvec, gofinal : node;

ss : MACHINE OF BITS (state[5..1])
WITH STATES (s0  = B"00000",  

             -- search
			 s1  = B"00001", -- initialize search registers
			 s2  = B"00010", -- check next root 
			 -- store
			 s3  = B"00100", -- store location
			 s4  = B"01000", -- store vector, inc counter

			 s99 = B"10000");

BEGIN

-- ****************
-- *** machine  ***
-- ****************

init = state[1];
counten = state[2];
loadloc = state[3];
loadvec = state[4];
gofinal = state[5];

ss.clk = sysclk;
ss.reset = GND;

CASE ss IS

	WHEN s0 =>
	  	IF (reset == VCC) THEN
	  	  ss = s0;
    	ELSE
	      ss = s1;
	    END IF;

-- search

	WHEN s1 =>		-- initialize search
	  	IF (reset == VCC) THEN
	  	  ss = s0;
	  	ELSE		
		  ss = s2;
	    END IF;

	WHEN s2 => 
	    IF (reset == VCC) THEN
	  	  ss = s0;
		ELSIF (cntchk[m] == GND) THEN
		  ss = s99;
		ELSIF (polyzero[m] == GND) THEN
		  ss = s3;
		ELSE  
		  ss = s2;
		END IF;

	WHEN s3 =>
	    IF (reset == VCC) THEN
	  	  ss = s0;
      ELSE
		  ss = s4;
		END IF;

	WHEN s4 =>
	    IF (reset == VCC) THEN
	  	  ss = s0;
   	ELSIF (cntchk[m] == GND) THEN
 		  ss = s99;
		ELSE
		  ss = s2;
		END IF;

	WHEN s99 =>
	    IF (reset == VCC) THEN
	  	  ss = s0;
		ELSE
		  ss = s99;
		END IF;

	WHEN others =>
		ss = s0;

END CASE;


-- ***********************
-- *** do chien search ***
-- ***********************

cmpcnt[] = n;

rootcnt[] = lcnta.q[];
lcnta.clock = sysclk;
lcnta.cnt_en = counten;
lcnta.sclr = reset;

cntchk[1] = rootcnt[1] $ cmpcnt[1];
FOR k IN 2 TO m GENERATE
  cntchk[k] = cntchk[k-1] # (rootcnt[k] $ cmpcnt[k]);
END GENERATE;

dftadd[] = lcntb.q[];
lcntb.clock = sysclk;
lcntb.cnt_en = loadvec;
lcntb.sclr = reset;

load[] = select1(dftadd[])
			  WITH (inwidth = m, outwidth = errs);

locreg[][].clk = sysclk;
FOR k IN 1 TO errs GENERATE
  locreg[k][] = (deladd[size..1]) & !reset;
  locreg[k][].ena = (load[k] & loadloc) # reset;

  mulout[k][] = gfmul( reg[k][], alpha[k][]) WITH (m=m, irrpol = irrpol);
END GENERATE; 

deladd[].clk = sysclk;
deladd[] = rootcnt[size..1];


-- reset not needed, initialized by state machine
reg[][].clk = sysclk;
FOR k IN 1 TO errs GENERATE
  reg[k][] = ((mulout[k][] & !init) # (bd[k][] & init));
  reg[k][].ena = init # counten;
END GENERATE;

alpha[1][] = negroot1;   -- a^-1
IF (errs >= 2) GENERATE
  alpha[2][] = negroot2;    -- a^-2
END GENERATE;
IF (errs >= 3) GENERATE
  alpha[3][] = negroot3;   -- a^-3
END GENERATE;
IF (errs >= 4) GENERATE
  alpha[4][] = negroot4;   -- a^-4
END GENERATE;
IF (errs >= 5) GENERATE
  alpha[5][] = negroot5;
END GENERATE;
IF (errs >= 6) GENERATE
  alpha[6][] = negroot6;
END GENERATE;
IF (errs >= 7) GENERATE
  alpha[7][] = negroot7;
END GENERATE;
IF (errs >= 8) GENERATE
  alpha[8][] = negroot8;
END GENERATE;
IF (errs >= 9) GENERATE
  alpha[9][] = negroot9;
END GENERATE;
IF (errs >= 10) GENERATE
  alpha[10][] = negroot10;
END GENERATE;
IF (errs >= 11) GENERATE
  alpha[11][] = negroot11;
END GENERATE;
IF (errs >= 12) GENERATE
  alpha[12][] = negroot12;
END GENERATE;
IF (errs >= 13) GENERATE
  alpha[13][] = negroot13;
END GENERATE;
IF (errs >= 14) GENERATE
  alpha[14][] = negroot14;
END GENERATE;
IF (errs >= 15) GENERATE
  alpha[15][] = negroot15;
END GENERATE;
IF (errs >= 16) GENERATE
  alpha[16][] = negroot16;
END GENERATE;
IF (errs >= 17) GENERATE
  alpha[17][] = negroot17;
END GENERATE;
IF (errs >= 18) GENERATE
  alpha[18][] = negroot18;
END GENERATE;
IF (errs >= 19) GENERATE
  alpha[19][] = negroot19;
END GENERATE;
IF (errs >= 20) GENERATE
  alpha[20][] = negroot20;
END GENERATE;
	IF (errs >= 21) GENERATE
  alpha[21][] = negroot21;
END GENERATE;
IF (errs >= 22) GENERATE
  alpha[22][] = negroot22;
END GENERATE;
IF (errs >= 23) GENERATE
  alpha[23][] = negroot23;
END GENERATE;
IF (errs >= 24) GENERATE
  alpha[24][] = negroot24;
END GENERATE;
IF (errs >= 25) GENERATE
  alpha[25][] = negroot25;
END GENERATE;



-- add all even regs together
evadder[1][m..1] = reg[2][m..1];
IF (even >= 2) GENERATE
  FOR J IN 2 TO even GENERATE
    evadder[J][m..1] = evadder[J-1][m..1] $ reg[2*j][m..1];
  END GENERATE;
END GENERATE;

-- do derivative (odd terms)
drvadder[1][m..1] = reg[1][m..1];
IF (drv >= 2) GENERATE
  FOR J IN 2 TO drv GENERATE
    drvadder[J][m..1] = drvadder[J-1][m..1] $ reg[2*J-1][m..1];
  END GENERATE;
END GENERATE;

-- reset not needed, deldrv[] is valid by the time root found
deldrv[] = drvadder[drv][];
deldrv[].clk = sysclk;


one[]=1;
halfadd[m..1] = evadder[even][m..1] $ drvadder[drv][m..1];  -- GFadd
poly[m..1] = halfadd[m..1] $ one[m..1]; -- GFadd

polyzero[1] = poly[1];
FOR k IN 2 TO m GENERATE
  polyzero[k] = polyzero[k-1] # poly[k];
END GENERATE;

-- *****************
-- *** omega(x)  ***
-- *****************

-- reset not needed, initialized by state machine
omreg[][].clk = sysclk;
FOR k IN 1 TO (errs-1) GENERATE
  omreg[k][] = ((omegamul[k][] & !init) # (omega[k+1][] & init));
  omreg[k][].ena = init # counten;
END GENERATE;

FOR k IN 1 TO (errs-1) GENERATE
  omegamul[k][] = gfmul( omreg[k][], alpha[k][]) WITH (m=m, irrpol = irrpol);
END GENERATE;

-- add all omega terms together
omadder[1][m..1] = omreg[1][m..1];
IF (errs > 2) GENERATE
  FOR J IN 2 TO (errs-1) GENERATE
    omadder[J][m..1] = omadder[J-1][m..1] $ omreg[J][m..1];  -- GFadd
  END GENERATE;
END GENERATE;

-- reset not needed, delom[] valid by the time root found
delom[m..1] = omadder[errs-1][m..1] $ omega[1][m..1];  -- GFadd
delom[].clk = sysclk;

-- ***********************
-- *** evaluate error  ***
-- ***********************

  divfield[] = gfdiv(delom[],deldrv[]) WITH (m=m, irrpol = irrpol, inv_file = inv_file);
  divfield[].clk = sysclk;

IF (genstart == 0) GENERATE
  vecfield[] = divfield[];
END GENERATE;

-- reset not needed, initializes after reset of sm
-- reset not needed, initializes after reset of sm
IF (genstart > 0 ) GENERATE
 
 -- calculate next root
  rootreg[].clk = sysclk;
  rootreg[].ena = init # counten;
  -- load 1 into rootreg on startup
  rootreg[m..2] = (rootmul[m..2] & !init);
  rootreg[1] = (rootmul[1] & !init) # init;

  rootpower[] = rootpower_seed;

  rootmul[] = gfmul(rootpower[],rootreg[]) WITH (m=m, irrpol = irrpol);

  delroot[1][] = rootreg[] & !reset;
  delroot[2][] = delroot[1][] & !reset;
  delroot[][].clk = sysclk;

  vecfield[] = gfmul(divfield[], delroot[2][]) WITH (m=m, irrpol = irrpol);

END GENERATE;

FOR k IN 1 TO errs GENERATE
  vecreg[k][] = vecfield[] & !reset;
  vecreg[k][].ena = (load[k] & loadvec) # reset;
END GENERATE;
vecreg[][].clk = sysclk;

-- ****************
-- *** outputs  ***
-- ****************

errvec[][] = vecreg[][];
errloc[][] = locreg[][];
numroots[] = dftadd[];

END;