Hubbry Logo
Programmable logic deviceProgrammable logic deviceMain
Open search
Programmable logic device
Community hub
Programmable logic device
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Programmable logic device
Programmable logic device
Programmable logic device
View on Wikipedia
from Wikipedia

A simplified programmable array logic device. The programmable elements (shown as a fuse) connect both the true and complemented inputs to the AND gates. These AND gates, also known as product terms, are ORed together to form a sum-of-products logic array.

A programmable logic device (PLD) is an electronic component used to build reconfigurable digital circuits. Unlike digital logic constructed using discrete logic gates with fixed functions, the function of a PLD is undefined at the time of manufacture. Before the PLD can be used in a circuit it must be programmed to implement the desired function.[1] Compared to fixed logic devices, programmable logic devices simplify the design of complex logic and may offer superior performance.[2] Unlike for microprocessors, programming a PLD changes the connections made between the gates in the device.

PLDs can broadly be categorised into, in increasing order of complexity, simple programmable logic devices (SPLDs), comprising programmable array logic, programmable logic array and generic array logic; complex programmable logic devices (CPLDs); and field-programmable gate arrays (FPGAs).

History

[edit]

In 1969, Motorola offered the XC157, a mask-programmed gate array with 12 gates and 30 uncommitted input/output pins.[3]

In 1970, Texas Instruments developed a mask-programmable IC based on the IBM read-only associative memory or ROAM. This device, the TMS2000, was programmed by altering the metal layer during the production of the IC. The TMS2000 had up to 17 inputs and 18 outputs with 8 JK flip-flops for memory. TI coined the term programmable logic array (PLA) for this device.[4]

In 1971, General Electric Company (GE) was developing a programmable logic device based on the new programmable read-only memory (PROM) technology. This experimental device improved on IBM's ROAM by allowing multilevel logic. Intel had just introduced the floating-gate UV EPROM so the researcher at GE incorporated that technology. The GE device was the first erasable PLD ever developed, predating the Altera EPLD by over a decade. GE obtained several early patents on programmable logic devices.[5][6][7]

In 1973 National Semiconductor introduced a mask-programmable PLA device (DM7575) with 14 inputs and 8 outputs with no memory registers. This was more popular than the TI part but the cost of making the metal mask limited its use. The device is significant because it was the basis for the field programmable logic array produced by Signetics in 1975, the 82S100. (Intersil actually beat Signetics to market but poor yield doomed their part.)[8][9]

In 1974 GE entered into an agreement with Monolithic Memories (MMI) to develop a mask-programmable logic device incorporating the GE innovations. The device was named programmable associative logic array or PALA. The MMI 5760 was completed in 1976 and could implement multilevel or sequential circuits of over 100 gates. The device was supported by a GE design environment where Boolean equations would be converted to mask patterns for configuring the device. The part was never brought to market.[10]

PLA

[edit]
Main article: Programmable logic array

In 1970, Texas Instruments developed a mask-programmable IC based on the IBM read-only associative memory or ROAM. This device, the TMS2000, was programmed by altering the metal layer during the production of the IC. The TMS2000 had up to 17 inputs and 18 outputs with 8 JK flip-flops for memory. TI coined the term programmable logic array for this device.[4]

A programmable logic array (PLA) has a programmable AND gate array, which links to a programmable OR gate array, which can then be conditionally complemented to produce an output. A PLA is similar to a ROM concept; however, a PLA does not provide full decoding of a variable and does not generate all the minterms as in a ROM.

The programmable logic sequencer (PLS/FPLS) is similar to a PLA, but with integral registered outputs using a number of flip-flops to allow creation of some state machines. Signetics introduced the first FPLS in 1979.[11]

PAL

[edit]
Main article: Programmable array logic

PAL devices have arrays of transistor cells arranged in a "fixed-OR, programmable-AND" plane used to implement "sum-of-products" binary logic equations for each of the outputs in terms of the inputs and either synchronous or asynchronous feedback from the outputs.

MMI introduced a breakthrough device in 1978, the programmable array logic or PAL. The architecture was simpler than that of Signetics' FPLA because it omitted the programmable OR array. This made the parts faster, smaller and cheaper. They were available in 20-pin 300-mil DIP packages, while the FPLAs came in 28-pin 600-mil packages. The PAL Handbook demystified the design process. The PALASM design software (PAL assembler) converted the engineers' Boolean equations into the fuse pattern required to program the part. The PAL devices were soon second-sourced by National Semiconductor, Texas Instruments and AMD.

After MMI succeeded with the 20-pin PAL parts, AMD introduced the 24-pin 22V10 PAL with additional features. After buying out MMI (1987), AMD spun off a consolidated operation as Vantis, and that business was acquired by Lattice Semiconductor in 1999.

GALs

[edit]
Main article: Generic array logic
Lattice GAL 16V8 and 20V8. These are 35-nanosecond devices.

An improvement on the PAL was the generic array logic device, or GAL, invented by Lattice Semiconductor in 1985. This device has the same logical properties as the PAL but can be erased and reprogrammed. The GAL is very useful in the prototyping stage of a design when any bugs in the logic can be corrected by reprogramming. GALs are programmed and reprogrammed using a PAL programmer, or, in the case of chips that support it, by using the in-circuit programming technique.

Lattice GALs combine CMOS and electrically erasable (E2) floating gate technology for a high-speed, low-power logic device. A similar device called a PEEL (programmable electrically erasable logic) was introduced by the International CMOS Technology (ICT) corporation.

Sometimes GAL chips are referred as simple programmable logic device (SPLD), analogous to complex programmable logic device (CPLD) below.

CPLDs

[edit]
Main article: Complex programmable logic device

PALs and GALs are available only in small sizes, equivalent to a few hundred logic gates. For bigger logic circuits, complex PLDs or CPLDs can be used. These contain the equivalent of several PALs linked by programmable interconnections, all in one integrated circuit. CPLDs can replace thousands, or even hundreds of thousands, of logic gates.

Some CPLDs are programmed using a PAL programmer, but this method becomes inconvenient for devices with hundreds of pins. A second method of programming is to solder the device to its printed circuit board, then feed it with a serial data stream from a personal computer. The CPLD contains a circuit that decodes the data stream and configures the CPLD to perform its specified logic function. Some manufacturers, such as Altera and Atmel (now Microchip), use JTAG to program CPLDs in-circuit from .JAM files.

FPGAs

[edit]
Main article: Field-programmable gate array

While PALs were being developed into GALs and CPLDs (all discussed above), a separate stream of development was happening. This type of device is based on gate array technology and is called the field-programmable gate array (FPGA). Early examples of FPGAs are the 82S100 array and 82S105 sequencer, by Signetics, introduced in the late 1970s. The 82S100 was an array of AND terms. The 82S105 also had flip-flop functions.

(Remark: 82S100 and similar ICs from Signetics have PLA structure, AND-plane + OR-plane.)

FPGAs use a grid of logic gates, and once stored, the data doesn't change, similar to that of an ordinary gate array. The term field-programmable means the device is programmed by the customer, not the manufacturer. FPGAs and gate arrays are similar but gate arrays can only be configured at the factory during fabrication.[12][13][14]

FPGAs are usually programmed after being soldered down to the circuit board, in a manner similar to that of larger CPLDs. In most larger FPGAs, the configuration is volatile and must be re-loaded into the device whenever power is applied or different functionality is required. Configuration is typically stored in a configuration PROM, EEPROM or flash memory.[15] EEPROM versions may be in-system programmable (typically via JTAG).

The difference between FPGAs and CPLDs is that FPGAs are internally based on look-up tables (LUTs), whereas CPLDs form the logic functions with sea-of-gates (e.g. sum of products). CPLDs are meant for simpler designs, while FPGAs are meant for more complex designs. In general, CPLDs are a good choice for wide combinational logic applications, whereas FPGAs are more suitable for large state machines such as microprocessors.

EPLDs

[edit]
An EPLD from Cypress in a PLCC-package

Using the same technology as EPROMs, EPLDs have a quartz window in the package that allows them to be erased on exposure to UV light.[16][17]

Using the same technology as EEPROMs, EEPLDs can be erased electrically.[16][17]

An erasable programmable logic device (EPLD) is an integrated circuit that comprises an array of PLDs that do not come pre-connected; the connections are programmed electrically by the user. Most GAL and FPGA devices are examples of EPLDs.[citation needed]

Other variants

[edit]

These are microprocessor circuits that contain some fixed functions and other functions that can be altered by code running on the processor. Designing self-altering systems requires that engineers learn new methods and that new software tools be developed.

