Zynq-7000 Architecture: Understanding ARM-FPGA Integration

When I first encountered the Zynq ARM architecture several years ago, I was skeptical. Another marketing gimmick combining two technologies that would be better kept separate? After designing multiple production boards around this platform, I can say with confidence that the integration of ARM processors with FPGA fabric in the Zynq chip represents a genuine breakthrough in embedded system design.

The Zynq 7000 ARM architecture isn’t just about putting an ARM core next to an FPGA on the same silicon. It’s about creating a tightly coupled system where hardware and software can communicate with bandwidth and latency that would be impossible to achieve with discrete components. For those of us who’ve struggled with the limitations of PCB-level integration between processors and FPGAs, this single-chip solution eliminates an entire class of design headaches.

This article breaks down the Zynq CPU architecture, explains how the ARM Processing System connects to the FPGA Programmable Logic, and provides practical insights for engineers evaluating this platform for their next project.

What Makes Zynq Architecture Different

The fundamental innovation in the Zynq chip is treating the ARM processor as the primary system element rather than an afterthought. Unlike soft-core processors instantiated in FPGA fabric (like MicroBlaze), the Zynq ARM cores are hardened silicon with dedicated cache hierarchy, memory controllers, and peripheral interfaces.

This approach delivers several concrete advantages:

Performance: The hardened ARM Cortex-A9 cores in Zynq 7000 ARM devices run at up to 1 GHz, approximately 25% faster than competing implementations. You’re getting genuine application processor performance, not a compromise.

Deterministic Boot: The Processing System (PS) boots first from its internal BootROM. Your software starts running before any FPGA configuration happens. This simplifies system bring-up dramatically compared to pure FPGA designs.

Reduced PCB Complexity: A single Zynq chip replaces what would traditionally require separate processor and FPGA devices, along with all the associated power supplies, decoupling, and high-speed routing between packages.

On-Chip Bandwidth: Over 3,000 interconnects link the PS and Programmable Logic (PL), providing up to 100 Gb/s of bandwidth. That’s roughly an order of magnitude more than you’d achieve routing signals between discrete chips on a PCB.

The ARM Cortex-A9 Processing System

The heart of every Zynq CPU is the Application Processing Unit (APU), built around ARM Cortex-A9 MPCore processors. Let me break down what’s actually inside.

Processor Core Specifications

NEON and Floating-Point Acceleration

Each Zynq ARM core includes optional co-processors that significantly expand computational capability:

NEON SIMD Engine: This Single Instruction Multiple Data unit performs up to 16 operations per instruction, dramatically accelerating media processing, DSP algorithms, and data-parallel workloads. If you’re doing any kind of signal processing on the ARM side, enabling NEON in your compiler flags can yield 2-4x performance improvements on suitable code.

VFPv3 Floating-Point Unit: The integrated FPU handles single and double-precision floating-point operations in hardware. Previous ARM architectures required software emulation for floating-point math, so this represents a substantial performance gain for scientific and control applications.

Memory Management Unit

The MMU in Zynq 7000 ARM cores enables full virtual memory support, which is essential for running Linux or other memory-protected operating systems. It handles translation between virtual and physical addresses with hardware acceleration, supporting both 4 KB and larger page sizes.

Cache Coherency and the Snoop Control Unit

When both ARM cores access shared memory, the Snoop Control Unit (SCU) maintains cache coherency automatically. This is critical for symmetric multiprocessing (SMP) Linux configurations where the kernel scheduler moves threads between cores freely.

The SCU also interfaces with the Accelerator Coherency Port (ACP), allowing FPGA-based hardware accelerators to participate in the cache coherency protocol. This capability becomes extremely valuable when you need to share complex data structures between software and hardware without explicit cache management.

Read more Xilinx FPGA Series:

Best Zynq UltraScale+ Development Boards Compared (2024)

How to Install Vivado on Windows 11: Step-by-Step Tutorial

Spartan-3E FPGA Board: Beginner Tutorial & Project Ideas

Where to Buy Xilinx FPGAs: Complete Authorized Distributors Guide

