lpm_counter.tdf

基于SIIGX的PCIe的Kit

							nLoad = !(SyncClr # sset # sload # Wrap);					
						END GENERATE;
					ELSE GENERATE
				
					IF UseClearableCounterMode() GENERATE
						ASSERT (0) REPORT "LUT2" SEVERITY DEBUG;	-- sclr feeds nclr
						nClr = !SyncClr;
						nState[] = Count[];
						LoadLCELL[] = LoadSSet[];
						nLoad = !(sset # sload # Wrap);
					ELSE GENERATE
			
					IF !UseLabWideSclr() & UseFuncSCLR() GENERATE
						ASSERT (0) REPORT "LUT3" SEVERITY DEBUG;	-- sclr feeds DATA1
						nClr = VCC;
						nState[] = !SyncClr & Count[];
						LoadLCELL[] = LoadSSet[];
						nLoad = !(!SyncClr & (sset # sload # Wrap));
					ELSE GENERATE
						IF UseLabWideSclr() GENERATE
							ASSERT (0) REPORT "LUT4a" SEVERITY DEBUG;
							nClr = !SyncClr;	-- feeds wide-lab sclr
						ELSE GENERATE
							ASSERT (0) REPORT "LUT4b" SEVERITY DEBUG;
							nClr = VCC;			-- counter without sclr
						END GENERATE;
		
						IF USED(sset) GENERATE
							ASSERT (0) REPORT "LUT5" SEVERITY DEBUG;
							IF USED(LPM_SVALUE) GENERATE
								nState[] = (sset & sc.result[]) # (!sset & Count[]);
							ELSE GENERATE
								nState[] = sset # (!sset & Count[]);
							END GENERATE;
							LoadLCELL[] = LoadSLoad[];
							nLoad = !(!sset & (sload # Wrap));
						ELSE GENERATE
		
							IF COUNT_ONLY_UP() & !UseSyncClrModUp() GENERATE
								ASSERT (0) REPORT "LUT6" SEVERITY DEBUG; -- special wrap up
								nState[] = !wrap & Count[];
								LoadLCELL[] = data[];
								nLoad = !sload;
							ELSE GENERATE
								ASSERT (0) REPORT "LUT7" SEVERITY DEBUG;	-- special wrap down
								nState[] = (wrap & scdw.result[]) # (!wrap & Count[]);
														-- use sload only if up/down counter
								LoadLCELL[] = (sload # !UseModulus # DnWrapOnly) & data[];
								nLoad = !(sload # (ce & LoadUpWrap));
							END GENERATE;
						END GENERATE;
					END GENERATE;
					END GENERATE;
					END GENERATE;
					END GENERATE;
					END GENERATE;
					END GENERATE;

					-- Create the counter output according to nClr and nLoad LCELL inputs
					IF NEED_DFFEA_FOR_ASYNC() GENERATE
						IF USED(aset) # USED(aconst) GENERATE
							IF USED(aclr) GENERATE
								dffs[] = (nClr & ((!nLOAD & LoadLCELL[]) # (nLoad & nState[]))) $ !latch_signal[];
							ELSE GENERATE
								dffs[] = (nClr & ((!nLOAD & LoadLCELL[]) # (nLoad & nState[]))) $ a_val[];
							END GENERATE;
						ELSE GENERATE
							dffs[] = nClr & ((!nLOAD & LoadLCELL[]) # (nLoad & nState[]));
						END GENERATE;
					ELSE GENERATE
						dffs[] = nClr & ((!nLOAD & LoadLCELL[]) # (nLoad & nState[]));
					END GENERATE;

					-- Avoid Warnings on unused nodes
					nState[] = GND & LoadSSet[] & UseLoadSSet & ENA_DATA & UseSClr & SyncClr & DirUpDown & LoadUpWrap;

				ELSE GENERATE	-- LoadMuxLCELL()

					dffs[].ena = clk_en;
					DontWrap = (DirUpDown & !upwrap) # (!DirUpDown & !dnwrap);

					IF USED(LPM_SVALUE) GENERATE
						IF CntEnThroughCarryChain() GENERATE
							dffs[].d = !sclr & (sset & sc.result[] # !sset & (sload & data[] # !sload &
								((!ce # DontWrap) & Count[] # (ce & dnwrap) & scdw.result[])));
						ELSE GENERATE
							dffs[].d = !sclr & (sset & sc.result[] # !sset & (sload & data[] # !sload & (ce & 
								((DontWrap & Count[]) # (dnwrap & scdw.result[])) # !ce & dffs[].q)));
						END GENERATE;
					ELSE GENERATE
						IF CntEnThroughCarryChain() GENERATE
							dffs[].d = !sclr & (sset # !sset & (sload & data[] # !sload & (
								(!ce # DontWrap) & Count[] # (ce & dnwrap) & scdw.result[])));
						ELSE GENERATE
							dffs[].d = !sclr & (sset # !sset & (sload & data[] # !sload & 
								(ce & (DontWrap & Count[] # dnwrap & scdw.result[]) # !ce & dffs[].q)));
						END GENERATE;
					END GENERATE;
				END GENERATE;
				IF NEED_DFFEA_FOR_ASYNC() GENERATE
					IF USED(aset) # USED(aconst) GENERATE
						IF USED(aclr) GENERATE
							pre_hazard[] = dffs[].q;
							safe_q[] = (pre_hazard[] & latch_signal[] & effective_clrn[]) # 
									     (!latch_signal[] & !pre_hazard[] & effective_clrn[]) #
									     (!aclr & !effective_prn[]);
						ELSE GENERATE
							safe_q[] = dffs[].q $ a_val[];
						END GENERATE;
					ELSE GENERATE
						safe_q[] = dffs[].q;
					END GENERATE;
					carrybit[LPM_WIDTH..1].sin = safe_q[];
				ELSE GENERATE
					carrybit[LPM_WIDTH..1].sin = dffs[].q;
				END GENERATE;

			ELSE GENERATE	-- FLEXUseCarryChain()

				dffs[].ena = clk_en;

	-- Special logic for MODULUS counters
				upwrap = GND;
				dnwrap = GND;
				IF NEED_DFFEA_FOR_ASYNC() GENERATE
					IF COUNT_UP() AND ModulusCounter() GENERATE
						upwrap = cmpconst(safe_q[]) WITH( WIDTH=LPM_WIDTH, CVALUE=LPM_MODULUS-1 );
					END GENERATE;
					IF COUNT_DOWN() AND ModulusCounter() GENERATE
						dnwrap = cmpconst(safe_q[]) WITH( WIDTH=LPM_WIDTH, CVALUE=0 );
					END GENERATE;
	-- synchronous logic
					IF USED(aset) # USED(aconst) GENERATE
						IF USED(aclr) GENERATE
							IF USED(sconst) GENERATE
								dffs[].d = ((sconst & sc.result[]) # !sconst & (sload & data[]
											# !sload & (ce & nState[] # !ce & safe_q[]) ))
											$ !latch_signal[];
							ELSE GENERATE
								IF USED(LPM_SVALUE) GENERATE
									dffs[].d = (!sclr & (sset & sc.result[] # !sset & (sload & data[]
												# !sload & (ce & nState[] # !ce & safe_q[]) )))
												$ !latch_signal[];
								ELSE GENERATE
									dffs[].d = (!sclr & (sset # (sload & data[] 
												# !sload & (ce & nState[] # !ce & safe_q[]) )))
												$ !latch_signal[];
								END GENERATE;
							END GENERATE;
						ELSE GENERATE
							IF USED(sconst) GENERATE
								dffs[].d = ((sconst & sc.result[]) # !sconst & (sload & data[]
											# !sload & (ce & nState[] # !ce & safe_q[]) ))
											$ a_val[];
							ELSE GENERATE
								IF USED(LPM_SVALUE) GENERATE
									dffs[].d = (!sclr & (sset & sc.result[] # !sset & (sload & data[]
												# !sload & (ce & nState[] # !ce & safe_q[]) )))
												$ a_val[];
								ELSE GENERATE
									dffs[].d = (!sclr & (sset # (sload & data[] 
												# !sload & (ce & nState[] # !ce & safe_q[]) )))
												$ a_val[];
								END GENERATE;
							END GENERATE;
						END GENERATE;
					ELSE GENERATE
						IF USED(sconst) GENERATE
							dffs[].d = (sconst & sc.result[]) # !sconst & (sload & data[]
										# !sload & (ce & nState[] # !ce & safe_q[]) );
						ELSE GENERATE
							IF USED(LPM_SVALUE) GENERATE
								dffs[].d = !sclr & (sset & sc.result[] # !sset & (sload & data[]
											# !sload & (ce & nState[] # !ce & safe_q[]) ));
							ELSE GENERATE
								dffs[].d = !sclr & (sset # (sload & data[] 
											# !sload & (ce & nState[] # !ce & safe_q[]) ));
							END GENERATE;
						END GENERATE;
					END GENERATE;
					-- next counting state
					add_sub.dataa[] = safe_q[];	
				ELSE GENERATE
					IF COUNT_UP() AND ModulusCounter() GENERATE
						upwrap = cmpconst(dffs[].q) WITH( WIDTH=LPM_WIDTH, CVALUE=LPM_MODULUS-1 );
					END GENERATE;
					IF COUNT_DOWN() AND ModulusCounter() GENERATE
						dnwrap = cmpconst(dffs[].q) WITH( WIDTH=LPM_WIDTH, CVALUE=0 );
					END GENERATE;
	-- synchronous logic
					IF USED(sconst) GENERATE
						dffs[].d = (sconst & sc.result[]) # !sconst & (sload & data[]
									# !sload & (ce & nState[] # !ce & dffs[].q) );
					ELSE GENERATE
						IF USED(LPM_SVALUE) GENERATE
							dffs[].d = !sclr & (sset & sc.result[] # !sset & (sload & data[]
										# !sload & (ce & nState[] # !ce & dffs[].q) ));
						ELSE GENERATE
							dffs[].d = !sclr & (sset # (sload & data[] 
										# !sload & (ce & nState[] # !ce & dffs[].q) ));
						END GENERATE;
					END GENERATE;

					-- next counting state
					add_sub.dataa[] = dffs[].q;
				END GENERATE;
		
				IF LPM_WIDTH>1 GENERATE add_sub.datab[]=1; ELSE GENERATE add_sub.datab[]=VCC; END GENERATE;

				IF COUNT_ONLY_UP() GENERATE
					nState[] = !upwrap & add_sub.result[];
				ELSE GENERATE
					IF COUNT_ONLY_DOWN() GENERATE
						nState[] = (!dnwrap & add_sub.result[]) # (dnwrap & scdw.result[]);
					ELSE GENERATE			-- up/down counter
						add_sub.add_sub = DirUpDown;
						nState[] = (DirUpDown & !upwrap & add_sub.result[]) #
							(!DirUpDown & (!dnwrap & add_sub.result[] # dnwrap & scdw.result[]));
					END GENERATE;
				END GENERATE;
	-- Avoid warnings on unused nodes
				nState[] = GND & scdw.result[] & upwrap & dnwrap & DirUpDown;

				IF !ModulusCounter() GENERATE
					cout = (add_sub.cout xnor DirUpDown) and cin;
				ELSE GENERATE
					cout = ((DirUpDown and upwrap) or (!DirUpDown and dnwrap)) and cin;
				END GENERATE;
				IF NEED_DFFEA_FOR_ASYNC() GENERATE
					IF USED(aset) # USED(aconst) GENERATE
						IF USED(aclr) GENERATE
							pre_hazard[] = dffs[].q;
							safe_q[] = (pre_hazard[] & latch_signal[] & effective_clrn[]) # 
							           (!latch_signal[] & !pre_hazard[] & effective_clrn[]) #
							           (!aclr & !effective_prn[]);
						ELSE GENERATE
							safe_q[] = dffs[].q $ a_val[];
						END GENERATE;
					ELSE GENERATE
						safe_q[] = dffs[].q;
					END GENERATE;				
					q[] = safe_q[];
				ELSE GENERATE
					q[] = dffs[].q;
				END GENERATE;

			END GENERATE;		-- FLEXUseCarryChain()

		END GENERATE;	-- OK_to_use_8count()
		END GENERATE;	-- OK_to_use_pcustom()

	-------------------------------------------------------------------------------
	-- Counter decode output

		IF USED(eq) GENERATE
			IF LPM_WIDTH>=4 GENERATE
				decode.data[] = q[3..0];

	-- make sure the MSB counter bits are zero
				IF LPM_WIDTH>4 GENERATE
					decode.enable = cmpconst( q[LPM_WIDTH-1..4] ) WITH( WIDTH=LPM_WIDTH-4, CVALUE=0 );
				END GENERATE;

			ELSE GENERATE
				decode.data[] = ( 0, q[] );
			END GENERATE;
			eq[] = decode.eq[];
		ELSE GENERATE
			eq[] = GND;
		END GENERATE;
		
	-------------------------------------------------------------------------------
		END GENERATE;	-- need_not_gate_push_back_off()
	ELSE GENERATE
	-- can use the wysiwyg counter
	-- connect the inputs only if necessary otherwise the lower counter will detect a probe
	-- and do something bad

		IF USED(clock) GENERATE
			wysi_counter.clock = clock;
		END GENERATE;

		IF USED(clk_en) GENERATE
			wysi_counter.clk_en = clk_en;
		END GENERATE;

		IF USED_UPDOWN() GENERATE
			IF USED(updown) GENERATE
				wysi_counter.updown = updown;
			END GENERATE;
		END GENERATE;

		IF USED(cnt_en) GENERATE
			wysi_counter.cnt_en = cnt_en;
		END GENERATE;

		IF USED(aclr) GENERATE
			wysi_counter.aclr = aclr;
		END GENERATE;

		IF USED(aset) GENERATE
			wysi_counter.aset = aset;
		END GENERATE;

		IF USED(aconst) GENERATE
			wysi_counter.aconst = aconst;
		END GENERATE;

		IF USED(aload) GENERATE
			wysi_counter.aload = aload;
		END GENERATE;

		IF USED(sclr) GENERATE
			wysi_counter.sclr = sclr;
		END GENERATE;

		IF USED(sset) GENERATE
			wysi_counter.sset = sset;
		END GENERATE;

		IF USED(sconst) GENERATE
			wysi_counter.sconst = sconst;
		END GENERATE;

		IF USED(sload) GENERATE
			wysi_counter.sload = sload;
		END GENERATE;

		IF USED(data) GENERATE
			wysi_counter.data[] = data[];
		END GENERATE;

		IF USED(cin) GENERATE
			wysi_counter.cin = cin;
		END GENERATE;

		q[] = wysi_counter.q[];
		cout = wysi_counter.cout;

		-- Counter decode output
		IF USED(eq) GENERATE
			IF LPM_WIDTH>=4 GENERATE
				decode.data[] = q[3..0];

	-- make sure the MSB counter bits are zero
				IF LPM_WIDTH>4 GENERATE
					decode.enable = cmpconst( q[LPM_WIDTH-1..4] ) WITH( WIDTH=LPM_WIDTH-4, CVALUE=0 );
				END GENERATE;

			ELSE GENERATE
				decode.data[] = ( 0, q[] );
			END GENERATE;
			eq[] = decode.eq[];
		ELSE GENERATE
			eq[] = GND;
		END GENERATE;

	END GENERATE;
	END GENERATE;
	IF !USED(eq) GENERATE
		eq[] = GND;
	END GENERATE;
	IF !USED(cout) GENERATE
		cout = GND;
	END GENERATE;
	IF !USED(q) GENERATE
		q[] = GND;
	END GENERATE;
END;