PLDs are being sold now that contain a microprocessor with a fixed function (the so-called core) surrounded by programmable logic. These devices let designers concentrate on adding new features to designs without having to worry about making the microprocessor work. Also, the fixed-function microprocessor takes less space on the chip than a part of the programmable gate array implementing the same processor, leaving more space for the programmable gate array to contain the designer's specialized circuits.

How PLDs retain their configuration

[edit]

A PLD is a combination of a logic device and a memory device. The memory is used to store the pattern that was given to the chip during programming. Most of the methods for storing data in an integrated circuit have been adapted for use in PLDs. These include:

Silicon antifuses are connections that are made by applying a voltage across a modified area of silicon inside the chip. They are called antifuses because they work in the opposite way to normal fuses, which begin life as connections until they are broken by an electric current.

SRAM, or static RAM, is a volatile type of memory, meaning that its contents are lost each time the power is switched off. SRAM-based PLDs therefore have to be programmed every time the circuit is switched on. This is usually done automatically by another part of the circuit.

An EPROM memory cell is a MOSFET (metal-oxide-semiconductor field-effect transistor, or MOS transistor) that can be switched on by trapping an electric charge permanently on its gate electrode. This is done by a PAL programmer. The charge remains for many years and can only be removed by exposing the chip to strong ultraviolet light in a device called an EPROM eraser.

Flash memory is non-volatile, retaining its contents even when the power is switched off. It is stored on floating-gate MOSFET memory cells, and can be erased and reprogrammed as required. This makes it useful in PLDs that may be reprogrammed frequently, such as PLDs used in prototypes. Flash memory is a kind of EEPROM that holds information using trapped electric charges similar to EPROM. Consequently, flash memory can hold information for years, but possibly not as many years as EPROM.

As of 2005, most CPLDs are electrically programmable and erasable, and non-volatile. This is because they are too small to justify the inconvenience of programming internal SRAM cells every time they start up, and EPROM cells are more expensive due to their ceramic package with a quartz window.

PLD programming languages

[edit]

Many PAL programming devices accept input in a standard file format, commonly referred to as 'JEDEC files'. They are analogous to software compilers. The languages used as source code for logic compilers are called hardware description languages, or HDLs.[1]

PALASM, ABEL and CUPL are frequently used for low-complexity devices, while Verilog and VHDL are popular higher-level description languages for more complex devices. The more limited ABEL is often used for historical reasons, but for new designs, VHDL is more popular, even for low-complexity designs.

For modern PLD programming languages, design flows, and tools, see FPGA and reconfigurable computing.

PLD programming devices

[edit]

A device programmer is used to transfer the Boolean logic pattern into the programmable device. In the early days of programmable logic, every PLD manufacturer also produced a specialized device programmer for its family of logic devices. Later, universal device programmers came onto the market that supported several logic device families from different manufacturers. Today's device programmers usually can program common PLDs (mostly PAL/GAL equivalents) from all existing manufacturers. Common file formats used to store the Boolean logic pattern (fuses) are JEDEC, Altera POF (programmable object file), or Xilinx BITstream.[18]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Programmable logic device

View on Grokipedia
from Grokipedia
A programmable logic device (PLD) is an that can be configured by the user after to perform specific custom logic functions, enabling the implementation of reconfigurable digital circuits without requiring fixed hardware designs. These devices offer flexibility in digital system development by allowing modifications through programming, which contrasts with application-specific that are rigid once fabricated. The history of PLDs traces back to the late 1960s, when early prototypes like Motorola's XC157 mask-programmable gate array (MPGA) with 30 I/O pins and 12 gates were introduced in 1969, followed by Texas Instruments' TMS2000 in 1970 featuring 8 JK flip-flops, 17 inputs, and 18 outputs. Subsequent developments included GE's erasable PLD with multilevel logic in 1971 and National Semiconductor's DM7575 in 1973, marking the shift toward reprogrammable technologies such as ultraviolet-erasable PROMs and EEPROM-based devices by the mid-1970s. This evolution culminated in more advanced architectures, with Signetics' 82S100, an early field-programmable logic array (FPLA), appearing in 1975, paving the way for modern PLDs that support millions of logic gates. PLDs are broadly classified into simple programmable logic devices (SPLDs), complex programmable logic devices (CPLDs), and field-programmable gate arrays (FPGAs), each differing in complexity and reconfiguration capabilities. SPLDs, such as programmable read-only memories (PROMs) that store via fuse links, programmable logic arrays (PLAs) with programmable AND and OR planes, (PALs) featuring programmable AND arrays and fixed OR arrays, and (GALs) that are reprogrammable versions of PALs using technology, handle basic combinational and with fewer gates. CPLDs integrate multiple SPLD-like macrocells with programmable interconnects, supporting hundreds to thousands of gates and using technologies like or flash for in-system reprogramming. FPGAs represent the most sophisticated type, comprising configurable logic blocks (CLBs), programmable interconnects, and input/output blocks, often programmed via SRAM, , or flash, enabling implementations with millions of elements for high-density applications. Programming PLDs typically involves hardware description languages like or , or graphical tools, with configurations downloaded via interfaces such as or USB, allowing for and field updates. Key advantages include cost-effectiveness for low-to-medium production volumes, high performance in custom logic execution, and reconfigurability that reduces time-to-market compared to traditional discrete logic or . Applications span (e.g., filters and modulators), communications (e.g., modems and routers), industrial control systems, embedded systems, devices, , and , where adaptability to evolving requirements is essential.

Fundamentals

Definition and Principles

A programmable logic device (PLD) is an that can be configured by the user after manufacturing to implement specific digital logic functions, enabling the creation of custom combinational and sequential circuits on a single chip. Unlike application-specific (ASICs), which have fixed functionality defined during fabrication and are suited for high-volume production, PLDs offer post-production programmability, making them ideal for flexible designs where requirements may evolve. This reconfigurability is achieved through electronic programming mechanisms, such as SRAM-based configuration that loads logic definitions on or non-volatile antifuse links that permanently set connections. At their core, PLDs operate on principles of Boolean logic implementation, where user-defined functions are realized through programmable interconnects and logic elements that map inputs to outputs based on specified truth tables or equations. is supported by structures that compute instantaneous outputs solely from current inputs, often using sum-of-products forms involving programmable AND planes or lookup tables (LUTs) that store precomputed results for small input sets (e.g., a 4-input LUT with 16 entries). extends this by incorporating memory elements like flip-flops to retain state, allowing outputs to depend on both current inputs and prior states, thus enabling finite state machines and registers. The granularity of PLDs ranges from basic gate-level equivalents to higher-level system functions, accommodating designs from simple to complex subsystems. Key advantages of PLDs stem from their reconfigurability, which facilitates , cost-effective low-volume production, and in-field updates without hardware replacement, reducing time-to-market and development costs compared to custom . Device is typically measured in equivalent logic gates or configurable cells, scaling from hundreds in simpler devices to millions in advanced ones, reflecting the computational capacity and they can handle. A generic of a PLD consists of an of programmable logic blocks—each capable of implementing basic functions—interconnected by a network of programmable switches that route signals dynamically, with input/output pins interfacing to external systems.

Basic Architecture and Operation

Programmable logic devices (PLDs) feature architectures that vary by type but generally include programmable logic blocks for implementing user-defined functions, extensive programmable interconnect resources for signal routing, and input/output (I/O) blocks for external interfacing. In simpler PLDs like and , logic is realized using an AND array to generate product terms from inputs and their complements, and an OR array to sum selected terms, enabling sum-of-products (SOP) expressions. More complex devices, such as field-programmable gate arrays (FPGAs), employ configurable logic blocks (CLBs) that utilize lookup tables (LUTs) to implement arbitrary combinational functions by addressing precomputed values, often combined with multiplexers for efficient routing within the block. Programmable logic elements, such as macrocells in simple and complex PLDs or slices within CLBs in FPGAs, serve as the fundamental building blocks for both combinational and sequential logic. These elements typically integrate combinational logic outputs with optional flip-flops for state storage, along with features like XOR gates for output polarity control and configurable paths for direct combinational outputs. Detailed architectures of macrocells and CLBs are covered in sections on specific PLD types. I/O blocks manage external connections, incorporating tri-state buffers that allow pins to operate in input (high-impedance), output (driving), or bidirectional modes, while providing buffering to meet load and signaling standards. In operation, PLDs are configured using technologies such as one-time programmable fuses or antifuses (blown via high current or dielectric breakdown), non-volatile //Flash cells (programmed electrically and erasable via UV or electrical means), or volatile SRAM (requiring reconfiguration on each power-up). This configuration defines the logic functions and interconnections: for array-based designs, inputs are decoded to form product terms (e.g., A⋅B‾A \cdot \overline{B}) in the AND plane, which are then ORed to produce outputs; in LUT-based designs, inputs select entries from the table to compute functions directly. For in SOP form, the expression is F=∑(Ai⋅Bj⋯ )F = \sum (A_i \cdot B_j \cdots) where the sum selects programmed product terms, with literals derived from inputs. LUTs generalize this by storing any function for their input width. Sequential operation involves clocked flip-flops (typically D-type) for state retention, with global or local clocks ensuring synchronous timing across elements. Signal flow in PLDs proceeds from input decoding and logic evaluation in the programmable blocks, through interconnect , to processing in logic elements, and finally to output buffering in I/O blocks, where tri-state controls manage bus access. Power consumption includes static leakage in memory elements and dynamic switching in logic and , while is influenced by propagation delays in and interconnects, which have decreased significantly with advances in technology.