Xilinx Alveo Accelerator Cards: Data Center FPGA Guide

Xilinx AMD Acquisition: What It Means for FPGA Developers

Xilinx Artix-7 FPGA Family: Features, Specs & Selection Guide

Xilinx Artix-7 FPGA Price Guide

Xilinx CPLD Programmer and Xilinx CPLD Board: The Complete Guide for Engineers

Xilinx FPGA Programming for Beginners: First Project Tutorial

Xilinx JTAG Programming: Complete Hardware Setup & Debug Tutorial

Xilinx Kintex-7 FPGA: Mid-Range Performance Powerhouse

Xilinx Spartan-3 FPGA: Legacy Support & Migration Guide

Xilinx Spartan-6 FPGA: Still Relevant? Complete 2025 Guide

Xilinx Spartan-7 FPGA: Low-Cost Solution for Embedded Design

Xilinx Virtex-7 FPGA: High-End Performance for Critical Applications

Processing System Hardened Peripherals

Beyond the Zynq CPU cores, the Processing System includes an extensive collection of hardened peripheral controllers. These aren’t using FPGA resources; they’re dedicated silicon optimized for their specific functions.

DDR Memory Controller

The integrated DDR controller in Zynq chip devices supports DDR3, DDR3L, DDR2, and LPDDR2 memories with 16-bit or 32-bit interfaces. The controller handles all the timing complexity of modern DRAM, including periodic refresh, training, and ECC if enabled.

From a PCB designer’s perspective, having the memory controller inside the Zynq package means you only need to route the DDR signals themselves. There’s no separate controller chip with its own power and signal integrity requirements.

PS-PL Interconnect Architecture

Here’s where the Zynq 7000 ARM architecture really distinguishes itself. The connection between Processing System and Programmable Logic isn’t a simple parallel bus; it’s a sophisticated interconnect based on the ARM AMBA AXI protocol.

AXI Interface Types

The Zynq chip provides multiple interface categories optimized for different use cases:

General Purpose Ports (GP)

The GP interfaces handle control-plane traffic between the Zynq ARM processor and FPGA logic. When your software needs to configure hardware registers, read status, or exchange moderate amounts of data, GP ports are the appropriate choice.

The master GP ports (M_AXI_GP) let ARM software access memory-mapped registers in your PL design. The slave GP ports (S_AXI_GP) allow PL-side logic to access PS peripherals or memory, though with lower bandwidth than the HP ports.

High-Performance Ports (HP)

When you need to move large amounts of data between FPGA logic and DDR memory, the four HP ports are your workhorses. Each can be configured as 32-bit or 64-bit, and they include FIFO buffers for read and write traffic.

A single HP port running at maximum throughput can achieve approximately 1.2 GB/s. Using multiple HP ports in parallel, Zynq designs can approach the theoretical DDR bandwidth limit of around 4.2 GB/s (for DDR3-1066 with a 32-bit interface).

Accelerator Coherency Port (ACP)

The ACP provides something unique: hardware-managed cache coherency between FPGA accelerators and the Zynq CPU caches. When a PL-side accelerator reads data through the ACP, it automatically receives the most recent version, whether that data lives in DDR or in the ARM’s L1/L2 caches.

This eliminates the need for explicit cache flush and invalidate operations in your software. For applications where the ARM and FPGA share complex data structures with fine-grained access patterns, ACP can significantly simplify your design and improve performance.

The tradeoff is latency. ACP accesses go through the cache coherency protocol, which adds cycles compared to direct HP port access. For bulk data transfers where coherency can be managed at a higher level, HP ports typically perform better.

Programmable Logic Resources

The PL portion of a Zynq chip is essentially a 7-series FPGA. Depending on the specific device variant, you get either Artix-7 or Kintex-7 class resources.

FPGA Resources by Device Family

Clock Distribution

The PL receives up to four fabric clocks (FCLK0-3) from the PS clock generation subsystem. These clocks are derived from the PS’s PLLs and can be independently configured for different frequencies.

