syn_eras_str.tdf

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

throut = state[7];
forout = state[8];
nextstage = state[9];
clrstage = state[10];
resetmass = state[11];
resetchn = state[12];

latchstage = nextstage;

rr[].clk = sysclk;
rr[] = r[] & !clrstage; 
rr[].ena = (wrzero[size] & dsin) # clrstage;
rr[].clrn = !reset;

reg[][].clk = sysclk;
reg[][].ena = (wrzero[size] & dsin) # clrstage;
reg[][].clrn = !reset;

FOR k IN 1 TO check GENERATE
  synout[k][m..1] = rr[m..1] $ mulout[k][m..1]; -- gfadd
END GENERATE;

reg[][] = synout[][] & !clrstage;

alpha[1][] = root1;
alpha[2][] = root2;
alpha[3][] = root3;
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;

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

syn[][] = synout[][];


addwrite[] = lcnta.q[];
lcnta.data[] = nval[];
lcnta.clock = sysclk;
lcnta.cnt_en = (wrzero[size] & dsin);
lcnta.sload = clrstage;
lcnta.aclr = reset;


addread[] = lcntb.q[];
lcntb.data[] = nval[];
lcntb.clock = sysclk;
lcntb.cnt_en = (rdzero[size] & dsout);
lcntb.sload = clrstage;
lcntb.aclr = reset;

wrzero[1] = addwrite[1];
rdzero[1] = addread[1];
FOR k IN 2 TO size GENERATE
  wrzero[k] = wrzero[k-1] # addwrite[k];
  rdzero[k] = rdzero[k-1] # addread[k];
END GENERATE; 

readdone[].clk = sysclk;
readdone[].clrn = !reset;
readdone[1] = !rdzero[size] & !clrstage;
readdone[2] = readdone[1] & !clrstage;
readdone[3] = readdone[2] & !clrstage;

deldone.clk = sysclk;
deldone.clrn = !reset;
deldone = wrzero[size] & !clrstage; -- write last symbol

dataone[] = lpm_ram_dq ( rr[], onemux[], (deldone & onein),sysclk,sysclk)
		        WITH (LPM_WIDTH = m, LPM_WIDTHAD = size, LPM_INDATA = "REGISTERED", 
				      LPM_ADDRESS_CONTROL = "REGISTERED", LPM_OUTDATA = "REGISTERED");

datatwo[] = lpm_ram_dq ( rr[], twomux[], (deldone & twoin),sysclk,sysclk)
		        WITH (LPM_WIDTH = m, LPM_WIDTHAD = size, LPM_INDATA = "REGISTERED", 
				      LPM_ADDRESS_CONTROL = "REGISTERED", LPM_OUTDATA = "REGISTERED");

datathr[] = lpm_ram_dq ( rr[], thrmux[], (deldone & thrin),sysclk,sysclk)
		        WITH (LPM_WIDTH = m, LPM_WIDTHAD = size, LPM_INDATA = "REGISTERED", 
				      LPM_ADDRESS_CONTROL = "REGISTERED", LPM_OUTDATA = "REGISTERED");

datafor[] = lpm_ram_dq ( rr[], formux[], (deldone & forin),sysclk,sysclk)
		        WITH (LPM_WIDTH = m, LPM_WIDTHAD = size, LPM_INDATA = "REGISTERED", 
				      LPM_ADDRESS_CONTROL = "REGISTERED", LPM_OUTDATA = "REGISTERED");

onemux[] = (addwrite[] & onein) # (addread[] & oneout);
twomux[] = (addwrite[] & twoin) # (addread[] & twoout);
thrmux[] = (addwrite[] & thrin) # (addread[] & throut);
formux[] = (addwrite[] & forin) # (addread[] & forout);

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

FOR j IN 1 TO check GENERATE
  addeq[j][1] = errloc[j][1] $ deladd[2][1];
  FOR k IN 2 TO size GENERATE
    addeq[j][k] = addeq[j][k-1] # (errloc[j][k] $ deladd[2][k]);
  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;

dummy[] = (dataone[] & oneout) # (datatwo[] & twoout) #
		    (datathr[] & throut) # (datafor[] & forout);

rsoutff[].clk = sysclk;
rsoutff[].clrn = !reset;
rsoutff[m..1] = (dummy[m..1] $ (errmux[check][m..1] & !bypass)) & !clrstage;

bsnode[1] = !addeq[1][size];
FOR k IN 2 TO check GENERATE
  bsnode[k] = !addeq[k][size] # bsnode[k-1];
END GENERATE;
bserr[1] = errmux[check][1];
FOR k IN 2 TO m GENERATE
  bserr[k] = errmux[check][k] # bserr[k-1];
END GENERATE;
-- don't indicate error if errval = 0 
bs = bsnode[check] & bserr[m];
bs.clk = sysclk;
bs.clrn = !reset;

badsym = bs;

-- unless output state, outvalid stays low
oval = rdzero[size] & (state[5] # state[6] # state[7] # state[8]);
ovdel[].clk = sysclk;
ovdel[].clrn = !reset;
ovdel[1] = oval & !clrstage;
ovdel[2] = ovdel[1] & !clrstage;
ovdel[3] = ovdel[2] & !clrstage;
ovdel[4] = ovdel[3] & !clrstage;
--ovdel[].clrn = !clrstage;

outvalid = ovdel[4];

rdyin = wrzero[size];

	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[] & clrstage) # (multroot[] & !clrstage);
rootpos[].clk = sysclk;
rootpos[].ena = clrstage # dsin;
rootpos[].clrn = !reset;

zero[] = 0;

cnt_eras.data[] = zero[];
cnt_eras.clock = sysclk;
cnt_eras.cnt_en = dsin & eras_ind & wrzero[size];
cnt_eras.sload = clrstage;
cnt_eras.aclr = reset;
num_eras[] = cnt_eras.q[];

sh_alpha[][].clk = sysclk;
sh_alpha[][].ena = (eras_ind & dsin) # clrstage;
sh_alpha[][].clrn = !reset;
sh_alpha[1][] = rootpos[] & !clrstage; 
For K in 2 to check generate
--  Put sh_alpha down to up ie shift from 1 to check
	sh_alpha[K][] = sh_alpha[K-1][] & !clrstage; 
end generate;	

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

END;