Historical Development

Origins and Early Innovations

The origins of programmable logic devices (PLDs) trace back to the early , building on the introduction of programmable read-only memories (PROMs) around 1970 by companies like and Radiation Inc., which provided a foundation for configurable digital logic. PROMs allowed users to program memory contents in the field using fuse-blowing techniques, inspiring designers to adapt similar concepts for logic implementation amid the rising complexity and cost of custom application-specific integrated circuits (). This need arose as TTL-based boards required replacing numerous discrete random logic gates with more efficient, flexible alternatives to reduce board space and design time. A key innovation came in 1970 with ' development of the first (PLA), the TMS2000, a mask-programmable based on IBM's read-only associative () technology. The TMS2000 featured an AND-OR array structure capable of implementing combinational and sequential logic, with up to 17 inputs, 18 outputs, and 8 JK flip-flops for state storage, marking the shift from pure to programmable logic functions. Early PLAs like this focused on streamlining random logic in TTL systems but faced challenges such as high manufacturing costs, limited density (typically 16-48 inputs), and one-time mask programmability during manufacturing, or later irreversible fuse blowing in field-programmable variants, which restricted revisions and . In 1975, Monolithic Memories Inc. (MMI) advanced the field with the invention of the device by engineers John Birkner and H.T. Chua, leveraging bipolar PROM technology for higher speeds compared to earlier MOS-based designs. PALs simplified the PLA architecture by fixing the OR array while keeping the AND array programmable, enabling faster prototyping of to replace multiple TTL chips on circuit boards. Despite these innovations, early PLDs remained expensive and density-limited, often supporting only small-scale functions, yet they laid the groundwork for field-configurable logic by addressing the inefficiencies of custom silicon in rapidly evolving digital systems.

Key Milestones and Commercialization

The 1980s marked a pivotal shift in programmable logic devices (PLDs) toward reprogrammable and CMOS-based architectures, addressing limitations of earlier fuse-based PLA and PAL devices that required physical replacement for reconfiguration. In 1985, introduced the (GAL) family, the first commercially successful electrically erasable PLDs using technology for in-system reprogrammability without ultraviolet erasure, enabling faster design iterations and broader adoption in prototyping. Shortly thereafter, in 1984, Corporation launched the EP300, the industry's first erasable PLD (EPLD) built on technology, which significantly reduced power consumption compared to bipolar predecessors and facilitated integration into battery-powered and high-density applications. These innovations overcame the one-time programmability of early PLDs, spurring commercial growth by allowing engineers to test and modify logic without hardware swaps. The late 1980s and 1990s saw the commercialization of more complex PLD architectures, driven by the invention of field-programmable gate arrays (FPGAs) and complex PLDs (CPLDs). Xilinx, founded in 1984, released the XC2064 in 1985, the first FPGA, which supported larger, user-configurable logic designs through an array of configurable logic blocks and programmable interconnects, revolutionizing custom circuit development for volumes under 50,000 units. In the 1990s, CPLDs gained traction with Xilinx's XC9500 series, introduced around 1996, offering non-volatile flash-based storage, in-system programmability, and densities up to thousands of gates, ideal for in embedded systems. Market drivers included the widespread shift to processes for significantly lower static power dissipation—EPLDs and GALs consumed much less power than bipolar equivalents—and the integration of PC-based design tools, such as Lattice's GAL Programmer software released in the mid-1980s, which allowed logic synthesis and simulation directly on PCs, democratizing PLD development. By 2000, the MOS logic IC sector had reached $31 billion, with PLDs contributing to its growth through adoption in telecommunications, computing, and consumer electronics. Key corporate events further shaped PLD commercialization. In 1999, acquired Vantis Corporation from for $500 million, gaining advanced SRAM-based FPGA technology and strengthening its position in high-density reprogrammable logic. This consolidation helped Lattice expand its portfolio amid growing competition. In 2015, completed its $16.7 billion acquisition of , integrating PLD expertise into its and AI ecosystems; as of 2025, this merger continues to influence PLD evolution through enhanced software tools and silicon integration, boosting market penetration in .

Simple Programmable Logic Devices

Programmable Logic Array (PLA)

The Programmable Logic Array (PLA) represents the foundational type of simple programmable logic device, introduced in the early as a mask-programmable by , enabling flexible realization of functions through two fully programmable logic levels. Its core architecture features a programmable AND plane, which generates product terms (minterms) by selectively connecting inputs and their complements to fixed AND gates, followed by a programmable OR plane that combines these product terms to produce outputs, thereby supporting arbitrary sum-of-products (SOP) or product-of-sums (POS) expressions without restrictions on logic complexity. PLAs were fabricated using bipolar technology for high-speed applications or for lower power, with representative densities in the 1970s and 1980s typically accommodating 16 to 32 inputs, up to 72 product terms, and 8 to 16 outputs, making them suitable for implementing state machines, sequencers, and control logic in digital systems during that period. Programming in early bipolar PLAs relied on fuse-based mechanisms, where metallic fuses were selectively blown via electrical pulses to establish connections in the AND and OR planes for one-time configuration, while later variants employed floating-gate transistors for non-volatile, reprogrammable storage. Despite their versatility, PLAs exhibit limitations such as increased physical size and propagation delays compared to devices with fixed planes, owing to the dense interconnects required for dual-array programmability, which also contributed to higher power dissipation in bipolar implementations.

Programmable Array Logic (PAL)

Programmable Array Logic (PAL) devices, introduced by Monolithic Memories Inc. (MMI) in 1978, represent an optimized class of simple programmable logic devices (SPLDs) designed for high-speed implementation of combinational and simple functions. Unlike the more versatile (PLA), PAL prioritizes speed and density by employing a programmable AND array feeding into a fixed OR array, at the expense of some flexibility in OR-plane customization. The core architecture of a PAL features a programmable AND plane composed of fusible links that allow selected input signals and their complements to form product terms, which are routed to a fixed OR array to produce sum-of-products outputs. Each output connects to a , which includes a D-type flip-flop configurable for registered operation, along with feedback multiplexers to support and state storage. This design enables efficient realization of up to several dozen product terms per device, with bidirectional I/O pins enhancing pin utilization for both inputs and outputs. PAL devices exhibit high performance, with propagation delays typically in the 10-25 ns range, achieved through bipolar TTL fabrication using Schottky processes for reduced switching times. Standard configurations use 20- or 24-pin DIP packages, supporting 10-22 inputs and a similar number of outputs; the PAL20L8, for example, provides 10 dedicated inputs and 8 programmable outputs with three-state capability. Programming occurs via a one-time fuse-blowing process, where high-current pulses sever selected links in the AND array using compatible programmers. Software tools like CUPL (Compiler for Universal Programmable Logic) enable design entry through Boolean equations, which are compiled into fuse patterns for direct device configuration, streamlining the implementation of custom logic. During their peak era, PALs found widespread use as on microcomputer boards, interfacing microprocessors with memory, peripherals, and buses through functions like address decoding and control signal generation. MMI and collectively developed numerous variants, including speed grades, low-power options, and expanded I/O configurations, with early handbooks documenting over two dozen family members that evolved into broader offerings.

Generic Array Logic (GAL)

