Hubbry Logo
AMD Am2900AMD Am2900Main
Open search
AMD Am2900
Community hub
AMD Am2900
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
AMD Am2900
AMD Am2900
AMD Am2900
View on Wikipedia
from Wikipedia
AMD Am2901: 4-bit-slice ALU

Am2900 is a family of integrated circuits (ICs) created in 1975 by Advanced Micro Devices (AMD). They were constructed with bipolar devices, in a bit-slice topology, and were designed to be used as modular components each representing a different aspect of a computer control unit (CCU). By using the bit slicing technique, the Am2900 family was able to implement a CCU with data, addresses, and instructions to be any multiple of four bits by multiplying the number of ICs. This requires more ICs to implement than what could be done on a single CPU IC, but at the time, the TTL Am2900 chips ran at 20–40 MHz, which was much faster than the 2–3 MHz CMOS/NMOS microprocessors of the era such as the Intel 8085. 8085 emulators were implemented around two Am2900 chips which ran 5 to 10 times faster than the 8085-based designs they replaced.

The Am2901 chip included an arithmetic logic unit (ALU) and 16 4-bit processor register slices, and was the "core" of the series. It could count using 4 bits and implement binary operations as well as various bit shifting operations. The Am2909 was a 4-bit-slice address sequencer that could generate 4-bit addresses on a single chip, and by using n of them, it was able to generate 4n-bit addresses. It had a stack that could store a microprogram counter up to four nest levels, as well as a stack pointer.[1]

The Am2901 and some of the other chips in the family were second sourced by an unusually large number of other manufacturers, starting with Motorola and then Raytheon—both in 1975—and also Cypress Semiconductor, National Semiconductor, NEC, Thomson, and Signetics. In the Soviet Union and later Russia the Am2900 family was manufactured as the 1804 series (with, e.g., the Am2901 designated as КР1804ВС1/KR1804VS1)[2][3][4] which was known to be in production in 2016.[5]

Computers made with Am2900-family chips

[edit]

There are probably many more, but here are some known machines using these parts:

  • The Apollo Computer Tern family: DN460, DN660 and DSP160. All used the same system board emulating the Motorola 68010 instruction set.[6]
  • The Itek Advanced Technology Airborne Computer (ATAC) used on the Galileo Attitude and Articulation Control Computer System and some Navy aircraft had a 16-register, 16-bit word width assembled from 4-bit-wide 2900 series processors. Four special instructions were added to the Galileo version of the ATAC, and later some chips were replaced with radiation-hardened 2901 chips.[7]
  • Data General Nova 4, which obtained 16-bit word width using four Am2901 ALUs in parallel. The floating point board has 15 Am2901 ALUs on it.[8]
  • Digital Equipment Corporation (DEC) PDP-11 models PDP-11/34 FP11-A[9][10] and PDP-11/44 FP11-F[11] floating-point options.[12]
  • The DEC VAX 11/730, which used eight Am2901s in the CPU.[13]
  • Hewlett-Packard 1000 A-series model A600 used four Am2901 ALUs for its 16-bit processor[14]
  • The Xerox Dandelion, the machine used in the Xerox Star and Xerox 1108 Lisp machine.[15]
  • Several models of the GEC 4000 series minicomputers: 4060, 4150, 4160 (four Am2901 each, 16-bit ALU), and 4090 and all 418x and 419x systems (eighteen Am2901 each, 32-bit integer ALU or 8-bit exponent, 64-bit Double Precision floating point ALU).[16]
  • The DEC KS10 PDP-10 model.[17]
  • The UCSD Pascal P-machine processor designed at NCR by Joel McCormack.
  • A number of MAI Basic Four machines.[18]
  • The Tektronix 4052 graphics system computer.
  • The SM-1420, Soviet clone of PDP-11, used Soviet clone of Am2901 (4 ICs in the CPU and 16 ICs in the FPU) [19] perhaps also used in others.[20]
  • The Lilith computer designed at ETH Zürich by Niklaus Wirth.
  • Atari's vector graphics arcade machines Red Baron, Battlezone, and Tempest each used four Am2901 ICs in their "math box" auxiliary circuit boards.
  • Atari's raster graphics arcade machine I, Robot, the first commercial game featuring filled polygons,[21] included a math processor built around four Am2901 chips.[22]
  • Pixar Image Computer, 4 Channel Processors each with 4 Am2900's
  • Eventide H949 Harmonizer; four Am2901 chips (and several microcode PROMs) are used to generate addresses and generate reference voltages for the DAC system – audio was not processed in the 2901 ALU section.
  • Many Siemens Teleperm and S5 PLCs used for industrial control were built using the 2900 series.
  • The AT&T 3B20D used eight Am2901's in its ALU.[23]
  • Geac Computer Corporation 2000, 6000, 8000, and 9000 were all based on 4 x Am2901 chips. The GEAC 9500 was based on the Am29101. The GEAC 2000 was used in pharmacies. The other models were used in library, banking, and insurance automation. The 2000 was a single processor unit. The 6000 and 8000 contained four processors, each dedicated to one of comms, disk, tape, or program processing. The 8000 had local processor memory whereas the 6000 did not. The 9000 and 9500 were AMP systems with up to 8 CPU modules.
  • Later iterations of the Ferranti Argus 700 e.g. the 700F and 700G, used Am2901 devices, as did as some of the A700 peripheral channel controllers for e.g. hard and floppy disc drives
  • The High Level Hardware Limited Orion, a user-microcodable minicomputer running Unix.[24]
  • The 168/E, developed in the late 1970s at the SLAC National Accelerator Laboratory to execute a subset of the IBM 360/370 instructions.[25]
  • Warrex Centurion, an 8-bit minicomputer built by Warrex Computer Corporation (later just Centurion), a Texas based company from the late 1970s to the 1980s. The Am2909 and Am2911 microprogram sequencers and the Am2901 ALU were used in the CPU6 variant.[26]
  • The PerkinElmer Computer Systems Division utilized Am2900 devices in the ALU of their 3200 series supermini computers.
  • The second-generation 16-bit CPU of the NCR I-8250 family of accounting-computers, which replaced the earlier 605-model 4-board CPU that used discrete 7400-series TTL chips.