Within the PL, you have access to the same clock management resources as standalone 7-series FPGAs: MMCMs (Mixed-Mode Clock Managers) and PLLs for generating additional clock domains, and global clock buffers for distribution.

Analog Mixed Signal (XADC)

Every Zynq 7000 ARM device includes the XADC dual 12-bit ADC block capable of 1 MSPS per channel. This enables on-chip voltage and temperature monitoring, as well as external analog signal digitization without additional components.

From the PS, you can access XADC through a dedicated interface. From the PL, you have direct access to the digitized samples for custom processing pipelines.

Read more Xilinx Products:

XCVU35P-L2FSVH2104E: AMD Virtex UltraScale+ HBM FPGA Specifications, Features & Applications

XCVU35P-1FSVH2892E: High-Performance AMD Virtex UltraScale+ HBM FPGA

XC2C256-7FT256I CoolRunner-II CPLD: High-Performance Programmable Logic Device

XC2C128-7VQ100C: High-Performance CoolRunner-II CPLD for Advanced Digital Design

XC18V01SO20I: High-Performance Configuration PROM for FPGA Applications

XQ18V04VQ44N: Military-Grade 4Mbit FPGA Configuration PROM by AMD Xilinx

XC18V02VQG44I: Complete Guide to Xilinx 2Mbit In-System Programmable Configuration PROM

XC18V02PC44C0936: AMD Xilinx 2Mbit In-System Programmable Configuration PROM for FPGA Applications

XC2C512-7FT256C: AMD Xilinx CoolRunner-II CPLD | 512 Macrocell Programmable Logic Device

XC17S30PC: Xilinx Spartan OTP Configuration PROM for FPGA Applications

Design Flow for ARM-FPGA Integration

Working with the Zynq ARM architecture requires understanding how the hardware and software design flows intersect. The process differs significantly from either pure FPGA or pure ARM development.

Hardware Design in Vivado

The typical hardware design flow starts in Vivado’s IP Integrator, where you:

1. Instantiate the ZYNQ7 Processing System IP
2. Configure PS clocks, peripherals, and DDR settings
3. Add PL logic and IP cores
4. Connect PL modules to PS through appropriate AXI interfaces
5. Run synthesis, implementation, and bitstream generation
6. Export hardware description (XSA file) for software development

The IP Integrator provides block diagram-based design entry that makes connecting the Zynq CPU to custom logic relatively straightforward. Board presets for common development boards configure the PS automatically with correct DDR timing, peripheral assignments, and clock settings.

Software Development in Vitis

With the hardware description exported, software development proceeds in Vitis:

1. Create a platform project from the XSA file
2. The tool automatically generates Board Support Package (BSP) and First Stage Bootloader (FSBL)
3. Create application projects targeting the Zynq CPU
4. Build, debug, and profile using JTAG or other connections

Vitis supports both bare-metal (standalone) and Linux-based development. For bare-metal applications, you have direct access to hardware with minimal overhead. For Linux applications, you gain access to the rich Linux ecosystem at the cost of some real-time determinism.

Task Partitioning Decisions

The most critical design decision is partitioning functionality between Zynq ARM software and PL hardware. General guidelines:

Implement in ARM Software:

• Complex control flow and decision making
• User interfaces and network protocol stacks
• Tasks with irregular memory access patterns
• Functions requiring floating-point or transcendental operations

Implement in FPGA Hardware:

• Fixed-function data processing pipelines
• Tasks requiring deterministic timing
• Highly parallel operations (image processing, DSP)
• Custom peripheral interfaces

Consider Both:

• Algorithm development often benefits from ARM prototyping before PL optimization
• Some workloads partition naturally (ARM for setup/teardown, PL for steady-state processing)

Real-World Performance Considerations

Understanding theoretical specifications is one thing; achieving good performance in practice requires attention to several factors.

Memory Bandwidth Bottlenecks

In most Zynq designs, DDR memory bandwidth becomes the limiting factor for data-intensive applications. The DDR controller supports approximately 4.2 GB/s theoretical bandwidth with DDR3-1066, but practical throughput is typically 70-80% of theoretical maximum due to protocol overhead and access patterns.

