Were people building FPGAs out of TTL logic prior to the first sales in 1984?

Question

My experience growing up was that my Dad would program 'EEPROMs' or Flash ROMs from his Apple IIGS. (I don't know if that is similar to an FPGA or not). He used these in custom wire-wrap computers he was building (around 1986-1989).

We know that the first FPGAs went on sale in 1984.

I've just finished reading Charles Petzold's book, Code: The Hidden Language of Computer Hardware and Software. In it Charles explains building relays into gates, gates into logic components, and logic components into computing machines.

He talks about the book TTL Data Book for Design Engineers which first came out in 1973. (I'm assuming people had lists of TTL gate chips prior to this). This talks a lot about the Texas Instruments 7400 series of logic gate chips.

Now to me it seems you could combine TTL chips (or relays or transistors) into a CPU using the instructions in this book. But everything online says "use FPGAs instead! It's easier for that scale! [Unless you're getting the concepts and want to see the end to end view]". Fair enough - some pragmatism is good - it depends on what the outcome is.

When you look at the structure of an FGPA - it appears to only have slightly more complexity than a 4-bit adder.

Now I don't know when the first four-bit adder was invented. (My guess is it came out of Claude Shannon's work on boolean logic in 1948).

So somewhere between 1948 and 1984 someone must have thought of the idea of FPGAs.

Assumption: By "people" I mean any hobbyist or engineer who is not explicitly prototyping the next FPGA to be manufactured by Naval Surface Warfare Center, Altera and Xilinx.

My question is: Were people building FPGAs out of TTL logic prior to the first sales in 1984?

Answer 1

Yes at one level we did do designs in TTL but usually not the whole structure of an FPGA. From memory I'm pretty sure that the QL ULA was wire wrapped first (I worked with David Karlin the QL designer) usually the problems were mostly to do with the signal timings due to longer wire lengths when you did stuff in TTL (I'm ignoring power and heat for this discussion).

At the sort of time period you're talking about I suspect most folks used things like the AMD2900 for custom CPU designs (the wikipedia page goes into a long list of designs)

In 1988 when I worked with David on a Ethernet chip design (a chip called ENZO) we breadboarded the data separator in TTL. Later (1990..2) we did initial prototypes of designs using Actel chips and I did a 80286 based support chipset design for an embedded system with most of an AT system built in (I skipped DMA as it wasn't needed) in a single part.

We ran out space when I did a networked chip for a mixing desk (1983?) (not that big IIRC less that 10000 gates) but we prototyped it in sections disabling bits of logic to gain enough space to test with. The Actel parts were the biggest available and the main logic block was 4 input mux followed by a latch. (Muxes make great logic gates you can do nearly all four input logic gates with one) They were very expensive at the time (I have a figure of £400 in my head which was probably over $1000 at the time) You could make a 4 bit gray counter out of 4 LUTs which I was rather pleased with. We didn't use Verilog/VHDL as you could beat it by hand fairly easily (also the designs were small enough to work with at the gate/latch/flipflop level).

We used a Toshiba sea of gates technology for our production ASICs a bit more flexible than a ULA but along similar lines.

In 1984 a FPGA would be too slow and small to produce a useful CPU. Certainly in the early 90s you would have been limited to single digit MHz and I seem to remember really struggling with propagation delays on the 80826 support chipset design I did.

Answer 2

For the individual hobbyist or small development shop, the equivalent of FPGAs weren't available. Hardware logic was built from manually routed or wire-wrapped boards with many 74xx logic chips.

An intermediate step for volume production that was available in the early 1980s was the uncommitted logic array (“ULA”) or gate array. One of the earliest uses was in the Sinclair ZX81. While the final logic connection mask had to be applied at the factory, for volume production ULAs proved cheaper and more compact than discrete logic chips.

Answer 3

Before FPGAs were PALs (Programmable Array Logic) and PLDs (Programmable Logic Devices). These had a programmable logic matrix of various forms, often followed by a flop to hold the result. Many variations were made, each trying to find the best package. These were roughly equivalent to MSI (medium scale integration) TTL circuits. Your comparison with a bit-slice adder is apt.

Eventually, as integration increased, more complex devices were made. I built some pretty useful logic around the AMD CPLDs (Complex Programmable Logic Devices), and also using some Atmel FPLAs (Field Programmable Logic Arrays).

FPGAs (Field Programmable Gate Arrays) went through a state where they contained every larger arrays of equivalent elements. Some were programmable like FLASH parts, and some loaded their logic configuration each time they were powered up.

The wheel of creation continues to turn, and now FPGAs often include processor cores, and special PHYs to connect with high-speed interfaces, such as USB, PCIe, DDR, and HDMI.

In the beginning, I designed programmable logic by drawing TTL diagrams and compiling that into fuse maps (sometimes by hand). Now, I do FPGA designs in Verilog and leave it up to the tool chain. Schematics as a representational tool don't scale as well as code.

Answer 4

The main point of FPGAs is the ability to have an (almost) arbitrary connectivity between the Configurable Logic Blocks (CLBs) within the FPGA chip. This is achieved by having configurable switch networks between the rows and columns of CLBs.

When the logic blocks are implemented with individual chips, the closest equivalent of a configurable switch network is a breadboard.

Therefore the answer is "yes, they were", as breadboards are quite field-configurable.