dd.tdf

直接数字频率合成器

INCLUDE "lpm_constant.inc";

OPTIONS NAME_SUBSTITUTION = ON;
PARAMETERS
(
	LPM_WIDTH,
	LPM_AVALUE = "UNUSED",
	LPM_SVALUE = "UNUSED",
	LPM_FFTYPE = "DFF",
	DEVICE_FAMILY,
	CBXI_PARAMETER = "NOTHING"
);

-- Get device definitions
INCLUDE "aglobal42.inc";

-- Checks to see if external async control is needed
DEFINE NEED_EXT_ASYNC_LOAD() = (FAMILY_HAS_PRESET() == 0)
								AND (USED(aload) # (USED(aclr) & USED(aset)));

FUNCTION @CBXI_PARAMETER (aclr, aload, aset, clock, data[LPM_WIDTH-1..0], enable, sclr, sload, sset)
RETURNS (q[LPM_WIDTH-1..0]);

SUBDESIGN lpm_ff
(
	data[LPM_WIDTH-1..0]		: INPUT = GND;
	clock						: INPUT;
	enable						: INPUT = VCC;
	aclr, aset, aload			: INPUT = GND;
	sclr, sset, sload			: INPUT = GND;
	q[LPM_WIDTH-1..0]			: OUTPUT;
)

VARIABLE
	IF CBXI_PARAMETER != "NOTHING" GENERATE
		auto_generated : @CBXI_PARAMETER WITH ( CBXI_PARAMETER = "NOTHING" );
	ELSE GENERATE
	dffs[LPM_WIDTH-1..0]		: DFFE;
	din[LPM_WIDTH-1..0]			: NODE;
	nxd[LPM_WIDTH-1..0]			: NODE;
	IF (USED(LPM_AVALUE)) GENERATE
		ac	: lpm_constant WITH (LPM_WIDTH=LPM_WIDTH, LPM_CVALUE=LPM_AVALUE);
	END GENERATE;
	IF (USED(LPM_SVALUE)) GENERATE
		sc	: lpm_constant WITH (LPM_WIDTH=LPM_WIDTH, LPM_CVALUE=LPM_SVALUE);
	END GENERATE;
	IF (NEED_EXT_ASYNC_LOAD()) GENERATE
		a_was_set[LPM_WIDTH-1..0]	: NODE;
		IF (USED(aset) == 0 & USED(aclr) == 0) GENERATE
			dlat[LPM_WIDTH-1..0]	: LATCH;
		END GENERATE;
		IF (USED(aload) & (USED(aclr) # USED(aset))) GENERATE
			any_clear[LPM_WIDTH-1..0]	: LCELL;
			any_set[LPM_WIDTH-1..0]		: LCELL;
		ELSE GENERATE
			any_clear[LPM_WIDTH-1..0]	: NODE;
			any_set[LPM_WIDTH-1..0]		: NODE;
		END GENERATE;
		q_node[LPM_WIDTH-1..0]		: LCELL;
	ELSE GENERATE
		q_node[LPM_WIDTH-1..0]		: NODE;
	END GENERATE;
	END GENERATE;
BEGIN

	ASSERT (LPM_WIDTH > 0)
			REPORT "Value of LPM_WIDTH parameter value must be greater than 0"
			SEVERITY ERROR
			HELP_ID LPM_FF_WIDTH;

	ASSERT (LPM_FFTYPE == "DFF" # LPM_FFTYPE == "TFF")
			REPORT "Illegal value for LPM_FFTYPE parameter (%) -- value must be DFF or TFF"
				LPM_FFTYPE
			SEVERITY ERROR
			HELP_ID LPM_FF_TYPE;

	ASSERT (USED(aset) # USED(LPM_AVALUE) == 0)
			REPORT "Ignored LPM_AVALUE parameter because the aset port is not used"
			SEVERITY WARNING
			HELP_ID LPM_FF_AVALUE;

	ASSERT (USED(sset) # USED(LPM_SVALUE) == 0)
			REPORT "Ignored LPM_SVALUE parameter because the sset port is not used"
			SEVERITY WARNING
			HELP_ID LPM_FF_SVALUE;

	ASSERT (FAMILY_IS_KNOWN() == 1)
			REPORT "Megafunction lpm_ff 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_FF_FAMILY_UNKNOWN;

	IF 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(clock) GENERATE
			auto_generated.clock = clock;
		END GENERATE;
		IF USED(data) GENERATE
			auto_generated.data[] = data[];
		END GENERATE;
		IF USED(enable) GENERATE
			auto_generated.enable = enable;
		END GENERATE;
		IF USED(q) GENERATE
			q[] = auto_generated.q[];
		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;
	ELSE GENERATE
	% common ports %
	dffs[].ena = enable;
	dffs[].clk = clock;

	% Normal value to be loaded into the DFFE's .d port is din[] %
	IF (LPM_FFTYPE == "DFF") GENERATE
		din[] = data[];
	ELSE GENERATE
		IF USED(data) GENERATE
			din[] = data[] $ dffs[].q;
		ELSE GENERATE
			din[] = !dffs[].q;
		END GENERATE;
	END GENERATE;

	% Asynchronous control logic %
	IF (NEED_EXT_ASYNC_LOAD()) GENERATE
		% Generate clear and set signals for hazard coverage %
		IF (USED(LPM_AVALUE)) GENERATE
			any_clear[] = aclr # aset & !ac.result[] # !aset & aload & !data[];
			any_set[] = !aclr & (aset & ac.result[] # !aset & aload & data[]);
		ELSE GENERATE
			any_clear[] = aclr # !aset & aload & !data[];
			any_set[] = aset # aload & data[];
		END GENERATE;
		% Generate a_was_set signals (remembers if last async was aset) %
		IF (USED(aset) == 0 & USED(aclr) == 0) GENERATE
			% ena control for external latch that remembers which of %
			% clear or preset was most recently needed %
			dlat[].d = data[];
			dlat[].ena = aload;
			a_was_set[] = dlat[].q;
		ELSE GENERATE
			% Implements an RS-latch with inputs: any_set, any_clear %
			a_was_set[] = !(any_clear[] # !(a_was_set[] # any_set[]));
		END GENERATE;
		dffs[].clrn = !(aload # aset # aclr);
	ELSE GENERATE
		IF (USED(LPM_AVALUE)) GENERATE
			dffs[].clrn = !aclr & (!aset # ac.result[]) & (aset # !aload # data[]);
			dffs[].prn = aclr # (!aset # !ac.result[]) & (aset # !aload # !data[]);
		ELSE GENERATE
			IF (USED(aclr) # USED(aload)) GENERATE
				dffs[].clrn = !aclr & (aset # !aload # data[]);
			END GENERATE;
			IF (USED(aset) # USED(aload)) GENERATE
				dffs[].prn = aclr # !aset & (!aload # !data[]);
			END GENERATE;
		END GENERATE;
	END GENERATE;

	% Synchronous input logic %
	IF (USED(LPM_SVALUE)) GENERATE
		nxd[] = !sclr & ( sset & sc.result[]
						# !sset & ( sload & data[]
								  # !sload & din[]));
	ELSE GENERATE
		nxd[] = !sclr & (sset # ( sload & data[]
								# !sload & din[]));
	END GENERATE;

	IF (NEED_EXT_ASYNC_LOAD()) GENERATE
		dffs[].d = nxd[] $ a_was_set[];
	ELSE GENERATE
		dffs[].d = nxd[];
	END GENERATE;

	% Connect outputs %
	IF (NEED_EXT_ASYNC_LOAD()) GENERATE
		q_node[] = ((dffs[].q $ a_was_set[]) # any_set[]) & !any_clear[];
	ELSE GENERATE
		q_node[] = dffs[].q;
	END GENERATE;
	q[] = q_node[];
	END GENERATE; -- CBXI
END;