FPGA Programming with Linux

Short of opening your own chip fab, you can't get much closer to the metal than FPGA programming.

Free software licenses and operating systems like GNU/Linux make it possible to
learn programming and customize state-of-the-art software in countless
ways. Hacking software, however, isn't the last frontier anymore.
What if you could hack integrated circuits directly—that is, tell a
chip to connect its internal transistors to create exactly the custom,
real-time digital hardware you want? This is precisely what you can do with
Field Programmable Gate Arrays (FPGAs). In this article, I explain how
to do it with nothing else but your Linux computer and an inexpensive
development board.

This isn't the first time Linux Journal has covered FPGAs (see Resources),
but these devices have made huge progress since those
articles were written. Plus, prices for powerful development boards
have come down dramatically. Today, you can do really cool things with
a $200–$300 FPGA-based board, a typical personal computer and one
square foot of desk space. Finally, the FPGA community is now big enough and
stable enough to make life much easier for beginners. The major FPGA
makers offer text or video tutorials and forums where even newbies
can find support. Above all, Web sites like Opencores.org codevelop
and release Linux-compatible FPGAs and boards like the EUS 100LX with
the same spirit (and licenses) as free software. In summary, the barrier
to entry is much lower now than it was even just a couple years ago,
making FPGA design both a cool hobby and an affordable and
interesting addition to the offerings of even high schools.

An FPGA Is Not a Microprocessor

A digital integrated circuit (IC) is a chip that deals only with binary
digits—meaning signals that can assume only one of two states: 0 or 1,
high or low voltage and so on. An FPGA is an IC consisting of one array of
digital logic gates. These basic circuits, made up of a few transistors each,
instantiate either a flip-flop or lookup tables capable of implementing
any boolean function of up to four binary signals. The magic of FPGAs is
that the connections among the logic gates (the actual circuit
you need) are made at power-up by reading the configuration instructions
written into a bit file. Changing the file changes the function of the FPGA.

As flexible as they are, microprocessors are always and only
microprocessors: single-purpose hardware that is capable only of
executing (relatively slowly) instructions in one machine language. An
FPGA, instead, becomes whatever hardware you need. It can morph into a
microprocessor, a game console, a real-time IP switch or encryption
device, an antitheft server or anything else you can
imagine. The only limits are that your circuit cannot require more
transistors or external pins than those physically present on the chip,
and it can't go faster than the intrinsic propagation delay from
gate to gate.

That said, modern FPGAs are powerful enough to let you squeeze several
Linux-compatible microprocessors, like the Nios, the PowerPC or the
Microblaze, inside
them and still have lots of room for your own custom circuits. In many
cases, you can load certified CPU designs from libraries and place them
on silicon with simple commands, creating very flexible, complete systems
inside just one chip.

The major manufacturers of FPGAs and other programmable ICs are Altera and
Xilinx, followed by Lattice and Atmel. Although the example in this article
uses Xilinx products, the general procedure is the same with all vendors,
and all of them have similar boards. In all cases, the design software
is closed-source and often expensive, but it is possible to download
either free trial versions valid for one or two months, or free versions
with reduced functionality but free upgrades and no expiration date.

The current way to design FPGAs is to write a behavioral model in a
Hardware Description Language (HDL), like Verilog or VHDL, which supports
concurrency and synchronous circuits. Concurrency allows you to create fully
parallel, independent processes, each describing how to
update some variables continuously. Synchronous circuits, instead, are those made of
flip-flops that change their state only on the edge of some clock signal.

After the design has been written and verified with an HDL simulator,
a compiler creates a list of all the logic gates and the wires
(nets) that must connect them to reproduce the functionality of the HDL
model. After this logic synthesis, layout programs read the netlist and
several constraints files to find out which logic gates inside the FPGAs
must be used and which physical, internal wires must connect them to each
other. The end result is the bit file that the FPGA reads at power-up.

The official Xilinx design suite is called ISE Foundation
(www.xilinx.com/ise), and the reduced functionality version is called
Webpack. Both programs run on Windows, Red Hat Enterprise and SUSE Linux
Enterprise (32- or 64-bit). Other Linux distributions may work too,
but there is no guarantee.

ISE has a graphical installer where you must accept the software license
and enter the key you got after a free registration on the Xilinx
Web site. After it's finished, you'll find a script called settings32.sh
or settings64.sh in the installation directory—that's the one you have
to source to add the Xilinx software to your path. After this, type
ise at the prompt to launch the Project Navigator (Figure 1). This
is a front end to a bunch of specialized programs, one for each design
phase. You also can run most of these back-end utilities from the command
line. The Navigator includes a Tcl prompt and, if you select
Project→Generate Tcl Script, it will save all the commands you
entered through the GUI as a Tcl script.

Figure 1. Xilinx Design Suite

Other ISE components, like the simulator, the FPGA Editor and ChipScope,
have graphical interfaces. You'd use the FPGA Editor to place and
connect single gates manually when the software fails to do it according to your
specs. ChipScope is like a software oscilloscope with a USB
probe. During synthesis, you can add special circuits to your design
that will buffer the internal signals you want to see and send them
over a USB cable to the ChipScope software for display. We'll see the
ISE HDL simulator at work in a moment.

The board I got from Xilinx for this article is the Spartan-3AN Starter
Kit (Figure 2), based on the Spartan XC3S700AN FPGA (Figure 3), which
contains about 700K system gates. Around it there are several memory
chips, a 50MHz onboard clock, a connector for an external clock and
several extra components, from D/A and A/D converters to generic I/O
pins, assorted LEDs, sliders and push buttons and, finally, a two-line
LCD display. The ports (Figure 4), are enough to make a full-custom
Linux PC out of this board: 10/100 Ethernet/PHY, USB, keyboard, VGA,
serial and stereo mini-jack for PWM audio. A universal power adapter and
USB cable are included, as are four different bit files that demonstrate
the capabilities of the FPGA. The corresponding design files are freely
downloadable from the Xilinx Web site.

I read your article on FPGA design on Linux. May I suggest you have a look at SCLive. It's a 200 something MB liveCD (can be made persistent on USB stick) dedicated to hardware description languages. It has tutorials on VHDL, Verilog, SystemC and has all the tools (open source) required to start designing with those HDLs.

Trending Topics

Upcoming Webinar

Getting Started with DevOps - Including New Data on IT Performance from Puppet Labs 2015 State of DevOps Report

August 27, 2015
12:00 PM CDT

DevOps represents a profound change from the way most IT departments have traditionally worked: from siloed teams and high-anxiety releases to everyone collaborating on uneventful and more frequent releases of higher-quality code. It doesn't matter how large or small an organization is, or even whether it's historically slow moving or risk averse — there are ways to adopt DevOps sanely, and get measurable results in just weeks.