Ever since Xilinx introduced to the world ‘field-programmable gate arrays,’ popularly known as FPGAs, these have been extensively used for various applications. The name ‘field-programmable’ originates from the fact that an FPGA can be configured by a customer or a designer after manufacturing rather than during fabrication.
In essence, an FPGA is a two-dimensional array of generic logic cells and programmable switches that is configured using hardware description language (HDL), very high-speed integrated circuit hardware description language (VHDL) and VERILOG to name a few. FPGAs can be used to implement any logical function that an application-specific integrated circuit (ASIC) could perform. Some of the reasons for its popularity in modern electronics are its ability to update the functionality after shipping, partial re-configuration of a portion of the design and low engineering costs relative to ASIC design.
FPGAs contain programmable logic components called logic blocks, and a hierarchy of reconfigurable interconnects. A logic cell can be configured to perform a simple function, and a programmable switch can be customised to provide interconnections among the logic cells. A custom design can be implemented by specifying the function of each logic cell and selectively setting the connection of each programmable switch. Once the design and synthesis is complete, you can use a simple adaptor cable to download the desired logic cell and switch configuration to the FPGA device and obtain the custom circuit. In most FPGAs, the logic blocks also include memory elements, which may be simple flip-flops or more complete blocks of memory.
In addition to digital functions, some FPGAs have analogue features. The most common analogue feature is programmable slew rate and drive strength on each output pin, allowing the engineer to set slower rates on lightly loaded pins that would otherwise ring unacceptably, and to set stronger, faster rates on heavily loaded pins on high-speed channels that would otherwise run too slow.
Another relatively common analogue feature is differential comparators on input pins designed to be connected to differential signalling channels. A few mixed-signal FPGAs have integrated peripheral analogue-to-digital converters (ADCs) and digital-to-analogue converters (DACs) with analogue signal conditioning blocks allowing them to operate as a system-on-a-chip. Such devices blur the line between an FPGA, which carries digital 1’s and 0’s on its internal programmable interconnect fabric, and field-programmable analogue array (FPAA), which carries analogue values on its internal programmable interconnect fabric.
Types of FPGA
Major categories of FPGAs include SRAM-based FPGAs, Flash-based FPGAs and antifuse-based FPGAs. SRAM-based FPGAs store logic cells configuration data in the static memory (organised as an array of latches). Since SRAM is volatile and can’t keep data without power source, such FPGAs must be programmed or configured upon start.
There are two basic modes of programming: master mode and slave mode. In master mode, the FPGA reads configuration data from an external source, such as an external Flash memory chip. In slave mode, the FPGA is configured by an external master device, such as a processor. This can be usually done via a dedicated configuration interface or via a boundary-scan (JTAG) interface. SRAM-based FPGAs include most chips of Xilinx Virtex and Spartan families and Altera Stratix and Cyclone.
SRAM-based FPGA with an internal flash memory. This type of FPGA is similar to the conventional SRAM-based devices, except that it contains internal flash memory blocks, thus eliminating the need to have an external non-volatile memory. One example of such an FPGA is the Xilinx Spartan-3AN family (Fig. 1). Each model of Spartan-3AN has an on-chip flash memory module with an SPI interface capable of storing two or more configuration bit streams, which can be chosen during start-up. Internal non-volatile memory can also be useful to prevent unauthorised bitstream copying.
Flash-based FPGAs. The true flash-based FPGAs shouldn’t be confused with SRAM-based FPGAs with internal flash memory. The SRAM-based FPGAs with internal flash memory use flash only during start-up to load data to the SRAM configuration cells. On the contrary, true flash-based FPGAs use flash as a primary resource for configuration storage, and don’t require SRAM. This technology has the advantage of being less power-consuming. Flash-based FPGAs are also more tolerant to radiation effects. Flash-based FPGA families such as Igloo (Fig. 2) and ProASIC3 are manufactured by Actel. As in the previous case, using flash-based FPGAs can be a solution to prevent unauthorised bitstream copying.
Antifuse-based FPGAs. Antifuse-based FPGAs are different in that they can be programmed only once. The antifuse is a device that doesn’t conduct current initially, but can be ‘burned’ to conduct. Antifuse-based FPGAs can’t be then reprogrammed since there is no way to return a burned antifuse into the initial state. Antifuse-based device families include Accelerator (Fig. 3) produced by Actel.
An FPGA consists of an array of uncommitted configurable logic blocks, programmable interconnects and input/output (I/O) blocks. Fig. 4 shows the basic architecture of an FPGA.
FPGA architecture is dominated by programmable interconnects, and the configurable logic blocks are relatively simpler. Logic blocks within an FPGA can be small, called fine-grained architecture, or larger, called coarse-grained architecture.