Members of the Am2900 family

[edit]
AMD Am2903: 4-bit-slice ALU

The Am2900 Family Data Book lists:[27]

  • Am2901 – 4-bit bit-slice ALU and processor register set (1975)
  • Am2902 – Look-Ahead Carry Generator
  • Am2903 – 4-bit-slice ALU, with hardware multiply
  • Am2904 – Status and Shift Control Unit
  • Am2905 – Bus Transceiver
  • Am2906 – Bus Transceiver with Parity
  • Am2907 – Bus Transceiver with Parity
  • Am2908 – Bus Transceiver with Parity
  • Am2909 – 4-bit-slice address sequencer
  • Am2910 – Microprogram Controller
  • Am2911 – 4-bit-slice address sequencer
  • Am2912 – Bus Transceiver
  • Am2913 – Priority Interrupt Expander
  • Am2914 – Priority Interrupt Controller
  • Am2915 – Quad 3-State Bus Transceiver
  • Am2916 – Quad 3-State Bus Transceiver
  • Am2917 – Quad 3-State Bus Transceiver
  • Am2918 – Instruction Register, Quad D Register
  • Am2919 – Instruction Register, Quad Register
  • Am2920 – Octal D-Type Flip-Flop
  • Am2921 – 1-to-8 Decoder
  • Am2922 – 8-Input Multiplexer (MUX)
  • Am2923 – 8-Input MUX
  • Am2924 – 3-Line to 8-Line Decoder
  • Am2925 – System Clock Generator and Driver
  • Am2926 – Schottky 3-State Quad Bus Driver
  • Am2927/Am2928 – Quad 3-State Bus Transceiver
  • Am2929 – Schottky 3-State Quad Bus Driver
  • Am2930 – Main Memory Program Control
  • Am2932 – Main Memory Program Control
  • Am2940 – Direct Memory Addressing (DMA) Generator
  • Am2942 – Programmable Timer/Counter/DMA Generator
  • Am2946/Am2947 – Octal 3-State Bidirectional Bus Transceiver
  • Am2948/Am2949 – Octal 3-State Bidirectional Bus Transceiver
  • Am2950/Am2951 – 8-bit Bidirectional I/O Ports
  • Am2954/Am2955 – Octal Registers
  • Am2956/Am2957 – Octal Latches
  • Am2958/Am2959 – Octal Buffers/Line Drivers/Line Receivers
  • Am2960 – Cascadable 16-bit Error Detection and Correction Unit
  • Am2961/Am2962 – 4-bit Error Correction Multiple Bus Buffers
  • Am2964 – Dynamic Memory Controller
  • Am2965/Am2966 – Octal Dynamic Memory Driver

Many of these chips also have 7400 series numbers such as the 74F2960 / Am2960.

See also

[edit]

References

[edit]

Further reading

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

AMD Am2900

View on Grokipedia
from Grokipedia
The Am2900 is a family of bipolar bit-slice integrated circuits introduced by Advanced Micro Devices () in 1975, consisting of modular components for building custom, high-performance microprogrammable processors and controllers with scalable word lengths in multiples of 4 bits. At the heart of the family is the Am2901, a 4-bit (ALU) slice featuring a 16×4-bit two-port bipolar RAM (used for microprogram control), an 8-function ALU supporting operations like addition, subtraction, and shifting, four status flags, and carry-lookahead capabilities for efficient cascading into 8-, 16-, 32-, or wider data paths. The Am2901 operates at speeds up to 15 MHz in commercial versions and 12 MHz in military versions and was designed using third-generation TTL Schottky technology for reliability in demanding environments, including military and applications compliant with standards. Complementing the Am2901 are control and support devices such as the Am2909 microprogram sequencer, which provides 4-bit addressing for up to 4K words of with a 4×4 push/pop stack and 16-way conditional branching when paired with the Am29803A; the Am2914 vectored priority controller for handling up to 8 levels with nesting and vectoring; and various bus transceivers, registers, multipliers (e.g., Am25LS14), and registered PROMs (e.g., Am29774) for memory and I/O functions. These elements enable pipelined execution, three-state bus sharing, and special arithmetic features like normalization and high-speed , reducing component counts compared to discrete logic designs while supporting microprogrammed architectures over fixed-instruction sets. The Am2900 family played a pivotal role in 1970s computing by facilitating the transition from core-memory-based systems to LSI-based microprogrammable machines, finding applications in minicomputers, peripheral controllers, emulators, and high-reliability sectors like aerospace and defense, where its flexibility allowed tailored performance exceeding standard microprocessors of the era. AMD supported the family with tools like assemblers, PROM programmers, and evaluation boards, sustaining its use into the 1980s through enhancements like the Am2901A and Am2903 variants with added functions for division and extended ALU operations.