Generic Array Logic (GAL) devices represent an erasable evolution of (PAL) structures, introduced by in 1985 to address the one-time programmability limitation of traditional bipolar PALs. These devices employ electrically erasable and programmable (EEPROM) technology, specifically Lattice's E²CMOS process, enabling multiple reprogramming cycles without requiring physical replacement. This innovation allowed designers to iterate logic functions iteratively during development, significantly reducing prototyping costs and time compared to fuse-based PALs. The architecture of GAL mirrors that of PAL in its core AND/OR array configuration but replaces the fixed fusible links in the AND array with floating-gate EEPROM cells, while the OR array remains fixed. Erasure is achieved electronically through high-voltage pulses applied via standard programming equipment, completing in less than 100 milliseconds, followed by reprogramming without ultraviolet exposure or special handling. Output Logic Macrocells (OLMCs) provide configurable modes—such as registered, combinatorial, or complex—for flexible logic implementation, with each macrocell supporting variable product terms (e.g., up to 10 terms per output in some configurations). This design ensures pin-for-pin compatibility with PAL devices, facilitating drop-in replacements. Key characteristics include operation at a 5 V supply voltage, with programming requiring a higher VPP of approximately 9 V for erasure and writing, and a guaranteed of at least 100 erase/write cycles per cell, alongside 20-year . A representative example is the GAL16V8, a 20-pin device released in 1985 that emulates PAL16L8 and PAL16R8 functions, featuring eight OLMCs, propagation delays as low as 3.5 ns, and typical power consumption of 75 mA. These attributes enable high-speed operation up to 250 MHz system frequency in optimized designs. The primary advantages of GAL lie in its cost-effective support for design iteration, as reprogramming avoids the expense of new devices, and its role as a precursor to (ISP) techniques in later PLDs. Additionally, GAL incorporates features, such as a programmable security cell that locks the fuse map to prevent unauthorized reading or copying, erasable only through full reprogramming. This combination of erasability, compatibility, and protection made GAL a for simple logic replacement in embedded systems during the late 1980s and 1990s.

Complex and Erasable PLDs

Erasable Programmable Logic Device (EPLD)

The Erasable Programmable Logic Device (EPLD), introduced by in 1984, represents an early CMOS-based advancement in programmable logic, enabling UV-erasable, non-volatile reconfiguration to bridge the gap between simple fixed-architecture devices and more intricate designs. These devices utilized or cells for storage, allowing erasure through ultraviolet light exposure typically requiring 30 minutes to 2 hours, which facilitated iterative prototyping without electrical reprogramming hardware. Unlike prior bipolar technologies, EPLDs offered significantly lower power consumption—often less than 40% of equivalent bipolar devices—while achieving higher integration densities suitable for replacing multiple TTL components. At their core, EPLD architectures comprised multiple programmable array logic (PAL)-like blocks, known as logic array blocks (LABs), interconnected via a global programmable interconnect (PIA) for flexible signal across the device. Each LAB contained macrocells with configurable AND/OR s, supporting up to 192 or more macrocells per device, enabling complex combinational and implementations. For instance, Altera's MAX 7000 series, prominent in the , delivered densities up to 5,000 gates with propagation delays as low as 15 ns, making them viable for applications like address decoding and state machines. Programming of EPLDs relied on standard JEDEC files generated by tools such as MAX+PLUS II, which compiled designs into fusemap data for in-circuit or off-circuit loading via dedicated programmers. Macrocells could be programmed as D-type, T-type, JK, or SR flip-flops, or purely combinatorial, with support for up to 256 macrocells in advanced configurations to handle expanded input/output requirements. Building briefly on the reprogrammability pioneered in devices like Lattice's GALs, EPLDs extended this capability through CMOS scalability for broader I/O and density, though relying on UV erasure rather than electrical methods. As programmable logic evolved, EPLDs served as direct precursors to complex PLDs (CPLDs), influencing architectures with enhanced interconnects, but were phased out by the early 2000s in favor of electrically erasable, flash-based alternatives like Altera's MAX II series introduced in 2004, which eliminated the need for UV exposure and improved reconfiguration speed. By the 2010s, classic EPLDs were declared obsolete, with legacy support limited to existing inventories.

Complex Programmable Logic Device (CPLD)

Complex programmable logic devices (CPLDs) represent an evolution from erasable programmable logic devices (EPLDs) by integrating multiple arrays of macrocells with a centralized programmable interconnect array (PIA) to enable larger-scale designs while maintaining predictable performance. The core architecture typically consists of 4 to 16 logic array blocks (LABs), each containing PAL- or GAL-like macrocells that implement combinational and functions through configurable AND-OR planes and flip-flops. These macrocells are interconnected via the PIA, a switch matrix that routes signals between LABs, inputs, outputs, and buried nodes using elements such as flash or , allowing instant-on operation without external configuration memory. This fixed interconnect structure ensures low propagation delays and reliable timing, as the routing paths are determined at configuration time and do not require dynamic reconfiguration. CPLDs offer logic densities ranging from approximately 600 to 10,000 usable gates, making them suitable for mid-scale applications where speed and power efficiency are prioritized over extreme flexibility. Their non-volatile nature eliminates reconfiguration delays, enabling fast pin-to-pin logic delays as low as a few nanoseconds, which is advantageous in systems requiring immediate functionality upon power-up. For instance, Xilinx's CoolRunner family, introduced in the early , emphasized ultra-low power consumption with standby currents under 100 μA, targeting portable and remote applications through its Fast Zero Power (FZP) architecture. Similarly, Altera's MAX II series, launched in 2004, utilized a flash-based to deliver non-volatile CPLDs with up to 2,210 logic elements and reduced power compared to prior generations, achieving up to 50% lower total power in competitive benchmarks. Modern iterations, such as 's MAX 10 series introduced in 2014, extend these capabilities with higher densities and integrated features like analog-to-digital converters while preserving CPLD predictability. The design flow for CPLDs focuses on partitioning user logic to fit within the fixed and PIA resources, using synthesis tools to map (HDL) code into the device's AND-OR array structure. Timing closure is achieved through static , where tools simulate across predefined paths without simulation-based verification, ensuring compliance with clock and setup/hold requirements due to the architecture's inherent predictability. In , CPLDs are commonly employed for to interface components, providing reliable signal routing and control without the overhead of more complex devices.

Field-Programmable Gate Arrays

Core Architecture

The core architecture of a (FPGA) consists of a two-dimensional of configurable logic blocks (CLBs) interconnected by programmable resources and surrounded by blocks (IOBs). Each CLB serves as the fundamental unit for implementing user-defined logic and storage, typically comprising multiple basic logic elements (BLEs) that include look-up tables (LUTs) for combinational functions and flip-flops for sequential elements. This island-style layout enables massive parallelism and scalability, distinguishing FPGAs from earlier programmable logic devices like complex programmable logic devices (CPLDs), which rely on fixed arrays rather than a flexible grid of independent blocks. Within a CLB, LUTs form the primary logic elements, each capable of implementing any of 4 to 6 inputs by storing the in SRAM bits; for an n-input LUT, the capacity is 2n2^n configuration bits, allowing versatile mapping of complex or small arithmetic units. For instance, flip-flops paired with each LUT provide state retention, configurable as edge-triggered registers or latches with optional clock enables and resets, enabling the realization of finite state machines or pipelines. In the seminal Xilinx Virtex family introduced in , each CLB contains four 4-input LUTs and four flip-flops organized into two slices, arranged in a rectangular array such as 64 rows by 96 columns for the XCV1000 device, supporting densities up to 1 million system . Resource utilization metrics, such as slices per logic function, guide ; a typical slice might implement 4-8 equivalent or a single 4-bit , depending on the function's complexity. Routing in FPGAs is facilitated by segmented wiring channels and switch matrices that connect CLBs and IOBs, with programmable switches—implemented via pass transistors or multiplexers—controlling signal paths for arbitrary connectivity. These interconnect resources, including short single-length wires, medium-length buffered lines, and long lines spanning the chip, occupy 80-90% of the total die area to accommodate the high typical of logic designs. IOBs, positioned along the chip periphery, interface with external signals, incorporating programmable buffers, pull-up resistors, and support for standards like LVTTL, ensuring seamless integration with surrounding systems.

Routing and Interconnect Resources

