Spartan-3E Libraries Guide For HDL Designs: ISE 8.2i
Spartan-3E Libraries Guide For HDL Designs: ISE 8.2i
ISE 8.2i
R
R
Xilinx is disclosing this Document and Intellectual Property (hereinafter “the Design”) to you for use in the development of designs to operate
on, or interface with Xilinx FPGAs. Except as stated herein, none of the Design may be copied, reproduced, distributed, republished,
downloaded, displayed, posted, or transmitted in any form or by any means including, but not limited to, electronic, mechanical,
photocopying, recording, or otherwise, without the prior written consent of Xilinx. Any unauthorized use of the Design may violate copyright
laws, trademark laws, the laws of privacy and publicity, and communications regulations and statutes.
Xilinx does not assume any liability arising out of the application or use of the Design; nor does Xilinx convey any license under its patents,
copyrights, or any rights of others. You are responsible for obtaining any rights you may require for your use or implementation of the Design.
Xilinx reserves the right to make changes, at any time, to the Design as deemed desirable in the sole discretion of Xilinx. Xilinx assumes no
obligation to correct any errors contained herein or to advise you of any correction if such be made. Xilinx will not assume any liability for the
accuracy or correctness of any engineering or technical support or assistance provided to you in connection with the Design.
THE DESIGN IS PROVIDED “AS IS” WITH ALL FAULTS, AND THE ENTIRE RISK AS TO ITS FUNCTION AND IMPLEMENTATION IS
WITH YOU. YOU ACKNOWLEDGE AND AGREE THAT YOU HAVE NOT RELIED ON ANY ORAL OR WRITTEN INFORMATION OR
ADVICE, WHETHER GIVEN BY XILINX, OR ITS AGENTS OR EMPLOYEES. XILINX MAKES NO OTHER WARRANTIES, WHETHER
EXPRESS, IMPLIED, OR STATUTORY, REGARDING THE DESIGN, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE, TITLE, AND NONINFRINGEMENT OF THIRD-PARTY RIGHTS.
IN NO EVENT WILL XILINX BE LIABLE FOR ANY CONSEQUENTIAL, INDIRECT, EXEMPLARY, SPECIAL, OR INCIDENTAL DAMAGES,
INCLUDING ANY LOST DATA AND LOST PROFITS, ARISING FROM OR RELATING TO YOUR USE OF THE DESIGN, EVEN IF YOU
HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THE TOTAL CUMULATIVE LIABILITY OF XILINX IN CONNECTION
WITH YOUR USE OF THE DESIGN, WHETHER IN CONTRACT OR TORT OR OTHERWISE, WILL IN NO EVENT EXCEED THE
AMOUNT OF FEES PAID BY YOU TO XILINX HEREUNDER FOR USE OF THE DESIGN. YOU ACKNOWLEDGE THAT THE FEES, IF
ANY, REFLECT THE ALLOCATION OF RISK SET FORTH IN THIS AGREEMENT AND THAT XILINX WOULD NOT MAKE AVAILABLE
THE DESIGN TO YOU WITHOUT THESE LIMITATIONS OF LIABILITY.
The Design is not designed or intended for use in the development of on-line control equipment in hazardous environments requiring fail-
safe controls, such as in the operation of nuclear facilities, aircraft navigation or communications systems, air traffic control, life support, or
weapons systems (“High-Risk Applications”). Xilinx specifically disclaims any express or implied warranties of fitness for such High-Risk
Applications. You represent that use of the Design in such High-Risk Applications is fully at your risk.
Copyright © 1995-2006 Xilinx, Inc. All rights reserved. XILINX, the Xilinx logo, and other designated brands included herein are trademarks
of Xilinx, Inc. PowerPC is a trademark of IBM, Inc. All other trademarks are the property of their respective owners.
Guide Contents
This guide contains the following:
• Information about additional resources and conventions used in this guide.
• A general introduction to the Spartan-3E primitives.
• A listing of the primitives and macros that are supported by the Spartan-3E archi-
tecture, organized by functional categories.
• Individual sections for each of the primitive design elements, including VHDL
and Verilog instantiation and inference code examples.
• Referrals to additional sources of information.
Additional Resources
To find additional documentation, see the Xilinx website at:
http://www.xilinx.com/literature.
To search the Answer Database of silicon, software, and IP questions and answers, or
to create a technical support WebCase, see the Xilinx website at:
http://www.xilinx.com/support.
Conventions
This document uses the following conventions. An example illustrates each
convention.
Typographical
The following typographical conventions are used in this document:
Online Document
The following conventions are used in this document:
Introduction
This version of the Libraries Guide describes the primitive and macro design elements
that make up the Xilinx Unified Libraries and are supported by the Spartan-3E
architecture, and includes examples of instantiation and inference code for each
primitive.
Xilinx maintains software libraries with hundreds of functional design elements
(primitives and macros) for a variety of device architectures. New functional elements
are assembled with each release of development system software. In addition to a
comprehensive, unified library containing all design elements, beginning in 2004,
Xilinx developed a separate library for each architecture. This Spartan-3E guide is one
in a series of architecture-specific libraries.
This guide describes the primitive elements available for Xilinx Spartan-3E FPGA
devices. Common logic functions can be implemented with these elements and more
complex functions can be built by combining macros and primitives.
Functional Categories
The functional categories list the available design elements in each category, along
with a brief description of each element that is supported under each Xilinx
architecture.
Table of Contents
About this Guide
Guide Contents ............................................................................................................................ 3
Additional Resources ................................................................................................................ 3
Conventions .................................................................................................................................. 3
Introduction .................................................................................................................................. 4
Functional Categories ................................................................................................................ 5
Attributes and Constraints ...................................................................................................... 5
Functional Categories
Arithmetic Functions ................................................................................................................. 9
Clock Components ..................................................................................................................... 9
Config/BSCAN Components .................................................................................................. 9
I/O Components .......................................................................................................................... 9
RAM/ROM .................................................................................................................................. 10
Registers & Latches .................................................................................................................. 10
Shift Registers ............................................................................................................................ 10
Slice/CLB Primitives ................................................................................................................ 10
About the Spartan-3E Design Elements
BSCAN_SPARTAN3 ................................................................................................................ 15
BUFG ............................................................................................................................................. 17
BUFGCE ....................................................................................................................................... 19
BUFGCE_1 ................................................................................................................................... 21
BUFGMUX .................................................................................................................................. 23
BUFGMUX_1 .............................................................................................................................. 25
CAPTURE_SPARTAN3 ........................................................................................................... 27
DCM_SP ....................................................................................................................................... 29
FDCPE ........................................................................................................................................... 35
FDRSE ........................................................................................................................................... 37
IBUF ............................................................................................................................................... 39
IBUFDS ......................................................................................................................................... 41
IBUFG ............................................................................................................................................ 43
IBUFGDS ..................................................................................................................................... 45
IDDR2 ........................................................................................................................................... 47
IOBUF ............................................................................................................................................ 49
IOBUFDS ..................................................................................................................................... 51
KEEPER ........................................................................................................................................ 53
LDCPE ........................................................................................................................................... 55
LUT1, 2, 3, 4 ................................................................................................................................. 57
LUT1_D, LUT2_D, LUT3_D, LUT4_D ............................................................................... 63
LUT1_L, LUT2_L, LUT3_L, LUT4_L ................................................................................... 69
MULT_AND ................................................................................................................................ 75
MULT18X18SIO ......................................................................................................................... 77
MUXCY ......................................................................................................................................... 79
MUXCY_D ................................................................................................................................... 81
MUXCY_L .................................................................................................................................... 83
MUXF5 .......................................................................................................................................... 85
MUXF5_D .................................................................................................................................... 87
MUXF5_L ..................................................................................................................................... 89
MUXF6 .......................................................................................................................................... 91
MUXF6_D .................................................................................................................................... 93
MUXF6_L ..................................................................................................................................... 95
MUXF7 .......................................................................................................................................... 97
MUXF7_D .................................................................................................................................... 99
Arithmetic Functions
Functional Categories
This section categorizes, by function, the Spartan-3E design elements described in
detail later in this guide. The elements (primitive and macro implementations) are
listed in alphanumeric order under each of the following functional categories:
Arithmetic Functions I/O Components Shift Registers
Clock Components RAM/ROM Slice/CLB Primitives
Config/BSCAN Components Registers & Latches
Arithmetic Functions
Design Element Description
MULT18X18SIO Primitive: 18x18 Cascadable Signed Multiplier with Optional Input and Output registers, Clock Enable, and Synchronous Reset
Clock Components
Design Element Description
Config/BSCAN Components
Design Element Description
I/O Components
Design Element Description
RAM/ROM
RAM/ROM
Design Element Description
FDCPE Primitive : D Flip-Flop with Clock Enable and Asynchronous Preset and Clear
FDRSE Primitive : D Flip-Flop with Synchronous Reset and Set and Clock Enable
LDCPE Primitive : Transparent Data Latch with Asynchronous Clear and Preset and Gate Enable
Shift Registers
Design Element Description
SRLC16E Primitive : 16-Bit Shift Register Look-Up-Table (LUT) with Carry and Clock Enable
Slice/CLB Primitives
Design Element Description
Slice/CLB Primitives
Slice/CLB Primitives
BSCAN_SPARTAN3
BSCAN_SPARTAN3
Primitive: Spartan-3 Boundary Scan Logic Control Circuit
Usage
This design element is instantiated, rather than inferred.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
BSCAN_SPARTAN3_inst : BSCAN_SPARTAN3
port map (
CAPTURE => CAPTURE, -- CAPTURE output from TAP controller
DRCK1 => DRCK1, -- Data register output for USER1 functions
DRCK2 => DRCK2, -- Data register output for USER2 functions
RESET => RESET, -- Reset output from TAP controller
SEL1 => SEL1, -- USER1 active output
SEL2 => SEL2, -- USER2 active output
SHIFT => SHIFT, -- SHIFT output from TAP controller
TDI => TDI, -- TDI output from TAP controller
UPDATE => UPDATE, -- UPDATE output from TAP controller
TDO1 => TDO1, -- Data input for USER1 function
BSCAN_SPARTAN3
BSCAN_SPARTAN3 BSCAN_SPARTAN3_inst (
.CAPTURE(CAPTURE), // CAPTURE output from TAP controller
.DRCK1(DRCK1), // Data register output for USER1 functions
.DRCK2(DRCK2), // Data register output for USER2 functions
.RESET(RESET), // Reset output from TAP controller
.SEL1(SEL1), // USER1 active output
.SEL2(SEL2), // USER2 active output
.SHIFT(SHIFT), // SHIFT output from TAP controller
.TDI(TDI), // TDI output from TAP controller
.UPDATE(UPDATE), // UPDATE output from TAP controller
.TDO1(TDO1), // Data input for USER1 function
.TDO2(TDO2) // Data input for USER2 function
);
BUFG
BUFG
Primitive: Global Clock Buffer
Usage
To use a specific type of buffer, instantiate it manually. This design element is
supported for schematics and instantiation. Synthesis tools usually infer a BUFG on
any clock net. If there are more clock nets than BUFGs, the synthesis tool usually
instantiates BUFGs for the clocks that are most used. The BUFG contains both a BUFG
and an IBUFG.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
BUFG_inst : BUFG
port map (
O => O, -- Clock buffer output
I => I -- Clock buffer input
);
BUFG
BUFG BUFG_inst (
.O(O), // Clock buffer output
.I(I) // Clock buffer input
);
BUFGCE
BUFGCE
BUFGCE is a clock buffer with one clock input, one clock output, and a clock enable
CE line. Its O output is "0" when clock enable (CE) is Low (inactive). When clock enable
(CE) is High, the I input is transferred to the O output.
I O
Inputs Outputs
BUFGCE
I CE O
X9384
X 0 0
I 1 I
Usage
This design element is supported for instantiations but not for inference.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
BUFGCE_inst : BUFGCE
port map (
O => O, -- Clock buffer ouptput
CE => CE, -- Clock enable input
I => I -- Clock buffer input
);
BUFGCE
BUFGCE BUFGCE_inst (
.O(O), // Clock buffer output
.CE(CE), // Clock enable input
.I(I) // Clock buffer input
);
BUFGCE_1
BUFGCE_1
BUFGCE is a clock buffer with one clock input, one clock output, and a clock enable
CE line. Its O output is High (1) when clock enable (CE) is Low (inactive). When clock
I O enable (CE) is High, the I input is transferred to the O output.
Inputs Outputs
BUFGCE_1
I CE O
X9385
X 0 1
I 1 I
Usage
This design element is supported for schematics and instantiations, but not for
inference.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
BUFGCE_1_inst : BUFGCE_1
port map (
O => O, -- Clock buffer ouptput
CE => CE, -- Clock enable input
I => I -- Clock buffer input
);
BUFGCE_1
BUFGCE_1 BUFGCE_1_inst (
.O(O), // Clock buffer output
.CE(CE), // Clock enable input
.I(I) // Clock buffer input
);
BUFGMUX
BUFGMUX
BUFGMUX is a multiplexed global clock buffer that can select between two input
BUFGMUX clocks: I0 and I1. When the select input (S) is Low, the signal on I0 is selected for
I0
output (O). When the select input (S) is High, the signal on I1 is selected for output.
O
I1 BUFGMUX and BUFGMUX_1 are distinguished by the state the output assumes
S when that output switches between clocks in response to a change in input.
BUGFMUX assumes output state 0 and BUFGMUX_1 assumes output state 1.
X9251
Note: BUFGMUX guarantees that when S is toggled, the output remains in the inactive state
until the next active clock edge (either I0 or I1) occurs.
Inputs Outputs
I0 I1 S O
I0 X 0 I0
X I1 1 I1
X X ↑ 0
X X ↓ 0
Usage
This design element is supported for schematics and instantiations but not for
inference.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
BUFGMUX_inst : BUFGMUX
port map (
O => O, -- Clock MUX output
I0 => I0, -- Clock0 input
I1 => I1, -- Clock1 input
S => S -- Clock select input
BUFGMUX
);
BUFGMUX BUFGMUX_inst (
.O(O), // Clock MUX output
.I0(I0), // Clock0 input
.I1(I1), // Clock1 input
.S(S) // Clock select input
);
BUFGMUX_1
BUFGMUX_1
BUFGMUX_1 is a multiplexed global clock buffer that can select between two input
BUFGMUX_1 clocks I0 and I1. When the select input (S) is Low, the signal on I0 is selected for
output (O). When the select input (S) is High, the signal on I1 is selected for output.
I0
O BUFGMUX and BUFGMUX_1 are distinguished by the state the output assumes
I1 when that output switches between clocks in response to a change in input.
BUFGMUX assumes output state 0 and BUFGMUX_1 assumes output state 1.
S
Inputs Outputs
X9252 I0 I1 S O
I0 X 0 I0
X I1 1 I1
X X ↑ 1
X X ↓ 1
Usage
This design element is supported for schematics and instantiations but not for
inference.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
BUFGMUX_1_inst : BUFGMUX_1
port map (
O => O, -- Clock MUX output
I0 => I0, -- Clock0 input
I1 => I1, -- Clock1 input
S => S -- Clock select input
);
BUFGMUX_1
BUFGMUX_1 BUFGMUX_1_inst (
.O(O), // Clock MUX output
.I0(I0), // Clock0 input
.I1(I1), // Clock1 input
.S(S) // Clock select input
);
CAPTURE_SPARTAN3
CAPTURE_SPARTAN3
Primitive: Spartan-3 Register State Capture for Bitstream Readback
CAPTURE_SPARTAN3 CAPTURE_SPARTAN3 devices provide user control over when to capture register
(flip-flop and latch) information for readback. Spartan-3E devices provide the
CAP readback function through dedicated configuration port instructions.
The CAPTURE_SPARTAN3 symbol is optional. Without it, readback is still
performed, but the asynchronous capture function it provides for register states is not
CLK
available.
Spartan-3E devices allow users to capture register (flip-flop and latch) states only.
X9931 Although LUT RAM, SRL, and block RAM states are read back, they cannot be
captured. An asserted high CAP signal indicates that the registers in the device are to
be captured at the next Low-to-High clock transition.
By default, data is captured after every trigger (transition on CLK while CAP is
asserted). To limit the readback operation to a single data capture, add the ONESHOT
attribute to CAPTURE_SPARTAN3 devices.
Usage
This design element is instantiated rather than inferred.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
CAPTURE_SPARTAN3_inst : CAPTURE_SPARTAN3
port map (
CAP => CAP, -- Capture input
CLK => CLK -- Clock input
);
CAPTURE_SPARTAN3
CAPTURE_SPARTAN3 CAPTURE_SPARTAN3_inst (
.CAP(CAP), // Capture input
.CLK(CLK) // Clock input
);
DCM_SP
DCM_SP
Primitive: Digital Clock Manager
DCM
CLKIN CLK0
DCM_SP is a digital clock manager that provides multiple functions. It can implement
CLKFB CLK90
a clock delay locked loop, a digital frequency synthesizer, digital phase shifter.
CLK180 Note: All unused inputs must be driven Low, automatically tying the inputs Low if they are
RST CLK270 unused. The DSSEN input pin for the DCM_SP is no longer recommended for use and should
CLK2X remain unconnected in the design.
CLK2X180
Output Description
CLK0 Clock at 1x CLKIN frequency
CLK180 Clock at 1x CLK0 frequency, shifted 180o with regards to CLK0
CLK270 Clock at 1x CLK0 frequency, shifted 270o with regards to CLK0
CLK2X Clock at 2x CLK0 frequency, in phase with CLK0
CLK2X180 Clock at 2x CLK0 frequency shifted 180o with regards to CLK2X
CLK90 Clock at 1x CLK0 frequency, shifted 90o with regards to CLK0
CLKDV Clock at (1/n) x CLK0 frequency, where n=CLKDV_DIVIDE value.
CLKDV is in phase with CLK0.
LOCKED All enabled DCM_SP features locked.
DCM_SP
FrequencyCLKFX=
(CLKFX_MULTIPLY_value/CLKFX_DIVIDE_value) * FrequencyCLKIN
Both the CLKFX or CLKFX180 output can be used simultaneously.
CLKFX180 is 1x the CLKFX frequency, shifted 180o with regards to CLKFX. CLKFX
and CLKFX180 always have a 50/50 duty cycle.
The CLK_FEEDBACK attribute set to NONE causes the DCM_SP to be in the Digital
Frequency Synthesizer mode. The CLKFX and CLKFX180 are generated without
phase correction with respect to CLKIN.
The DSSEN input pin for the DCM_SP is no longer recommended for use and should
remain unconnected in the design.
DCM_SP
FACTORY_JF Attribute
The FACTORY_JF attribute affects the DCM_SP's jitter filter characteristic. This
attribute is set the default value of C080 and should not be modified unless otherwise
instructed by Xilinx.
Bit Description
0 Phase Shift Overflow*
1 = |PHASE_SHIFT| > 255
1 DLL CLKIN stopped**
1 = CLKIN stopped toggling
2 DLL CLKFX stopped
1 = CLKFX stopped toggling
3 No
4 No
5 No
6 No
7 No
* Phase Shift Overflow also goes high if the end of the phase shift delay line is reached
(see the product data sheet for the value of the maximum shifting delay).
** If only the DFS outputs are used (CLKFX & CLKFX180), this status bit does not go
high if CLKIN stops.
LOCKED
When LOCKED is high, all enabled signals are locked.
RST
The master reset input (RST) resets DCM_SP to its initial (power-on) state. The signal
at the RST input is asynchronous and must be held High for 2 ns.
Usage
This component is instantiated in the code as it cannot be easily inferred in synthesis
tools. Some synthesis tools can allow inference via an attribute. See your synthesis
tool documentation.
DCM_SP
Available Attributes
Attribute Type Allowed Values Default Description
CLK_ String "NONE", "1X" or "1X” Specifies clock
FEEDBACK "2X” feedback of NONE, 1X
or 2X.
CLKDV_DIVIDE Real 1.5, 2.0, 2.5, 3.0, 3.5, 2.0 Specifies the extent to
4.0, 4.5, 5.0, 5.5, 6.0, which the DCM_SP
6.5, 7.0, 7.5, 8.0, 9.0, clock divider (CLKDV
10.0, 11.0, 12.0, 13.0, output) is to be
14.0, 15.0 or 16.0 frequency divided.
CLKFX_DIVIDE Integer 1 to 32 1 Specifies the frequency
divider value for the
CLKFX output.
CLKFX_MULTI- Integer 1 to 32 4 Specifies the frequency
PLY multiplier value for the
CLKFX output.
CLKIN_ Boolean FALSE, TRUE FALSE Enables CLKIN divide
DIVIDE_ by two features.
BY_2
CLKIN_ Real Any value (in ns) 0 Specifies the input
PERIOD within the period to the DCM_SP
operating CLKIN input in ns).
frequency of the
device.
CLKOUT_ String "NONE", "FIXED" "NONE” Specifies the phase
PHASE_ or "VARIABLE” shift of NONE, FIXED
SHIFT or VARIABLE.
DESKEW_ String "SOURCE_ "SYSTEM_ Sets configuration bits
ADJUST SYNCHRONOUS", SYNCHRO- affecting the clock
"SYSTEM_ NOUS" delay alignment
SYNCHRONOUS" between the DCM_SP
or "0" to "15” output clocks and an
FPGA clock input pin.
FACTORY_JF 16-Bit Any 16-Bit x8080 The FACTORY_JF
Hexidecimal Hexadecimal value attribute affects the
DCMs jitter filter
characteristic. This
attribute is set the
default value of F0F0
and should not be
modified unless
otherwise instructed
by Xilinx.
PHASE_SHIFT Integer -255 to 255 0 Defines the amount of
fixed phase shift from -
255 to 255
STARTUP_ Boolean FALSE, TRUE FALSE Delays configuration
WAIT DONE until DCM_SP
LOCK.
DCM_SP
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
DCM_inst : DCM_SP
generic map (
CLKDV_DIVIDE => 2.0, -- Divide by: 1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0,5.5,6.0,6.5
-- 7.0,7.5,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0 or 16.0
CLKFX_DIVIDE => 1, -- Can be any interger from 1 to 32
CLKFX_MULTIPLY => 4, -- Can be any Integer from 1 to 32
CLKIN_DIVIDE_BY_2 => FALSE, -- TRUE/FALSE to enable CLKIN divide by two feature
CLKIN_PERIOD => 0.0, -- Specify period of input clock
CLKOUT_PHASE_SHIFT => "NONE", -- Specify phase shift of NONE, FIXED or VARIABLE
CLK_FEEDBACK => "1X", -- Specify clock feedback of NONE, 1X or 2X
DESKEW_ADJUST => "SYSTEM_SYNCHRONOUS", -- SOURCE_SYNCHRONOUS, SYSTEM_SYNCHRONOUS or
-- an Integer from 0 to 15
DFS_FREQUENCY_MODE => "LOW", -- HIGH or LOW frequency mode for frequency synthesis
DLL_FREQUENCY_MODE => "LOW", -- HIGH or LOW frequency mode for DLL
DUTY_CYCLE_CORRECTION => TRUE, -- Duty cycle correction, TRUE or FALSE
FACTORY_JF => X"C080", -- FACTORY JF Values
PHASE_SHIFT => 0, -- Amount of fixed phase shift from -255 to 255
STARTUP_WAIT => FALSE) -- Delay configuration DONE until DCM_SP LOCK, TRUE/FALSE
port map (
CLK0 => CLK0, -- 0 degree DCM_SP CLK ouptput
CLK180 => CLK180, -- 180 degree DCM_SP CLK output
CLK270 => CLK270, -- 270 degree DCM_SP CLK output
CLK2X => CLK2X, -- 2X DCM_SP CLK output
CLK2X180 => CLK2X180, -- 2X, 180 degree DCM_SP CLK out
CLK90 => CLK90, -- 90 degree DCM_SP CLK output
CLKDV => CLKDV, -- Divided DCM_SP CLK out (CLKDV_DIVIDE)
CLKFX => CLKFX, -- DCM_SP CLK synthesis out (M/D)
CLKFX180 => CLKFX180, -- 180 degree CLK synthesis out
LOCKED => LOCKED, -- DCM_SP LOCK status output
PSDONE => PSDONE, -- Dynamic phase adjust done output
STATUS => STATUS, -- 8-bit DCM_SP status bits output
CLKFB => CLKFB, -- DCM_SP clock feedback
CLKIN => CLKIN, -- Clock input (from IBUFG, BUFG or DCM_SP)
PSCLK => PSCLK, -- Dynamic phase adjust clock input
PSEN => PSEN, -- Dynamic phase adjust enable input
PSINCDEC => PSINCDEC, -- Dynamic phase adjust increment/decrement
RST => RST -- DCM_SP asynchronous reset input
);
DCM_SP
DCM_SP #(
.CLKDV_DIVIDE(2.0), // Divide by: 1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0,5.5,6.0,6.5
// 7.0,7.5,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0 or 16.0
.CLKFX_DIVIDE(1), // Can be any Integer from 1 to 32
.CLKFX_MULTIPLY(4), // Can be any Integer from 2 to 32
.CLKIN_DIVIDE_BY_2("FALSE"), // TRUE/FALSE to enable CLKIN divide by two feature
.CLKIN_PERIOD(0.0), // Specify period of input clock
.CLKOUT_PHASE_SHIFT("NONE"), // Specify phase shift of NONE, FIXED or VARIABLE
.CLK_FEEDBACK("1X"), // Specify clock feedback of NONE, 1X or 2X
.DESKEW_ADJUST("SYSTEM_SYNCHRONOUS"), // SOURCE_SYNCHRONOUS, SYSTEM_SYNCHRONOUS or
// an Integer from 0 to 15
.DFS_FREQUENCY_MODE("LOW"), // HIGH or LOW frequency mode for frequency synthesis
.DLL_FREQUENCY_MODE("LOW"), // HIGH or LOW frequency mode for DLL
.DUTY_CYCLE_CORRECTION("TRUE"), // Duty cycle correction, TRUE or FALSE
.FACTORY_JF(16'hC080), // FACTORY JF values
.PHASE_SHIFT(0), // Amount of fixed phase shift from -255 to 255
.STARTUP_WAIT("FALSE") // Delay configuration DONE until DCM_SP LOCK, TRUE/FALSE
) DCM_inst (
.CLK0(CLK0), // 0 degree DCM_SP CLK output
.CLK180(CLK180), // 180 degree DCM_SP CLK output
.CLK270(CLK270), // 270 degree DCM_SP CLK output
.CLK2X(CLK2X), // 2X DCM_SP CLK output
.CLK2X180(CLK2X180), // 2X, 180 degree DCM_SP CLK out
.CLK90(CLK90), // 90 degree DCM_SP CLK output
.CLKDV(CLKDV), // Divided DCM_SP CLK out (CLKDV_DIVIDE)
.CLKFX(CLKFX), // DCM_SP CLK synthesis out (M/D)
.CLKFX180(CLKFX180), // 180 degree CLK synthesis out
.LOCKED(LOCKED), // DCM_SP LOCK status output
.PSDONE(PSDONE), // Dynamic phase adjust done output
.STATUS(STATUS), // 8-bit DCM_SP status bits output
.CLKFB(CLKFB), // DCM_SP clock feedback
.CLKIN(CLKIN), // Clock input (from IBUFG, BUFG or DCM_SP)
.PSCLK(PSCLK), // Dynamic phase adjust clock input
.PSEN(PSEN), // Dynamic phase adjust enable input
.PSINCDEC(PSINCDEC), // Dynamic phase adjust increment/decrement
.RST(RST) // DCM_SP asynchronous reset input
);
FDCPE
FDCPE
Primitive: D Flip-Flop with Clock Enable and Asynchronous Preset and
Clear
FDCPE is a single D-type flip-flop with data (D), clock enable (CE), asynchronous
preset (PRE), and asynchronous clear (CLR) inputs and data output (Q). The
PRE
asynchronous PRE, when High, sets the Q output High; CLR, when High, resets the
output Low. Data on the D input is loaded into the flip-flop when PRE and CLR are
D FDCPE Low and CE is High on the Low-to-High clock (C) transition. When CE is Low, the
CE Q clock transitions are ignored.
C
The flip-flop is asynchronously cleared, output Low, when power is applied.
CLR
For Spartan-3E devices, the power-on condition can be simulated when global
set/reset (GSR) is active.
X4389
GSR defaults to active-High but can be inverted by adding an inverter in front of the
GSR input of the Spartan-3E symbol.
Inputs Outputs
CLR PRE CE D C Q
1 X X X X 0
0 1 X X X 1
0 0 0 X X No Change
0 0 1 0 ↑ 0
0 0 1 1 ↑ 1
Usage
This design element typically should be inferred in the design code; however, the
element can be instantiated for cases where strict placement control, relative
placement control, or initialization attributes need to be applied.
Available Attributes
Allowed
Attribute Type Default Description
Values
INIT 1-Bit 1-Bit Binary 1'b0 Sets the initial value of
Binary Q output after
configuration
FDCPE
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- FDCPE: Single Data Rate D Flip-Flop with Asynchronous Clear, Set and
-- Clock Enable (posedge clk). All families.
-- Xilinx HDL Libraries Guide version 8.1i
FDCPE_inst : FDCPE
generic map (
INIT => '0') -- Initial value of register ('0' or '1')
port map (
Q => Q, -- Data output
C => C, -- Clock input
CE => CE, -- Clock enable input
CLR => CLR, -- Asynchronous clear input
D => D, -- Data input
PRE => PRE -- Asynchronous set input
);
// FDCPE: Single Data Rate D Flip-Flop with Asynchronous Clear, Set and
// Clock Enable (posedge clk). All families.
// Xilinx HDL Libraries Guide Version 8.1i
FDCPE #(
.INIT(1'b0) // Initial value of register (1'b0 or 1'b1)
) FDCPE_inst (
.Q(Q), // Data output
.C(C), // Clock input
.CE(CE), // Clock enable input
.CLR(CLR), // Asynchronous clear input
.D(D), // Data input
.PRE(PRE) // Asynchronous set input
);
FDRSE
FDRSE
Primitive: D Flip-Flop with Synchronous Reset and Set and Clock
Enable
S
FDRSE is a single D-type flip-flop with synchronous reset (R), synchronous set (S),
and clock enable (CE) inputs and data output (Q). The reset (R) input, when High,
overrides all other inputs and resets the Q output Low during the Low-to-High clock
D FDRSE Q
transition. (Reset has precedence over Set.) When the set (S) input is High and R is
CE
Low, the flip-flop is set, output High, during the Low-to-High clock (C) transition.
C
Data on the D input is loaded into the flip-flop when R and S are Low and CE is High
during the Low-to-High clock transition.
R X3732
The flip-flop is asynchronously cleared, output Low, by default, when power is
applied or when GSR is active.
Inputs Outputs
R S CE D C Q
1 X X X ↑ 0
0 1 X X ↑ 1
0 0 0 X X No Change
0 0 1 1 ↑ 1
0 0 1 0 ↑ 0
Usage
This design element typically should be inferred in the design code; however, the
element can be instantiated for cases where strict placement control, relative
placement control, or initialization attributes need to be applied.
Available Attributes
Allowed
Attribute Type Default Description
Values
INIT Binary 0, 1 0 Sets the initial value of
Q output after
configuration and on
GSR
FDRSE
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- FDRSE: Single Data Rate D Flip-Flop with Synchronous Clear, Set and
-- Clock Enable (posedge clk). All families.
-- Xilinx HDL Libraries Guide version 8.1i
FDRSE_inst : FDRSE
generic map (
INIT => '0') -- Initial value of register ('0' or '1')
port map (
Q => Q, -- Data output
C => C, -- Clock input
CE => CE, -- Clock enable input
D => D, -- Data input
R => R, -- Synchronous reset input
S => S -- Synchronous set input
);
// FDRSE: Single Data Rate D Flip-Flop with Synchronous Clear, Set and
// Clock Enable (posedge clk). All families.
// Xilinx HDL Libraries Guide Version 8.1i
FDRSE #(
.INIT(1'b0) // Initial value of register (1'b0 or 1'b1)
) FDRSE_inst (
.Q(Q), // Data output
.C(C), // Clock input
.CE(CE), // Clock enable input
.D(D), // Data input
.R(R), // Synchronous reset input
.S(S) // Synchronous set input
);
IBUF
IBUF
Primitive: Single-Ended Input Buffer with Selectable I/O Standard
Input Buffers are necessary to isolate the internal circuit from the signals coming into
IBUF the FPGA. IBUFs are contained in input/output blocks (IOB). IBUFs allow the
specification of the particular I/O Standard to configure the I/O. In general, an IBUF
I O should be used for all single-ended data input or bidirectional pins.
Usage
IBUFs are automatically inserted (inferred) to any signal directly connected to a top
level input or inout port of the design by the synthesis tool. It is generally
recommended to allow the synthesis tool to infer this buffer however if so desired, the
IBUF can be instantiated into the design. In order to do so, connect the input port, I, of
the component directly to the associated top-level input or in-out port and connect the
output port, O, to the FPGA logic to be sourced by that port. Modify any necessary
generic maps (VHDL) or named parameter value assignment (Verilog) in order to
change the default behavior of the component.
Available Attribute
Attribute Type Allowed Values Default Description
IOSTANDARD String "DEFAULT "DEFAULT” Use to assign an
I/O standard to an
I/O primitive.
IBUF_DELAY_ Integer 0 to 16 0 Specifies the
VALUE amount of
additional delay to
add to the non-
registered path out
of the IOB.
IFD_DELAY_ String "AUTO" or 0 to 8 "AUTO” Specifies the
VALUE amount of
additional delay to
add to the
registered path
within the IOB.
Note: Consult the device user guide or databook for the allowed values and the default value.
IBUF
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
IBUF_inst : IBUF
generic map (
IOSTANDARD => "DEFAULT")
port map (
O => O, -- Buffer output
I => I -- Buffer input (connect directly to top-level port)
);
IBUF #(
.IOSTANDARD("DEFAULT") // Specify the input I/O standard
)IBUF_inst (
.O(O), // Buffer output
.I(I) // Buffer input (connect directly to top-level port)
);
IBUFDS
IBUFDS
Primitive: Differential Signaling Input Buffer with Selectable I/O Interface
Usage
This design element is supported for instantiation but not for inference.
Available Attributes
Allowed
Attribute Type Default Description
Values
DIFF_TERM Boolean FALSE, TRUE FALSE Enables the built-in
differential termination
resistor.
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O
standard to an I/O
primitive.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
IBUFDS
IBUFDS_inst : IBUFDS
generic map (
IBUF_DELAY_VALUE => "0", -- Specify the amount of added input delay for buffer, "0"-"16" (Spartan-3E
only)
IFD_DELAY_VALUE => "AUTO", -- Specify the amount of added delay for input register, "AUTO", "0"-"8"
(Spartan-3E only)
IOSTANDARD => "DEFAULT")
port map (
O => O, -- Clock buffer output
I => I, -- Diff_p clock buffer input (connect directly to top-level port)
IB => IB -- Diff_n clock buffer input (connect directly to top-level port)
);
IBUFDS #(
.DIFF_TERM("FALSE"), // Differential Termination
.IBUF_DELAY_VALUE("0"), // Specify the amount of added input delay for the buffer, "0"-"16" (Spartan-
3E only)
.IFD_DELAY_VALUE("AUTO"), // Specify the amount of added delay for input register, "AUTO", "0"-"8"
(Spartan-3E .IOSTANDARD("DEFAULT") // Specify the input I/O standard
) IBUFDS_inst (
.O(O), // Clock buffer output
.I(I), // Diff_p clock buffer input (connect directly to top-level port)
.IB(IB) // Diff_n clock buffer input (connect directly to top-level port)
);
IBUFG
IBUFG
Primitive: Dedicated Input Buffer with Selectable I/O Interface
IBUFG is dedicated to input buffers and is used for connecting to the clock buffer
BUFG or DCM_SP. You can attach an IOSTANDARD attribute to an IBUFG instance.
I O
The IBUFG input can only be driven by the global clock pins. The IBUFG output can
drive CLKIN of a DCM_SP, BUFG, or user logic. IBUFG can be routed to user logic
and does not have to be routed to a DCM_SP.
IBUFG
X10181
Attach an IOSTANDARD attribute to an IBUFG and assign the value indicated in the
"IOSTANDARD (Attribute Value)" column to program the input for the I/O standard
associated with that value.
Usage
This design element is supported for schematic and instantiation. Synthesis tools
usually infer a BUFGP on any clock net. If there are more clock nets than BUFGPs, the
synthesis tool usually instantiates BUFGPs for the clocks that are most used. The
BUFGP contains both a BUFG and an IBUFG.
Available Attributes
Attribute Type Allowed Values Default Description
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O
standard to an I/O
primitive.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
IBUFG_inst : IBUFG
generic map (
IBUF_DELAY_VALUE => "0", -- Specify the amount of added input delay for buffer, "0"-"16" (Spartan-3E
only)
IOSTANDARD => "DEFAULT")
port map (
O => O, -- Clock buffer output
IBUFG
IBUFG #(
.IOSTANDARD("DEFAULT")
) IBUFG_inst (
.O(O), // Clock buffer output
.I(I) // Clock buffer input (connect directly to top-level port)
);
IBUFGDS
IBUFGDS
Primitive: Dedicated Differential Signaling Input Buffer with Selectable
I/O Interface
IBUFGDS is a dedicated differential signaling input buffer for connection to the clock
I buffer (BUFG) or DCM_SP. In IBUFGDS, a design-level interface signal is represented
O
IB as two distinct ports (I and IB), one deemed the "master" and the other the "slave." The
master and the slave are opposite phases of the same logical signal (for example,
MYNET and MYNETB).
X9255
Inputs Outputs
I IB O
0 0 No Change
0 1 0
1 0 1
1 1 No Change
Usage
This design element is supported for instantiation, but not for inference.
Available Attributes
Allowed
Attribute Type Default Description
Values
DIFF_TERM Boolean FALSE, TRUE FALSE Enables the built-in
differential termination
resistor.
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O
standard to an I/O
primitive.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
IBUFGDS
IBUFGDS_inst : IBUFGDS
generic map (
DIFF_TERM => "FALSE", -- Differential Termination
IBUF_DELAY_VALUE => "0", -- Specify the amount of added input delay for buffer, "0"-"16" (Spartan-3E
only)
IOSTANDARD => "DEFAULT")
port map (
O => O, -- Clock buffer output
I => I, -- Diff_p clock buffer input (connect directly to top-level port)
IB => IB -- Diff_n clock buffer input (connect directly to top-level port)
);
IBUFGDS #(
.DIFF_TERM("FALSE"),
.IOSTANDARD("DEFAULT")
) IBUFGDS_inst (
.O(O), // Clock buffer output
.I(I), // Diff_p clock buffer input
.IB(IB) // Diff_n clock buffer input
);
IDDR2
IDDR2
Primitive: Double Data Rate Input D Flip-Flop with Optional Data
Alignment, Clock Enable and Programmable Synchronous or
Asynchronous Set/Reset
The IDDR2 is an input double data rate (DDR) register useful in capturing double
data-rate signals entering the FPGA. The IDDR2 requires two clocks to be connected
IDDR2
D
to the component, C0 and C1, so that data is captured at the positive edge of both C0
C0 Q0
C1
and C1 clocks. The IDDR2 features an active high clock enable port, CE, which can be
CE used to suspend the operation of the registers and both set and reset ports that can be
Q1
R configured to be synchronous or asynchronous to the respective clocks. The IDDR2
S
has an optional alignment feature, which allows both output data ports to the
component to be aligned to a single clock.
X10237
Usage
The IDDR2 must be instantiated to be incorporated into a design. To change the
default behavior of the IDDR2, attributes can be modified via the generic map
(VHDL) or named parameter value assignment (Verilog) as a part of the instantiated
component. The IDDR2 can be either connected directly to a top-level input port in
the design where an appropriate input buffer can be inferred or to an instantiated
IBUF, IOBUF, IBUFDS or IOBUFDS. All inputs and outputs of this component should
either be connected or properly tied off.
Available Attributes
Allowed
Attribute Type Default Description
Values
DDR_ALIGN- String "NONE", "NONE” Sets output alignment.
MENT "C0" or "C1”
INIT_Q0 Integer 0 or 1 0 Sets initial state of the Q0
output to
0 or 1.
INIT_Q1 Integer 0 or 1 0 Sets initial state of the Q1
output to
0 or 1.
SRTYPE String "SYNC" or "SYNC” Specifies "SYNC" or "ASYNC"
"ASYNC” set/reset.
IDDR2
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- IDDR2: Input Double Data Rate Input Register with Set, Reset
-- and Clock Enable. Spartan-3E
-- Xilinx HDL Libraries Guide version 8.1i
IDDR2_inst : IDDR2
generic map(
DDR_ALIGNMENT => "NONE", -- Sets output alignment to "NONE", "C0", "C1"
INIT_Q0 => '0', -- Sets initial state of the Q0 output to '0' or '1'
INIT_Q1 => '0', -- Sets initial state of the Q1 output to '0' or '1'
SRTYPE => "SYNC") -- Specifies "SYNC" or "ASYNC" set/reset
port map (
Q0 => Q0, -- 1-bit output captured with C0 clock
Q1 => Q1, -- 1-bit output captured with C1 clock
C0 => C0, -- 1-bit clock input
C1 => C1, -- 1-bit clock input
CE => CE, -- 1-bit clock enable input
D => D, -- 1-bit data input
R => R, -- 1-bit reset input
S => S -- 1-bit set input
);
// IDDR2: Input Double Data Rate Input Register with Set, Reset
// and Clock Enable. Spartan-3E
// Xilinx HDL Libraries Guide Version 8.1i
IDDR2 #(
.DDR_ALIGNMENT("NONE"), // Sets output alignment to "NONE", "C0" or "C1"
.INIT_Q0(1'b0), // Sets initial state of the Q0 output to 1'b0 or 1'b1
.INIT_Q1(1'b0), // Sets initial state of the Q1 output to 1'b0 or 1'b1
.SRTYPE("SYNC") // Specifies "SYNC" or "ASYNC" set/reset
) IDDR2_inst (
.Q0(Q0), // 1-bit output captured with C0 clock
.Q1(Q1), // 1-bit output captured with C1 clock
.C0(C0), // 1-bit clock input
.C1(C1), // 1-bit clock input
.CE(CE), // 1-bit clock enable input
.D(D), // 1-bit DDR data input
.R(R), // 1-bit reset input
.S(S) // 1-bit set input
);
IOBUF
IOBUF
Primitive: bidirectional Buffer with Selectable I/O Interface
T I IO O
1 X Z X
0 1 1 1
0 0 0 0
Usage
These design elements are instantiated and inferred.
Available Attributes
Attribute Type Allowed Values Default Description
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O
standard to an I/O
primitive.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
IOBUF
IOBUF_inst : IOBUF
generic map (
DRIVE => 12,
IBUF_DELAY_VALUE => "0", -- Specify the amount of added input delay for buffer, "0"-"16" (Spartan-3E
only)
IFD_DELAY_VALUE => "AUTO", -- Specify the amount of added delay for input register, "AUTO", "0"-"8"
(Spartan-3E only)
IOSTANDARD => "DEFAULT",
SLEW => "SLOW")
port map (
O => O, -- Buffer output
IO => IO, -- Buffer inout port (connect directly to top-level port)
I => I, -- Buffer input
T => T -- 3-state enable input
);
IOBUF #(
.DRIVE(12), // Specify the output drive strength
.IBUF_DELAY_VALUE("0"), // Specify the amount of added input delay for the buffer, "0"-"16" (Spartan-
3E only)
.IFD_DELAY_VALUE("AUTO"), // Specify the amount of added delay for input register, "AUTO", "0"-"8"
(Spartan-3E only)
.IOSTANDARD("DEFAULT"), // Specify the I/O standard
.SLEW("SLOW") // Specify the output slew rate
) IOBUF_inst (
.O(O), // Buffer output
.IO(IO), // Buffer inout port (connect directly to top-level port)
.I(I), // Buffer input
.T(T) // 3-state enable input
);
IOBUFDS
IOBUFDS
Usage
This design element is instantiated rather than inferred.
Available Attibutes
Allowed
Attribute Type Default Description
Values
DRIVE Integer 2, 4, 6, 8, 12, 12 Selects output drive
16, 24 strength (mA) for the
SelectIO buffers that use
the LVTTL, LVCMOS12,
LVCMOS15, LVCMOS18,
LVCMOS25, or LVCMOS33
interface I/O standard.
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O
standard to an I/O
primitive.
SLEW String "SLOW" or "SLOW” Sets the output rise and fall
"FAST” time.
-- Copy the following two statements and paste them before the
IOBUFDS
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
IOBUFDS_inst : IOBUFDS
generic map (
IBUF_DELAY_VALUE => "0", -- Specify the amount of added input delay for buffer, "0"-"16" (Spartan-3E
only)
IFD_DELAY_VALUE => "AUTO", -- Specify the amount of added delay for input register, "AUTO", "0"-"8"
(Spartan-3E only)
IOSTANDARD => "DEFAULT")
port map (
O => O, -- Buffer output
IO => IO, -- Diff_p inout (connect directly to top-level port)
IOB => IOB, -- Diff_n inout (connect directly to top-level port)
I => I, -- Buffer input
T => T -- 3-state enable input
);
IOBUFDS #(
.IBUF_DELAY_VALUE("0"), // Specify the amount of added input delay for the buffer, "0"-"16" (Spartan-
3E only)
.IFD_DELAY_VALUE("AUTO"), // Specify the amount of added delay for input register, "AUTO", "0"-"8"
(Spartan-3E only)
.IOSTANDARD("DEFAULT") // Specify the I/O standard
) IOBUFDS_inst (
.O(O), // Buffer output
.IO(IO), // Diff_p inout (connect directly to top-level port)
.IOB(IOB), // Diff_n inout (connect directly to top-level port)
.I(I), // Buffer input
.T(T) // 3-state enable input
);
KEEPER
KEEPER
Primitive: KEEPER Symbol
KEEPER is a weak keeper element used to retain the value of the net connected to its
bidirectional O pin. For example, if a logic 1 is being driven onto the net, KEEPER
drives a weak/resistive 1 onto the net. If the net driver is then 3-stated, KEEPER
continues to drive a weak/resistive 1 onto the net.
Usage
This design element is instantiated rather than inferred.
O
X8718
VHDL Instantiation Template
-- KEEPER : In order to incorporate this function into the design,
-- VHDL : the following instance declaration needs to be placed
-- instance : in the architecture body of the design code. The
-- declaration : instance name (KEEPER_inst) and/or the port declarations
-- code : after the "=>" assignment maybe changed to properly
-- : connect this function to the design. Delete or comment
-- : out inputs/outs that are not necessary.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
KEEPER_inst : KEEPER
port map (
O => O -- Keeper output (connect directly to top-level port)
);
KEEPER KEEPER_inst (
.O(O), // Keeper output (connect directly to top-level port)
);
KEEPER
LDCPE
LDCPE
PRE LDCPE is a transparent data latch with data (D), asynchronous clear (CLR),
asynchronous preset (PRE), and gate enable (GE). When CLR is High, it overrides the
D LDCPE other inputs and resets the data (Q) output Low. When PRE is High and CLR is Low, it
GE Q
presets the data (Q) output High. Q reflects the data (D) input while the gate (G) input
G
and gate enable (GE) are High and CLR and PRE are Low. The data on the D input
during the High-to-Low gate transition is stored in the latch. The data on the Q output
CLR
remains unchanged as long as G or GE remains Low.
X8371
The latch is asynchronously cleared, output Low, when power is applied, or when
global reset is active.
For Spartan-3E devices, power-on conditions are simulated when global set/reset
(GSR) is active.
GSR defaults to active-High but can be inverted by adding an inverter in front of the
GSR input of the Spartan-3E symbol.
Inputs Outputs
CLR PRE GE G D Q
1 X X X X 0
0 1 X X X 1
0 0 0 X X No Change
0 0 1 1 0 0
0 0 1 1 1 1
0 0 1 0 X No Change
0 0 1 ↓ D D
Usage
This design element typically should be inferred in the design code; however, the
element can be instantiated for cases where strict placement control, relative
placement control, or initialization attributes need to be applied.
Available Attributes
Allowed
Attribute Type Default Description
Values
INIT 1-Bit 1 or 0 0 Sets the initial value of
Q output after
configuration
LDCPE
LDCPE_inst : LDCPE
generic map (
INIT => '0') -- Initial value of the latch
port map (
Q => Q, -- Data output
CLR => CLR, -- Asynchronous clear/reset input
D => D, -- Data input
G => G, -- Gate input
GE => GE, -- Gate enable input
);
LDCPE #(
.INIT(1'b0) // Initial value of latch (1'b0 or 1'b1)
) LDCPE_inst (
.Q(Q), // Data output
.CLR(CLR), // Asynchronous clear/reset input
.D(D), // Data input
.G(G), // Gate input
.GE(GE), // Gate enable input
.PRE(PRE) // Asynchronous preset/set input
);
LUT1, 2, 3, 4
LUT1, 2, 3, 4
Primitive: 1-, 2-, 3-, 4-Bit Look-Up-Table with General Output
LUT1, LUT2, LUT3, and LUT4 are, respectively, 1-, 2-, 3-, and 4-bit look-up-tables
LUT1 (LUTs) with general output (O).
X9852
LUT1 provides a look-up-table version of a buffer or inverter.
LUTs are the basic Spartan-3E building blocks. Two LUTs are available in each CLB
I1 LUT2 slice; four LUTs are available in each CLB. The variants, “LUT1_D, LUT2_D, LUT3_D,
O LUT4_D”and “LUT1_L, LUT2_L, LUT3_L, LUT4_L”provide additional types of
I0
outputs that can be used by different timing models for more accurate pre-layout
timing estimation.
X8379 LUT3 Function Table
Inputs Outputs
I2 LUT3
I1 I2 I1 I0 O
I0 O
0 0 0 INIT[0]
X8382 0 0 1 INIT[1]
0 1 0 INIT[2]
0 1 1 INIT[3]
I3 LUT4
1 0 0 INIT[4]
I2
I1
O 1 0 1 INIT[5]
I0 1 1 0 INIT[6]
1 1 1 INIT[7]
X8385
INIT = binary equivalent of the hexadecimal number assigned to the INIT attribute
Usage
LUTs are inferred with the logic portions of the HDL code. Xilinx suggests that you
instantiate LUTs only if you have a need to implicitly specify the logic mapping, or if
you need to manually place or relationally place the logic.
Available Attributes
LUT1
LUT1, 2, 3, 4
LUT2
LUT3
LUT4
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT1_inst : LUT1
generic map (
INIT => "00")
port map (
O => O, -- LUT general output
I0 => I0 -- LUT input
);
LUT1, 2, 3, 4
LUT1 #(
.INIT(2'b00) // Specify LUT Contents
) LUT1_inst (
.O(O), // LUT general output
.I0(I0) // LUT input
);
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT2_inst : LUT2
generic map (
INIT => X"0")
port map (
O => O, -- LUT general output
I0 => I0, -- LUT input
I1 => I1 -- LUT input
);
LUT2 #(
.INIT(4'h0) // Specify LUT Contents
) LUT2_inst (
.O(O), // LUT general output
LUT1, 2, 3, 4
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT3_inst : LUT3
generic map (
INIT => X"00")
port map (
O => O, -- LUT general output
I0 => I0, -- LUT input
I1 => I1, -- LUT input
I2 => I2 -- LUT input
);
LUT3 #(
.INIT(8'h00) // Specify LUT Contents
) LUT3_inst (
.O(O), // LUT general output
.I0(I0), // LUT input
.I1(I1), // LUT input
.I2(I2) // LUT input
);
LUT1, 2, 3, 4
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT4_inst : LUT4
generic map (
INIT => X"0000")
port map (
O => O, -- LUT general output
I0 => I0, -- LUT input
I1 => I1, -- LUT input
I2 => I2, -- LUT input
I3 => I3 -- LUT input
);
LUT4 #(
.INIT(16'h0000) // Specify LUT Contents
) LUT4_inst (
.O(O), // LUT general output
.I0(I0), // LUT input
.I1(I1), // LUT input
.I2(I2), // LUT input
.I3(I3) // LUT input
);
LUT1, 2, 3, 4
LUT1_L, LUT2_L, LUT3_L, and LUT4_L are, respectively, 1-, 2-, 3-, and 4- bit look-up-
LUT1_L LO
tables (LUTs) with a local output (LO) that connects to another output within the
same CLB slice and to the fast-connect buffer.
I0
A mandatory INIT attribute, with an appropriate number of hexadecimal digits for
X8378
the number of inputs, must be attached to the LUT to specify its function.
LUT1_L provides a look-up-table version of a buffer or inverter.
I1 LUT2_L LO
See also “LUT1, 2, 3, 4”and “LUT1_D, LUT2_D, LUT3_D, LUT4_D”
LUT3_L Function Table
I0
Inputs Outputs
X8381
I2 I1 I0 LO
I2 LUT3_L LO
0 0 0 INIT[0]
I1 0 0 1 INIT[1]
I0 0 1 0 INIT[2]
0 1 1 INIT[3]
X8384
1 0 0 INIT[4]
1 0 1 INIT[5]
I3 LUT4_L
I2
LO
1 1 0 INIT[6]
I1
I0
1 1 1 INIT[7]
INIT = binary equivalent of the hexadecimal number assigned to the INIT attribute
X8387
Usage
LUTs are inferred with the logic portions of the HDL code. Xilinx suggests that you
instantiate LUTs only if you have a need to implicitly specify the logic mapping, or if
you need to manually place or relationally place the logic.
Available Attributes
LUT1_L
LUT3_L
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT1_L_inst : LUT1_L
generic map (
INIT => "00")
port map (
LO => LO, -- LUT local output
I0 => I0 -- LUT input
);
LUT1_L #(
.INIT(2'b00) // Specify LUT Contents
) LUT1_L_inst (
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT2_L_inst : LUT2_L
generic map (
INIT => X"0")
port map (
LO => LO, -- LUT local output
I0 => I0, -- LUT input
I1 => I1 -- LUT input
);
LUT2_L #(
.INIT(4'h0) // Specify LUT Contents
) LUT2_L_inst (
.LO(LO), // LUT local output
.I0(I0), // LUT input
.I1(I1) // LUT input
);
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT3_L_inst : LUT3_L
generic map (
INIT => X"00")
port map (
LO => LO, -- LUT local output
I0 => I0, -- LUT input
I1 => I1, -- LUT input
I2 => I2 -- LUT input
);
LUT3_L #(
.INIT(8'h00) // Specify LUT Contents
) LUT3_L_inst (
.LO(LO), // LUT local output
.I0(I0), // LUT input
.I1(I1), // LUT input
.I2(I2) // LUT input
);
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT4_L_inst : LUT4_L
generic map (
INIT => X"0000")
port map (
LO => LO, -- LUT local output
I0 => I0, -- LUT input
I1 => I1, -- LUT input
I2 => I2, -- LUT input
I3 => I3 -- LUT input
);
LUT4_L #(
.INIT(16'h0000) // Specify LUT Contents
) LUT4_L_inst (
.LO(LO), // LUT local output
.I0(I0), // LUT input
.I1(I1), // LUT input
.I2(I2), // LUT input
.I3(I3) // LUT input
);
LUT1_D LO LUT1_D, LUT2_D, LUT3_D, and LUT4_D are, respectively, 1-, 2-, 3-, and 4-bit look-
up-tables (LUTs) with two functionally identical outputs, O and LO. The O output is a
I0 O general interconnect. The LO output is connects to another output within the same
CLB slice and to the fast connect buffer.
X8377
A mandatory INIT attribute, with an appropriate number of hexadecimal digits for
the number of inputs, must be attached to the LUT to specify its function.
I1 LUT2_D LO
LUT1_D provides a look-up-table version of a buffer or inverter.
I0 O See also “LUT1, 2, 3, 4”and“LUT1_L, LUT2_L, LUT3_L, LUT4_L”
X8380
LUT3_D Function Table
Inputs Outputs
I2 LUT3_D LO
I2 I1 I0 O LO
I1
I0 O 0 0 0 INIT[0] INIT[0]
0 0 1 INIT[1] INIT[1]
X8383
0 1 0 INIT[2] INIT[2]
0 1 1 INIT[3] INIT[3]
LUT4_D
I3 1 0 0 INIT[4] INIT[4]
I2 LO
I1 O
1 0 1 INIT[5] INIT[5]
I0 1 1 0 INIT[6] INIT[6]
1 1 1 INIT[7] INIT[7]
X8386
INIT = binary equivalent of the hexadecimal number assigned to the INIT attribute
Usage
LUTs are inferred with the logic portions of the HDL code. Xilinx suggests that you
instantiate LUTs only if you have a need to implicitly specify the logic mapping, or if
you need to manually place or relationally place the logic.
Available Attributes
LUT1_D
LUT3_D
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT1_D_inst : LUT1_D
generic map (
INIT => "00")
port map (
LO => LO, -- LUT local output
O => O, -- LUT general output
I0 => I0 -- LUT input
);
LUT1_D #(
.INIT(2'b00) // Specify LUT Contents
) LUT1_D_inst (
.LO(LO), // LUT local output
.O(O), // LUT general output
.I0(I0) // LUT input
);
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT2_D_inst : LUT2_D
generic map (
INIT => X"0")
port map (
LO => LO, -- LUT local output
O => O, -- LUT general output
I0 => I0, -- LUT input
I1 => I1 -- LUT input
);
LUT2_D #(
.INIT(4'h0) // Specify LUT Contents
) LUT2_D_inst (
.LO(LO), // LUT local output
.O(O), // LUT general output
.I0(I0), // LUT input
.I1(I1) // LUT input
);
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT3_D_inst : LUT3_D
generic map (
INIT => X"00")
port map (
LO => LO, -- LUT local output
O => O, -- LUT general output
I0 => I0, -- LUT input
I1 => I1, -- LUT input
I2 => I2 -- LUT input
);
LUT3_D #(
.INIT(8'h00) // Specify LUT Contents
) LUT3_D_inst (
.LO(LO), // LUT local output
.O(O), // LUT general output
.I0(I0), // LUT input
.I1(I1), // LUT input
.I2(I2) // LUT input
);
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
LUT4_D_inst : LUT4_D
generic map (
INIT => X"0000")
port map (
LO => LO, -- LUT local output
O => O, -- LUT general output
I0 => I0, -- LUT input
I1 => I1, -- LUT input
I2 => I2, -- LUT input
I3 => I3 -- LUT input
);
LUT4_D #(
.INIT(16'h0000) // Specify LUT Contents
) LUT4_D_inst (
.LO(LO), // LUT local output
.O(O), // LUT general output
.I0(I0), // LUT input
.I1(I1), // LUT input
.I2(I2), // LUT input
.I3(I3) // LUT input
);
MULT_AND
MULT_AND
Primitive: Fast Multiplier AND
MULT_AND is a logical AND gate component that can be used to reduce logic and
improve speed when the user is building soft multipliers within the device fabric. It
can also be used in some carry-chain operations to reduce the needed LUTs to
I1 implement some functions. The I1 and I0 inputs must betconnected to the I1 and I0
LO
I0 inputs of the associated LUT. The LO output must be connected to the DI input of the
associated MUXCY, MUXCY_D, or MUXCY_L.
X8405 Inputs Output
I1 I0 LO
0 0 0
0 1 0
1 0 0
1 1 1
LO MUXCY_L
S
0 1
DI CI
LUT4
B1 I3
A1 I2
LI SUM1
B0 I1 O O
CI
A0 IO
XORCY
I1
LO
I0
MULT_AND
CO
X8733
Usage
This design element can be instantiated and inferred.
MULT_AND
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
MULT_AND_inst : MULT_AND
port map (
LO => LO, -- MULT_AND output (connect to MUXCY DI)
I0 => I0, -- MULT_AND data[0] input
I1 => I1 -- MULT_AND data[1] input
);
MULT_AND MULT_AND_inst (
.LO(LO), // MULT_AND output (connect to MUXCY DI)
.I0(I0), // MULT_AND data[0] input
.I1(I1) // MULT_AND data[1] input
);
MULT18X18SIO
MULT18X18SIO
Primitive: 18x18 Cascadable Signed Multiplier with Optional Input and
Output registers, Clock Enable, and Synchronous Reset
The MULT18X18SIO is a 36-bit output, 18x18-bit input dedicated signed multiplier.
This component can perform asynchronous multiplication operations when the
A(17:0) MULT18X18SIO P(35:0)
B(17:0) attributes AREG, BREG and PREG are all set to 0. Alternatively, synchronous
CEA
CEB
multiplication operations of different latency and performance characteristics can be
CEP performed when any combination of those attributes is set to 1. When using the
CLK
RSTA multiplier in synchronous operation, the MULT18X18SIO features active high clock
RSTB
RSTP
enables for each set of register banks in the multiplier, CEA, CEB and CEP, as well as
BCIN(17:0) BCOUT(17:0)
synchronous resets, RSTA, RSTB, and RSTP. Multiple MULT18X18SIOs can be
X10238
cascaded to create larger multiplication functions using the BCIN and BCOUT ports
in combination with the B_INPUT attribute.
Usage
The MULT18X18SIO can be inferred by most synthesis tools using standard VHDL or
Verilog notation for multiplication. Alternatively, Core GeneratorTM System and other
IP can also create multiplication functions using this component. If preferred, the
MULT18X18SIO can be instantiated into the VHDL or Verilog code to give full control
over the implementation of the component. To change the default behavior of the
MULT18X18SIO, attributes can be modified via the generic map (VHDL) or named
parameter value assignment (Verilog) as a part of the instantiated component.
Available Attributes
Allowed
Attribute Type Default Description
Values
AREG Integer 1 or 0 1 Enable the input registers on the A port
(1=on, 0=off).
B_INPUT String "DIRECT" or "DIREC B input from B(17:0) (DIRECT) or from
"CASCADE” T” BCIN (17:0) (CASCADE).
BREG Integer 1 or 0 1 Enable the input registers on the B port
(1=on, 0=off).
PREG Integer 1 or 0 1 Enable the output registers on the P
port (1=on, 0=off).
-- Copy the following two statements and paste them before the
MULT18X18SIO
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
MULT18X18SIO_inst : MULT18X18SIO
generic map (
AREG => 1, -- Enable the input registers on the A port (1=on, 0=off)
BREG => 1, -- Enable the input registers on the B port (1=on, 0=off)
B_INPUT => "DIRECT", -- B cascade input "DIRECT" or "CASCADE"
PREG => 1) -- Enable the input registers on the P port (1=on, 0=off)
port map (
BCOUT => BCOUT, -- 18-bit cascade output
P => P, -- 36-bit multiplier output
A => A, -- 18-bit multiplier input
B => B, -- 18-bit multiplier input
BCIN => BCIN, -- 18-bit cascade input
CEA => CEA, -- Clock enable input for the A port
CEB => CEB, -- Clock enable input for the B port
CEP => CEP, -- Clock enable input for the P port
CLK => CLK, -- Clock input
RSTA => RSTA, -- Synchronous reset input for the A port
RSTB => RSTB, -- Synchronous reset input for the B port
RSTP => RSTP, -- Synchronous reset input for the P port
);
MULT18X18SIO #(
.AREG(1), // Enable the input registers on the A port (1=on, 0=off)
.BREG(1), // Enable the input registers on the B port (1=on, 0=off)
.B_INPUT("DIRECT"), // B cascade input "DIRECT" or "CASCADE"
.PREG(1) // Enable the input registers on the P port (1=on, 0=off)
) MULT18X18SIO_inst (
.BCOUT(BCOUT), // 18-bit cascade output
.P(P), // 36-bit multiplier output
.A(A), // 18-bit multiplier input
.B(B), // 18-bit multiplier input
.BCIN(BCIN), // 18-bit cascade input
.CEA(CEA), // Clock enable input for the A port
.CEB(CEB), // Clock enable input for the B port
.CEP(CEP), // Clock enable input for the P port
.CLK(CLK), // Clock input
.RSTA(RSTA), // Synchronous reset input for the A port
.RSTB(RSTB), // Synchronous reset input for the B port
.RSTP(RSTP) // Synchronous reset input for the P port
);
MUXCY
MUXCY
Primitive: 2-to-1 Multiplexer for Carry Logic with General Output
MUXCY implements a 1-bit high-speed carry propagate function. One such function
O
can be implemented per logic cell (LC), for a total of 8 bits per configurable logic block
S (CLB) for Spartan-3E.
MUXCY
0 1 The direct input (DI) of a slice is connected to the DI input of the MUXCY. The carry in
(CI) input of an LC is connected to the CI input of the MUXCY. The select input (S) of
DI CI the MUXCY is driven by the output of the lookup table (LUT) and configured as a
X8728 MUX function. The carry out (O) of the MUXCY reflects the state of the selected input
and implements the carry out function of each LC. When Low, S selects DI; when set
to High, S selects CI.
The variants, “MUXCY_D”and “MUXCY_L”provide additional types of outputs that
can be used by different timing models for more accurate pre-layout timing
estimation.
Inputs Outputs
S DI CI O
0 1 X 1
0 0 X 0
1 X 1 1
1 X 0 0
Usage
This design element can be instantiated and inferred.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
MUXCY_inst : MUXCY
port map (
O => O, -- Carry output signal
MUXCY
MUXCY MUXCY_inst (
.O(O), // Carry output signal
.CI(CI), // Carry input signal
.DI(DI), // Data input signal
.S(S) // MUX select, tie to '1' or LUT4 out
);
MUXCY_D
MUXCY_D
Primitive: 2-to-1 Multiplexer for Carry Logic with Dual Output
Inputs Outputs
S DI CI O LO
0 1 X 1 1
0 0 X 0 0
1 X 1 1 1
1 X 0 0 0
Usage
This design element can only be instantiated. Synthesis tools use the MUXCY
primitive, then MAP uses the MUXCY_D.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
MUXCY_D_inst : MUXCY_D
port map (
LO => LO, -- Carry local output signal
MUXCY_D
MUXCY_D MUXCY_D_inst (
.LO(LO), // Carry local output signal
.O(O), // Carry general output signal
.CI(CI), // Carry input signal
.DI(DI), // Data input signal
.S(S) // MUX select, tie to '1' or LUT4 out
);
MUXCY_L
MUXCY_L
Primitive: 2-to-1 Multiplexer for Carry Logic with Local Output
Inputs Outputs
S DI CI LO
0 1 X 1
0 0 X 0
1 X 1 1
1 X 0 0
Usage
This design element can only be instantiated. Synthesis tools use the MUXCY
primitive, then MAP uses the MUXCY_L.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
MUXCY_L_inst : MUXCY_L
port map (
LO => LO, -- Carry local output signal
CI => CI, -- Carry input signal
DI => DI, -- Data input signal
S => S -- MUX select, tie to '1' or LUT4 out
);
MUXCY_L
MUXCY_L MUXCY_L_inst (
.LO(LO), // Carry local output signal
.CI(CI), // Carry input signal
.DI(DI), // Data input signal
.S(S) // MUX select, tie to '1' or LUT4 out
);
MUXF5
MUXF5
Primitive: 2-to-1 Look-Up Table Multiplexer with General Output
Inputs Outputs
S I0 I1 O
0 1 X 1
0 0 X 0
1 X 1 1
1 X 0 0
Usage
This design element can be instantiated and inferred.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF5: Slice MUX to tie two LUT4's together with general output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF5_inst : MUXF5
port map (
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie directly to the output of LUT4)
I1 => I1, -- Input (tie directoy to the output of LUT4)
S => S -- Input select to MUX
);
MUXF5
// MUXF5: Slice MUX to tie two LUT4's together with general output
// For use with All FPGAs
// Xilinx HDL Libraries Guide Version 8.1i
MUXF5 MUXF5_inst (
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie directly to the output of LUT4)
.I1(I1), // Input (tie directoy to the output of LUT4)
.S(S) // Input select to MUX
);
MUXF5_D
MUXF5_D
Primitive: 2-to-1 Look-Up Table Multiplexer with Dual Output
Inputs Outputs
S I0 I1 O LO
0 1 X 1 1
0 0 X 0 0
1 X 1 1 1
1 X 0 0 0
Usage
This design element can only be instantiated. Synthesis tools use the MUXF5, then
MAP uses the MUXF5_D.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF5_D: Slice MUX to tie two LUT4's together with general and local outputs
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF5_D_inst : MUXF5_D
port map (
LO => LO, -- Ouptut of MUX to local routing
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie directly to the output of LUT4)
I1 => I1, -- Input (tie directoy to the output of LUT4)
S => S -- Input select to MUX
);
MUXF5_D
// MUXF5_D: Slice MUX to tie two LUT4's together with general and local outputs
// For use with All FPGAs
// Xilinx HDL Libraries Guide Version 8.1i
MUXF5_D MUXF5_D_inst (
.LO(LO), // Ouptut of MUX to local routing
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie directly to the output of LUT4)
.I1(I1), // Input (tie directoy to the output of LUT4)
.S(S) // Input select to MUX
);
MUXF5_L
MUXF5_L
Primitive: 2-to-1 Look-Up Table Multiplexer with Local Output
S The LO output is used to connect to other inputs within the same CLB slice.
X8433 See also “MUXF5”and “MUXF5_D”.
Inputs Output
S I0 I1 LO
0 1 X 1
0 0 X 0
1 X 1 1
1 X 0 0
Usage
This design element can only be instantiated. Synthesis tools use the MUXF5
primitive, then MAP uses the MUXF5_L.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF5_L: Slice MUX to tie two LUT4's together with local output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF5_L_inst : MUXF5_L
port map (
LO => LO, -- Output of MUX to local routing
I0 => I0, -- Input (tie directly to the output of LUT4)
I1 => I1, -- Input (tie directoy to the output of LUT4)
S => S -- Input select to MUX
);
MUXF5_L
// MUXF5_L: Slice MUX to tie two LUT4's together with local output
// For use with All FPGAs
// Xilinx HDL Libraries Guide Version 8.1i
MUXF5_L MUXF5_L_inst (
.LO(LO), // Output of MUX to local routing
.I0(I0), // Input (tie directly to the output of LUT4)
.I1(I1), // Input (tie directoy to the output of LUT4)
.S(S) // Input select to MUX
);
MUXF6
MUXF6
MUXF6 provides a multiplexer function in one half of a Spartan-3E CLB (two slices)
I0 for creating a function-of-6 lookup table or an 8-to-1 multiplexer in combination with
the associated four lookup tables and two MUXF5s. The local outputs (LO) from the
O two MUXF5s in the CLB are connected to the I0 and I1 inputs of the MUXF6. The S
I1
input is driven from any internal net. When Low, S selects I0. When High, S selects I1.
S
X8434 The variants, “MUXF6_D” and “MUXF6_L”, provide additional types of outputs that
can be used by different timing models for more accurate pre-layout timing
estimation.
Inputs Outputs
S I0 I1 O
0 1 X 1
0 0 X 0
1 X 1 1
1 X 0 0
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF6: CLB MUX to tie two MUXF5's together with general output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF6_inst : MUXF6
port map (
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie to MUXF5 LO out)
I1 => I1, -- Input (tie to MUXF5 LO out)
S => S -- Input select to MUX
);
MUXF6
// MUXF6: CLB MUX to tie two MUXF5's together with general output
// For use with All FPGAs
// Xilinx HDL Libraries Guide Version 8.1i
MUXF6 MUXF6_inst (
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie to MUXF5 LO out)
.I1(I1), // Input (tie to MUXF5 LO out)
.S(S) // Input select to MUX
);
MUXF6_D
MUXF6_D
Primitive: 2-to-1 Look-Up Table Multiplexer with Dual Output
Inputs Outputs
S I0 I1 O LO
0 1 X 1 1
0 0 X 0 0
1 X 1 1 1
1 X 0 0 0
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF6_D: CLB MUX to tie two MUXF5's together with general and local outputs
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF6_D_inst : MUXF6_D
port map (
LO => LO, -- Ouptut of MUX to local routing
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie to MUXF5 LO out)
I1 => I1, -- Input (tie to MUXF5 LO out)
S => S -- Input select to MUX
);
MUXF6_D
// MUXF6_D: CLB MUX to tie two MUXF5's together with general and local outputs
// For use with All FPGAs
// Xilinx HDL Libraries Guide Version 8.1i
MUXF6_D MUXF6_D_inst (
.LO(LO), // Ouptut of MUX to local routing
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie to MUXF5 LO out)
.I1(I1), // Input (tie to MUXF5 LO out)
.S(S) // Input select to MUX
);
MUXF6_L
MUXF6_L
Primitive: 2-to-1 Look-Up Table Multiplexer with Local Output
MUXF6_L provides a multiplexer function in half of a Spartan-3E CLB (two slices) for
creating a function-of-6 lookup table or an 8-to-1 multiplexer in combination with the
I0
LO associated four lookup tables and two MUXF5s. The local outputs (LO) from the two
MUXF5s in the CLB are connected to the I0 and I1 inputs of the MUXF6. The S input is
I1 driven from any internal net. When Low, S selects I0. When High, S selects I1.
S The LO output is used to connect to other inputs within the same CLB slice.
X8436 See also “MUXF6”and “MUXF6_D”.
Inputs Output
S I0 I1 LO
0 1 X 1
0 0 X 0
1 X 1 1
1 X 0 0
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF6_L: CLB MUX to tie two MUXF5's together with local output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF6_L_inst : MUXF6_L
port map (
LO => LO, -- Output of MUX to local routing
I0 => I0, -- Input (tie to MUXF5 LO out)
I1 => I1, -- Input (tie to MUXF5 LO out)
S => S -- Input select to MUX
);
MUXF6_L
// MUXF6_L: CLB MUX to tie two MUXF5's together with local output
// For use with All FPGAs
// Xilinx HDL Libraries Guide Version 8.1i
MUXF6_L MUXF6_L_inst (
.LO(LO), // Output of MUX to local routing
.I0(I0), // Input (tie to MUXF5 LO out)
.I1(I1), // Input (tie to MUXF5 LO out)
.S(S) // Input select to MUX
);
MUXF7
MUXF7
Primitive: 2-to-1 Look-Up Table Multiplexer with General Output
Inputs Outputs
S I0 I1 O
0 I0 X I0
1 X I1 I1
X 0 0 0
X 1 1 1
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF7: CLB MUX to tie two MUXF6's together with general output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF7_inst : MUXF7
port map (
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie to MUXF6 LO out)
I1 => I1, -- Input (tie to MUXF6 LO out)
S => S -- Input select to MUX
);
MUXF7
// MUXF7: CLB MUX to tie two MUXF6's together with general output
// For use with FPGA
// Xilinx HDL Libraries Guide Version 8.1i
MUXF7 MUXF7_inst (
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie to MUXF6 LO out)
.I1(I1), // Input (tie to MUXF6 LO out)
.S(S) // Input select to MUX
);
MUXF7_D
MUXF7_D
Primitive: 2-to-1 Look-Up Table Multiplexer with Dual Output
MUXF7_D provides a multiplexer function in a full Spartan-3E CLB (four slices) for
creating a function-of-7 lookup table or a 16-to-1 multiplexer in combination with the
I0
LO associated lookup tables. Local outputs (LO) of MUXF6 are connected to the I0 and I1
inputs of the MUXF7. The S input is driven from any internal net. When Low, S selects
O I0. When High, S selects I1.
I1
S Outputs O and LO are functionally identical. The O output is a general interconnect.
X8432 The LO output connects to other inputs within the same CLB slice.
See also “MUXF7”and “MUXF7_L”.
Inputs Outputs
S I0 I1 O LO
0 I0 X I0 I0
1 X I1 I1 I1
X 0 0 0 0
X 1 1 1 1
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF7_D: CLB MUX to tie two MUXF6's together with general and local outputs
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF7_D_inst : MUXF7_D
port map (
LO => LO, -- Ouptut of MUX to local routing
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie to MUXF6 LO out)
I1 => I1, -- Input (tie to MUXF6 LO out)
S => S -- Input select to MUX
);
MUXF7_D
// MUXF7_D: CLB MUX to tie two MUXF6's together with general and local outputs
// For use with FPGAs.
// Xilinx HDL Libraries Guide Version 8.1i
MUXF7_D MUXF7_D_inst (
.LO(LO), // Ouptut of MUX to local routing
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie to MUXF6 LO out)
.I1(I1), // Input (tie to MUXF6 LO out)
.S(S) // Input select to MUX
);
MUXF7_L
MUXF7_L
Primitive: 2-to-1 Look-Up Table Multiplexer with Local Output
MUXF7_L provides a multiplexer function in a full Spartan-3E CLB (four slices) for
I0 creating a function-of-7 lookup table or a 16-to-1 multiplexer in combination with the
LO associated lookup tables. Local outputs (LO) of MUXF6 are connected to the I0 and I1
inputs of the MUXF7. The S input is driven from any internal net. When Low, S selects
I1 I0. When High, S selects I1.
S The LO output is used to connect to other inputs within the same CLB slice.
X8433
See also “MUXF7”and “MUXF7_D”.
Inputs Output
S I0 I1 LO
0 I0 X I0
1 X I1 I1
X 0 0 0
X 1 1 1
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF7_L: CLB MUX to tie two MUXF6's together with local output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF7_L_inst : MUXF7_L
port map (
LO => LO, -- Output of MUX to local routing
I0 => I0, -- Input (tie to MUXF6 LO out)
I1 => I1, -- Input (tie to MUXF6 LO out)
S => S -- Input select to MUX
);
MUXF7_L
// MUXF7_L: CLB MUX to tie two MUXF6's together with local output
// For use with FPGAs.
// Xilinx HDL Libraries Guide Version 8.1i
MUXF7_L MUXF7_L_inst (
.LO(LO), // Output of MUX to local routing
.I0(I0), // Input (tie to MUXF6 LO out)
.I1(I1), // Input (tie to MUXF6 LO out)
.S(S) // Input select to MUX
);
MUXF8
MUXF8
Primitive: 2-to-1 Look-Up Table Multiplexer with General Output
S I0 I1 O
0 I0 X I0
1 X I1 I1
X 0 0 0
X 1 1 1
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF8: CLB MUX to tie two MUXF7's together with general output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF8_inst : MUXF8
port map (
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie to MUXF7 LO out)
I1 => I1, -- Input (tie to MUXF7 LO out)
S => S -- Input select to MUX
);
MUXF8
// MUXF8: CLB MUX to tie two MUXF7's together with general output
// For use with FPGAs.
// Xilinx HDL Libraries Guide Version 8.1i
MUXF8 MUXF8_inst (
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie to MUXF7 LO out)
.I1(I1), // Input (tie to MUXF7 LO out)
.S(S) // Input select to MUX
);
MUXF8_D
MUXF8_D
Primitive: 2-to-1 Look-Up Table Multiplexer with Dual Output
MUXF8_D provides a multiplexer function in two full Spartan-3E CLBs for creating a
function-of-8 lookup table or a 32-to-1 multiplexer in combination with the associated
I0
LO four lookup tables and two MUXF8s. Local outputs (LO) of MUXF7 are connected to
the I0 and I1 inputs of the MUXF8. The (S) input is driven from any internal net. When
O
I1 Low, (S) selects I0. When High, (S) selects I1.
S Outputs O and LO are functionally identical. The O output is a general interconnect.
X8435 The LO output is used to connect to other inputs within the same CLB slice.
See also “MUXF8”and “MUXF8_L”.
Inputs Outputs
S I0 I1 O LO
0 I0 X I0 I0
1 X I1 I1 I1
X 0 0 0 0
X 1 1 1 1
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF8_D: CLB MUX to tie two MUXF7's together with general and local outputs
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF8_D_inst : MUXF8_D
port map (
LO => LO, -- Ouptut of MUX to local routing
O => O, -- Output of MUX to general routing
I0 => I0, -- Input (tie to MUXF7 LO out)
I1 => I1, -- Input (tie to MUXF7 LO out)
S => S -- Input select to MUX
);
MUXF8_D
// MUXF8_D: CLB MUX to tie two MUXF7's together with general and local outputs
// For use with FPGAa,
// Xilinx HDL Libraries Guide Version 8.1i
MUXF8_D MUXF8_D_inst (
.LO(LO), // Ouptut of MUX to local routing
.O(O), // Output of MUX to general routing
.I0(I0), // Input (tie to MUXF7 LO out)
.I1(I1), // Input (tie to MUXF7 LO out)
.S(S) // Input select to MUX
);
MUXF8_L
MUXF8_L
Primitive: 2-to-1 Look-Up Table Multiplexer with Local Output
MUXF8_L provides a multiplexer function in two full Spartan-3E CLBs for creating a
function-of-8 lookup table or a 32-to-1 multiplexer in combination with the associated
I0
LO four lookup tables and two MUXF8s. Local outputs (LO) of MUXF7 are connected to
the I0 and I1 inputs of the MUXF8. The S input is driven from any internal net. When
I1 Low, S selects I0. When High, S selects I1.
S The LO output connects to other inputs within the same CLB slice.
X8436
See also “MUXF8”and “MUXF8_D”.
Inputs Output
S I0 I1 LO
0 I0 X I0
1 X I1 I1
X 0 0 0
X 1 1 1
Usage
This design element can only be instantiated.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- MUXF8_L: CLB MUX to tie two MUXF7's together with local output
-- Xilinx HDL Libraries Guide Version 8.1i
MUXF8_L_inst : MUXF8_L
port map (
LO => LO, -- Output of MUX to local routing
I0 => I0, -- Input (tie to MUXF7 LO out)
I1 => I1, -- Input (tie to MUXF7 LO out)
S => S -- Input select to MUX
);
MUXF8_L
// MUXF8_L: CLB MUX to tie two MUXF7's together with local output
// For use with FPGAs.
// Xilinx HDL Libraries Guide Version 8.1i
MUXF8_L MUXF8_L_inst (
.LO(LO), // Output of MUX to local routing
.I0(I0), // Input (tie to MUXF7 LO out)
.I1(I1), // Input (tie to MUXF7 LO out)
.S(S) // Input select to MUX
);
OBUF
OBUF
Primitive: Single-ended Output Buffers
Output buffers are necessary for all output signals because they isolate the internal
circuit and provide drive current for signals leaving a chip. The OBUF is a constantly
OBUF enabled output buffer that specifies a single-ended output when a 3-state is not
I O necessary for the output. The output (O) of an OBUF should be connected directly to
the top-level ouput port in the design.
X9445 Usage
OBUFs are optional for use in schematics because they are automatically inserted into
a design, if necessary. To manually add this component, however, the component
should be placed in the top-level schematic connecting the output directly to an
output port marker.
OBUFs are available in bundles of 4, 8, or 16 to make it easier for you to incorporate
them into your design without having to apply multiples of them one at a time. (The
bundles are identified as OBUF4, OBUF8, and OBUF16.)
Available Attributes
Attribute Type Allowed Values Default Description
DRIVE Integer 2, 4, 6, 8, 12, 16, 12 Sets the output drive in
24 mA.
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O
standard to an I/O
primitive.
SLEW String "SLOW", "FAST”, "SLOW” Sets the output rise and fall
and “QUIETIO” time.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
OBUF
OBUF_inst : OBUF
generic map (
DRIVE => 12,
IOSTANDARD => "DEFAULT",
SLEW => "SLOW")
port map (
O => O, -- Buffer output (connect directly to top-level port)
I => I -- Buffer input
);
OBUF #(
.DRIVE(12), // Specify the output drive strength
.IOSTANDARD("DEFAULT"), // Specify the output I/O standard
.SLEW("SLOW") // Specify the output slew rate
) OBUF_inst (
.O(O), // Buffer output (connect directly to top-level port)
.I(I) // Buffer input
);
OBUFDS
OBUFDS
Primitive: Differential Signaling Output Buffer with Selectable I/O
Interface
I O OB
0 0 1
1 1 0
Usage
This design element should be instantiated rather than inferred.
Available Attributes
Attribute Type Allowed Values Default Description
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O standard
to an I/O primitive.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
OBUFDS_inst : OBUFDS
generic map (
IOSTANDARD => "DEFAULT")
port map (
O => O, -- Diff_p output (connect directly to top-level port)
OB => OB, -- Diff_n output (connect directly to top-level port)
OBUFDS
OBUFDS #(
.IOSTANDARD("DEFAULT") // Specify the output I/O standard
) OBUFDS_inst (
.O(O), // Diff_p output (connect directly to top-level port)
.OB(OB), // Diff_n output (connect directly to top-level port)
.I(I) // Buffer input
);
OBUFT
OBUFT
Primitive: 3-State Output Buffer with Active-Low Output Enable
Output buffers are necessary for all output signals because they isolate the internal
OBUFT circuit and provide drive current for signals leaving a chip. The OBUFT is a 3-state
T output buffer with input I, output O, and active-Low output enables (T). When T is
I O Low, data on the inputs of the buffers is transferred to the corresponding outputs.
When T is High, the output is high impedance (off or Z state).
X9449 An OBUFT output should be connected directly to the top-level output or inout port.
OBUFTs are generally used when a single-ended output is needed with a 3-state
capability, such as the case when building bidirectional I/O.
Inputs Outputs
T I O
1 X Z
0 1 1
0 0 0
Usage
OBUFTs are generally inferred by the synthesis when an output port is specified to
have a high impedance, Z, as well as drive an output. It is generally suggested to
infer this element however if more control of the usage of this component is necessary,
it can be instantiated.
Available Attributes
Attribute Type Allowed Values Default Description
DRIVE Integer 2, 4, 6, 8, 12, 16, 24 12 Selects output drive
strength (mA) for the
SelectIO buffers that use
the LVTTL, LVCMOS12,
LVCMOS15, LVCMOS18,
LVCMOS25, or LVCMOS33
interface I/O standard.
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O
standard to an I/O
primitive.
SLEW String "SLOW" , "FAST”, "SLOW” Sets the output rise and fall
and “QUIETIO” time.
OBUFT
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
OBUFT_inst : OBUFT
generic map (
DRIVE => 12,
IOSTANDARD => "DEFAULT",
SLEW => "SLOW")
port map (
O => O, -- Buffer output (connect directly to top-level port)
I => I, -- Buffer input
T => T -- 3-state enable input
);
OBUFT #(
.DRIVE(12), // Specify the output drive strength
.IOSTANDARD("DEFAULT"), // Specify the output I/O standard
.SLEW("SLOW") // Specify the output slew rate
) OBUFT_inst (
.O(O), // Buffer output (connect directly to top-level port)
.I(I), // Buffer input
.T(T) // 3-state enable input
);
OBUFTDS
OBUFTDS
Primitive: 3-State Differential Signaling Output Buffer with Active Low
Output Enable and Selectable I/O Interface
OBUFTDS is a single 3-state, differential signaling output buffer with active Low
T
enable and a Select I/O interface.
O
I
OB
When T is Low, data on the input of the buffer is transferred to the output (O) and
inverted output (OB). When T is High, both outputs are high impedance (off or Z
OBUFTDS state).
X9260
Inputs Outputs
I T O OB
X 1 Z Z
0 0 0 1
1 0 1 0
Usage
This design element is available for instantiation only.
Available Attributes
Attribute Type Allowed Values Default Description
DRIVE Integer 2, 4, 6, 8, 12, 16, 12 Selects output drive strength
24 (mA) for the SelectIO buffers
that use the LVTTL,
LVCMOS12, LVCMOS15,
LVCMOS18, LVCMOS25, or
LVCMOS33 interface I/O
standard.
IOSTANDARD String "DEFAULT” "DEFAULT” Use to assign an I/O standard
to an I/O primitive.
SLEW String "SLOW" or "SLOW” Sets the output rise and fall
"FAST” time.
OBUFTDS_inst : OBUFTDS
-- Edit the following generics to specify the I/O standard, drive and slew rate.
generic map (
DRIVE => 12,
IOSTANDARD => "LVDS_25",
SLEW => "SLOW")
port map (
O => O, -- Diff_p output (connect directly to top-level port)
OB => OB, -- Diff_n output (connect directly to top-level port)
I => I, -- Buffer input
T => T -- 3-state enable input
);
OBUFTDS
ODDR2
ODDR2
Primitive: Double Data Rate Output D Flip-Flop with Optional Data
Alignment, Clock Enable and Programmable Synchronous or
Asynchronous Set/Reset
The ODDR2 is an output double data rate (DDR) register useful in producing double
data-rate signals exiting the FPGA. The ODDR2 requires two clocks to be connected
ODDR2
D0
to the component, C0 and C1, so that data is provided at the positive edge of both C0
D1 Q
C0
and C1 clocks. The ODDR2 features an active high clock enable port, CE, which can
C1
be used to suspend the operation of the registers and both set and reset ports that can
CE be configured to be synchronous or asynchronous to the respective clocks. The
R ODDR2 has an optional alignment feature, which allows data to be captured by a
S
single clock yet clocked out by two clocks.
X10236
Usage
The ODDR2 must be instantiated to be incorporated into a design. To change the
default behavior of the ODDR2, attributes can be modified via the generic map
(VHDL) or named parameter value assignment (Verilog) as a part of the instantiated
component. The ODDR2 can be either connected directly to a top-level output port in
the design where an appropriate output buffer can be inferred or to an instantiated
OBUF, IOBUF, OBUFDS, OBUFTDS or IOBUFDS. All inputs and outputs of this
component should either be connected or properly tied off.
Available Attributes
Attribute Type Allowed Values Default Description
DDR_ String "NONE", "C0" or "NONE” Sets output alignment to
ALIGNMENT "C1” "NONE", "C0" or "C1."
INIT Integer 0 or 1 0 Sets initial state of the Q0
output to 0 or 1.
SRTYPE String "SYNC" or "SYNC” Specifies "SYNC" or
"ASYNC” "ASYNC" set/reset.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
ODDR2
-- ODDR2: Output Double Data Rate Output Register with Set, Reset
-- and Clock Enable. Spartan-3E
-- Xilinx HDL Libraries Guide version 8.1i
ODDR2_inst : ODDR2
generic map(
DDR_ALIGNMENT => "NONE", -- Sets output alignment to "NONE", "C0", "C1"
INIT => '0', -- Sets initial state of the Q output to '0' or '1'
SRTYPE => "SYNC") -- Specifies "SYNC" or "ASYNC" set/reset
port map (
Q => Q, -- 1-bit output data
C0 => C0, -- 1-bit clock input
C1 => C1, -- 1-bit clock input
CE => CE, -- 1-bit clock enable input
D0 => D0, -- 1-bit data input (associated with C0)
D1 => D1, -- 1-bit data input (associated with C1)
R => R, -- 1-bit reset input
S => S -- 1-bit set input
);
// ODDR2: Output Double Data Rate Output Register with Set, Reset
// and Clock Enable. Spartan-3E
// Xilinx HDL Libraries Guide Version 8.1i
ODDR2 #(
.DDR_ALIGNMENT("NONE"), // Sets output alignment to "NONE", "C0" or "C1"
.INIT(1'b0), // Sets initial state of the Q output to 1'b0 or 1'b1
.SRTYPE("SYNC") // Specifies "SYNC" or "ASYNC" set/reset
) ODDR2_inst (
.Q(Q), // 1-bit DDR output data
.C0(C0), // 1-bit clock input
.C1(C1), // 1-bit clock input
.CE(CE), // 1-bit clock enable input
.D0(D0), // 1-bit data input (associated with C0)
.D1(D1), // 1-bit data input (associated with C1)
.R(R), // 1-bit reset input
.S(S) // 1-bit set input
);
PULLDOWN
PULLDOWN
Primitive: Resistor to GND
Usage
This design element is instantiated rather than inferred.
X3860
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
PULLDOWN_inst : PULLDOWN
port map (
O => O -- Pulldown output (connect directly to top-level port)
);
PULLDOWN PULLDOWN_inst (
.O(O), // Pulldown output (connect directly to top-level port)
);
PULLDOWN
PULLUP
PULLUP
Primitive: Resistor to VCC, Open-Drain, and 3-State Outputs
The pull-up elements establish a High logic level for open-drain elements and macros
when all the drivers are off.
Usage
X3861 This design element is instantiated rather than inferred.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
PULLUP_inst : PULLUP
port map (
O => O -- Pullup output (connect directly to top-level port)
);
PULLUP PULLUP_inst (
.O(O), // Pullup output (connect directly to top-level port)
);
PULLUP
RAM16X1D
RAM16X1D
Primitive: 16-Deep by 1-Wide Static Dual Port Synchronous RAM
RAM16X1D is a 16-word by 1-bit static dual port random access memory with
synchronous write capability. The device has two separate address ports: the read
WE RAM16X1D SPO address (DPRA3 – DPRA0) and the write address (A3 – A0). These two address ports
D are completely asynchronous. The read address controls the location of the data
WCLK DPO driven out of the output pin (DPO), and the write address controls the destination of a
A0 valid write transaction.
A1 When the write enable (WE) is Low, transitions on the write clock (WCLK) are
A2 ignored and data stored in the RAM is not affected. When WE is High, any positive
transition on WCLK loads the data on the data input (D) into the word selected by the
A3
4-bit write address. For predictable performance, write address and data inputs must
DPRA0 be stable before a Low-to-High WCLK transition. This RAM block assumes an active-
DPRA1 High WCLK. WCLK can be active-High or active-Low. Any inverter placed on the
DPRA2 WCLK input net is absorbed into the block.
DPRA3 Mode selection is shown in the following truth table.
Inputs Outputs
X4950
WE (mode) WCLK D SPO DPO
0 (read) X X data_a data_d
1 (read) 0 X data_a data_d
1 (read) 1 X data_a data_d
1 (write) ↑ D D data_d
1 (read) ↓ X data_a data_d
data_a = word addressed by bits A3-A0
data_d = word addressed by bits DPRA3-DPRA0
The SPO output reflects the data in the memory cell addressed by A3 – A0. The DPO
output reflects the data in the memory cell addressed by DPRA3 – DPRA0.
Note: The write process is not affected by the address on the read address port.
Usage
This design element can be inferred or instantiated. The instantiation code is shown
below. For information on how to infer RAM, see the XST User Guide.
RAM16X1D
Available Attributes
Attribute Type Allowed Values Default Description
INIT 16-Bit 16-Bit Hexadecimal All zeros Initializes ROMs, RAMs,
Hexadeci registers, and look-up
mal tables.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
RAM16X1D_inst : RAM16X1D
generic map (
INIT => X"0000")
port map (
DPO => DPO, -- Port A 1-bit data output
SPO => SPO, -- Port B 1-bit data output
A0 => A0, -- Port A address[0] input bit
A1 => A1, -- Port A address[1] input bit
A2 => A2, -- Port A address[2] input bit
A3 => A3, -- Port A address[3] input bit
D => D, -- Port A 1-bit data input
DPRA0 => DPRA0, -- Port B address[0] input bit
DPRA1 => DPRA1, -- Port B address[1] input bit
DPRA2 => DPRA2, -- Port B address[2] input bit
DPRA3 => DPRA3, -- Port B address[3] input bit
WCLK => WCLK, -- Port A write clock input
WE => WE -- Port A write enable input
);
RAM16X1D
RAM16X1D #(
.INIT(16'h0000) // Initial contents of RAM
) RAM16X1D_inst (
.DPO(DPO), // Port A 1-bit data output
.SPO(SPO), // Port B 1-bit data output
.A0(A0), // Port A address[0] input bit
.A1(A1), // Port A address[1] input bit
.A2(A2), // Port A address[2] input bit
.A3(A3), // Port A address[3] input bit
.D(D), // Port A 1-bit data input
.DPRA0(DPRA0), // Port B address[0] input bit
.DPRA1(DPRA1), // Port B address[1] input bit
.DPRA2(DPRA2), // Port B address[2] input bit
.DPRA3(DPRA3), // Port B address[3] input bit
.WCLK(WCLK), // Port A write clock input
.WE(WE) // Port A write enable input
);
RAM16X1D
RAM16X1S
RAM16X1S
Primitive: 16-Deep by 1-Wide Static Synchronous RAM
Inputs Outputs
WE(mode) WCLK D O
0 (read) X X Data
1 (read) 0 X Data
1 (read) 1 X Data
1 (write) ↑ D D
1 (read) ↓ X Data
Data = word addressed by bits A3 – A0
Usage
This design element can be inferred or instantiated. The instantiation code is shown
below. For information on how to infer RAM, see the XST User Guide.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Hexadeci Any 16-bit value. All zeros Specifies initial contents of
mal the RAM.
RAM16X1S
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
RAM16X1S_inst : RAM16X1S
generic map (
INIT => X"0000")
port map (
O => O, -- RAM output
A0 => A0, -- RAM address[0] input
A1 => A1, -- RAM address[1] input
A2 => A2, -- RAM address[2] input
A3 => A3, -- RAM address[3] input
D => D, -- RAM data input
WCLK => WCLK, -- Write clock input
WE => WE -- Write enable input
);
RAM16X1S #(
.INIT(16'h0000) // Initial contents of RAM
) RAM16X1S_inst (
.O(O), // RAM output
.A0(A0), // RAM address[0] input
.A1(A1), // RAM address[1] input
.A2(A2), // RAM address[2] input
.A3(A3), // RAM address[3] input
.D(D), // RAM data input
.WCLK(WCLK), // Write clock input
.WE(WE) // Write enable input
);
RAM32X1D
RAM32X1D
Primitive: 32-Deep by 1-Wide Static Dual Static Port Synchronous RAM
RAM32X1D is a 32-word by 1-bit static dual port random access memory with
WE RAM32x1D
D SPO
synchronous write capability. The device has two separate address ports: the read
WCLK address (DPRA4 – DPRA0) and the write address (A4 – A0). These two address ports
A0 DPO are completely asynchronous. The read address controls the location of the data
A1 driven out of the output pin (DPO), and the write address controls the destination of a
A2
valid write transaction.
A3
A4 When the write enable (WE) is Low, transitions on the write clock (WCLK) are
DPRA0
DPRA1
ignored and data stored in the RAM is not affected. When WE is High, any positive
DPRA2 transition on WCLK loads the data on the data input (D) into the word selected by the
DPRA3 5-bit write address. For predictable performance, write address and data inputs must
DPRA4 be stable before a Low-to-High WCLK transition. This RAM block assumes an active-
X9261
High WCLK. WCLK can be active-High or active-Low. Any inverter placed on the
WCLK input net is absorbed into the block.
You can initialize RAM32X1D during configuration using the INIT attribute. See
“Specifying Initial Contents of a RAM” in the RAM16X1D section.
Mode selection is shown in the following truth table.
Inputs Outputs
The SPO output reflects the data in the memory cell addressed by A4 – A0. The DPO
output reflects the data in the memory cell addressed by DPRA4 – DPRA0.
Note: The write process is not affected by the address on the read address port.
Usage
This design element can be inferred or instantiated. The instantiation code is shown
below. For information on how to infer RAM, see the XST User Guide.
Available Attributes
Allowed
Attribute Type Default Description
Values
INIT 32-Bit 32-Bit All zeros Initializes ROMs,
Hexadeci Hexadecimal RAMs, registers, and
mal look-up tables.
RAM32X1D
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
RAM32X1D_inst : RAM32X1D
generic map (
INIT => X"00000000")
port map (
DPO => DPO, -- Port A 1-bit data output
SPO => SPO, -- Port B 1-bit data output
A0 => A0, -- Port A address[0] input bit
A1 => A1, -- Port A address[1] input bit
A2 => A2, -- Port A address[2] input bit
A3 => A3, -- Port A address[3] input bit
A4 => A4, -- Port A address[4] input bit
D => D, -- Port A 1-bit data input
DPRA0 => DPRA0, -- Port B address[0] input bit
DPRA1 => DPRA1, -- Port B address[1] input bit
DPRA2 => DPRA2, -- Port B address[2] input bit
DPRA3 => DPRA3, -- Port B address[3] input bit
DPRA4 => DPRA4, -- Port B address[4] input bit
WCLK => WCLK, -- Port A write clock input
WE => WE -- Port A write enable input
);
RAM32X1D #(
.INIT(32'h00000000) // Initial contents of RAM
) RAM32X1D_inst (
.DPO(DPO), // Port A 1-bit data output
.SPO(SPO), // Port B 1-bit data output
.A0(A0), // Port A address[0] input bit
.A1(A1), // Port A address[1] input bit
.A2(A2), // Port A address[2] input bit
.A3(A3), // Port A address[3] input bit
.A4(A4), // Port A address[4] input bit
RAM32X1D
RAM32X1D
RAM32X1S
RAM32X1S
Primitive: 32-Deep by 1-Wide Static Synchronous RAM
Inputs Outputs
WE (mode) WCLK D O
0 (read) X X Data
1 (read) 0 X Data
1 (read) 1 X Data
1 (write) ↑ D D
1 (read) ↓ X Data
Data = word addressed by bits A4 – A0
Usage
This design element can be inferred or instantiated. The instantiation code is shown
below. For information on how to infer RAM, see the XST User Guide.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Hexa- Any 32-bit value. All zeros Specifies initial contents of
decimal the RAM.
RAM32X1S
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
RAM32X1S_inst : RAM32X1S
generic map (
INIT => X"00000000")
port map (
O => O, -- RAM output
A0 => A0, -- RAM address[0] input
A1 => A1, -- RAM address[1] input
A2 => A2, -- RAM address[2] input
A3 => A3, -- RAM address[3] input
A4 => A4, -- RAM address[4] input
D => D, -- RAM data input
WCLK => WCLK, -- Write clock input
WE => WE -- Write enable input
);
RAM32X1S #(
.INIT(32'h00000000) // Initial contents of RAM
) RAM32X1S_inst (
.O(O), // RAM output
.A0(A0), // RAM address[0] input
.A1(A1), // RAM address[1] input
.A2(A2), // RAM address[2] input
.A3(A3), // RAM address[3] input
.A4(A4), // RAM address[4] input
.D(D), // RAM data input
.WCLK(WCLK), // Write clock input
.WE(WE) // Write enable input
);
RAM64X1S
RAM64X1S
Primitive: 64-Deep by 1-Wide Static Synchronous RAM
X9265
The signal output on the data output pin (O) is the data that is stored in the RAM at
the location defined by the values on the address pins.
You can initialize RAM64X1S during configuration using the INIT attribute. See
“Specifying Initial Contents of a RAM” in the RAM16X1D section.
Mode selection is shown in the following truth table.
Inputs Outputs
WE (mode) WCLK D O
0 (read) X X Data
1 (read) 0 X Data
1 (read) 1 X Data
1 (write) ↑ D D
1 (read) ↓ X Data
Data = word addressed by bits A5 – A0
Usage
This design element can be inferred or instantiated. The instantiation code is shown
below. For information on how to infer RAM, see the XST User Guide.
Available Attributes
Attribute Type Allowed Values Default Description
INIT 64-Bit 64-Bit Hexadecimal All zeros Initializes ROMs, RAMs,
Hexa- registers, and look-up
decimal tables.
RAM64X1S
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
RAM64X1S_inst : RAM64X1S
generic map (
INIT => X"0000000000000000")
port map (
O => O, -- 1-bit data output
A0 => A0, -- Address[0] input bit
A1 => A1, -- Address[1] input bit
A2 => A2, -- Address[2] input bit
A3 => A3, -- Address[3] input bit
A4 => A4, -- Address[4] input bit
A5 => A5, -- Address[5] input bit
D => D, -- 1-bit data input
WCLK => WCLK, -- Write clock input
WE => WE -- Write enable input
);
RAM64X1S #(
.INIT(64'h0000000000000000) // Initial contents of RAM
) RAM64X1S_inst (
.O(O), // 1-bit data output
.A0(A0), // Address[0] input bit
.A1(A1), // Address[1] input bit
.A2(A2), // Address[2] input bit
.A3(A3), // Address[3] input bit
.A4(A4), // Address[4] input bit
.A5(A5), // Address[5] input bit
.D(D), // 1-bit data input
.WCLK(WCLK), // Write clock input
.WE(WE) // Write enable input
);
RAM128X1S
RAM128X1S
Primitive: 128-Deep by 1-Wide Static Synchronous RAM
Inputs Outputs
WE (mode) WCLK D O
0 (read) X X Data
1 (read) 0 X Data
1 (read) 1 X Data
1 (write) ↑ D D
1 (read) ↓ X Data
Data = word addressed by bits A6 – A0
Usage
Below are example templates for instantiating this component into a design. These
templates can be cut and pasteddirectly into the user’s source code.
Available Attributes
Attribute Type Allowed Values Default Description
INIT 128-Bit 128-Bit Hexadecimal All zeros Initializes ROMs, RAMs,
Hexadeci registers, and look-up
mal tables.
RAM128X1S
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- RAM128X1S: 128 x 1 positive edge write, asynchronous read single-port distributed RAM
-- FPGAs.
-- Xilinx HDL Libraries Guide version 8.1i
RAM128X1S_inst : RAM128X1S
generic map (
INIT => X"00000000000000000000000000000000")
port map (
O => O, -- 1-bit data output
A0 => A0, -- Address[0] input bit
A1 => A1, -- Address[1] input bit
A2 => A2, -- Address[2] input bit
A3 => A3, -- Address[3] input bit
A4 => A4, -- Address[4] input bit
A5 => A5, -- Address[5] input bit
A6 => A6, -- Address[6] input bit
D => D, -- 1-bit data input
WCLK => WCLK, -- Write clock input
WE => WE -- Write enable input
);
// RAM128X1S: 128 x 1 positive edge write, asynchronous read single-port distributed RAM
// FPGAs.
// Xilinx HDL Libraries Guide Version 8.1i
RAM128X1S #(
.INIT(128'h00000000000000000000000000000000) // Initial contents of RAM
) RAM128X1S_inst (
.O(O), // 1-bit data output
.A0(A0), // Address[0] input bit
.A1(A1), // Address[1] input bit
.A2(A2), // Address[2] input bit
.A3(A3), // Address[3] input bit
.A4(A4), // Address[4] input bit
.A5(A5), // Address[5] input bit
.A6(A6), // Address[6] input bit
.D(D), // 1-bit data input
.WCLK(WCLK), // Write clock input
.WE(WE) // Write enable input
);
RAMB16_Sm_Sn
RAMB16_Sm_Sn
Primitive: 16384-Bit Data Memory and 2048-Bit Parity Memory, Dual-
Port Synchronous Block RAM with Port Width (m or n) Configured to 1,
2, 4, 9, 18, or 36 Bits
X9466
RAMB16_Sm_Sn
WEA RAMB16_S2_S9
WEB
ENB
WEB WEB
ENB ENB SSRB DOPB [0:0]
CLKB
SSRB DOB [1:0] SSRB DOB [3:0] DOB [7:0]
ADDRB [10:0]
CLKB CLKB
ADDRB [12:0] ADDRB [11:0] DIB [7:0]
DIA [3:0]
WEB WEB
ENB ENB
WEB
SSRB DOPB [1:0] SSRB DOPB [3:0] ENB
CLKB CLKB
DOB [15:0] DOB [31:0] SSRB DOB [3:0]
ADDRB [9:0] ADDRB [8:0]
CLKB
DIB [15:0] DIB [31:0] ADDRB [11:0]
X9467
RAMB16_Sm_Sn
X9468
RAMB16_Sm_Sn
independently configured to a specific data width. The possible port and cell
configurations are listed in the following table.
Port A Port B
Data Cellsa Parity Address Data Bus Parity Data Cellsa Parity Address Data Bus Parity
Component
Cellsa Bus Bus Cellsa Bus Bus
RAMB16_S1_ 16384 x 1 - (13:0) (0:0) - 16384 x 1 - (13:0) (0:0) -
S1
RAMB16_S1_ 16384 x 1 - (13:0) (0:0) - 8192 x 2 - (12:0) (1:0) -
S2
RAMB16_S1_ 16384 x 1 - (13:0) (0:0) - 4096 x 4 - (11:0) (3:0) -
S4
RAMB16_S1_ 16384 x 1 - (13:0) (0:0) - 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)
S9
RAMB16_S1_ 16384 x 1 - (13:0) (0:0) - 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)
S18
RAMB16_S1_ 16384 x 1 - (13:0) (0:0) - 512 x 32 512 x 4 (8:0) (31:0) (3:0)
S36
RAMB16_S2_ 8192 x 2 - (12:0) (1:0) - 8192 x 2 - (12:0) (1:0) -
S2
RAMB16_S2_ 8192 x 2 - (12:0) (1:0) - 4096 x 4 - (11:0) (3:0) -
S4
RAMB16_S2_ 8192 x 2 - (12:0) (1:0) - 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)
S9
RAMB16_S2_ 8192 x 2 - (12:0) (1:0) - 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)
S18
RAMB16_S2_ 8192 x 2 - (12:0) (1:0) - 512 x 32 512 x 4 (8:0) (31:0) (3:0)
S36
RAMB16_S4_ 4096 x 4 - (11:0) (3:0) - 4096 x 4 - (11:0) (3:0) -
S4
RAMB16_S4_ 4096 x 4 - (11:0) (3:0) - 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)
S9
RAMB16_S4_ 4096 x 4 - (11:0) (3:0) - 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)
S18
RAMB16_S4_ 4096 x 4 - (11:0) (3:0) - 512 x 32 512 x 4 (8:0) (31:0) (3:0)
S36
RAMB16_S9_ 2048 x 8 2048 x 1 (10:0) (7:0) (0:0) 2048 x 8 2048 x 1 (10:0) (7:0) (0:0)
S9
RAMB16_S9_ 2048 x 8 2048 x 1 (10:0) (7:0) (0:0) 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)
S18
RAMB16_S9_ 2048 x 8 2048 x 1 (10:0) (7:0) (0:0) 512 x 32 512 x 4 (8:0) (31:0) (3:0)
S36
RAMB16_S18 1024 x 16 1024 x 2 (9:0) (15:0) (1:0) 1024 x 16 1024 x 2 (9:0) (15:0) (1:0)
_S18
RAMB16_S18 1024 x 16 1024 x 2 (9:0) (15:0) (1:0) 512 x 32 512 x 4 (8:0) (31:0) (3:0)
_S36
RAMB16_Sm_Sn
Port A Port B
RAMB16_S36 512 x 32 512 x 4 (8:0) (31:0) (3:0) 512 x 32 512 x 4 (8:0) (31:0) (3:0)
_S36
aDepth x Width
Each port is fully synchronous with independent clock pins. All port A input pins
have setup time referenced to the CLKA pin and its data output bus DOA has a clock-
to-out time referenced to the CLKA. All port B input pins have setup time referenced
to the CLKB pin and its data output bus DOB has a clock-to-out time referenced to the
CLKB.
The enable ENA pin controls read, write, and reset for port A. When ENA is Low, no
data is written and the outputs (DOA and DOPA) retain the last state. When ENA is
High and reset (SSRA) is High, DOA and DOPA are set to SRVAL_A during the Low-
to-High clock (CLKA) transition; if write enable (WEA) is High, the memory contents
reflect the data at DIA and DIPA. When ENA is High and WEA is Low, the data stored
in the RAM address (ADDRA) is read during the Low-to-High clock transition. By
default, WRITE_MODE_A=WRITE_FIRST, when ENA and WEA are High, the data
on the data inputs (DIA and DIPA) is loaded into the word selected by the write
address (ADDRA) during the Low-to-High clock transition and the data outputs
(DOA and DOPA) reflect the selected (addressed) word.
The enable ENB pin controls read, write, and reset for port B. When ENB is Low, no
data is written and the outputs (DOB and DOPB) retain the last state. When ENB is
High and reset (SSRB) is High, DOB and DOPB are set to SRVAL_B during the Low-
to-High clock (CLKB) transition; if write enable (WEB) is High, the memory contents
reflect the data at DIB and DIPB. When ENB is High and WEB is Low, the data stored
in the RAM address (ADDRB) is read during the Low-to-High clock transition. By
default, WRITE_MODE_B=WRITE_FIRST, when ENB and WEB are High, the data on
the data inputs (DIB and PB) are loaded into the word selected by the write address
(ADDRB) during the Low-to-High clock transition and the data outputs (DOB and
DOPB) reflect the selected (addressed) word.
The above descriptions assume active High control pins (ENA, WEA, SSRA, CLKA,
ENB, WEB, SSRB, and CLKB). However, the active level can be changed by placing an
inverter on the port. Any inverter placed on a RAMB16 port is absorbed into the block
and does not use a CLB resource.
Port A Truth Table
Inputs Outputs
ADD
GSR ENA SSRA WEA CLKA DIA DIPA DOA DOPA RAM Contents
RA
Data RAM Parity RAM
1 X X X X X X X INIT_A INIT_A No Chg No Chg
0 0 X X X X X X No Chg No Chg No Chg No Chg
0 1 1 0 ↑ X X X SRVAL_A SRVAL_A No Chg No Chg
0 1 1 1 ↑ addr data pdata SRVAL_A SRVAL_A RAM(addr) RAM(addr)
=>data =>pdata
0 1 0 0 ↑ addr X X RAM(addr) RAM(addr) No Chg No Chg
RAMB16_Sm_Sn
Inputs Outputs
ADD
GSR ENA SSRA WEA CLKA DIA DIPA DOA DOPA RAM Contents
RA
0 1 0 1 ↑ addr data pdata No Chg1 No Chg1 RAM(addr) RAM(addr)
RAM RAM(addr) =>data =>pdata
(addr)2 2
data3 pdata3
GSR=Global Set Reset
INIT_A=Value specified by the INIT_A attribute for output register. Default is all zeros.
SRVAL_A=register value
addr=RAM address
RAM(addr)=RAM contents at address ADDR
data=RAM input data
pdata=RAM parity data
1WRITE_MODE_A=NO_CHANGE
2WRITE_MODE_A=READ_FIRST
3WRITE_MODE_A=WRITE_FIRST
Inputs Outputs
GSR ENB SSRB WEB CLKB ADDRB DIB DIPB DOB DOPB RAM Contents
Data RAM Parity RAM
1 X X X X X X X INIT_B INIT_B No Chg No Chg
0 0 X X X X X X No Chg No Chg No Chg No Chg
0 1 1 0 ↑ X X X SRVAL_B SRVAL_B No Chg No Chg
0 1 1 1 ↑ addr data pdata SRVAL_B SRVAL_B RAM(addr) RAM(addr)
=>data =>pdata
0 1 0 0 ↑ addr X X RAM(add RAM(add No Chg No Chg
r) r)
RAMB16_Sm_Sn
Inputs Outputs
GSR ENB SSRB WEB CLKB ADDRB DIB DIPB DOB DOPB RAM Contents
0 1 0 1 ↑ addr data pdata No Chg1 No Chg1 RAM(addr) RAM(addr)
RAM RAM(add =>data =>pdata
(addr)2 r)2
data3 pdata3
GSR=Global Set Reset
INIT_B=Value specified by the INIT_B attribute for output registers. Default is all zeros.
SRVAL_B=register value
addr=RAM address
RAM(addr)=RAM contents at address ADDR
data=RAM input data
pdata=RAM parity data
1WRITE_MODE_B=NO_CHANGE
2WRITE_MODE_B=READ_FIRST
3WRITE_MODE_B=WRITE_FIRST
Address Mapping
Each port accesses the same set of 18432 memory cells using an addressing scheme
that is dependent on the width of the port. For all port widths, 16384 memory cells are
available for data as shown in the “Port Address Mapping for Data” table below. For
9-, 18-, and 36-bit wide ports, 2408 parity memory cells are also available as shown in
“Port Address Mapping for Parity” table below. The physical RAM location that is
addressed for a particular width is determined from the following formula.
Start=((ADDR port+1)*(Widthport)) -1
End=(ADDRport)*(Widthport)
The following tables shows address mapping for each port width.
Data
Port Data Addresses
Width
1 16384 <-- 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
2 8192 <-- 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
4 4096 <-- 07 06 05 04 03 02 01 00
8 2048 <-- 03 02 01 00
16 1024 <-- 01 00
32 512 <-- 00
RAMB16_Sm_Sn
RAMB16_Sm_Sn
Data Parity
WEA WEB CLKA CLKB DIA DIB DIPA DIPB DOA DOB DOPA DOPB
RAM Ram
0 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM No Chg No Chg
1 0 ↑ ↑ DIA DIB DIPA DIPB No Chg X No Chg X DIA DIPA
0 1 ↑ ↑ DIA DIB DIPA DIPB X No Chg X No Chg DIB DIPB
1 1 ↑ ↑ DIA DIB DIPA DIPB No Chg No Chg No Chg No Chg X X
Data Parity
WEA WEB CLKA CLKB DIA DIB DIPA DIPB DOA DOB DOPA DOPB
RAM Ram
0 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM No Chg No Chg
1 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM DIA DIPA
0 1 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM DIB DIPB
1 1 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM X X
Data Parity
WEA WEB CLKA CLKB DIA DIB DIPA DIPB DOA DOB DOPA DOPB
RAM Ram
0 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM No Chg No Chg
1 0 ↑ ↑ DIA DIB DIPA DIPB DIA X DIPA X DIA DIPA
RAMB16_Sm_Sn
Data Parity
WEA WEB CLKA CLKB DIA DIB DIPA DIPB DOA DOB DOPA DOPB
RAM Ram
0 1 ↑ ↑ DIA DIB DIPA DIPB X DIB X DIPB DIB DIPB
1 1 ↑ ↑ DIA DIB DIPA DIPB X X X X X X
Data Parity
WEA WEB CLKA CLKB DIA DIB DIPA DIPB DOA DOB DOPA DOPB
RAM Ram
0 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM No Chg No Chg
1 0 ↑ ↑ DIA DIB DIPA DIPB No Chg X No Chg X DIA DIPA
0 1 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM DIB DIPB
1 1 ↑ ↑ DIA DIB DIPA DIPB No Chg X No Chg X DIB DIPB
Data Parity
WEA WEB CLKA CLKB DIA DIB DIPA DIPB DOA DOB DOPA DOPB
RAM Ram
0 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM No Chg No Chg
1 0 ↑ ↑ DIA DIB DIPA DIPB No Chg X No Chg X DIA DIPA
0 1 ↑ ↑ DIA DIB DIPA DIPB X DIB X DIPB DIB DIPB
1 1 ↑ ↑ DIA DIB DIPA DIPB No Chg X No Chg X X X
Data Parity
WEA WEB CLKA CLKB DIA DIB DIPA DIPB DOA DOB DOPA DOPB
RAM Ram
0 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM No Chg No Chg
1 0 ↑ ↑ DIA DIB DIPA DIPB RAM RAM RAM RAM DIA DIPA
0 1 ↑ ↑ DIA DIB DIPA DIPB X DIB X DIPB DIB DIPB
1 1 ↑ ↑ DIA DIB DIPA DIPB X DIB X DIPB DIA DIPA
Usage
These design elements can be inferred or instantiated. The instantiation code is shown
below. For information on how to infer RAM, see the XST User Guide.
RAMB16_Sm_Sn
Available Attributes
Allowed
Attribute Type Default Description
Values
INIT_00 To Binary/Hex- Any All zeros Specifies the initial contents of
INIT_3F adecimal the data portion of the RAM
array.
INIT_A Binary/Hex- Any All zeros Identifies the initial value of the
adecimal DOA/DOB output port after
completing configuration. For
Type, the bit width is dependent
on the width of the A or B port
of the RAM.
INIT_B Binary/Hex- Any All zeros Identifies the initial value of the
adecimal DOA/DOB output port after
completing configuration. For
Type, the bit width is dependent
on the width of the A or B port
of the RAM.
INITP_00 To Binary/Hex- Any All zeros Specifies the initial contents of
INITP_07 adecimal the parity portion of the RAM
array.
SIM_ String ¨ALL”, ¨ALL” Specifies the behavior during
COLLISION_ ¨NONE”, simulation in the event of a data
CHECK ¨WARNING” collision (data being read or
, or written to the same address from
¨GENERATE both ports of the Ram
_X_ONLY” simultaneously. "ALL" issues a
warning to simulator console
and generate an X or all
unknown data due to the
collision. This is the
recommended setting.
"WARNING" generates a
warning only and
"GENERATE_X_ONLY"
generates an X for unknown
data but won’t output the
occurrence to the simulation
console. "NONE" completely
ignores the error. It is suggested
to only change this attribute if
you can ensure the data
generated during a collision is
discarded.
SRVAL_A Binary/Hex- Any All zeros Allows the individual selection
adecimal of whether the DOA/DOB
output port sets (go to a one) or
reset (go to a zero) upon the
assertion of the SSRA/SSRB pin.
For Type, the bit width is
dependent on the width of the A
or B port of the RAM.
RAMB16_Sm_Sn
Allowed
Attribute Type Default Description
Values
SRVAL_B Binary/Hex- Any All zeros Allows the individual selection
adecimal of whether the DOA/DOB
output port sets (go to a one) or
reset (go to a zero) upon the
assertion of the SSRA/SSRB pin.
For Type, the bit width is
dependent on the width of the A
or B port of the RAM.
WRITE_MODE String "WRITE_FIR "WRITE_ Specifies the behavior of the
_A ST", "READ_ FIRST” DOA/DOB port upon a write
FIRST" or command to the respected port.
"NO_ If set to "WRITE_FIRST", the
CHANGE” same port that is written to
displays the contents of the
written data to the outputs upon
completion of the operation.
"READ_FIRST" displays the
prior contents of the RAM to the
output port prior to writing the
new data. "NO_CHANGE"
keeps the previous value on the
output port and won’t update
the output port upon a write
command. This is the suggested
mode if not using the read data
from a particular port of the
RAM.
WRITE_MODE String "WRITE_ "WRITE_ Specifies the behavior of the
_B FIRST", FIRST” DOA/DOB port upon a write
"READ_ command to the respected port.
FIRST" or If set to "WRITE_FIRST", the
"NO_ same port that is written to
CHANGE” displays the contents of the
written data to the outputs upon
completion of the operation.
"READ_FIRST" displays the
prior contents of the RAM to the
output port prior to writing the
new data. "NO_CHANGE"
keeps the previous value on the
output port and won’t update
the output port upon a write
command. This is the suggested
mode if not using the read data
from a particular port of the
RAM.
RAMB16_Sm_Sn
RAMB16_Sm_Sn
RAMB16_Sn
RAMB16_Sn
X9465
Component Data Cells Parity Cells Address Bus Data Bus Parity Bus
written and the outputs (DO and DOP) retain the last state. When EN is High and
reset (SSR) is High, DO and DOP are set to SRVAL during the Low-to-High clock
(CLK) transition; if write enable (WE) is High, the memory contents reflect the data at
DI and DIP. When SSR is Low, EN is High, and WE is Low, the data stored in the RAM
address (ADDR) is read during the Low-to-High clock transition. The output value
depends on the mode. By default WRITE_MODE=WRITE_FIRST, when EN and WE
RAMB16_Sn
are High and SSR is Low, the data on the data inputs (DI and DIP) is loaded into the
word selected by the write address (ADDR) during the Low-to-High clock transition.
See “Write Mode Selection” for information on setting the WRITE_MODE.
The above description assumes an active High EN, WE, SSR, and CLK. However, the
active level can be changed by placing an inverter on the port. Any inverter placed on
a RAMB16 port is absorbed into the block and does not use a CLB resource.
Inputs Outputs
INIT=Value specified by the INIT attribute for data memory. Default is all zeros.
SRVAL=Value after assertion of SSR as specified by the SRVAL attribute.
addr=RAM address
RAM(addr)=RAM contents at address ADDR
data=RAM input data
pdata=RAM parity data
aWRITE_MODE=NO_CHANGE
bWRITE_MODE=READ_FIRST
cWRITE_MODE=WRITE_FIRST
RAMB16_Sn
Usage
This design element can be inferred or instantiated. The instantiation code is shown
below. For information on how to infer RAM, see the XST User Guide.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Binary/Hexa- Any All zeros Identifies the initial
decimal value of the DO
output port after
completing
configuration. The bit
width is dependent
on the width of the A
or B port of the RAM.
INIT_00 ? Binary/Hexa- Any All zeros Specifies the initial
INIT_3F decimal contents of the data
portion of the RAM
array.
INITP_00 ? Binary/Hexa- Any All zeros Specifies the initial
INITP_07 decimal contents of the parity
portion of the RAM
array.
RAMB16_Sn
ROM16X1
ROM16X1
Primitive: 16-Deep by 1-Wide ROM
ROM16X1 is a 16-word by 1-bit read-only memory. The data output (O) reflects the
word selected by the 4-bit address (A3 – A0). The ROM is initialized with the INIT =
A0 ROM16X1 O value parameter during configuration. The value consists of four hexadecimal digits
A1 that are written into the ROM from the most-significant digit A=FH to the least-
A2 significant digit A=0H. For example, the INIT=10A7 parameter produces the data
stream:
A3
0001 0000 1010 0111
An error occurs if the INIT=value is not specified.
X4137
Usage
This design element should be instantiated rather than inferred.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Hexa- Any 16-bit value. All zeros Specifies the contents of the
decimal ROM.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
ROM16X1_inst : ROM16X1
generic map (
INIT => X"0000")
port map (
O => O, -- ROM output
A0 => A0, -- ROM address[0]
A1 => A1, -- ROM address[1]
A2 => A2, -- ROM address[2]
A3 => A3 -- ROM address[3]
);
ROM16X1
ROM16X1 #(
.INIT(16'h0000) // Contents of ROM
) ROM16X1_inst (
.O(O), // ROM output
.A0(A0), // ROM address[0]
.A1(A1), // ROM address[1]
.A2(A2), // ROM address[2]
.A3(A3) // ROM address[3]
);
ROM32X1
ROM32X1
Primitive: 32-Deep by 1-Wide ROM
ROM32X1 is a 32-word by 1-bit read-only memory. The data output (O) reflects the
ROM32X1 word selected by the 5-bit address (A4 – A0). The ROM is initialized with the INIT =
A0 O value parameter during configuration. The value consists of eight hexadecimal digits
A1 that are written into the ROM from the most-significant digit A=1FH to the least-
A2 significant digit A=00H. For example, the INIT=10A78F39 parameter produces the
A3 data stream:
A4
0001 0000 1010 0111 1000 1111 0011 1001
Usage
This design element should be instantiated rather than inferred.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Hexa- Any 32-bit value. All zeros Specifies the contents of
decimal the ROM.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
ROM32X1_inst : ROM32X1
generic map (
INIT => X"00000000")
port map (
O => O, -- ROM output
A0 => A0, -- ROM address[0]
A1 => A1, -- ROM address[1]
A2 => A2, -- ROM address[2]
A3 => A3, -- ROM address[3]
A4 => A4 -- ROM address[4]
);
-- End of ROM32X1_inst instantiation
ROM32X1
ROM32X1 #(
.INIT(32'h00000000) // Contents of ROM
) ROM32X1_inst (
.O(O), // ROM output
.A0(A0), // ROM address[0]
.A1(A1), // ROM address[1]
.A2(A2), // ROM address[2]
.A3(A3), // ROM address[3]
.A4(A4) // ROM address[4]
);
ROM64X1
ROM64X1
Primitive: 64-Deep by 1-Wide ROM
ROM64X1 is a 64-word by 1-bit read-only memory. The data output (O) reflects the
A0 ROM64X1 O word selected by the 6-bit address (A5 – A0). The ROM is initialized with an INIT =
A1 value parameter during configuration. The value consists of 16 hexadecimal digits
A2 that are written into the ROM from the most-significant digit A=FH to the least-
A3 significant digit A=0H.
A4 An error occurs if the INIT=value is not specified.
A5
X9730
Usage
This design element should be instantiated rather than inferred.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Hexa- Any 64-bit value. All zeros Specifies the contents of the
decimal ROM.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
ROM64X1_inst : ROM64X1
generic map (
INIT => X"0000000000000000")
port map (
O => O, -- ROM output
A0 => A0, -- ROM address[0]
A1 => A1, -- ROM address[1]
A2 => A2, -- ROM address[2]
A3 => A3, -- ROM address[3]
A4 => A4, -- ROM address[4]
A5 => A5 -- ROM address[5]
);
ROM64X1
ROM64X1 #(
.INIT(64'h0000000000000000) // Contents of ROM
) ROM64X1_inst (
.O(O), // ROM output
.A0(A0), // ROM address[0]
.A1(A1), // ROM address[1]
.A2(A2), // ROM address[2]
.A3(A3), // ROM address[3]
.A4(A4), // ROM address[4]
.A5(A5) // ROM address[5]
);
ROM128X1
ROM128X1
Primitive: 128-Deep by 1-Wide ROM
ROM128X1 is a 128-word by 1-bit read-only memory. The data output (O) reflects the
A0 ROM128X1 O word selected by the 7-bit address (A6 – A0). The ROM is initialized with an INIT =
A1 value parameter during configuration. The value consists of 32 hexadecimal digits
A2 that are written into the ROM from the most-significant digit A=FH to the least-
A3 significant digit A=0H.
A4
An error occurs if the INIT=value is not specified.
A5
A6
Usage
X9731
This design element should be instantiated rather than inferred.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Hexa- Any 128-bit value. All zeros Specifies the contents of
decimal the ROM.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
ROM128X1_inst : ROM128X1
generic map (
INIT => X"00000000000000000000000000000000")
port map (
O => O, -- ROM output
A0 => A0, -- ROM address[0]
A1 => A1, -- ROM address[1]
A2 => A2, -- ROM address[2]
A3 => A3, -- ROM address[3]
A4 => A4, -- ROM address[4]
A5 => A5, -- ROM address[5]
A6 => A6 -- ROM address[6]
);
ROM128X1
ROM128X1 #(
.INIT(128'h00000000000000000000000000000000) // Contents of ROM
) ROM128X1_inst (
.O(O), // ROM output
.A0(A0), // ROM address[0]
.A1(A1), // ROM address[1]
.A2(A2), // ROM address[2]
.A3(A3), // ROM address[3]
.A4(A4), // ROM address[4]
.A5(A5), // ROM address[5]
.A6(A6) // ROM address[6]
);
ROM256X1
ROM256X1
Primitive: 256-Deep by 1-Wide ROM
ROM256X1 is a 256-word by 1-bit read-only memory. The data output (O) reflects the
A0 ROM256X1 O word selected by the 8-bit address (A7– A0). The ROM is initialized with an
A1 INIT=value parameter during configuration. The value consists of 64 hexadecimal
A2 digits that are written into the ROM from the most-significant digit A=FH to the least-
A3 significant digit A=0H.
A4
A5 An error occurs if the INIT=value is not specified.
A6
A7
Usage
X9732
This design element should be instantiated rather than inferred.
Available Attributes
Attribute Type Allowed Values Default Description
INIT Hexa- Any 256-bit value. All zeros Specifies the contents of
decimal the ROM.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
ROM256X1_inst : ROM256X1
generic map (
INIT => X"0000000000000000000000000000000000000000000000000000000000000000")
port map (
O => O, -- ROM output
A0 => A0, -- ROM address[0]
A1 => A1, -- ROM address[1]
A2 => A2, -- ROM address[2]
A3 => A3, -- ROM address[3]
A4 => A4, -- ROM address[4]
A5 => A5, -- ROM address[5]
A6 => A6 -- ROM address[6]
A7 => A7 -- ROM address[7]
);
ROM256X1
ROM256X1 #(
.INIT(256'h0000000000000000000000000000000000000000000000000000000000000000) // Contents of ROM
) ROM256X1_inst (
.O(O), // ROM output
.A0(A0), // ROM address[0]
.A1(A1), // ROM address[1]
.A2(A2), // ROM address[2]
.A3(A3), // ROM address[3]
.A4(A4), // ROM address[4]
.A5(A5), // ROM address[5]
.A6(A6) // ROM address[6]
.A7(A7) // ROM address[7]
);
SRLC16E
SRLC16E
Primitive: 16-Bit Shift Register Look-Up-Table (LUT) with Carry and
Clock Enable
SRLC16E is a shift register look up table (LUT) with carry and clock enable. The
D SRLC16E
CE Q
inputs A3, A2, A1, and A0 select the output length of the shift register. The shift
CLK Q15
register can be of a fixed, static length or it can be dynamically adjusted.
A0 The shift register LUT contents are initialized by assigning a four-digit hexadecimal
A1
number to an INIT attribute. The first, or the left-most, hexadecimal digit is the most
A2
significant bit. If an INIT value is not specified, that value defaults to a value of four
A3
zeros (0000) so that the shift register LUT is cleared during configuration.
X9298 The data (D) is loaded into the first bit of the shift register during the Low-to-High
clock (CLK) transition. When CE is High, during subsequent Low-to-High clock
transitions, data is shifted to the next highest bit position as new data is loaded. The
data appears on the Q output when the shift register length determined by the
address inputs is reached.
The Q15 output is available for the user to cascade multiple shift register LUTs to
create larger shift registers.
Inputs Output
Am CLK CE D Q Q15
Am X 0 X Q(Am) Q(15)
Am X 1 X Q(Am) Q(15)
Am ↑ 1 D Q(Am - 1) Q15
m= 0, 1, 2, 3
Usage
This design element can be inferred or instantiated.
Available Attributes
Attribute Type Allowed Values Default Description
INIT 16-Bit 16-Bit Hexadecimal 16'h0000 Sets the initial value of
Hexa- content and output of
decimal shift register after
configuration
SRLC16E
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
-- SRLC16E: 16-bit cascable shift register LUT with clock enable operating on posedge of clock
-- FPGAs.
-- Xilinx HDL Libraries Guide version 8.1i
SRLC16E_inst : SRLC16E
generic map (
INIT => X"0000")
port map (
Q => Q, -- SRL data output
Q15 => Q15, -- Carry output (connect to next SRL)
A0 => A0, -- Select[0] input
A1 => A1, -- Select[1] input
A2 => A2, -- Select[2] input
A3 => A3, -- Select[3] input
CE => CE, -- Clock enable input
CLK => CLK, -- Clock input
D => D -- SRL data input
);
// SRLC16E: 16-bit cascable shift register LUT with clock enable operating on posedge of clock
// FPGAs.
// Xilinx HDL Libraries Guide Version 8.1i
SRLC16E #(
.INIT(16'h0000) // Initial Value of Shift Register
) SRLC16E_inst (
.Q(Q), // SRL data output
.Q15(Q15), // Carry output (connect to next SRL)
.A0(A0), // Select[0] input
.A1(A1), // Select[1] input
.A2(A2), // Select[2] input
.A3(A3), // Select[3] input
.CE(CE), // Clock enable input
.CLK(CLK), // Clock input
.D(D) // SRL data input
);
STARTUP_SPARTAN3E
STARTUP_SPARTAN3E
Primitive: Spartan-3E User Interface to the GSR, GTS, Configuration
Startup Sequence and Multi-Boot Trigger Circuitry
The STARTUP_SPARTAN3E component allows the connection of ports, or user
circuitry, to control certain dedicated circuitry and routes within the FPGA. Signals
GSR
STARTUP_SPARTAN3E connected to the GSR port of this component can control the global set/reset (referred
to as GSR) of the device. The GSR net connects to all registers in the device and places
GTS the registers into their initial value state. Connecting a signal to the GTS port connects
MBT that port to the dedicated route controlling the 3-state outputs of every pin in the
device. Connecting a clock signal to the CLK input allows the startup sequence after
CLK configuration to be synchronized to a user defined clock. The MBT (Multi-Boot
Trigger) pin allows the triggering of a new configuration.
X10235
Usage
The STARTUP_SPARTAN3E component must be instantiated to be incorporated into
a design. Do not connect any input not needed for the design.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
STARTUP_SPARTAN3E_inst : STARTUP_SPARTAN3E
port map (
CLK => CLK, -- Clock input for start-up sequence
GSR => GSR_PORT, -- Global Set/Reset input (GSR cannot be used for the port name)
GTS => GTS_PORT -- Global 3-state input (GTS cannot be used for the port name)
MBT => MBT -- Multi-Boot Trigger input
);
STARTUP_SPARTAN3E
STARTUP_SPARTAN3E STARTUP_SPARTAN3E_inst (
.CLK(CLK), // Clock input for start-up sequence
.GSR(GSR_PORT), // Global Set/Reset input (GSR can not be used as a port name)
.GTS(GTS_PORT), // Global 3-state input (GTS can not be used as a port name)
.MBT(MBT) // Multi-Boot Trigger input
);
XORCY
XORCY
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
XORCY_inst : XORCY
port map (
O => O, -- XOR output signal
CI => CI, -- Carry input signal
LI => LI -- LUT4 input signal
);
XORCY XORCY_inst (
.O(O), // XOR output signal
.CI(CI), // Carry input signal
.LI(LI) // LUT4 input signal
);
XORCY
XORCY_D
XORCY_D
Primitive: XOR for Carry Logic with Dual Output
XORCY_D is a special XOR used for generating faster and smaller arithmetic
LO functions.
LI
O Usage
CI
XORCY_D has two, functionally identical outputs: O and LO. The O output is a
X8409 general interconnect. The LO output connects to another output within the same CLB
slice.
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
XORCY_D_inst : XORCY_D
port map (
LO => LO, -- XOR local output signal
O => O, -- XOR general output signal
CI => CI, -- Carry input signal
LI => LI -- LUT4 input signal
);
XORCY_D XORCY_D_inst (
.LO(LO), // XOR local output signal
.O(O), // XOR general output signal
XORCY_D
XORCY_L
XORCY_L
XORCY_L is a special XOR with local LO output used for generating faster and
LO smaller arithmetic functions.
LI
CI Usage
The LO output connects to another output within the same CLB slice.
X8404
-- Copy the following two statements and paste them before the
-- Entity declaration, unless they already exist.
Library UNISIM;
use UNISIM.vcomponents.all;
-- <-----Cut code below this line and paste into the architecture body---->
XORCY_L_inst : XORCY_L
port map (
LO => LO, -- XOR local output signal
CI => CI, -- Carry input signal
LI => LI -- LUT4 input signal
);
XORCY_L XORCY_L_inst (
.LO(LO), // XOR local output signal
.CI(CI), // Carry input signal
.LI(LI) // LUT4 input signal
);
XORCY_L