Introduction

Overview

The AMD Am2900 is a family of bipolar integrated circuits introduced in 1975, designed as bit-slice components for constructing custom microprogrammed processors. These devices utilize low-power Schottky TTL technology, enabling high-performance building blocks for digital systems. Each chip in the family processes 4-bit slices, which can be interconnected in parallel to scale to wider word lengths, such as 16-bit or 32-bit configurations, allowing flexible adaptation to specific application requirements. Operating frequencies typically range from 20 to 40 MHz, significantly outperforming contemporary NMOS-based processors like the , which ran at 2–3 MHz. This speed advantage stemmed from the bipolar architecture's inherent efficiency in logic operations compared to early or NMOS alternatives. The primary purpose of the Am2900 family was to facilitate modular construction of control units (CCUs) within central processing units (CPUs), empowering designers to tailor architectures for optimized performance in microprogrammed environments. In a basic implementation, multiple slices are connected in parallel to form arithmetic logic units (ALUs), shift registers, and control logic arrays, providing a versatile foundation for system-level integration.

Historical Significance

The AMD Am2900 family emerged in the mid-, shortly after the introduction of early microprocessors such as Intel's 4004 in 1971 and 8080 in 1974, at a time when was transitioning from discrete logic and minicomputers to more integrated solutions but lacked standardized high-performance options for custom designs. This bit-slice approach provided engineers with modular components to build scalable processors, filling a gap before the dominance of fixed-architecture CISC and later RISC designs in the late 1970s and . Unlike fixed microprocessors, the Am2900 enabled the creation of tailored, high-speed central processing units for minicomputers and embedded applications through its microprogrammable structure, which supported custom instruction sets and flexible paths. This influenced broader trends in microprogramming, allowing designers to optimize for specific performance needs without relying on off-the-shelf chips, and facilitated scalability up to 32 bits or more by combining multiple 4-bit slices. The family achieved substantial market success, generating $15 million in sales by 1978 and reaching $35–40 million annually by the late 1970s, establishing it as a for bit-slice architectures in high-speed systems. captured a leading position in the logic market during this period, particularly in sectors like , , and , where its components powered systems from companies such as DEC and . Employing bipolar low-power Schottky technology, the Am2900 delivered significantly higher speeds than contemporary NMOS-based microprocessors, with components like the Am2901A achieving maximum clock frequencies of up to 40 MHz and specialized operations up to 100 times faster than equivalent fixed-instruction MOS designs, albeit at the cost of higher power consumption and lower density.

Development and Production

Origins and Design

The development of the AMD Am2900 family began in the early 1970s at , driven by the need to create proprietary high-performance logic devices amid growing demand for customizable computing solutions beyond fixed-function microprocessors like Intel's MOS-based offerings. Clive Ghest, an AMD engineer since 1970, proposed the concept around 1973 in an internal document known as the "pink paper," envisioning a bipolar for microprogrammable systems that could meet customer requirements for speed in commercial and applications. This initiative marked AMD's push into original design, leveraging bipolar technology to achieve faster operation than emerging MOS alternatives while maintaining compatibility with TTL logic standards for easier . The design team, led by design manager Bob McConnell, included architect Clive Ghest, logic designer John Mick, and circuit designer Tom Wong, who focused on creating a modular "building block" optimized for bit-sliced microprogrammed machines. Key goals emphasized flexibility through control, allowing users to instruction sets and data paths for specific applications, while prioritizing bipolar TTL implementation to deliver high-speed performance—up to several MHz in early configurations—suitable for minicomputers and controllers. This approach addressed limitations in discrete logic designs, reducing component count and enabling scalable word lengths by cascading slices. Early simulations using tools like were employed during to validate the architecture. A major innovation was the Am2901, the flagship 4-bit slice device integrating an arithmetic-logic unit (ALU) with a 16×4-bit (scratchpad) and support for microcode-driven operations, enabling efficient dual-port access for source and destination operands without external memory. This on-chip distinguished the Am2901 by streamlining microprogramming tasks like and manipulation, providing greater flexibility than prior bit-slice approaches that relied heavily on off-chip storage. First arrived in late 1974 or early 1975, with prototypes tested in AMD's internal systems to refine functionality despite initial yield challenges. The family was publicly announced on July 21, 1975, via a trade publication ad, positioning the Am2901 as the core element for high-performance custom processors.

Manufacturing and Second Sourcing