The and interconnect resources in field-programmable gate arrays (FPGAs) form a programmable network that connects configurable logic blocks (CLBs) and other elements, enabling flexible signal distribution across the device. This network is essential for FPGA scalability and performance, as it determines how efficiently signals can propagate without excessive delay or resource overuse. In the predominant island-style , CLBs are arranged as discrete "islands" embedded within a "sea" of interconnects, where horizontal and vertical channels surround each CLB to facilitate connections. This contrasts with sea-of-gates architectures, which distribute logic more uniformly without distinct block boundaries, though island-style remains the standard for modern commercial FPGAs due to its balance of flexibility and routability. Interconnect resources are categorized by their scope and purpose, including , global, and express types. interconnects consist of short wires that link adjacent CLBs or within a CLB cluster, typically spanning one or a few tiles for low-delay, intra-region signaling. Global interconnects, often implemented as long lines spanning multiple CLBs across the chip, provide chip-wide connectivity for broad signal distribution, such as clocks or reset signals. Express interconnects are dedicated high-speed paths that bypass standard routing for critical signals, reducing latency in high-performance applications by offering direct, low-resistance routes. At the heart of the routing are switch boxes, which manage connections between wiring segments at channel intersections. These are commonly designed using multiplexer-based structures, where programmable multiplexers select among incoming tracks to route signals, or buffered pass-gate configurations that employ gates controlled by configuration memory for efficient switching with minimal area overhead. Routing channels, running horizontally and vertically between CLBs, have a defined width measured in tracks per channel, typically ranging from 24 to 200 tracks depending on the FPGA family and density, to accommodate the required connectivity density. Key challenges in FPGA routing include congestion, where high demand for limited tracks in dense regions leads to unroutable designs or increased delays, and accurate delay modeling to predict signal propagation. Congestion is mitigated through place-and-route algorithms that balance , but it remains a primary of circuit . Delay modeling often employs the Elmore delay to account for RC parasitics in segmented wires and switches, providing a first-order estimate of signal crucial for timing closure. Commercial tools like 's handle place-and-route by optimizing these resources, using iterative negotiation to resolve congestion and meet timing constraints.

Modern Enhancements and Variants

Modern field-programmable gate arrays (FPGAs) have evolved significantly since the 2010s through the integration of hardened intellectual property (IP) blocks, enabling higher performance and reduced power consumption in system-on-chip (SoC) designs. These enhancements include specialized DSP slices, such as Xilinx's DSP48 and DSP58 engines, which provide efficient multiply-accumulate operations for signal processing tasks. PCIe interfaces are commonly hardened, as seen in Intel's Stratix 10 and Agilex families, supporting high-speed data transfer up to Gen5 rates for host-accelerator connectivity. Additionally, embedded ARM processors, like the quad-core Cortex-A53 in AMD's Zynq UltraScale+ MPSoCs, allow seamless fusion of programmable logic with scalar processing for adaptive computing platforms. A key advancement in is 3D stacking via technologies like AMD's Stacked Silicon Interconnect (SSI), first introduced in Virtex UltraScale+ devices and extended to the Versal architecture announced in , which stacks multiple dies to achieve higher density and bandwidth while improving power efficiency by minimizing interconnect distances. This heterogeneous integration reduces size, weight, and power (SWaP) compared to traditional planar designs, enabling applications requiring massive parallelism. Variants of modern FPGAs emphasize adaptive SoC capabilities and . Intel's Agilex 5 series (2024), incorporates AI Tensor Blocks for accelerated inference, offering up to 1.9x fabric performance over prior generations and supporting heterogeneous integration via Embedded Multi-Die Interconnect Bridge (EMIB). For low-power edge deployments, Lattice Semiconductor's Certus-NX family, built on 28 nm FD-SOI process since 2020, delivers up to 4x lower power than comparable FPGAs, with features like programmable back-bias for mode selection between low-power and high-performance operation, ideal for instant-on sensor interfaces. By 2023, AMD's Versal Premium series on TSMC's achieved densities exceeding 10 million logic cells, with the VP1902 model offering 18.5 million system logic cells for emulation and tasks, doubling programmable logic over predecessors. highlights include up to 99 (INT8) from enhanced DSP58 engines and support for 600G multirate Ethernet, enabling 5 Tb/s aggregate throughput for data-centric workloads. Power efficiency gains stem from advanced nodes and optimized architectures, such as FD-SOI in edge variants, reducing rates by 100x. Looking to 2025 trends, FPGAs are incorporating quantum-resistant support, as exemplified by Lattice's MachXO5-NX TDQ family, the first CNSA 2.0-compliant (PQC)-ready devices with hardware root of trust and crypto-agility for secure edge and applications. Densities continue surpassing 10 million cells, with forthcoming shifts to sub-7 nm processes like TSMC's 5 nm enhancing efficiency for AI and high-bandwidth networking, including 100G+ Ethernet standards.

Configuration Mechanisms

Memory Technologies for Retention

Some programmable logic devices (PLDs), particularly erasable and reprogrammable types, rely on technologies to retain configuration data without continuous , ensuring persistent logic functionality across power cycles. These technologies form the basis for storing the device's programmable interconnections and logic states, with key types including , and floating-gate-based and . Factory-based programming, used in some read-only memories (ROMs) and early PROMs, involves custom photomasks to define permanent metal or polysilicon interconnections during fabrication, providing high-volume, cost-effective solutions for fixed designs but lacking user reprogrammability after manufacturing. Antifuse technology employs a layer between two metal layers that, when subjected to a high programming voltage, undergoes breakdown to form a permanent low-resistance conductive link, enabling one-time programmable (OTP) configurations in devices like Actel's ProASIC family. This physical alteration ensures indefinite without power, as the connection persists structurally, offering superior reliability in radiation-hardened environments such as space applications, where long-term storage tests on antifuses demonstrate stability over decades. In contrast to reprogrammable options, antifuses provide exceptional endurance for static designs but cannot be erased or modified post-programming. Floating-gate EEPROM, a cornerstone of erasable PLDs like (GAL) devices from , stores configuration data as trapped charges on an isolated polysilicon gate within a structure, altering the transistor's to represent logic states. Programming injects electrons onto the floating gate via Fowler-Nordheim tunneling under high voltage, while electrical erasure removes them, allowing in-system reprogramming; GAL devices, such as the GAL16V8, utilize these E²CMOS cells for their AND-array configuration, typically comprising tens to hundreds of bits per device. Data in these non-volatile cells stems from the insulating oxide layers that minimize charge leakage, with typical lifespans of 10 to 20 years at , though accelerated testing at elevated temperatures confirms this through Arrhenius modeling of charge detrapping. Charge trapping in the tunnel oxide during repeated program/erase cycles can cause shifts, but optimized designs mitigate this for reliable operation. Flash memory, an evolution of used in Complex Programmable Logic Devices (CPLDs) like Xilinx's XC9500 series, employs similar floating-gate mechanisms but enables block-level electrical erasure for faster reconfiguration, storing configuration bits in dense — for instance, the XC9572XL CPLD features an integrated flash supporting up to several thousand configuration bits. Retention characteristics mirror , with non-volatile charge storage providing 20 years of under standard conditions, as verified in manufacturer specifications for industrial applications. Trade-offs between these technologies highlight antifuse's unmatched permanence and tolerance against and flash's reprogrammability, where the latter offer 10,000 to 1,000,000 write/erase cycles before oxide degradation impacts retention, balancing flexibility with endurance limits in environments. Emerging non-volatile memory technologies, such as magnetoresistive random-access memory (MRAM), are being explored for integration into FPGAs and PLDs as of 2025, offering instant-on reconfiguration, lower power, and resistance to radiation without the volatility of SRAM or limitations of flash.

Volatile and Non-Volatile Approaches

Volatile approaches to configuration in programmable logic devices (PLDs), primarily SRAM-based field-programmable gate arrays (FPGAs), rely on static random-access memory cells to store the device logic and interconnect settings. This method enables rapid reconfiguration, typically completing in hundreds of milliseconds to seconds for full device updates in modern implementations, with partial reconfiguration allowing faster selective updates often in milliseconds, making it suitable for applications requiring frequent or partial runtime changes without halting the entire system. However, SRAM's volatility means the configuration is lost upon power cycling, necessitating an external boot process—typically loading a bitstream from non-volatile storage like flash memory—each time the device powers up, which introduces a brief delay before functionality resumes. Partial reconfiguration, a key feature of SRAM-based FPGAs, allows selective updating of device regions while the rest continues operating uninterrupted, enhancing efficiency in dynamic environments such as adaptive signal processing or real-time systems. Non-volatile approaches, commonly implemented in complex programmable logic devices (CPLDs) using embedded flash or cells, retain configuration data indefinitely without power, enabling instant-on operation upon with no external required. This eliminates reconfiguration delays and supports boot-critical applications where immediate is essential, such as power sequencing or initialization in embedded controllers. Radiation-hardened variants of these non-volatile PLDs, like Microchip's RTG4 flash-based FPGAs (which share architectural similarities with CPLDs in configuration), withstand high-radiation environments or nuclear settings by leveraging flash's inherent resilience to single-event upsets, often achieving total ionizing dose tolerance exceeding 100 krad. These devices prioritize reliability in harsh conditions, with flash cells designed to maintain under . Hybrid configurations combine SRAM's speed with non-volatile storage, typically using flash or as a shadow memory that automatically copies the to SRAM cells during power-up, achieving reconfiguration times in hundreds of milliseconds to seconds while providing retention. This approach balances volatility's flexibility with non-volatility's persistence, common in devices like Actel's Fusion family, where flash holds the persistent image and SRAM drives runtime logic. In terms of power impacts, volatile SRAM-based PLDs consume higher static power—often exceeding 100 mW in mid-range FPGAs due to constant refresh needs—making them preferable for dynamic applications like accelerators that tolerate elevated consumption for reconfigurability. Conversely, non-volatile flash-based PLDs exhibit lower , around 50 mW or less, suiting boot-critical uses in battery-powered or low-power systems where minimizing idle draw is vital. Hybrids mitigate this by leveraging flash's low retention power during off-states but incur slight overhead from boot-time transfers. Retention in non-volatile PLDs is rigorously tested per standards like JESD22-A117, which evaluates endurance and over expected lifetimes, often projecting 10-20 years at elevated temperatures to ensure long-term reliability in deployed systems. Anti-tamper features further enhance in both volatile and non-volatile PLDs; for instance, modern FPGAs and CPLDs incorporate bitstream encryption, physical sensors for voltage/clock anomalies, and automatic upon detected intrusion, as outlined in 2025 DoD guidance for FPGA , preventing or unauthorized reconfiguration in sensitive applications like defense . These mechanisms, including device-level monitors in Lattice Avant-X and Microchip PolarFire families, respond to tampering by clearing configuration memory, thereby protecting .