When multiple PS and PL masters compete for DDR bandwidth, the interconnect’s Quality of Service (QoS) settings become important. The Zynq 7000 ARM architecture allows priority configuration for different traffic sources, ensuring latency-sensitive masters (like the ARM cores) receive preferential treatment.

Interrupt Latency

For real-time control applications, interrupt response time matters. The Zynq ARM cores achieve interrupt latency in the low microsecond range when running bare-metal code. Under Linux, interrupt latency increases to tens of microseconds due to kernel scheduling.

If your application requires deterministic sub-microsecond response, implement the critical path in PL hardware rather than relying on ARM interrupt handlers.

Power Management

The Zynq chip supports multiple power states and clock gating. The PS and PL occupy separate power domains, allowing the FPGA fabric to be powered down while ARM software continues running. This capability proves valuable in battery-powered applications where the FPGA is only needed intermittently.

Essential Resources for Zynq Development

Here are the documents and tools you’ll need when working with Zynq 7000 ARM devices:

Official Documentation

Download Links

• AMD Documentation Portal: https://docs.amd.com/r/en-US/ug585-zynq-7000-SoC-TRM
• Vivado Design Suite: https://www.xilinx.com/support/download.html
• The Zynq Book (Free): https://www.zynqbook.com/
• AMD Wiki: https://xilinx-wiki.atlassian.net/wiki/spaces/A/pages/189530183/Zynq-7000

Frequently Asked Questions

What’s the difference between Zynq ARM cores and soft processors like MicroBlaze?

The Zynq CPU uses hardened ARM Cortex-A9 silicon, delivering 5-10x the performance of soft-core alternatives at a fraction of the power consumption. Soft processors consume FPGA resources and can’t match the clock speeds or efficiency of dedicated processor silicon. However, MicroBlaze offers flexibility to instantiate multiple cores and customize the architecture, which hardened cores cannot provide.

Can I run Linux on Zynq devices?

Yes, the Zynq 7000 ARM cores fully support Linux. The dual Cortex-A9 with MMU provides all the architectural features required. PetaLinux tools from AMD simplify the process of building custom Linux distributions. The FPGA fabric remains fully functional alongside Linux, enabling hardware acceleration from user-space or kernel drivers.

How do I choose between HP and ACP ports for data movement?

Use HP ports for bulk data transfers where you can manage coherency at the application level (typically by ensuring software isn’t accessing the same buffers concurrently). Use ACP when your accelerator needs to share complex data structures with software and you want automatic coherency. HP ports offer higher bandwidth; ACP offers easier programming model for shared-memory scenarios.

What programming languages work with Zynq?

ARM software can use C, C++, Python (under Linux), and assembly. The ARM cores support standard tool chains including GCC. For FPGA logic, you’ll use Verilog, VHDL, or High-Level Synthesis (HLS) from C/C++. The AMD Vitis platform provides an integrated environment for both hardware and software development.

Is Zynq suitable for safety-critical applications?

AMD offers XA Zynq-7000 devices qualified for automotive applications (AEC-Q100). The Zynq chip architecture includes TrustZone security extensions, and the devices support secure boot and hardware-based encryption. For functional safety applications, appropriate redundancy and monitoring strategies must be implemented at the system level.

Wrapping Up

The Zynq ARM architecture represents a mature, well-supported platform for designs requiring both processor flexibility and FPGA-based hardware acceleration. The tight integration between the ARM Processing System and FPGA Programmable Logic enables performance levels that discrete two-chip solutions simply cannot match.

Whether you’re building industrial automation systems, embedded vision applications, or software-defined radio, understanding the Zynq 7000 ARM interconnect architecture is essential for extracting maximum performance. The learning curve is real, but the documentation and community support make this platform accessible to engineers willing to invest the effort.

Start with a development board, work through the official tutorials, and experiment with partitioning simple algorithms between hardware and software. Once you’ve experienced what on-chip ARM-FPGA integration can do, you’ll find it difficult to go back to discrete solutions.