The Am2900 family was initially fabricated at facility using a bipolar low-power Schottky process on 3-inch wafers with 3-micron . Introduced in July 1975, production yields started low at approximately 3-4 die per wafer but improved rapidly to around 30 die per wafer by mid-1975, enabling volume ramp-up and supporting annual sales growth from $3-5 million in 1977-1978 to $35-40 million by the early 1980s. This scaling contributed to significant cost reductions, aligning with the high-volume manufacturing characteristic of the era's production. To ensure supply chain reliability and broaden market adoption, AMD licensed the Am2900 family—particularly the Am2901—for second sourcing by multiple manufacturers starting in 1975. Initial agreements included in 1975, followed by and Thomson in 1976, with additional licensees such as , Fairchild, NEC, and Signetics joining by 1978. These arrangements, which involved no monetary or mask exchanges in some cases, allowed second sources to produce compatible devices, mitigating risks of shortages and facilitating integration into diverse systems from to applications. Production of the Am2900 family continued into the 1980s, with enhancements like the Am2901A using two-layer metal processes and later versions shrinking to 1.2-micron and 1-micron features on 6-inch wafers. In the Soviet Union, the family was cloned as the KR1804 series, with the Am2901 equivalent designated KR1804VS1, supporting legacy systems in military and industrial applications well into the 1990s. These clones extended the technology's lifespan amid geopolitical constraints on Western imports. AMD phased out active production of the original bipolar Am2900 devices in the late as focus shifted toward CMOS-based alternatives like the Am29000 RISC family, though second sources and derivatives sustained availability. The original Am2901 reached formal end-of-life around 2000, but stockpiles and continued manufacturing by licensees such as , , and supported ongoing use in legacy embedded and specialized systems through the .

Architecture

Bit-Slice Design Principles

The AMD Am2900 family utilizes a bit-slice architecture that horizontally partitions processor functions into 4-bit modules, such as the Am2901 (ALU) slice, enabling scalable data processing. These modules are daisy-chained in parallel to construct wider word lengths, for instance, n slices forming an n×4-bit suitable for 8-bit, 16-bit, or 32-bit systems. Carry propagation between slices is optimized through dedicated carry-lookahead circuitry, often implemented with the Am2902 device, which generates propagate and generate signals to accelerate arithmetic operations across multiple bits without sequential ripple delays. This bit-slice approach delivers key modularity benefits by permitting custom word lengths tailored to application needs, from compact 8-bit controllers to expansive 32-bit or 64-bit processors, without requiring custom silicon fabrication. It supports independent evolution of control and execution units, allowing designers to upgrade or modify one subsystem—such as the sequencer—while retaining compatible slices. The inherently microprogrammable structure further enhances flexibility, as instruction sets can be defined and altered via external to emulate diverse architectures, including those incompatible with fixed-instruction monolithic processors. Interconnections in the Am2900 emphasize synchronous operation among slices, with all parallel units sharing a centralized microcode ROM that stores the control program for uniform execution. Control signals, including those for RAM/ROM selection, ALU mode, and register operations, are broadcast simultaneously from the microinstruction word to every slice, ensuring cohesive datapath behavior without per-slice addressing overhead. Devices like the Am2910 sequencer orchestrate this distribution, sequencing microprogram addresses and relaying status flags from slices back to the control store. However, the bit-slice paradigm imposes limitations, notably the need for external microcode storage in PROMs or RAMs, such as the AM27S29, which increases component count and system latency compared to integrated solutions. Integration demands supplementary glue logic for tasks like signal decoding, status aggregation, and interface adaptation, complicating board layout and increasing potential failure points. Although this yields superior performance— with propagation delays as low as 80 ns—over contemporary microprocessors, the overall design complexity demands greater engineering effort than fully monolithic alternatives.

Core Functional Units

The AMD Am2900 family, particularly the Am2901 bit-slice , incorporates a core (ALU) as its primary computational element, designed as a 4-bit wide processing block that can be cascaded to form wider data paths. This ALU supports a range of arithmetic operations, including (R + S + C_n), subtraction in two modes (S - R and R - S), and increment (F = S + C_n), alongside logical functions such as OR (R OR S), AND (R AND S), NOT (NOT S), exclusive-OR (R EXOR S), and exclusive-NOR (R EXNOR S). It also facilitates shift and rotate operations through destination controls, with inputs derived from eight possible pairs (e.g., A and Q, A and B) selected via three control bits (I_0 to I_2). The ALU generates key status outputs, including zero detect (F=0, indicating all bits are zero), carry-out (C_{n+4}), overflow (OVR), and sign (F_3), which are latched for use in conditional sequencing; carry is enhanced by generate (G) and propagate (P) signals for lookahead across slices. Integral to the Am2901's data handling is a 16-word by 4-bit implemented as a two-port static RAM array, enabling simultaneous reads from two independent addresses (A_0-A_3 and B_0-B_3) while supporting a single write port to the B-addressed location when enabled. This structure provides 16 scratchpad registers per slice for temporary storage during computations, with data latched on the falling edge of the clock (CP) to ensure timing stability. Complementing the register file is a dedicated 4-bit Q-register for holding intermediate results, particularly useful in multi-cycle operations like or normalization, as it supports left or right shifts by one bit position under control of the destination select bits (I_6 to I_8). The Y-bus outputs from the ALU or registers are three-state, allowing direct connection to external buses while maintaining isolation across cascaded slices. Sequencing logic within the Am2901 core manages microprogram flow through a 4-level deep push/pop stack, which stores return addresses for subroutine calls and supports efficient nesting up to four levels deep. Address generation occurs via a microprogram counter (μPC) that can increment (Y + 1 → μPC), repeat (Y → μPC), or jump conditionally based on flags such as zero (Z), carry (C), sign (N), or overflow (OVR), with controls like S_0, S_1, FE ( execute), and PUP (push up) dictating operations including jump to subroutine (JSR) and return from subroutine (RTS). This stack integrates with the overall , often augmented by external sequencers like the Am2909, to handle looping and branching without external intervention. The design allows for pipelined execution, where the next address is fetched concurrently with the current microinstruction's decode. The interface employs a compact 9-bit instruction word (I_0 to I_8) derived from external ROM or RAM storage, partitioned into three 3-bit fields: source operand select (I_0-I_2), ALU function code (I_3-I_5), and destination/shift control (I_6-I_8), which together define elemental operations like data routing and . In broader systems, this core expands to a 26-bit or wider microinstruction format when including next-address fields (up to 12 bits) and conditional qualifiers, sourced from bipolar PROMs such as the Am27S series for program storage. Conditional execution is enabled via an enable (IEN) input, while the next microaddress is multiplexed from sources like the μPC, stack top, or direct inputs, ensuring flexible ; outputs include the processed result on the Y-bus and updated status flags for immediate feedback. This interface supports by propagating control signals across multiple slices without altering the core logic.

