bms_eras_str_half.tdf

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

	WHEN others =>
		mx = s0;

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];
load_llnum = olddelta;
shiftbdprev_ml = mst[18];
shift_sh_sel = mst[19];

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

-- no resets required, loaded after sm reset 
synreg[1][] = (syn[1][] & !shiftsynleft & !shiftsynright) # 
				  			(synreg[2][] & shiftsynleft) #
				  			(synreg[check][] & shiftsynright);
FOR k IN 2 TO check-1 GENERATE
synreg[k][] = (syn[k][] & !shiftsynleft & !shiftsynright) # 
				  				(synreg[k+1][] & shiftsynleft) #
				  				(synreg[k-1][] & shiftsynright);
END GENERATE;
synreg[check][] = (syn[check][] & !shiftsynleft & !shiftsynright) #
									(synreg[1][] & shiftsynleft) #
									(synreg[check-1][] & shiftsynright);

synreg[][].clk = sysclk;

synreg[1][].ena = latchsyn # shiftsynleft;   
FOR k IN 2 TO check GENERATE
synreg[k][].ena = latchsyn # shiftsynleft # shiftsynright;   
END GENERATE;

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

-- load onereg with zero after first shift
-- [m..2] bits always zero, use onenode[]
onereg = latchsyn # loadbdprev;
onereg.ena = shiftbdprev_lm # latchsyn # loadbdprev;
onereg.clk = sysclk;
onenode[1] = onereg;
onenode[m..2] = 0;

FOR k IN 1 TO check GENERATE
  bd[k][] = (addvec[k][] & !reset & !clearbd);
END GENERATE;

bd[][].clk = sysclk;

FOR k IN 1 TO nummult GENERATE
  bd[k][].ena = (!omsel[k] & loadbdleft) # clearbd # reset;
END GENERATE;
FOR k IN 1 TO (check-nummult) GENERATE
  bd[k+nummult][].ena = (!omsel[k+nummult] & loadbdright) # clearbd # reset;
END GENERATE;

omsel[].clk = sysclk;
omsel[].ena = incomega # reset;

omsel[1] = !reset;
FOR k IN 2 TO check GENERATE
	omsel[K] = omsel[K-1] & !reset;
end generate;

sh_sel[].clk = sysclk;
sh_sel[].ena = shift_sh_sel # reset;
bdprev[][].clk = sysclk;
bdprev[][].ena = loadbdprev # shiftbdprev_ml # shiftbdprev_lm # reset;

sh_sel[1] = !reset;
FOR k IN 2 TO check GENERATE
	sh_sel[K] = sh_sel[K-1] & !reset;
end generate;

bdprev[1][] = ((bdtemp[1][] & !shiftbdprev_ml & !shiftbdprev_lm & !reset) #
              (eras_pos[1][] & !shiftbdprev_ml & !shiftbdprev_lm & reset) #
              (onenode[] & !shiftbdprev_ml & shiftbdprev_lm) #
              (bdprev[2][] & shiftbdprev_ml & !shiftbdprev_lm));
FOR k IN 2 TO check-1 GENERATE
  bdprev[k][] = ((bdtemp[K][] & !shiftbdprev_ml & !shiftbdprev_lm & !reset) #
              (eras_pos[K][] & !shiftbdprev_ml & !shiftbdprev_lm & reset) #
              (bdprev[K-1][] & !shiftbdprev_ml & shiftbdprev_lm) #
              (bdprev[K+1][] & shiftbdprev_ml & !shiftbdprev_lm));

END GENERATE;
bdprev[check][] = ((bdtemp[check][] & !shiftbdprev_ml & !shiftbdprev_lm & !reset) #
              (eras_pos[check][] & !shiftbdprev_ml & !shiftbdprev_lm & reset) #
              (bdprev[check-1][] & !shiftbdprev_ml & shiftbdprev_lm) #
              (bdprev[1][] & shiftbdprev_ml & !shiftbdprev_lm));

-- reset not needed, as initialized with bd[][]
bdtemp[][] = (bd[][] & !reset) # (eras_pos[][] & reset);
bdtemp[][].clk = sysclk;
bdtemp[][].ena = loadbdtemp # reset;

