chn_std_dsc.tdf

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

-------------------------------------------------------------------------
-------------------------------------------------------------------------
--
-- Revision Control Information
--
-- $Workfile:   chn_std_dsc.tdf  $
-- $Archive:   P:/RS_std/units/Dec_dsc/ahdl/chn_std_dsc.tdv  $
--
-- $Revision:   1.3  $
-- $Date:   19 Aug 1999 15:20:52  $
-- $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_dsc
(
sysclk, reset, go : 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");

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

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

--			   s99 = B"00001");

BEGIN

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

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

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

CASE ss IS

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

-- search

	WHEN s1 =>
		  ss = s2;


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

	WHEN s3 =>
		  ss = s4;
	WHEN s4 =>
   	IF (cntchk[m] == GND) THEN
 		  ss = s99;
		ELSE
		  ss = s2;
		END IF;

	WHEN s99 =>
		ss = s99;
	
END CASE;


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

cmpcnt[] = n;

rootcnt[] = lcnta.q[];
lcnta.clock = sysclk;
lcnta.cnt_en = counten;
lcnta.aclr = 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.aclr = reset;

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

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

deladd[] = rootcnt[size..1]; -- delay location address to line up with root
deladd[].clk = sysclk;
deladd[].clrn = !reset;

reg[][].clk = sysclk;
reg[][].clrn = !reset;
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;

FOR k IN 1 TO errs GENERATE
  mulout[k][] = gfmul( reg[k][], alpha[k][]) WITH (m=m, irrpol = irrpol);
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;


deldrv[] = drvadder[drv][];
deldrv[].clk = sysclk;
deldrv[].clrn = !reset;

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)  ***
-- *****************

omreg[][].clk = sysclk;
omreg[][].clrn = !reset;
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];
  END GENERATE;
END GENERATE;

delom[m..1] = omadder[errs-1][m..1] $ omega[1][m..1];  -- GFadd
delom[].clk = sysclk;
delom[].clrn = !reset;

-- ***********************
-- *** 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;

IF (genstart > 0 ) GENERATE
  -- calculate next root
  rootreg[].clk = sysclk;
  rootreg[].clrn = !reset;
  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[];
  delroot[2][] = delroot[1][];
  delroot[][].clk = sysclk;
  delroot[][].clrn = !reset;

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

END GENERATE;


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

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

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

END;