Family Members

ALU and Arithmetic Devices

The Am2900 family's arithmetic and logic unit (ALU) devices form the computational core, enabling bit-sliced processors to perform high-speed operations on multi-bit words through cascading. The baseline device, the Am2901, is a 4-bit ALU slice that integrates an arithmetic-logic unit with a 16-word by 4-bit register file, supporting data steering and latching for efficient microprogrammed execution. It operates on two 4-bit operands selected from inputs A, B, Q (output register), or the register file, performing one of eight functions: three arithmetic (add, subtract with borrow-in, decrement) and five logical (AND, OR, XOR, XNOR, one's complement). Fabricated using advanced low-power Schottky bipolar technology for TTL compatibility, the Am2901 is housed in a 40-pin DIP package and serves as the foundational slice for building wider ALUs in custom CPUs and controllers. To accelerate carry propagation in wider configurations, the Am2902 provides standalone carry-lookahead generation, interfacing with up to four Am2901 slices to compute block carries in parallel rather than sequentially. It accepts propagate (P) and generate (G) signals from each slice along with a carry-in, producing carry-out signals for positions n+1 through n+16, which minimizes the delay inherent in ripple-carry chains—typically reducing multi-slice propagation from tens of nanoseconds to under 15 ns. Implemented in 16-pin low-power Schottky TTL-compatible packaging, the Am2902 draws up to approximately 550 mW and supports clock rates aligned with Am2901 slices for seamless wide-word arithmetic acceleration. The Am2903 extends the Am2901's capabilities with enhanced arithmetic support, including dedicated hardware for and division, making it suitable for and scientific computing applications. This 4-bit slice features a more versatile ALU performing 7 arithmetic operations (including add, subtract, and shift for multiply/divide steps) and 9 logical functions, alongside a 16x4-bit with infinite expandability via external addressing. It supports 4x4-bit multiplication yielding an 8-bit result and division through iterative operations, incorporating Booth's for efficient handling of signed two's-complement numbers by recoding the multiplier to reduce partial additions. Packaged in a 48-pin DIP using advanced low-power Schottky technology, the Am2903 maintains TTL compatibility and adds special microinstructions for normalization and three-port addressing. In typical configurations, four Am2901 slices form a 16-bit ALU operating at up to 15 MHz, delivering approximately 1 MIPS for basic integer operations while consuming about per slice, though actual throughput varies with efficiency and carry handling. These devices integrate with sequencers for microprogram control, enabling flexible arithmetic pipelines in bit-sliced systems.

Control and Sequencing Devices