--********************
--*** CORE SECTION ***
--********************

--*** calculate new delta ***

bdleft[][] = bdprev[][];
erasright[1][] = 1;

FOR K IN 2 TO check GENERATE
  erasright[K][] = bd[K-1][];
END GENERATE;

-- expand_check
FOR k IN 1 to check GENERATE

erasleft[K][] = (bdprev[1][] & sh_sel[k]) # (bdtemp[k][] & !sh_sel[K]);

deltaleft[k][] = synreg[check+1-k][];
deltaright[k][] = bd[k][]; 

bdright[k][] = deltamult[];

-- calculate omega
omegaleft[k][] = synreg[k][];
omegaright[k][] = (bdprev[1][] & !initomega) # (one[] & initomega);

END GENERATE;


FOR k IN 1 TO nummult-odd GENERATE
  addvec[k][] = bd[k][] $ mulout[k][];  -- gfadd
	addvec[k+nummult][] = bd[k+nummult][] $ mulout[k][];  -- gfadd
END GENERATE;
IF (odd == 1) GENERATE
  addvec[nummult][] = bd[nummult][] $ mulout[nummult][];  -- gfadd
END GENERATE;


-- multiply
FOR k IN 1 TO nummult-odd GENERATE

  mulleft[k][] = ( !multmux &
  							 ((erasleft[k][] & deltacalc & calcomega) #
  							 (deltaleft[k][] & deltacalc & !calcomega) # 
                 (bdleft[k][] & !deltacalc & !calcomega) #
                 (omegaleft[k][] & !deltacalc & calcomega)) ) #
				     			 ( multmux &
									 ((erasleft[k+nummult][] & deltacalc & calcomega) #
				     			 (deltaleft[k+nummult][] & deltacalc & !calcomega) # 
                 (bdleft[k+nummult][] & !deltacalc & !calcomega) #
                 (omegaleft[k+nummult][] & !deltacalc & calcomega)) );

  mulright[k][] = ( !multmux &
									 ((erasright[k][] & deltacalc & calcomega) #
  							 (deltaright[k][] & deltacalc & !calcomega) # 
                 (bdright[k][] & !deltacalc & !calcomega) #
                 (omegaright[k][] & !deltacalc & calcomega)) ) #
				      		 ( multmux &
									 ((erasright[k+nummult][] & deltacalc & calcomega) #
				      		 (deltaright[k+nummult][] & deltacalc & !calcomega) # 
                 (bdright[k+nummult][] & !deltacalc & !calcomega) #
                 (omegaright[k+nummult][] & !deltacalc & calcomega)) );

END GENERATE;

IF odd==1 GENERATE

  mulleft[nummult][] = ( !multmux &
  							 ((erasleft[nummult][] & deltacalc & calcomega) #
  							 (deltaleft[nummult][] & deltacalc & !calcomega) # 
                 (bdleft[nummult][] & !deltacalc & !calcomega) #
                 (omegaleft[nummult][] & !deltacalc & calcomega)) );

  mulright[nummult][] = ( !multmux &
									 ((erasright[nummult][] & deltacalc & calcomega) #
  							 (deltaright[nummult][] & deltacalc & !calcomega) # 
                 (bdright[nummult][] & !deltacalc & !calcomega) #
                 (omegaright[nummult][] & !deltacalc & calcomega)) );

END GENERATE;
mulleft[][].clk = sysclk;
mulright[][].clk = sysclk;

FOR k IN 1 TO nummult GENERATE
mulout[k][] = gfmul (mulleft[k][], mulright[k][])
					WITH (m = m, irrpol = irrpol);
END GENERATE;

-- calculate new delta
mulsum[1][] = mulout[1][];
IF (nummult>1) GENERATE
FOR k IN 2 TO nummult GENERATE
  mulsum[k][] = mulout[k][] $ mulsum[k-1][];
END GENERATE;
END GENERATE;

predelta[] = mulsum[nummult][] $ synreg[1][];
predelta[].clk = sysclk;