Programming and Design Flow

Hardware Description Languages

Hardware description languages (HDLs) serve as the primary means for specifying the logic functionality of programmable logic devices (PLDs), enabling designers to model hardware behavior at various levels for synthesis into device-specific structures such as macrocells in complex PLDs (CPLDs) or lookup tables (LUTs) in field-programmable gate arrays (FPGAs). These languages facilitate the creation of reusable, verifiable designs that can be simulated prior to implementation, ensuring correctness before configuration. Verilog, standardized as IEEE 1364, is an event-driven HDL that uses modules to encapsulate logic, with constructs like always blocks for describing sequential behavior and continuous assignments for . For instance, a simple RTL description of a in might appear as:

module logic_gate ( input a, b, c, output out ); assign out = (a & b) | (~c); endmodule

module logic_gate ( input a, b, c, output out ); assign out = (a & b) | (~c); endmodule

This code targets PLD resources by synthesizing the continuous assignment into gates or LUTs during the implementation process. VHDL, defined by IEEE 1076, adopts an entity-architecture paradigm where the entity declares the interface (ports) and the architecture body implements the internal logic, emphasizing strong typing for robustness in complex designs. A basic example for a logic component is:

entity logic_gate is port ( a, b, c : in bit; out : out bit ); end entity logic_gate; architecture behavioral of logic_gate is begin out <= (a and b) or (not c); end architecture behavioral;

entity logic_gate is port ( a, b, c : in bit; out : out bit ); end entity logic_gate; architecture behavioral of logic_gate is begin out <= (a and b) or (not c); end architecture behavioral;

Such descriptions are synthesized to map onto PLD macrocells or LUTs, with built-in simulation support for verification of timing and functionality. , outlined in IEEE 1800, extends with enhanced features for both design and verification, including interfaces, classes, and assertions, while maintaining compatibility with RTL modeling. It supports behavioral descriptions at higher abstraction levels, transitioning to synthesizable RTL code that optimizes for PLD targets like LUT-based fabrics. HDL usage spans from high-level behavioral models, which abstract away clock-level details, to precise RTL descriptions that explicitly handle register transfers and combinational paths, as in the Verilog assign statement example above. In PLD contexts, these models are verified through simulation to catch errors early, ensuring reliable mapping to device primitives without direct reference to configuration memory technologies. By 2025, the adoption of high-level synthesis (HLS) tools, which generate HDL from C++ or similar software languages, has grown significantly for FPGA designs, exemplified by AMD's Vitis HLS, allowing faster prototyping of complex algorithms while producing optimized RTL for LUT utilization. This evolution bridges software and hardware paradigms, reducing design time for PLD applications.

Synthesis and Implementation Tools

The synthesis and tools for programmable logic devices (PLDs) form a critical (EDA) pipeline that transforms (HDL) code into a configured for deployment on devices like field-programmable gate arrays (FPGAs) and complex PLDs (CPLDs). This process begins with synthesis, where the HDL is analyzed and optimized into a gate-level , followed by stages that map and route the design onto the target architecture. Key objectives include minimizing resource usage, meeting timing constraints, and estimating power consumption to ensure reliable performance. Synthesis involves several optimization steps, starting with parsing the HDL to identify synthesizable constructs and inferring hardware elements like registers and . techniques, such as constant propagation, , and retiming, reduce redundancy and improve efficiency. A pivotal phase is technology mapping, which decomposes the optimized logic into device-specific , such as look-up tables (LUTs) for FPGAs, ensuring compatibility with the PLD's configurable logic blocks. Commercial tools like 's Design Suite perform these steps through a unified flow, generating a synthesized netlist that serves as input for subsequent . Similarly, Intel's Quartus Prime software employs its own synthesis engine to convert HDL to a technology-mapped , incorporating high-level optimizations for arithmetic and state machines. Implementation follows synthesis with place-and-route (P&R), where logic elements are allocated to physical resources and interconnected via routing channels. Placement assigns components to specific locations on the device to minimize wire lengths and congestion, often using algorithms for scalability. Routing then establishes connections while respecting timing budgets and resource limits, employing path-based or algorithms to resolve conflicts. Timing , integrated throughout P&R, computes signal propagation delays and verifies slack—the margin between required and actual arrival times—against user-defined constraints. Area metrics track utilization in terms of slices or logic elements, while power estimation models dynamic and static consumption based on toggling rates and voltage. For routing optimization, —a probabilistic —iteratively perturbs wire assignments, accepting suboptimal moves with decreasing probability to escape local minima and achieve global routability. Prominent tools include Vivado, which integrates synthesis, placement, and routing in a single environment supporting incremental compilation for faster iterations on large designs. Quartus Prime offers similar capabilities, with advanced partitioning for modular designs and early power analysis to guide optimizations. For open-source alternatives, Yosys provides a flexible framework for Verilog synthesis, performing logic optimization and LUT mapping for simpler PLDs and FPGAs like Lattice iCE40, often paired with nextpnr for P&R. These tools output metrics reports, such as slice utilization under 80% for balanced designs or positive timing slack exceeding 10% of clock period, to validate feasibility before bitstream generation. As of 2025, advancements incorporate AI-assisted techniques in placement and routing using to improve design outcomes in complex FPGAs. Additionally, tools like and Quartus have enhanced multi-die support for heterogeneous FPGAs, enabling partitioned flows that handle inter-die routing while optimizing overall system timing and power.

Programming Hardware and Processes

Programming hardware for programmable logic devices (PLDs) primarily relies on boundary-scan interfaces compliant with the IEEE 1149.1 standard, also known as JTAG, which uses a Test Access Port (TAP) with dedicated pins for TDI (test data input), TDO (test data output), TMS (test mode select), and TCK (test clock). These interfaces enable in-system programming (ISP) through compact pods or cables that connect to a host computer via USB, allowing configuration without device removal from the circuit board. For high-throughput scenarios, PCIe interfaces support ISP by leveraging protocol-based configuration, where the PLD acts as an endpoint in a PCIe topology for direct bitstream transfer from the host. The programming process starts with bitstream generation, creating a compact from the post-synthesis that encodes the device's logic and configuration. This is then loaded into the PLD using serial modes, such as SPI or SelectMAP, which shift data bit-by-bit through dedicated pins, or parallel modes like BPI, which load multiple bits simultaneously via a wider bus for faster configuration in larger devices. Verification follows loading via readback, where the PLD's internal configuration memory is serially scanned out and compared against the original to confirm integrity and detect errors. Key protocols include JTAG daisy-chaining for multiple PLDs, where devices are connected in series to share a single interface, enabling sequential or parallel configuration while monitoring status signals like CONF_DONE. mechanisms provide one-time programmable non-volatile storage for security keys and settings, blown via high-current pulses to set permanent bits that cannot be reversed. In FPGAs supporting dynamic operation, partial reconfiguration protocols allow runtime loading of modular bitstreams through the Internal Configuration Access Port (ICAP) or , updating specific regions without halting the entire device. As of 2025, secure programming standards emphasize AES-256 encryption for bitstreams during boot and loading, using modes like Galois Counter Mode (GCM) or Counter (CTR) to ensure and before decryption on-chip. Tools such as iMPACT, integrated in the ISE Design Suite, facilitate these processes by supporting JTAG chain detection, bitstream delivery, and programming for legacy and compatible devices.

Traditional and Emerging Uses