The control and sequencing devices in the Am2900 family provide the logic necessary for generating microinstruction addresses and managing program flow in microprogrammed systems, enabling flexible execution of complex instruction sequences through external control stores like ROM or . These components operate as bit-slice elements, allowing scalability to wider address spaces by cascading multiple devices, and they interface directly with the family's arithmetic units to incorporate status flags for conditional operations. The Am2909 serves as a 4-bit microprogram sequencer optimized for address generation in systems with up to 4K words of control storage when cascaded. It includes a 4-deep stack to support subroutine nesting up to four levels, along with a , incrementer, and 4-input for selecting the next address source. The device supports 12 addressing modes, such as direct loading from D inputs, incrementing the counter, popping from the stack, conditional branching based on ALU flags or external OR inputs, and paged addressing for larger spaces. Housed in a 28-pin package, it uses Low-Power Schottky technology for high-speed operation up to 12.5 MHz, with three-state outputs for bus compatibility and a single +5V supply. The Am2910 functions as a more integrated 12-bit microprogram controller, combining sequencing logic with on-chip instruction decoding to handle up to 4K words in external RAM or ROM control stores. It features a 5-deep stack for subroutine calls and returns, a 4-bit loop counter for repetitive sequences, vectoring logic to jump to specific addresses on external requests, and wait-state generation for synchronizing slower accesses. The controller executes 16 microinstructions, including modes for direct addressing, indirect via the microprogram counter (μPC), stack-based jumps, and conditional branches on ALU status flags or external conditions, with an internal 97-bit mapping to decode opcodes and generate control signals. Packaged in 40 pins, it supports clock speeds up to 20 MHz and includes three-state outputs for direct bus interfacing. The Am2911 is a 4-bit microprogram sequencer closely related to the Am2909, providing similar address generation capabilities but without the OR inputs for external conditional logic, making it suitable for simpler branching schemes. It incorporates a , 4-deep stack, and for modes like direct, increment, stack pop, and conditional jumps based on internal flags, with support for address multiplexing to interface with external control store memories such as bipolar PROMs for storage. Available in a 20-pin package, it shares the Am2909's electrical characteristics, including TTL compatibility and operation from 0°C to 70°C. The Am2914 is a 4-bit vectored priority interrupt controller that handles up to 8 interrupt levels with daisy-chaining for expansion, supporting nesting, priority resolution, and automatic vectoring to microprogram routines for efficient interrupt management in Am2900-based systems. These devices interact by having the sequencer (Am2909 or Am2911) or controller (Am2910) generate addresses that drive the external control store, such as a bipolar PROM holding 1K x 4-bit words with multiplexed addressing to reduce pin count. The Am2910 can incorporate Am2909/Am2911 slices for extended addressing, while all accept ALU flag inputs for conditional sequencing, ensuring synchronized microinstruction fetch and execution without delving into data manipulation. This architecture allows up to four levels of subroutine nesting and efficient handling of s by vectoring to PROM-stored routines.

Support and Peripheral Devices

The Am2900 family includes a variety of support and peripheral devices designed to facilitate status handling, shifting, interfacing, timing synchronization, and in bit-slice systems. These auxiliary chips enable efficient integration of core functional units like ALUs and sequencers by managing ancillary operations such as generation, bus isolation, and multi-phase clock distribution. Over 30 such devices were developed, including high-speed buffer series, to support complete system designs without extensive discrete logic. The Am2904 functions as a bidirectional shifter and , performing arithmetic and logical shifts across multiple slices while capturing and multiplexing condition codes like carry, overflow, zero, and sign. It supports 32 shift and rotate modes through three-state multiplexers and two internal s (microprogram status register and machine status register), with bidirectional I/O pins (QIO₀ to QIO₃) for serial data propagation and output enables (OE) for bus control. This device handles parity generation, overflow detection, and , generating carry-in signals for ALU operations and integrating directly with Am2901 or Am2903 slices via clock (CP) and data inputs (Di). The Am2940 serves as a DMA address generator, providing interfacing for direct memory access by incrementing or decrementing addresses in four control modes and executing eight instructions to manage word counts and data transfers. It features an internal three-state bus for communication and expandable 8-bit slicing, with 24 mA output sink capability to isolate data buses in multi-slice configurations. This chip supports system-level interfacing by generating DONE signals and coordinating operations, reducing the need for external counters in Am2900-based controllers. The Am2930 is a 4-bit wide Program Control Unit for machine-level addressing and sequencing, featuring 32 instructions, a 17-level stack, a , auxiliary register, and full adder for relative addressing. It supports timing through clock inputs and output pins (Y0 to Y3). As a 4-bit slice device, it ensures reliable operation in high-speed microprogrammed systems by cascading slices and managing instruction enables, essential for . The Am25LS and Am25HS series encompass high-speed buffers and components, such as the Am25LS253 multiplexers, Am25LS240/244 buffers for byte swapping, Am25LS138 decoders for chip selects, and Am25LS164 shift registers, operating at Schottky TTL speeds with three-state outputs and 50 mV noise margins. These devices handle bus organization, signal buffering (with 8 mA/0.36 mA ), and interfacing in multi-slice setups, minimizing propagation delays and supporting interrupt controllers or high-speed data paths. Their role in allows designers to assemble complete Am2900 systems with reduced component count and enhanced reliability.

Applications

Computers and Minicomputers

The Am2900 family played a key role in enhancing the performance of several minicomputers from Digital Equipment Corporation (DEC), particularly in floating-point processing for PDP-11 systems. The PDP-11/34, a 16-bit minicomputer introduced in 1976, incorporated the FP11-A floating-point unit built around Am2901 ALU slices to provide hardware acceleration for floating-point arithmetic, improving computational efficiency for scientific and engineering applications. Similarly, the PDP-11/44, released in 1977, used the FP11-F floating-point processor, which leveraged multiple Am2900 devices for higher-speed 16-bit operations, enabling faster execution of complex calculations compared to software emulation. The VAX-11/730, a 32-bit workstation from 1977, integrated eight Am2901 slices directly into its CPU design as a floating-point accelerator, supporting the VAX architecture's demand for precise 32-bit processing in multi-user environments. Data General's Nova 4 series, launched in 1977, represented a significant upgrade in the market by adopting Am2900 components for its core CPU implementation. The Nova 4 achieved 16-bit word width through four parallel Am2901 ALUs, replacing earlier TTL logic and delivering up to 50% faster performance over the Nova 3 model, which facilitated broader use in real-time data processing and industrial control tasks. This bit-slice approach allowed scalable performance while maintaining compatibility with existing Nova software ecosystems. The HP 1000 A600 series used Am2900 slices to implement a 16-bit processor, supporting real-time control in and automation environments. The 4052 graphics terminal, released in 1979, employed Am2900 components for its 16-bit processing core, enabling sophisticated and data visualization. In the , the SM-1420 minicomputer, a clone of the PDP-11 introduced in the early , employed KR1804VS1 ICs—direct equivalents to the Am2901—for its CPU and , with four slices in the CPU and 16 in the FPU to ensure compatibility with Elbrus architectures and PDP-11 software. This design allowed the SM-1420 to serve as a reliable platform for scientific computing in restricted technology environments.