-- reset not needed
delta[] = mulsum[nummult][] $ predelta[];
delta[].clk = sysclk;
delta[].ena = newdelta;

deltaprev[m..2] = delta[m..2] & !reset;
deltaprev[1] = delta[1] # reset;
deltaprev[].clk = sysclk;
deltaprev[].ena = olddelta # reset;

-- reset not needed, just for timing purposes
deltamult[] = gfdiv (delta[], deltaprev[])
				  WITH (m=m, irrpol=irrpol, inv_file = inv_file);
deltamult[].clk = sysclk;

deltazero[1] = delta[1];
FOR k IN 2 TO m GENERATE
deltazero[k] = delta[k] # deltazero[k-1];
END GENERATE;

--****************
--*** COUNTERS ***
--****************

mloop[] = mcount.q[];
mcount.clock = sysclk;
mcount.cnt_en = incm;
mcount.sclr = reset;

mchk[1] = mloop[1] $ mcmp[1];
eras_zero[1] = num_eras_q[1];
init_syn[1] = mloop[1] $ num_eras_q[1];
omegachk[1] = omegaloop[1] $ omegacmp[1];

FOR k IN 2 TO wide GENERATE
mchk[k] = mchk[k-1] # (mloop[k] $ mcmp[k]);
	eras_zero[k] = num_eras_q[k] # eras_zero[k-1];
init_syn[k] = init_syn[k-1] # (mloop[k] $ num_eras_q[k]);
omegachk[k] = omegachk[k-1] # (omegaloop[k] $ omegacmp[k]);
END GENERATE;

--onewide[] = 1;
-- L = M+1-L

--(llnuma[],,) = lpm_add_sub ( VCC, mloop[], llnum[],,,)
--				  WITH (LPM_WIDTH = wide, LPM_DIRECTION = "SUB");

add_sub1.cin = VCC;
add_sub1.dataa[] = mloop[];
add_sub1.datab[] = llnum[];
llnuma[] = add_sub1.result[];

--(llnumb[],,) = lpm_add_sub ( GND, num_eras_q[], onewide[],,,)
--				  WITH (LPM_WIDTH = wide, LPM_DIRECTION = "ADD");

add_sub2.cin = GND;
add_sub2.dataa[] = num_eras_q[];
add_sub2.datab[] = 1;
llnumb[] = add_sub2.result[];

--(llnumnode[],,) = lpm_add_sub ( GND, llnuma[], llnumb[],,,)
--				  WITH (LPM_WIDTH = wide, LPM_DIRECTION = "ADD");

add_sub3.cin = GND;
add_sub3.dataa[] = llnuma[];
add_sub3.datab[] = llnumb[];
llnumnode[] = add_sub3.result[];

llnum[] = (llnumnode[] & !reset) # (num_eras[] & reset);
llnum[].clk = sysclk;
llnum[].ena = load_llnum # reset;

num_eras_q[].clk = sysclk;
num_eras_q[].ena = reset;
num_eras_q[] = num_eras[];

-- 2L <= m + num_eras_q?

--(mloop_plus_eras_num[],,) = lpm_add_sub ( GND, (0,mloop[]), (0,num_eras_q[]),,,)
--				  WITH (LPM_WIDTH = wide+1, LPM_DIRECTION = "ADD");

add_sub4.cin = GND;
add_sub4.dataa[] = (0,mloop[]);
add_sub4.datab[] = (0,num_eras_q[]);
mloop_plus_eras_num[] = add_sub4.result[];

--(,,,,,tlm) = lpm_compare ( (llnum[],0), mloop_plus_eras_num[],,)
--				  WITH (LPM_WIDTH = (wide+1));

compare1.dataa[] = (llnum[],0);
compare1.datab[] = mloop_plus_eras_num[];
tlm = compare1.aleb;

omegaloop[] = omegacount.q[];
omegacount.clock = sysclk;
omegacount.cnt_en = incomega;
omegacount.sclr = reset;


--***************
--*** OUTPUTS ***
--***************

bdout[][] = bdprev[][];
omegaout[][] = bd[][];
numerr[] = llnum[];
done = massdone;

END;