Programmable logic devices (PLDs), particularly field-programmable gate arrays (FPGAs) and complex programmable logic devices (CPLDs), have long served as essential tools in electronic design for prototyping and integration. In traditional applications, FPGAs are widely used for (ASIC) prototyping, allowing designers to emulate ASIC functionality before committing to costly fabrication processes, thereby reducing development time and expenses by up to several months. CPLDs, with their instant-on capabilities and simpler , are commonly employed for in printed circuit boards (PCBs), facilitating interfaces between microcontrollers and peripherals such as sensors or displays without requiring full custom silicon. Additionally, PLDs implement digital controllers in embedded systems, handling tasks like and state machine operations where flexibility is needed over fixed-function alternatives. Emerging applications leverage the reconfigurability of PLDs to address demands in and resource-constrained environments. FPGAs act as reconfigurable AI accelerators, particularly for tensor in data centers during the 2020s, enabling efficient deep neural network (DNN) inference by optimizing hardware for specific models and reducing latency compared to general-purpose processors. In for (IoT) devices, low-power CPLDs and FPGAs support real-time data at the network periphery, minimizing latency and power consumption for applications like smart sensors and industrial automation. As of 2025, trends include enhanced AI/ML acceleration at the edge and low-power optimizations for automotive and IoT applications. For instance, 's (formerly ) Alveo accelerator cards, such as the U50 and U200 models, deliver high-, energy-efficient real-time ML in and on-premises environments, achieving up to 90 times the of CPUs on key workloads. Similarly, AMD Versal AI Edge Series Gen 2 adaptive SoCs have been announced by Subaru for next-generation EyeSight systems, with silicon samples available from mid-2025 and deployment in models starting around 2026, integrating AI engines for and vision . The PLD market reflects these evolving uses, with the FPGA segment projected to reach approximately $11.7 billion in 2025, driven by demand in and AI sectors, with FPGAs comprising the majority of deployments. A notable shift is toward and emerging base stations, where FPGAs handle massive multiple-input multiple-output () beamforming and high-bandwidth , supporting scalable deployments without ASIC non-recurring engineering costs.

Security Considerations and Challenges

Programmable logic devices (PLDs), particularly field-programmable gate arrays (FPGAs), face significant vulnerabilities due to their reconfigurable nature, which exposes configuration bitstreams to attacks. Attackers can intercept and analyze bitstreams to extract (IP) or reconstruct hardware designs, often using specialized tools to map bitstream data back to high-level logic structures. Side-channel attacks, such as , further exacerbate these risks by exploiting variations in power consumption during configuration or operation to infer sensitive data like keys without direct access to the bitstream. Additionally, hardware Trojans—malicious circuits inserted during the —can be embedded in third-party IP cores or FPGA netlists, enabling stealthy backdoors that activate under specific conditions to compromise functionality or leak data. These Trojans are particularly challenging to detect in outsourced designs, as they may remain dormant until triggered by rare inputs or environmental factors. Volatile SRAM-based FPGAs present unique challenges, as their configuration memory loses data upon power loss, but brief interruptions can allow cold-boot-style attacks where remnants of the are recovered from partially decayed SRAM cells using specialized cooling techniques. For non-volatile PLDs, such as those using flash or technologies, cloning remains a key risk; the interface, commonly used for programming, can be exploited to read out the entire configuration if not properly secured, enabling unauthorized duplication of devices in high-volume production. These issues are compounded in scenarios, where untrusted vendors may access or tamper with configurations during or deployment. In October 2025, researchers uncovered a new vulnerability in FPGA chips allowing physical access-based attacks on configuration . To mitigate these threats, modern PLDs incorporate bitstream encryption schemes, such as AES-based protection in Xilinx 7-series FPGAs, which decrypts configurations only after secure key loading to prevent interception and reverse engineering. Physical unclonable functions (PUFs), implemented via ring oscillators or SRAM startup values on FPGAs, generate device-unique keys that resist cloning by leveraging manufacturing variations, serving as roots of trust for authentication and key derivation. Intel Agilex FPGAs employ secure enclave designs through the Secure Device Manager, which enforces authenticated boot flows and isolates sensitive operations in hardware-trusted zones to protect against tampering. Emerging standards, such as NIST IR 8320, outline hardware-enabled security techniques for platforms like FPGAs, emphasizing layered defenses including remote attestation and secure provisioning to address cloud and edge deployment risks. A notable vulnerability in Xilinx devices, exemplified by the 2020 break of 7-series bitstream encryption (demonstrating key recovery via side-channel methods), underscores the need for ongoing updates to these countermeasures.