Embedded and Specialized Systems

The AMD Am2900 family played a key role in embedded and specialized systems, where its bit-slice enabled custom, high-performance processors tailored for real-time and domain-specific tasks, often through microprogrammable control units. In arcade gaming, integrated four Am2901 ALU slices into the "math box" auxiliary boards of machines like Red Baron (1980), Battlezone (1980), and Tempest (1981) to perform 3D coordinate transformations and vector plotting at 10 MHz, supporting smooth real-time rendering without a general-purpose CPU for . For the pioneering raster-based (1984)—the first commercial game with filled s—a custom 16-bit math processor built around four Am2901 chips handled complex 3D filling and calculations, demonstrating the family's adaptability for advanced . Beyond gaming, the Am2900 powered graphics and peripheral systems requiring precise . The Xerox Star 8010 workstation's Dandelion hardware featured a custom processor based on the AMD 2900 bit-slice family, providing microcode-programmable execution for Lisp-based operations in its innovative environment. In audio , the Eventide H949 Harmonizer (1979) utilized four Am2901 chips alongside PROMs to generate DAC addresses and reference voltages, facilitating , delay, and modulation effects with fine resolution for musical applications. In industrial and military domains, the Am2900's reliability and speed suited harsh environments. Many Siemens PLCs for factory automation incorporated 2900-series devices to execute control logic in real-time industrial processes, leveraging custom microcode for fault-tolerant operation. At the SLAC National Accelerator Laboratory, the 168/E controller from the late 1970s emulated a subset of IBM 360/370 instructions for particle physics experiment timing and data acquisition, achieving execution speeds comparable to half an IBM 370 model. Other specialized uses included the workstation from ETH Zürich, which employed Am2901-based processing for its compact, single-user computing environment. Across these implementations, custom adaptations allowed the bipolar TTL Am2900 to operate at speeds up to 20 MHz, optimizing for low-latency tasks like vector rendering or control sequencing without the overhead of fixed-instruction CPUs.

Legacy and Influence

Impact on Computing

The AMD Am2900 family pioneered bit-slice modularity in microprocessor design, enabling engineers to assemble processors with customizable word widths—such as 16-bit, 32-bit, or even 64-bit—by interconnecting 4-bit slices, which offered unprecedented flexibility for high-performance custom CPUs. This approach became the de facto standard for bit-slice architectures, significantly influencing subsequent designs by emphasizing scalable, microprogrammable components over fixed single-chip solutions. By facilitating the implementation of complex instruction sets through microcode rather than hardwired logic, the Am2900 popularized microprogramming as a core practice in minicomputer and embedded system development during the late 1970s and early 1980s. The family's market success was substantial, with sales reaching $15 million by 1978 and peaking at approximately $40 million annually, reflecting millions of chips shipped worldwide for use in over a hundred diverse systems, including minicomputers and specialized applications. It bridged the transition from multi-chip TTL logic assemblies to VLSI-era single-chip microprocessors, empowering the creation of cost-effective, high-speed machines in industries like , , and before the dominance of integrated processors in the mid-1980s. Notable deployments included the VAX-11/730 minicomputer and the workstation, underscoring its role in enabling performant systems during the PDP-11 and VAX computing eras. Technically, the Am2900 highlighted the performance advantages of bipolar technology, with devices like the Am2901 achieving clock speeds up to 20 MHz in standard TTL versions, with later variants and optimal conditions reaching 40 MHz or higher in ECL implementations, which supported rapid arithmetic and logic operations essential for real-time applications. However, its high power dissipation—often exceeding several watts per chip—and associated challenges exemplified the limitations of bipolar logic, accelerating the industry's shift to more efficient processes by the early 1980s. This legacy influenced the evolution of processor architectures by demonstrating the trade-offs between speed, power, and in pre-VLSI designs. The Am2900's educational impact was profound, serving as a cornerstone in curricula through resources like the seminal Bit-Slice Microprocessor Design by engineers John Mick and James Brick, which detailed its application in microprogrammed systems and trained generations of engineers. 's extensive seminars—over 1,000 conducted globally—and development tools like the System 29 further disseminated its principles, while oral histories from the original design team preserve accounts of its innovations in high-speed computing. These materials emphasized conceptual advancements in and microcoding, shaping pedagogical approaches to long after its production ceased around 2000.

Modern Relevance and Emulations

