bms_eras_dsc_half.tdf

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

-------------------------------------------------------------------------
-------------------------------------------------------------------------
--
-- Revision Control Information
--
-- $Workfile:   bms_eras_dsc_half.tdf  $
-- $Archive:   P:/RS_eras/units/Dec_dsc/ahdl/bms_eras_dsc_half.tdv  $
--
-- $Revision:   1.2  $
-- $Date:   20 Aug 1999 12:07:26  $
-- $Author			:  Alejandro Diaz-Manero
--
-- Project      :  RS_eras
--
-- Description	: 
--
-- Copyright 1999 (c) Altera Corporation
-- All rights reserved
--
-------------------------------------------------------------------------
-------------------------------------------------------------------------

FUNCTION lpm_add_sub (cin, dataa[LPM_WIDTH-1..0], datab[LPM_WIDTH-1..0], 
					  add_sub, clock, aclr)
 RETURNS (result[LPM_WIDTH-1..0], cout, overflow);

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 lpm_compare (dataa[LPM_WIDTH-1..0], datab[LPM_WIDTH-1..0], clock, aclr)
 RETURNS (alb, aeb, agb, ageb, aneb, aleb);

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

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


PARAMETERS
(
m = 8,			-- GF size (2^m)
irrpol = 285,	-- field polynomial
check = 8, 		-- number of check symbols (= # of syndromes)
inv_file = "inv_8_285.hex"
);

constant wide = ceil(log2(check+1));
constant nummult = ceil(check DIV 2);
constant odd = nummult > floor(check DIV 2) ? 1:0;

subdesign bms_eras_dsc_half
(
 sysclk, reset, go, syn[check..1][m..1], num_eras[wide..1], eras_pos[check..1][m..1] : INPUT;
 bdout[check..1][m..1], omegaout[check..1][m..1], numerr[wide..1], done : OUTPUT;
)

VARIABLE

synreg[check..1][m..1], bd[check..1][m..1], bdprev[check..1][m..1], bdtemp[check..1][m..1] : dffe;
one[m..1] : node;
sh_sel[check..1] : dffe;
erasleft[check..1][m..1], erasright[check..1][m..1] : node;
onereg : dffe;
onenode[m..1] : node;

deltaleft[check..1][m..1], deltaright[check..1][m..1] : node;
bdleft[check..1][m..1], bdright[check..1][m..1] : node;
mulleft[nummult..1][m..1], mulright[nummult..1][m..1], deltamult[m..1] : dffe; 
mulout[nummult..1][m..1] : node;
mulsum[nummult..1][m..1], addvec[check..1][m..1] : node;
deltazero[m..1] : node;
predelta[m..1], delta[m..1], deltaprev[m..1] : dffe;

llnumnode[wide..1], llnuma[wide..1], llnumb[wide..1] : node;
llnum[wide..1] : dffe;
mloop[wide..1], omegaloop[wide..1] : node;
mchk[wide..1], mcmp[wide..1], omegachk[wide..1], omegacmp[wide..1] : node;  
tlm : node;
init_syn[wide..1], eras_zero[wide..1] : node;
mloop_plus_eras_num[wide+1..1] : node;

num_eras_q[wide..1], omsel[check..1] : dffe;
omegaleft[check..1][m..1], omegaright[check..1][m..1] : node;

loadsyn, loadbdleft, loadbdright, loadbdprev, loadbdtemp, load_llnum : node;
multmux : node;
shiftsynleft, shiftsynright, clearbd, shiftbdprev_lm, shift_sh_sel : node;
deltacalc, newdelta, olddelta, shiftbdprev_ml : node;
incm : node;
incomega, initomega, calcomega : node;
massdone : node;

mcount, omegacount : lpm_counter WITH (LPM_WIDTH = wide);

add_sub1 : lpm_add_sub WITH (LPM_WIDTH = wide, LPM_DIRECTION = "SUB");
add_sub2, add_sub3 : lpm_add_sub WITH (LPM_WIDTH = wide, LPM_DIRECTION = "ADD");
add_sub4 : lpm_add_sub WITH (LPM_WIDTH = wide+1, LPM_DIRECTION = "ADD");
compare1 : lpm_compare WITH (LPM_WIDTH = wide+1);


  mx : MACHINE OF BITS (mst[20..1])
	   WITH STATES
			(s0  = B"00001000001000000000",

			 s1  = B"10001000001000010000",  -- load syndromes, multmux
			 s1a = B"00001000001000010010",  -- load bdright, multmux
			 s1b = B"00001000001000000000",  -- keep selecting deltacalc calomega
			 s1c = B"01101001001000100001",  -- shift syndrome as num erasures,
                                         -- incm, load bdleft, shiftbdprev_ml, shift_sh_sel
			 s1d = B"00001000001000010000",  -- multmux
			 s1e = B"00000000000000001000",  -- load bdtemp
			 s2a = B"00000000000000000100",  -- load bdprev not inc mloop
			 s2b = B"00000000011100000000",  -- calc new delta = Sm + (series)B(j)*S(m-j), shiftbdprev_lm

			 s77a= B"00000000011000010000",  -- 1 pipe stage to top of gfmuls, multmux
			 s77b= B"00000000011000010000",  -- 1 pipe stage to top of gfmuls

			 s3  = B"00000000000000000000",  -- if new delta <> 0, calc new BD

			 s4  = B"00000000000000001000",  -- TD = BD, BD = BD - deltamult*(D^i)*BDprev
			 s5  = B"00000000000000010001",  -- load first half BD  , multmux
			 s5a = B"00000000000000010010",  -- load second half BD, check 2L <= m?
			 s6  = B"00000000100000000100",  -- L = m+1-L, i=1, BDprev = BDtemp, olddelta = delta, load llnum
			 s8  = B"00000001000000100000",  -- inc mloop, shift synregs left

			 s10 = B"00001100000010001000",  -- initialize omegaleft, loadbdtemp, clearbd
			 s11 = B"00001100000001010101",  -- initialize omegaright, loadbdprev, shift synregs right
			
			 s12 = B"00001010000000000010",  -- calc omegaleft, load omegaright, incomega
			 s13 = B"00101000000001010001",  -- calc omegaright, load omegaleft, synshiftright, shiftbdprev_ml

			 s14 = B"00100000000000000000",  -- last shiftbdprev_ml

			 s99 = B"00010000000000000000");


BEGIN

mcmp[] = check;
omegacmp[] = check-1; 
one[] = 1;

--*********************
--*** STATE MACHINE ***
--*********************

mx.clk = sysclk;
mx.reset = reset;

CASE mx IS

	WHEN s0 =>
	  IF (go == VCC) THEN
		mx = s1;
		else
		mx = S0;
	  END IF;

	WHEN s1 =>
		if eras_zero[wide] == VCC then
			mx = S1a;
		else
		  mx = S2a;
		end if;

	when S1a => mx = S1b;
	when S1b => mx = S1c;
	when S1c => mx = S1d;

  when S1d => 
    if init_syn[wide] == VCC then
			mx = S1a;
		else
			mx = S1e;
		end if;
	
	when S1e => mx = S2a;
	when S2a => mx = S2b;
	WHEN s2b =>
	  IF (mchk[wide] == VCC) THEN
		mx = s77a;
	  ELSE	
		mx = s10;
	  END IF;

	WHEN s77a => mx = s77b;
	WHEN s77b => mx = s3;

	WHEN s3 =>
	  IF (deltazero[m] == VCC) THEN
		mx = s4;
	  ELSE
		mx = s8;
	  END IF;

	WHEN s4 => mx = s5;
	WHEN s5 => mx = s5a;
	WHEN s5a =>
	  IF (tlm == VCC) THEN
		mx = s6;
	  ELSE
		mx = s8;
	  END IF;

 	WHEN s6 => mx = s8;
	WHEN s8 => mx = s2b;

	WHEN s10 =>	mx = s11;
	WHEN s11 =>	mx = s12;

	WHEN s12 =>
   	IF (omegachk[wide] == VCC) THEN
		  mx = s13;
		ELSE
		  mx = s14;
		END IF;
	WHEN s13 => mx = s12;
	WHEN s14 =>	mx = s99;
	WHEN s99 =>	mx = s99;
 
END CASE;

loadbdleft = mst[1];
loadbdright = mst[2];
loadbdprev = mst[3];
loadbdtemp = mst[4];
multmux = mst[5];
shiftsynleft = mst[6];
shiftsynright = mst[7];
clearbd = mst[8];
shiftbdprev_lm = mst[9];
deltacalc = mst[10];
newdelta = mst[11];
olddelta = mst[12];
incm = mst[13]; 
incomega = mst[14]; 
initomega = mst[15]; 
calcomega = mst[16];
massdone = mst[17];
shiftbdprev_ml = mst[18];
shift_sh_sel = mst[19];
loadsyn = mst[20];
load_llnum = olddelta;


--************************
--*** SYNDROME SECTION ***
--************************

synreg[1][] = (syn[1][] & !shiftsynleft) # (synreg[2][] & shiftsynleft);
synreg[1][].ena = loadsyn # shiftsynleft;
FOR k IN 2 TO check-1 GENERATE
  synreg[k][] = (syn[k][] & !shiftsynleft & !shiftsynright) # 
				  (synreg[k+1][] & shiftsynleft) #
				  (synreg[k-1][] & shiftsynright);
	synreg[k][].ena = loadsyn # shiftsynleft # shiftsynright;   
END GENERATE;
synreg[check][] = (syn[check][] & !shiftsynleft & !shiftsynright) #
                  (synreg[1][] & shiftsynleft) #
									(synreg[check-1][] & shiftsynright);
synreg[check][].ena = loadsyn # shiftsynleft # shiftsynright;

synreg[][].clk = sysclk;


--******************
--*** BD-OMEGA SECTION ***
--******************

-- load onereg with zero after first shift
--onereg[] = (one[] & !shiftbdprev);
onereg = loadsyn # loadbdprev;
onereg.ena = shiftbdprev_lm # loadsyn # loadbdprev;