lpm_counter.tdf

基于SIIGX的PCIe的Kit

															ONE_INPUT_IS_CONSTANT="YES",
															LPM_DIRECTION="SUB" );
							ELSE GENERATE		-- up/down counter
								add_sub	: lpm_add_sub WITH( LPM_WIDTH=LPM_WIDTH, CBXI_PARAMETER = "NOTHING",
															ONE_INPUT_IS_CONSTANT="YES",
															LPM_DIRECTION="DEFAULT" );
							END GENERATE;
						END GENERATE;
					END GENERATE;

					DirUpDown, upwrap, dnwrap, ce: NODE;
					IF (LPM_MODULUS != 0) GENERATE
						scdw: lpm_constant WITH( LPM_WIDTH=LPM_WIDTH, LPM_CVALUE=LPM_MODULUS-1, CBXI_PARAMETER = "NOTHING" );
					ELSE GENERATE
						scdw: lpm_constant WITH( LPM_WIDTH=LPM_WIDTH, LPM_CVALUE=0, CBXI_PARAMETER = "NOTHING" );
					END GENERATE;
				END GENERATE;
			END GENERATE;

	-- Output decoder
			IF USED(eq) GENERATE
				decode	: lpm_decode WITH( LPM_WIDTH=4, LPM_DECODES= %2^LPM_WIDTH% 16, CBXI_PARAMETER = "NOTHING" );
	--  MAX+PLUS II only implements 16 eq outputs, instead of 2^LPM_WIDTH according to
	--   the LPM_COUNTER standard
			END GENERATE;
		END GENERATE;
	ELSE GENERATE
		-- able to use a wysiwyg generated counter
		
		-- Stratix family is ClearBox now
		IF (FAMILY_STRATIX() == 1) GENERATE
			wysi_counter : alt_counter_stratix WITH ( LPM_WIDTH = LPM_WIDTH, LPM_DIRECTION = LPM_DIRECTION,
													LPM_MODULUS = LPM_MODULUS, CBXI_PARAMETER = "NOTHING", 
													LPM_AVALUE = USED(LPM_AVALUE) ? LPM_AVALUE : "UNUSED",
													LPM_SVALUE = USED(LPM_SVALUE) ? LPM_SVALUE : "UNUSED"
												  );
		ELSE GENERATE
		IF (FAMILY_FLEX10K() == 1) GENERATE
			wysi_counter : alt_counter_f10ke WITH ( LPM_WIDTH = LPM_WIDTH, LPM_DIRECTION = LPM_DIRECTION,
													LPM_MODULUS = LPM_MODULUS, 
													LPM_AVALUE = USED(LPM_AVALUE) ? LPM_AVALUE : "UNUSED",
													LPM_SVALUE = USED(LPM_SVALUE) ? LPM_SVALUE : "UNUSED"
												  );
		ELSE GENERATE
		IF (FAMILY_FLEX10KE() == 1) GENERATE
			wysi_counter : alt_counter_f10ke WITH ( LPM_WIDTH = LPM_WIDTH, LPM_DIRECTION = LPM_DIRECTION,
													LPM_MODULUS = LPM_MODULUS, 
													LPM_AVALUE = USED(LPM_AVALUE) ? LPM_AVALUE : "UNUSED",
													LPM_SVALUE = USED(LPM_SVALUE) ? LPM_SVALUE : "UNUSED"
												  );
		ELSE GENERATE
		IF (FAMILY_FLEX6000() == 1) GENERATE
			wysi_counter : alt_synch_counter_f WITH ( LPM_WIDTH = LPM_WIDTH, LPM_DIRECTION = LPM_DIRECTION,
													LPM_MODULUS = LPM_MODULUS, 
													LPM_AVALUE = USED(LPM_AVALUE) ? LPM_AVALUE : "UNUSED",
													LPM_SVALUE = USED(LPM_SVALUE) ? LPM_SVALUE : "UNUSED"
												  );
		ELSE GENERATE
			wysi_counter : alt_synch_counter WITH ( LPM_WIDTH = LPM_WIDTH, LPM_DIRECTION = LPM_DIRECTION,
													LPM_MODULUS = LPM_MODULUS, 
													LPM_AVALUE = USED(LPM_AVALUE) ? LPM_AVALUE : "UNUSED",
													LPM_SVALUE = USED(LPM_SVALUE) ? LPM_SVALUE : "UNUSED"
												  );
		END GENERATE;
		END GENERATE;
		END GENERATE;
		END GENERATE;

	-- Output decoder
			IF USED(eq) GENERATE
				decode	: lpm_decode WITH( LPM_WIDTH=4, LPM_DECODES= %2^LPM_WIDTH% 16, CBXI_PARAMETER = "NOTHING" );
	--  MAX+PLUS II only implements 16 eq outputs, instead of 2^LPM_WIDTH according to
	--   the LPM_COUNTER standard
			END GENERATE;

	END GENERATE;
	END GENERATE;
