syn_eras_dsc.tdf

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

-------------------------------------------------------------------------
-------------------------------------------------------------------------
--
-- Revision Control Information
--
-- $Workfile:   syn_eras_dsc.tdf  $
-- $Archive:   P:/RS_eras/units/Dec_dsc/ahdl/syn_eras_dsc.tdv  $
--
-- $Revision:   1.2  $
-- $Date:   31 Aug 1999 13:24:46  $
-- $Author			:  Alejandro Diaz-Manero
--
-- Project      :  RS_eras
--
-- Description	: 
--
-- Copyright 1999 (c) Altera Corporation
-- All rights reserved
--
-------------------------------------------------------------------------
-------------------------------------------------------------------------

FUNCTION lpm_ram_dq (data[LPM_WIDTH-1..0], address[LPM_WIDTHAD-1..0], we, 
				     inclock, outclock)
   RETURNS (q[LPM_WIDTH-1..0]);

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]);


PARAMETERS
(
n = 204,		-- length of code ((check+1) to 255)
m = 8,			-- GF size (2^m)	(4 to 8)
irrpol = 285,	-- field polynomial
check = 16, 		-- number of check symbols (= # of syndromes)
first_root, one_half,
root1 = 1, root2 = 2, root3 = 4, root4 = 8, root5 = 16, root6 = 32, root7 = 64, root8 = 128,
root9 = 195, root10 = 69, root11 = 138, root12 = 215, root13 = 109, root14 = 218, root15 = 119,
root16 = 238, root17 = 31, root18 = 62, root19 = 124, root20 = 248, root21 = 51, root22 = 102,
root23 = 204, root24 = 91, root25 = 182, root26 = 175, root27 = 157, root28 = 249, root29 = 49,
root30 = 98, root31 = 196, root32 = 75, root33 = 150, root34 = 239, root35 = 29, root36 = 58,
root37 = 116, root38 = 232, root39 = 19, root40 = 38, root41 = 1, root42 = 2, root43 = 4,
root44 = 8, root45 = 16, root46 = 32, root47 = 64, root48 = 128, root49 = 195, root50 = 69
);

constant size = ceil(log2(n+1));
constant wide = ceil(log2(check+1));


subdesign syn_eras_dsc
(
 sysclk, reset, rsin[m..1], dsin, dsout, eras_ind : INPUT;
 gofinal, bypass : INPUT;
 errvec[check..1][m..1], errloc[check..1][size..1] : INPUT;
 rdyin, outvalid : OUTPUT;
 num_eras[wide..1], eras_roots[check..1][m..1] : OUTPUT;
 syn[check..1][m..1], startmass, rsout[m..1] : OUTPUT;
)

VARIABLE

sh_alpha[check..1][m..1] : dffe;
multroot[m..1] : node;
rootpos[m..1] : dffe;

first_rootpos[m..1], one_div_bytwo[m..1] : node;

rr[m..1], reg[check..1][m..1], deldone, deladd[2..1][size..1] : dffe;
ovdel[4..1], rsoutff[m..1] : dffe;
synout[check..1][m..1], mulout[check..1][m..1] : node;
alpha[check..1][m..1] : node;
addmux[size..1], dummy[m..1], addzero[size..1] : node;
addeq[check..1][size..1], errmux[check..1][m..1] : node;
adden, loadread, writedis, oval, counten, first_pulse : node;
nval[size..1] : node;

lcnta : lpm_counter WITH (LPM_WIDTH = size, LPM_DIRECTION = "DOWN" );
cnt_eras : lpm_counter WITH (LPM_WIDTH = wide, LPM_DIRECTION = "UP" );

ss : MACHINE OF BITS (state[4..1])
  WITH STATES (s0  = B"1000",
         s0b = B"0100", 
			   s1  = B"0101",
			   s2  = B"0011",
			   s99 = B"0001");

BEGIN

startmass = state[1];
loadread = state[2];
writedis = state[3];
first_pulse = state[4];

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

CASE ss IS
 
	WHEN s0 =>
	    ss = S0b;
	
	WHEN s0b =>
		IF (adden == VCC) THEN
		  ss = s0b;
		ELSE
		  ss = s1;
		END IF;

-- start massey-berlekamp algorithm
	WHEN s1 =>
		IF (gofinal == GND) THEN
		  ss = s1;
		ELSE
		  ss = s2;
		END IF;

-- load address for read
	WHEN s2 =>
		ss = s99;

	WHEN s99 =>
		ss = s99;

END CASE;

reg[][].clk = sysclk;
reg[][].clrn = !reset;
reg[][].ena = addzero[size] & dsin;
reg[][] = synout[][];

rr[].clk = sysclk;
rr[].clrn = !reset;
rr[].ena = (addzero[size] & dsin); 
rr[] = rsin[]; 

FOR k IN 1 TO check GENERATE
  synout[k][] = rr[] $ mulout[k][];  -- gfadd
  mulout[k][] = gfmul(reg[k][],alpha[k][]) WITH (m=m, irrpol=irrpol);
END GENERATE;


alpha[1][] = root1;
alpha[2][] = root2;
IF (check >= 3) GENERATE
  alpha[3][] = root3;
END GENERATE;
IF (check >= 4) GENERATE
  alpha[4][] = root4;
END GENERATE;
IF (check >= 5) GENERATE
  alpha[5][] = root5;
END GENERATE;
IF (check >= 6) GENERATE
  alpha[6][] = root6;
END GENERATE;
IF (check >= 7) GENERATE
  alpha[7][] = root7;
END GENERATE;
IF (check >= 8) GENERATE
  alpha[8][] = root8;
END GENERATE;
IF (check >= 9) GENERATE
  alpha[9][] = root9;
END GENERATE;
IF (check >= 10) GENERATE
  alpha[10][] = root10;
END GENERATE;
IF (check >= 11) GENERATE
  alpha[11][] = root11;
END GENERATE;
IF (check >= 12) GENERATE
  alpha[12][] = root12;
END GENERATE;
IF (check >= 13) GENERATE
  alpha[13][] = root13;
END GENERATE;
IF (check >= 14) GENERATE
  alpha[14][] = root14;
END GENERATE;
IF (check >= 15) GENERATE
  alpha[15][] = root15;
END GENERATE;
IF (check >= 16) GENERATE
  alpha[16][] = root16;
END GENERATE;
IF (check >= 17) GENERATE
  alpha[17][] = root17;
END GENERATE;
IF (check >= 18) GENERATE
  alpha[18][] = root18;
END GENERATE;
IF (check >= 19) GENERATE
  alpha[19][] = root19;
END GENERATE;
IF (check >= 20) GENERATE
  alpha[20][] = root20;
END GENERATE;
IF (check >= 21) GENERATE
  alpha[21][] = root21;
END GENERATE;
IF (check >= 22) GENERATE
  alpha[22][] = root22;
END GENERATE;
IF (check >= 23) GENERATE
  alpha[23][] = root23;
END GENERATE;
IF (check >= 24) GENERATE
  alpha[24][] = root24;
END GENERATE;
IF (check >= 25) GENERATE
  alpha[25][] = root25;
END GENERATE;
IF (check >= 26) GENERATE
  alpha[26][] = root26;
END GENERATE;
IF (check >= 27) GENERATE
  alpha[27][] = root27;
END GENERATE;
IF (check >= 28) GENERATE
  alpha[28][] = root28;
END GENERATE;
IF (check >= 29) GENERATE
  alpha[29][] = root29;
END GENERATE;
IF (check >= 30) GENERATE
  alpha[30][] = root30;
END GENERATE;
IF (check >= 31) GENERATE
  alpha[31][] = root31;
END GENERATE;
IF (check >= 32) GENERATE
  alpha[32][] = root32;
END GENERATE;
IF (check >= 33) GENERATE
  alpha[33][] = root33;
END GENERATE;
IF (check >= 34) GENERATE
  alpha[34][] = root34;
END GENERATE;
IF (check >= 35) GENERATE
  alpha[35][] = root35;
END GENERATE;
IF (check >= 36) GENERATE
  alpha[36][] = root36;
END GENERATE;
IF (check >= 37) GENERATE
  alpha[37][] = root37;
END GENERATE;
IF (check >= 38) GENERATE
  alpha[38][] = root38;
END GENERATE;
IF (check >= 39) GENERATE
  alpha[39][] = root39;
END GENERATE;
IF (check >= 40) GENERATE
  alpha[40][] = root40; 
END GENERATE;
IF (check >= 41) GENERATE
  alpha[41][] = root41;
END GENERATE;
IF (check >= 42) GENERATE
  alpha[42][] = root42;
END GENERATE;
IF (check >= 43) GENERATE
  alpha[43][] = root43;
END GENERATE;
IF (check >= 44) GENERATE
  alpha[44][] = root44;
END GENERATE;
IF (check >= 45) GENERATE
  alpha[45][] = root45;
END GENERATE;
IF (check >= 46) GENERATE
  alpha[46][] = root46;
END GENERATE;
IF (check >= 47) GENERATE
  alpha[47][] = root47;
END GENERATE;
IF (check >= 48) GENERATE
  alpha[48][] = root48;
END GENERATE;
IF (check >= 49) GENERATE
  alpha[49][] = root49;
END GENERATE;
IF (check >= 50) GENERATE
  alpha[50][] = root50;
END GENERATE;

nval[] = n;

addmux[] = lcnta.q[];
lcnta.data[] = nval[];
lcnta.clock = sysclk;
lcnta.cnt_en = counten;
lcnta.sload = loadread # first_pulse;

counten = adden & (dsin # startmass) & (dsout # !startmass);

addzero[1] = addmux[1];
FOR k IN 2 TO size GENERATE
  addzero[k] = addzero[k-1] # addmux[k];
END GENERATE; 

adden = addzero[size];

deldone.clk = sysclk;
deldone = adden & writedis; -- write last symbol
deldone.clrn = !reset;

dummy[] = lpm_ram_dq ( rr[], addmux[], deldone,sysclk,sysclk)
		     WITH (LPM_WIDTH = m, LPM_WIDTHAD = size, LPM_INDATA = "REGISTERED", 
				   LPM_ADDRESS_CONTROL = "REGISTERED", LPM_OUTDATA = "REGISTERED");

-- delay address 2clks to line up add with data on output
deladd[][].clk = sysclk;
deladd[][].clrn = !reset;
deladd[1][] = addmux[];
deladd[2][] = deladd[1][];

FOR k IN 1 TO check GENERATE
  addeq[k][1] = errloc[k][1] $ deladd[2][1];
  FOR I IN 2 TO size GENERATE
    addeq[K][I] = addeq[K][I-1] # (errloc[K][I] $ deladd[2][I]);
  END GENERATE;
END GENERATE;

errmux[1][] = errvec[1][] & !(addeq[1][size]);
FOR k IN 2 TO check GENERATE
  errmux[k][] = errmux[k-1][] # (errvec[k][] & !(addeq[k][size]));
END GENERATE;

rsoutff[].clk = sysclk;
rsoutff[].clrn = ! reset;
FOR k IN 1 TO m GENERATE
  rsoutff[k] = dummy[k] $ (errmux[check][k] & !bypass);
END GENERATE;

oval = (startmass & !loadread & !writedis) & adden;
ovdel[].clk = sysclk;
ovdel[].clrn = !reset;
ovdel[1] = oval;
ovdel[2] = ovdel[1];
ovdel[3] = ovdel[2];
ovdel[4] = ovdel[3];

outvalid = ovdel[4];

rdyin = addzero[size] & !startmass;
syn[][] = synout[][];
rsout[] = rsoutff[];


-------
-- Erasures processing
---------

one_div_bytwo[] = one_half;

multroot[] = gfmul(rootpos[], one_div_bytwo[]) WITH (irrpol=irrpol,m=m);    

first_rootpos[] = first_root;

rootpos[] = (first_rootpos[] & first_pulse) # (multroot[] & !first_pulse);
rootpos[].clk = sysclk;
rootpos[].ena = first_pulse # dsin;

cnt_eras.clock = sysclk;
cnt_eras.cnt_en = dsin & eras_ind & addzero[size];
cnt_eras.aclr = reset;
num_eras[] = cnt_eras.q[];

sh_alpha[][].clk = sysclk;
sh_alpha[][].clrn = !reset;
sh_alpha[][].ena = eras_ind & dsin & addzero[size]; 

sh_alpha[1][] = rootpos[];
For K in 2 to check generate

  sh_alpha[K][] = sh_alpha[K-1][];

end generate;	

eras_roots[][] = sh_alpha[][];

END;