References

  1. https://www.electrical4u.com/programmable-logic-devices/
  2. https://www.ampheo.com/blog/programmable-logic-devicesplds-basics-types-applications-and-examples
  3. https://course.khoury.northeastern.edu/cs3650/ssl/TEXT-CD/Content/COD3e/CDSections/HP_AppB.pdf
  4. https://standards.nasa.gov/sites/default/files/standards/NASA/Baseline-w/CHANGE-1/1/Historical/2013-12-02_NASA-HDBK-4008_Draft1_Clean_Published.pdf
  5. https://www.physics.wisc.edu/courses/home/spring2025/623/lecture_notes/digital/programmable-logic.pdf
  6. https://www.eng.auburn.edu/~nelson/courses/elec4200/Slides/Programmable%20Logic%20Devices.pdf
  7. https://web.itu.edu.tr/~ateserd/vlsi2/2007/FPGAs&CPLD.pdf
  8. https://www.eecg.toronto.edu/~jayar/pubs/brown/survey.pdf
  9. https://www.eetimes.com/who-made-the-first-pld/
  10. https://www.computerhistory.org/siliconengine/pal-user-programmable-logic-devices-introduced/
  11. https://www.eejournal.com/article/how-the-fpga-came-to-be-part-3/
  12. https://www.company-histories.com/Lattice-Semiconductor-Corp-Company-History.html
  13. https://www.eejournal.com/article/how-the-fpga-came-to-be-part-4/
  14. https://www.eejournal.com/article/how-the-fpga-came-to-be-part-5/
  15. http://www.bitsavers.org/components/xilinx/xcell/Xcell19.pdf
  16. https://www.semichips.org/news/archives/pr06072000_53.htm
  17. https://www.eetimes.com/lattice-semiconductor-acquires-vantis-corp-from-amd/
  18. https://www.intc.com/news-events/press-releases/detail/302/intel-completes-acquisition-of-altera
  19. https://www.embedded.com/milestones-in-embedded-systems-design/
  20. https://www.tce.edu/sites/default/files/PDF/14EC770-ASIC-DESIGN-K-Kalyani.pdf
  21. https://www.sciencedirect.com/topics/computer-science/programmable-logic-array
  22. https://ieeexplore.ieee.org/document/1675427
  23. https://www.edn.com/milestones-that-mattered-pals-found-first-programmable-logic-success/
  24. https://bitsavers.computerhistory.org/components/mmi/_dataBooks/1981_MMI_PAL_Handbook_2ed.pdf
  25. https://bitsavers.trailing-edge.com/components/amd/programmable_logic/1984_AMD_Programmable_Array_Logic_Handbook.pdf
  26. https://bitsavers.trailing-edge.com/components/latticeSemiconductor/_dataBooks/1992_Lattice_GAL_Data_Book.pdf
  27. http://www.ele.uva.es/~jesman/BigSeti/ftp/Componentes/GAL/introgal.pdf
  28. https://www.alldatasheet.com/datasheet-pdf/pdf/70214/LATTICE/GAL16V8D.html
  29. https://retrobrewcomputers.org/n8vem-pbwiki-archive/0/82152589/Programmable%20logic%20devices%20-%20v1.6.pdf
  30. http://bitsavers.org/components/altera/_dataBooks/1990_Altera_Data_Book.pdf
  31. https://www.design-reuse.com/news/202507178-altera-takes-radical-new-direction-with-max-ii-cplds/
  32. https://cdrdv2-public.intel.com/654718/m7000.pdf
  33. https://docs.amd.com/api/khub/documents/f7Zy0wuHkbMe8x6U2KPmGQ/content
  34. https://phys.org/news/2004-07-altera-shipping-max-ii-devices.html
  35. https://www.intel.com/content/www/us/en/products/details/fpga/max/10/overview.html
  36. https://cse.usf.edu/~haozheng/teach/cda4253/doc/fpga-arch-overview.pdf
  37. https://www.eecg.toronto.edu/~jayar/pubs/theses/Brown/StephenBrown.pdf
  38. http://www.gstitt.ece.ufl.edu/courses/eel4720_5721/reading/Routing.pdf
  39. http://ndl.ethernet.edu.et/bitstream/123456789/21879/1/20.pdf
  40. https://docs.amd.com/r/en-US/ug474_7Series_CLB/Interconnect-Resources
  41. https://people.ece.ubc.ca/stevew/papers/pdf/imran_masc.pdf
  42. https://www.ttcenter.ir/ArticleFiles/ENARTICLE/3772.pdf
  43. https://www.eecg.toronto.edu/~jayar/pubs/theses/Swartz/JordanSwartz.pdf
  44. https://docs.amd.com/api/khub/documents/0DCtdlWHj25lhQst_AhD0g/content
  45. https://docs.amd.com/r/en-US/ug1485-versal-architecture-premium-series-libraries/DSP58
  46. https://indico.ific.uv.es/event/3294/contributions/9111/attachments/6254/6988/Stratix_V_-_Stratix_V_Features.pdf
  47. https://www.eetimes.com/xilinx-unveils-16nm-ultrascale-fpgas-mpsocs-3d-ics/
  48. https://docs.amd.com/v/u/en-US/wp380_Stacked_Silicon_Interconnect_Technology
  49. https://www.amd.com/en/products/adaptive-socs-and-fpgas/versal/premium-series.html
  50. https://static4.arrow.com/-/media/arrow/files/pdf/intel-agilex-5-fpgas-datasheet.pdf?h=16&thn=1&w=16&hash=7D286BE529CD202A731503AA9421AE42
  51. https://www.latticesemi.com/Products/FPGAandCPLD/Certus-NX
  52. https://www.amd.com/content/dam/amd/en/documents/products/adaptive-socs-and-fpgas/versal/versal-premium-series-product-brief.pdf
  53. https://finance.yahoo.com/news/lattice-launches-industry-first-pqc-130000789.html
  54. http://www.pldworld.com/html/technote/Tour_of_PLDs.htm
  55. https://ww1.microchip.com/downloads/aemdocuments/documents/fpga/ApplicationNotes/ApplicationNotes/low_power_an.pdf
  56. https://www.researchgate.net/publication/259092734_Long_term_storage_reliability_of_antifuse_field_programmable_gate_arrays
  57. https://www.st.com/resource/en/application_note/an4653-cycling-endurance-and-data-retention-of-high-density-eeprom-based-on-cmos-f8h-process-stmicroelectronics.pdf
  58. https://kolodny.net.technion.ac.il/files/2016/07/E2PROM01485793.pdf
  59. https://electronics.stackexchange.com/questions/188445/do-cpld-devices-lose-non-volatile-memory-over-long-periods-of-time
  60. https://www.st.com/resource/en/application_note/an5866-guidelines-for-cycling-endurance-and-data-retention-of-page-eeproms-stmicroelectronics.pdf
  61. https://www.latticesemi.com/Blog/2025/01/16/16/41/From-Flash-to-MRAM
  62. https://www.eetimes.com/new-lattice-transfr-solution-enables-transparent-fpga-reconfiguration-while-system-operates/
  63. https://www.microchip.com/en-us/products/fpgas-and-plds/radiation-tolerant-fpgas
  64. https://ww1.microchip.com/downloads/aemdocuments/documents/fpga/ProductDocuments/SupportingCollateral/lapu_wp.pdf
  65. https://www.wevolver.com/article/cpld-vs-fpga-a-comprehensive-technical-analysis-and-implementation-guide
  66. https://www.magmio.com/news/149-cpld-vs-fpga
  67. https://www.jedec.org/sites/default/files/docs/22A117B.pdf
  68. https://media.defense.gov/2025/Jan/07/2003625567/-1/-1/0/CTR_FPGA_SECURITY_GUIDANCE.PDF
  69. https://www.latticesemi.com/en/Blog/2024/07/30/15/14/Lattice-Avant-X-Securing-the-Digital-Frontier
  70. https://standards.ieee.org/ieee/1364/3641/
  71. https://www.eg.bucknell.edu/~csci320/2016-fall/wp-content/uploads/2015/08/verilog-std-1364-2005.pdf
  72. https://standards.ieee.org/ieee/1076/5179/
  73. https://www.0x04.net/~mwk/vstd/ieee-1076-2019.pdf
  74. https://standards.ieee.org/ieee/1800/7743/
  75. https://www.amd.com/en/products/software/adaptive-socs-and-fpgas/vitis/vitis-hls.html
  76. https://docs.amd.com/r/en-US/ug1399-vitis-hls
  77. https://www.synopsys.com/implementation-and-signoff/fpga-based-design/synplify.html
  78. https://docs.amd.com/r/en-US/ug901-vivado-synthesis
  79. https://www.intel.com/content/www/us/en/programmable/quartushelp/current/index.htm
  80. https://yosyshq.net/yosys/
  81. http://class.ece.iastate.edu/cpre583/HW/mini_survey/Place_and_route.pdf
  82. https://ieeexplore.ieee.org/document/9836761/
  83. https://dl.acm.org/doi/10.1145/3728467
  84. https://docs.amd.com/r/en-US/ug912-vivado-properties/SLR
  85. https://www.intel.com/content/www/us/en/docs/programmable/683872/25-1/embedded-multi-die-interconnect-bridge-emib.html
  86. https://docs.amd.com/r/en-US/ug570-ultrascale-configuration/Boundary-Scan-Using-IEEE-Standard-1149.1
  87. https://www.corelis.com/education/tutorials/boundary-scan/
  88. https://cdrdv2-public.intel.com/650344/wp-01132-stxv-cvpcie.pdf
  89. https://www.eng.auburn.edu/~nelson/courses/elec4200/FPGA/ug470_7Series_Config.pdf
  90. https://docs.amd.com/r/en-US/ug908-vivado-programming-debugging/Readback-and-Verify
  91. https://www.intel.com/content/www/us/en/docs/programmable/683777/current/jtag-multi-device-configuration.html
  92. https://docs.amd.com/r/en-US/xapp1267-encryp-efuse-program/eFUSE-Programming-General-Recommendations
  93. https://www.intel.com/content/www/us/en/docs/programmable/683834/21-3/creating-a-partial-reconfiguration-design-89923.html
  94. https://docs.amd.com/r/en-US/ug1283-bootgen-user-guide/Encryption-and-Authentication
  95. https://www.xilinx.com/support/download/index.html/content/xilinx/en/downloadNav/vivado-design-tools/archive-ise.html
  96. https://cdrdv2-public.intel.com/650579/wp-01004.pdf
  97. https://www.intel.com/content/www/us/en/programmable/customertraining/webex/PLDBasics/presentation_html5.html
  98. https://ieeexplore.ieee.org/document/797022/
  99. https://www.intel.com/content/www/us/en/learn/fpga-for-ai.html
  100. https://www.utmel.com/blog/categories/integrated%2520circuit/emerging-trends-in-complex-programmable-logic-devices-market-2025
  101. https://www.latticesemi.com/en/how-do-fpgas-help-improve-edge-computing
  102. https://www.amd.com/en/products/accelerators/alveo/u200/a-u200-a64g-pq-g.html
  103. https://www.amd.com/en/newsroom/press-releases/2024-4-9-amd-extends-leadership-adaptive-soc-portfolio-with.html
  104. https://finance.yahoo.com/news/fpga-market-worth-19-34-140100609.html
  105. https://dataintelo.com/report/global-fpga-and-pld-market
  106. https://www.xilinx.com/publications/reports/mobile-experts-market-report.pdf
  107. https://sailin.luddy.indiana.edu/papers/duncan2019fpga.pdf
  108. https://link.springer.com/chapter/10.1007/978-3-031-70411-6_2
  109. https://ieeexplore.ieee.org/document/8418606/
  110. https://eprint.iacr.org/2018/012.pdf
  111. https://etd.ohiolink.edu/acprod/odb_etd/ws/send_file/send?accession=ucin1554217182155068&disposition=inline
  112. https://ieeexplore.ieee.org/document/10103698/
  113. https://www.mdpi.com/2410-387X/8/3/36
  114. https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-763.pdf
  115. https://www.xilinx.com/publications/prod_mktg/DesignSecurity_ssht.pdf
  116. https://www.usenix.org/system/files/sec20-ender.pdf
  117. https://news.rub.de/english/2025-10-17-it-security-researchers-uncover-new-security-vulnerability-fpga-chips
  118. https://adaptivesupport.amd.com/s/article/52881?language=en_US
  119. https://www.sciencedirect.com/science/article/pii/S0167926021000766
  120. https://www.mdpi.com/2410-387X/7/4/55
  121. https://www.intel.com/content/www/us/en/docs/programmable/683673/22-3/configuration-overview.html
  122. https://csrc.nist.gov/pubs/ir/8320/final
Add your contribution
Related Hubs
User Avatar
No comments yet.