The AMD Am2900 family entered the final phase of its production lifecycle in the late , with production continuing until its end-of-life around 2000 and no new fabrication occurring in Western facilities thereafter. In , Soviet-era clones under the KR1804 series (such as the KR1804VS1 equivalent to the Am2901) were manufactured as second-source devices starting in and persisted in legacy military and industrial applications in and former Soviet states for specialized computing needs. These clones supported ongoing maintenance of older infrastructure where compatibility with bipolar bit-slice architectures remained essential. Emulations of the Am2900 family have sustained its technical legacy through both hardware and software implementations. FPGA-based recreations, such as models of the Am2901 ALU and supporting devices, enable modern synthesis onto platforms like the Terasic DE10-Nano board, allowing enthusiasts to build custom bit-slice processors for educational or retro system projects. Software simulations, including cycle-accurate models in the emulator, replicate the Am2900's behavior for arcade hardware like Atari's Battlezone, which employed multiple Am2901 slices alongside a Z8002 CPU for vector graphics processing. In the hobbyist and retrocomputing communities, open-source repositories provide examples and resources for Am2900-based CPUs, facilitating hands-on builds of 1970s-era systems. Projects recreating boards, such as FPGA-assisted kits, further promote experimentation with bit-slice sequencing and ALU operations without relying on scarce original ICs. Despite these efforts, contemporary of the Am2900 remains sparse, with its parallel bit-slice structure offering untapped potential for niche applications like custom AI accelerators, though no significant explorations have emerged.

References

  1. https://www.computerhistory.org/collections/catalog/102658341
  2. http://www.bitsavers.org/components/amd/bitslice/1978_The_Am2900_Family_Data_Book.pdf
  3. https://spectrum.ieee.org/the-runnersup-more-earthshaking-chips
  4. https://www.hp9845.net/9845_backup/downloads/articles/Bit-Sliced_Microprocessor_of_the_Am2900_Family.pdf
  5. https://ieeexplore.ieee.org/iel2/782/1536/00038675.pdf
  6. https://www.inf.pucrs.br/calazans/undergrad/orgcomp_EC/mat_microproc/intel-8085_datasheet.pdf
  7. http://archive.computerhistory.org/resources/text/Oral_History/AMD_2900/102658341.05.01.pdf
  8. http://bitsavers.org/components/amd/bitslice/1978_The_Am2900_Family_Data_Book.pdf
  9. http://bitsavers.org/components/amd/bitslice/1979_AMD_2900family.pdf
  10. https://www.zagroselec.ir/stfiles/getappdocument/1/true/752e981b-8519-4da6-9431-c9de84a4d481.pdf
  11. https://www.cpushack.com/2011/02/17/the-amd-2901-bit-slicer-and-second-sourcing/
  12. http://bitsavers.informatik.uni-stuttgart.de/magazines/Microcomputer_Digest/Microcomputer_Digest_v02n06_Dec75.pdf
  13. http://www.bitsavers.org/components/amd/bitslice/Mick_Bit-Slice_Microprocessor_Design_1980.pdf
  14. http://www.righto.com/2020/04/inside-am2901-amds-1970s-bit-slice.html
  15. https://w140.com/tekwiki/images/2/2f/AM2901A_data_sheet.pdf
  16. https://gordonbell.azurewebsites.net/Computer_Structures_Principles_and_Examples/csp0202.htm
  17. https://www.cselettronica.com/datasheet/AM2909.pdf
  18. https://vaxbarn.com/p800/am2910.pdf
  19. https://www.pilianidis.gr/images/sync_products/03-AM2911APC/AM2911APC.pdf
  20. https://datasheet.octopart.com/AM2930DC-AMD-datasheet-182222562.pdf
  21. http://www.bitsavers.org/pdf/dec/pdp11/1134/FP11-A_RevC_FMPS_MP00189_Dec76.pdf
  22. https://archive.org/stream/bitsavers_decpdp11midebwghAHF632DMCFP11FFP11FFLTGPNTPRTACKFP_3094020/AH-F632D-MC__FP11-F__FP11F_FLTG_PNT_PRT_A__CKFPAD0__%28C%2979-82_djvu.txt
  23. https://www.ricomputermuseum.org/collections-gallery/equipment/data-general-nova-4
  24. https://www.cpushack.com/2017/01/06/hp-1000-a600-the-lighting-processor/
  25. https://w140.com/tekwiki/wiki/4052
  26. https://www.cia.gov/readingroom/docs/DOC_0000498114.pdf
  27. http://www.atarihq.com/danb/irobot.shtml
  28. http://toastytech.com/guis/star.html
  29. https://seriescircuits.com/wp-content/uploads/2024/08/Eventide-H949-Schematics.pdf
  30. https://www.slac.stanford.edu/pubs/slacpubs/2000/slac-pub-2206.pdf
  31. http://www.bitsavers.org/pdf/eth/lilith/ThePersonalComputerLilith_1981.pdf
  32. https://en.wikichip.org/wiki/amd/am2900
  33. https://github.com/jacketizer/am2900-verilog
  34. https://github.com/MaisiKoleni/Am2900ME
  35. https://hackaday.io/project/195342-am2900-evaluation-and-training-board
Add your contribution
Related Hubs
User Avatar
No comments yet.