-------------------------------------------------------------------------------
BEGIN
	-- cause:	The clock port is not connected
	-- action:	Connect the clock port of this megafunction
	ASSERT USED(clock)
		REPORT "clock port must be connected for lpm_counter"
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_NEEDS_CLOCK;

	-- assert block
	ASSERT LPM_WIDTH>0
		REPORT "Value of LPM_WIDTH parameter must be greater than 0"
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_WIDTH;

	ASSERT !USED(aconst) # USED(LPM_AVALUE)
		REPORT "Value of LPM_AVALUE parameter must be assigned if aconst port is used"
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_ACONST;

	ASSERT !USED(aconst) # (!USED(aclr) & !USED(aset))
		REPORT "Can't use aconst port if aclr or aset port is used"
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_ACONFLICT;

	ASSERT !USED(sconst) # USED(LPM_SVALUE)
		REPORT "Value of LPM_SVALUE parameter must be assigned if sconst port is used"
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_SCONST;

	ASSERT !USED(sconst) # (!USED(sclr) & !USED(sset))
		REPORT "Can't use sconst port if sclr or sset port is used"
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_SCONFLICT;

	ASSERT (LPM_MODULUS == 0) # (LPM_WIDTH>31) # (Ceil_Log2_Modulus()<=LPM_WIDTH)
		REPORT "Value of LPM_MODULUS parameter (%) is too large for a %-bit counter"
			LPM_MODULUS, LPM_WIDTH
		SEVERITY WARNING
		HELP_ID LPM_COUNTER_MODULUS_BIG;

	ASSERT (LPM_DIRECTION=="DEFAULT") # (LPM_DIRECTION=="UP") # (LPM_DIRECTION=="DOWN")
		REPORT "Illegal value for LPM_DIRECTION parameter (%) -- value must be DEFAULT, UP, or DOWN" 
			LPM_DIRECTION
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_DIRECTION;

	ASSERT (LPM_DIRECTION=="DEFAULT") # !USED_UPDOWN()
		REPORT "Can't use LPM_DIRECTION parameter if updown port is used"
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_DIR_CONFLICT;

	ASSERT (!USE_CARRY_CHAINS()) # (CARRY_CHAIN_LENGTH>3)
		REPORT "Ignored request for carry chain -- chain length setting is too low (< 4) to create useful carry chains"
		SEVERITY WARNING
		HELP_ID LPM_COUNTER_CARRY_LOW;


	ASSERT USED(data) !$ (USED(aload) # USED(sload))
		REPORT "Either aload or sload is used without the data[] port connected or the data[] port is connected to ground"
		SEVERITY WARNING
		HELP_ID LPM_COUNTER_LOAD_WITHOUT_DATA;

	ASSERT (CARRY_CNT_EN=="ON") # (CARRY_CNT_EN=="OFF") # (CARRY_CNT_EN=="SMART")
		REPORT "Illegal value for CARRY_CNT_EN parameter (%) -- value must be SMART, ON, or OFF" 
		CARRY_CNT_EN
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_CARRY_CNT_EN;

	ASSERT (LABWIDE_SCLR=="ON") # (LABWIDE_SCLR=="OFF")
		REPORT "Illegal value for LABWIDE_SCLR parameter (%) -- value must be ON or OFF" LABWIDE_SCLR
		SEVERITY ERROR
		HELP_ID LPM_COUNTER_LABWIDE_SCLR;

	-- Cause:	The current device family doesn't match any of those listed in aglobal60.inc.
	--			This probably means that this megafunction is from a previous release of MAX+plus II
	--			that didn't know about this device family.  The megafunction should still work,
	--			but the results may not be optimal.
	-- Action:	If the old version of the megafunction is coming from an archived project directory,
	--			then get the latest version of the megafunction (and aglobal60.inc).  This could also be
	--			caused if MAX+plus II has libraries from an older version in its library path.
	--			In this case, make sure that MAX+plus II has current libraries in its library path.
	ASSERT (FAMILY_IS_KNOWN() == 1)
		REPORT "Megafunction lpm_counter does not recognize the current device family (%) -- ensure that you are using the newest version of the megafunction"
			DEVICE_FAMILY
		SEVERITY WARNING
		HELP_ID LPM_COUNTER_FAMILY_UNKNOWN;
		
	IF (CBX_FAMILY() == 1 & CBXI_PARAMETER != "NOTHING") GENERATE
	IF USED(aclr) GENERATE
		auto_generated.aclr = aclr;
	END GENERATE;
	IF USED(aload) GENERATE
		auto_generated.aload = aload;
	END GENERATE;
	IF USED(aset) GENERATE
		auto_generated.aset = aset;
	END GENERATE;
	IF USED(cin) GENERATE
		auto_generated.cin = cin;
	END GENERATE;
	IF USED(clk_en) GENERATE
		auto_generated.clk_en = clk_en;
	END GENERATE;
	IF USED(clock) GENERATE
		auto_generated.clock = clock;
	END GENERATE;
	IF USED(cnt_en) GENERATE
		auto_generated.cnt_en = cnt_en;
	END GENERATE;
	IF USED(cout) GENERATE
		cout = auto_generated.cout;
	END GENERATE;
	IF USED(data) GENERATE
		auto_generated.data[] = data[];
	END GENERATE;
	IF USED(q) GENERATE
		q[] = auto_generated.q[];
	END GENERATE;
	IF USED(eq) GENERATE
		eq[] = auto_generated.eq[];
	END GENERATE;
	IF USED(sclr) GENERATE
		auto_generated.sclr = sclr;
	END GENERATE;
	IF USED(sload) GENERATE
		auto_generated.sload = sload;
	END GENERATE;
	IF USED(sset) GENERATE
		auto_generated.sset = sset;
	END GENERATE;
	IF USED(updown) GENERATE
		auto_generated.updown = updown;
	END GENERATE;
		

	ELSE GENERATE
		
-------------------------------------------------------------------------------
	IF USE_OLD_VERSION() GENERATE
		ASSERT (0) REPORT "+++++++++++ This is a OLD_VERSION LPM_COUNTER" SEVERITY DEBUG;
		IF need_not_gate_push_back_off() GENERATE

			ASSERT (0) REPORT "need_not_gate_push_back_off()=%" need_not_gate_push_back_off() SEVERITY DEBUG;
			c2.clock = clock;
			IF USED(data)		GENERATE	c2.data[]	= data[];	END GENERATE;
			IF USED(clk_en)		GENERATE	c2.clk_en	= clk_en;	END GENERATE;
			IF USED(cnt_en)		GENERATE	c2.cnt_en	= cnt_en;	END GENERATE;
			IF USED_UPDOWN() GENERATE
				IF USED(updown) GENERATE
					c2.updown = updown;
				END GENERATE;
			END GENERATE;
			IF USED(aclr)		GENERATE	c2.aclr		= aclr;		END GENERATE;
			IF USED(aset)		GENERATE	c2.aset		= aset;		END GENERATE;
			IF USED(aconst)		GENERATE	c2.aconst	= aconst;	END GENERATE;
			IF USED(aload)		GENERATE	c2.aload	= aload;	END GENERATE;
			IF USED(sclr)		GENERATE	c2.sclr		= sclr;		END GENERATE;
			IF USED(sset)		GENERATE	c2.sset		= sset;		END GENERATE;
			IF USED(sconst)		GENERATE	c2.sconst	= sconst;	END GENERATE;
			IF USED(sload)		GENERATE	c2.sload	= sload;	END GENERATE;
			IF USED(q)			GENERATE	q[]			= c2.q[];	END GENERATE;
			IF USED(eq)			GENERATE	eq[]		= c2.eq[];	END GENERATE;
			IF USED(cin)		GENERATE	c2.cin		= cin;		END GENERATE;
			IF USED(cout)		GENERATE	cout		= c2.cout;	END GENERATE;

		ELSE GENERATE

		IF OK_to_use_pcustom() GENERATE

			ASSERT (0) REPORT "OK_to_use_pcustom()=%" OK_to_use_pcustom() SEVERITY DEBUG;
			dffs[0].d = !sclr and (dffs[0].q xor (cnt_en & cin));
			dffs[].clk = clock;
			dffs[].ena = clk_en;
			dffs[].clrn = !aclr;

			IF LPM_DIRECTION!="DOWN" GENERATE
				and_a[0] = dffs[0] and cin;
				IF LPM_WIDTH>=2 GENERATE
					and_a[LPM_WIDTH-1..1] = dffs[LPM_WIDTH-1..1] and and_a[LPM_WIDTH-2..0];
				END GENERATE;
			END GENERATE;

			and_b[0] = !dffs[0] and cin;
			IF LPM_WIDTH>=2 GENERATE
				and_b[LPM_WIDTH-1..1] = !dffs[LPM_WIDTH-1..1] and and_b[LPM_WIDTH-2..0];
			END GENERATE;

			IF LPM_WIDTH>1 GENERATE
				IF LPM_DIRECTION=="DOWN" GENERATE
					dffs[LPM_WIDTH-1..1] = !sclr and (dffs[LPM_WIDTH-1..1] xor (cnt_en & and_b[LPM_WIDTH-2..0]));
				ELSE GENERATE
					IF USED_UPDOWN() GENERATE
						dffs[LPM_WIDTH-1..1] = !sclr and (dffs[LPM_WIDTH-1..1] xor (cnt_en & updown & and_a[LPM_WIDTH-2..0] # !sclr & cnt_en & !updown & and_b[LPM_WIDTH-2..0]));
					ELSE GENERATE
						dffs[LPM_WIDTH-1..1] = !sclr and (dffs[LPM_WIDTH-1..1] xor (cnt_en & and_a[LPM_WIDTH-2..0]));
					END GENERATE;
				END GENERATE;
			END GENERATE;
			q[] = dffs[];

			IF LPM_DIRECTION=="DOWN" GENERATE
				cout = and_b[LPM_WIDTH-1];
			ELSE GENERATE
				IF USED_UPDOWN() GENERATE
					cout = (and_a[LPM_WIDTH-1] and updown) or (and_b[LPM_WIDTH-1] and !updown);
				ELSE GENERATE
					cout = and_a[LPM_WIDTH-1];
				END GENERATE;
			END GENERATE;

		ELSE GENERATE	-- OK_to_use_pcustom() 

		IF OK_to_use_8count() GENERATE

			ASSERT (0) REPORT "OK_to_use_8count()=%" OK_to_use_8count() SEVERITY DEBUG;
			IF USED(sset) GENERATE
				IF USED(LPM_SVALUE) GENERATE
					p8c[].(h, g, f, e, d, c, b, a) = LPM_SVALUE;
				ELSE GENERATE
					p8c[].(h, g, f, e, d, c, b, a) = VCC;
				END GENERATE;
			ELSE GENERATE
				IF Is_multiple_of_8(LPM_WIDTH) GENERATE
					p8c[].(h, g, f, e, d, c, b, a) = data[];
				ELSE GENERATE
					p8c[].(h, g, f, e, d, c, b, a) = (0, data[]);
				END GENERATE;
			END GENERATE;

			IF LPM_DIRECTION=="DOWN" GENERATE
				p8c[].dnup = VCC;
			ELSE GENERATE
				IF USED_UPDOWN() GENERATE
					p8c[].dnup = !updown;
				ELSE GENERATE
					p8c[].dnup = GND;
				END GENERATE;
			END GENERATE;
			p8c[].clk = clock;
			p8c[].clrn = !aclr;
			p8c[].setn = !aload # aclr;
			p8c[].ldn = !(sload # sset);

			-- wire up Count Enable signal, with logic for later stages
			p8c0.gn = !(cnt_en and cin);
			IF LPM_WIDTH>8 GENERATE
	--			p8c[CEIL(LPM_WIDTH div 8)-1..1].gn =  p8c[CEIL(LPM_WIDTH div 8)-2..0].cout !& cnt_en;
				p8c[CEIL(LPM_WIDTH div 8)-1..1].gn = !p8c[CEIL(LPM_WIDTH div 8)-2..0].cout;
			END GENERATE;

			-- define outputs
			IF Is_multiple_of_8(LPM_WIDTH) GENERATE
				q[] = p8c[].(qh, qg, qf, qe, qd, qc, qb, qa);
				cout = p8c[CEIL(LPM_WIDTH div 8)-1].cout;
			ELSE GENERATE
				IF LPM_WIDTH>8 GENERATE
					q[(FLOOR(LPM_WIDTH div 8)*8)-1..0] = 
						p8c[CEIL(LPM_WIDTH div 8)-2..0].(qh, qg, qf, qe, qd, qc, qb, qa);
				END GENERATE;

				q[FLOOR(LPM_WIDTH div 8)*8] = p8c[CEIL(LPM_WIDTH div 8)-1].qa;
				IF (LPM_WIDTH > (FLOOR(LPM_WIDTH div 8)*8)+1) GENERATE
					q[(FLOOR(LPM_WIDTH div 8)*8)+1] = p8c[CEIL(LPM_WIDTH div 8)-1].qb;
				END GENERATE;
				IF (LPM_WIDTH > (FLOOR(LPM_WIDTH div 8)*8)+2) GENERATE
					q[(FLOOR(LPM_WIDTH div 8)*8)+2] = p8c[CEIL(LPM_WIDTH div 8)-1].qc;
				END GENERATE;
				IF (LPM_WIDTH > (FLOOR(LPM_WIDTH div 8)*8)+3) GENERATE
					q[(FLOOR(LPM_WIDTH div 8)*8)+3] = p8c[CEIL(LPM_WIDTH div 8)-1].qd;
				END GENERATE;
				IF (LPM_WIDTH > (FLOOR(LPM_WIDTH div 8)*8)+4) GENERATE
					q[(FLOOR(LPM_WIDTH div 8)*8)+4] = p8c[CEIL(LPM_WIDTH div 8)-1].qe;
				END GENERATE;
				IF (LPM_WIDTH > (FLOOR(LPM_WIDTH div 8)*8)+5) GENERATE
					q[(FLOOR(LPM_WIDTH div 8)*8)+5] = p8c[CEIL(LPM_WIDTH div 8)-1].qf;
				END GENERATE;
				IF (LPM_WIDTH > (FLOOR(LPM_WIDTH div 8)*8)+6) GENERATE
					q[(FLOOR(LPM_WIDTH div 8)*8)+6] = p8c[CEIL(LPM_WIDTH div 8)-1].qg;
				END GENERATE;

			END GENERATE;
		
		ELSE GENERATE	-- OK_to_use_8count()

			ASSERT (0) REPORT "nExtraSyncInput()=%" nExtraSyncInput() SEVERITY DEBUG;
			ASSERT (0) REPORT "nLoadInput()=%" nLoadInput() SEVERITY DEBUG;
			ASSERT (0) REPORT "nLoadDataInput()=%" nLoadDataInput() SEVERITY DEBUG;
			ASSERT (0) REPORT "FAMILY_HAS_ENABLE_LUT_INPUT()=%" FAMILY_HAS_ENABLE_LUT_INPUT() SEVERITY DEBUG;
			ASSERT (0) REPORT "ModulusCounter()=%" ModulusCounter() SEVERITY DEBUG;
			ASSERT (0) REPORT "FLEXUseCarryChain()=%" FLEXUseCarryChain() SEVERITY DEBUG;
	-------------------------------------------------------------------------------
	-- FLEX devices