The Creation of the IBM PC

A little-known system, the DataMaster, drove many of the design choices for the original IBM PC

Source: Byte, September 1990
Author: David J. Bradley

Based on this HTML version. Style and minor corrections by Tomáš Slavotínek.

In August 1980, I had finished my work on what was to become the IBM System/23 DataMaster. The DataMaster was an Intel 8085-based system intended to run business applications written in BASIC. I had written some of the device-control code for that system and was looking at extending the design to the 8086 architecture.

I had heard rumors of a task force that was looking for a low-cost system design. The project sounded interesting, but I was enjoying the DataMaster work.

Then my manager called me in. He told me that IBM's Boca Raton division had been given the job of building a low-cost system. Management had assembled a team of engineers, and they needed someone to write the control code. I was to join 11 others in daily meetings at 8 a.m.

At that time, the design for the machine existed only as a few descriptive charts. A year later, on August 12, 1981, we announced the IBM Personal Computer. Here is the story of how we made the design decisions that shaped the IBM PC.

Humble Beginnings

The DataMaster program began in February 1978. Many of its design elements — the keyboard, for example — were later used on the IBM PC. This same development effort also produced a group of trained engineers already familiar with personal computer design.

The DataMaster was a single-element design. The one-piece package contained the keyboard, a 12-inch monochrome display, and a pair of 8-inch floppy disk drives. Although this design was suitable for the System/23 business environment, it didn't have the flexibility needed for a personal computer.

The DataMaster's 8-bit 8085 CPU was a very close relative of the 8080 and executed the same instruction set. During the design team's work on the DataMaster, we ran up against the limits of the 64K-byte address space and had to invent an external paging mechanism to address at least 256K bytes of memory. In designing this system, we became familiar with the Intel architecture and support chips.

The DataMaster system had a built-in BASIC interpreter, just like many of the personal computer designs of the time. During the DataMaster development, we "converged" our BASIC with the BASIC used on the IBM System/34. That change delayed the DataMaster by nearly a year.

That experience taught us two things about getting a product to market rapidly: We needed to use an existing BASIC, and we needed to streamline the IBM development process. Applying what we learned was one of the reasons for the success of the IBM PC. We went to Microsoft for a BASIC interpreter. And we used our own fast-path development process, which included using executives to convince the rest of the corporation that we were on the right track.

The First View

Refinement of the original PC design swapped the positions of the power supply and the expansion cards, allowing the adapters to extend the full length of the box. That move put the power switch in the back corner — a long reach for users.

In the initial design, we included a pair of 5½-inch floppy disk drives, a horizontal system board, and five expansion slots. Because of our experience with the DataMaster, we made the keyboard and display separate from the computer. The basic logic was to go on the system board, but expansion cards would give each system a unique flavor.

The width and depth of the box had to fit on a standard desk-top and still leave room for the keyboard. After subtracting areas for the power supply and disk drives, the remaining space determined the size of the system board and expansion cards.

The initial system design was quite different from the device we finally announced. We shipped all systems with a minimum of 16K bytes of RAM on the system board. All systems had 40K bytes of ROM, which consisted of a 32K-byte BASIC interpreter and an 8K-byte BIOS. Our first design called for a total of five slots — exactly the same number that ended up in the finished product. We wound up actually developing most of the features on our original list, with the exception of the 8-inch disk drives; also, we changed the printer adapter to an industry-standard parallel port.

A major influence on the system design was the just-enacted FCC Class B requirement for electronic devices in the home. As the industry painfully learned in those early years, "hardening" the system to contain electromagnetic emissions was difficult, and sometimes more art than science. We designed the adapter-card brackets to fit securely in the enclosure to reduce the leakage. Many hours of testing, including some open-field work conducted in the Everglades (where bug removal took on a completely different meaning), were necessary to make the system pass the FCC criteria.

We had learned from the DataMaster development and from the experiences of others that even a company the size of IBM couldn't develop all the hardware and software to make a personal computer a success. From the beginning, we decided to publish data concerning all the hardware and software interfaces. Anyone designing an adapter or a program to run on the IBM PC would get as much information as we had available. A compilation of all the system specifications used during the system development and testing became the Technical Reference Manual.

This wire-wrap board was the original planar built to prove the feasibility of the IBM PC design prior to laying out the printed circuit board. A similar one was built and shipped to Microsoft in December 1980 for development of the software.

The photo above shows the top of the board; the photo below shows the bottom.

Why the 8088?

There were a number of reasons why we chose the Intel 8088 as the IBM PC's central processor.

  1. The 64K-byte address limit had to be overcome. This requirement meant that we had to use a 16-bit microprocessor.
  2. The processor and its peripherals had to be available immediately. There was no time for new LSI chip development, and manufacturing lead times meant that quantities had to be available right away.
  3. We couldn't afford a long learning period; we had to use technology we were familiar with. And we needed a rich set of support chips — we wanted a system with a DMA controller, an interrupt controller, timers, and parallel ports.
  4. There had to be both an operating system and applications software available for the processor.

We narrowed our decision down to the Intel 8086 or 8088. The Boca Raton engineers were familiar with these processors and their support chips. For programmers, the 8086/8088 architecture is a straightforward map from the 8080 architecture. The Microsoft BASIC group had already ported its BASIC interpreter from the 8080 to the 8086. There was also a DOS that ran on the 8086. Expansion of the address space was our primary goal. We chose the 8088 because of its 8-bit data bus. The smaller bus saved money in the areas of RAM, ROM, and logic for the simple system.

A bonus we got from choosing this Intel processor was the numeric coprocessor. The 8087 gave the 8088 a fast partner for floating-point calculations. But since the 8087 wasn't yet available when the PC was announced, we simply left an empty socket on the board and didn't disclose a use for it.

16K Bytes and Up

The IBM PC was offered with 16K bytes of RAM, expandable to 64K bytes on the system board. We used 16K-bit DRAM chips because they were readily available. We built two memory-expansion cards, a 32K-byte and a 64K-byte card. With a fully populated system board and three 64K-byte cards, you could get up to 256K bytes of memory — at that time, an impressive amount for a personal computer.

We made one design choice that was unprecedented in a personal computer: to include parity on the memory. We thought it was very important to detect errors that might be caused by a failure in the memory and not allow the corrupted data to propagate further in the system. We believed it was better to halt the machine than to continue with errors. If an application program wished to change the way the parity error was handled, it could do so by simply changing the nonmaskable interrupt handler.

Why did DOS end up limited to 640K bytes? The answer is surprisingly simple. The 8088 has an address space of 1 megabyte. We reserved the upper 128K bytes for ROM on the system board. We wanted the video memory on the display adapters to be in the processor address space, so we reserved a 128K-byte section of memory for them. Finally, we reserved 128K bytes of memory for ROM or RAM on other adapter cards. At the time, we thought those allotments were generous.

When you subtract the reserved sections, the remainder is 640K bytes. Since the capacity of the original IBM PC was 256K bytes of RAM, and the norm for systems at that time was 64K bytes, we felt comfortable with the design. Although 640K bytes did become a limitation, so did the other reserved areas. I don't think there was a better way of arranging the memory that would have made a significant difference.

Supporting the Processor

The support chips brought a lot of function to the IBM PC. DMA speeds up the I/O performance by relieving the processor of transferring the data between memory and I/O devices. We wanted the system to be able to perform multiple operations. A good example is allowing the user to type ahead on the keyboard while the disk transfers data. This feature enhanced the system's convenience and utility. We also used DMA for memory refresh, since it already had the control logic to request the bus and provide addresses to memory.

Being able to type ahead also requires keyboard interrupts. Using the eight-level interrupt controller relieved the processor from checking I/O operations continuously.

Even though the hardware and firmware shipped with the system didn't take full advantage of the DMA and interrupt capabilities, we included these functions for others. For example, the BIOS for the serial port didn't use the interrupt capabilities, but the serial communications built into Advanced BASIC did. Serial transmission and reception could take place under interrupt control while the BASIC program was executing.

The three-channel timer/counter let the IBM PC tell time, at least as long as the power was on. It was also the refresh timer and generated tones for the speaker. In addition, the counter could be used for many of the system's timing functions — for example, the code in the BIOS that read the cassette storage device. That code used the timer to determine the length of a bit cycle and decide whether a 1 or a 0 had been recorded.

Color and Text

We designed the IBM PC for two different roles: a business computer and a home computer. To support this versatility, we developed separate video adapters: CGA for the home and the Monochrome Display Adapter (MDA) for business.

MDA was based on the DataMaster display, which was monochrome and text-only. DataMaster used the Intel 8275 CRT controller to generate the display. While the 8275 cut down on memory contention (by buffering each row of characters internal to the chip), it had two problems: It was limited to 7 bits for each character and so could display only 128 different characters, and it could set character attributes only by sacrificing a character position to the attribute specification. Thus, highlighting a word required a preceding and following attribute byte — one to turn on highlighting, and one to turn it off.

MDA has a single mode, 25 rows of 80 columns of text. We didn't use the DataMaster design because we preferred to do our own — using the Motorola 6845 for video timings — and put memory on the card for character and attribute storage. This design allowed us to have 256 characters, and we could specify the attributes for each character position. MDA was the first multifunction board developed for the IBM PC. It had a single parallel port to connect it to a printer.

For the IBM PC, we needed at least 256 characters to support the major languages, because the I in IBM stands for "international". Our experience with the DataMaster gave us a pretty good set to use. We also wanted "business graphics" in the character set (e.g., the lines and corners used to form boxes). We filled the remaining spaces with some word processing marks, Greek letters, and a few math symbols.

We wanted CGA to be able to work with a home TV as well as with a TV-frequency monitor. That criterion pretty much determined all the important things — like the number of dots on the screen. Two of the modes, 40- by 25-character text and 320-by 200-pixel all-points-addressable (APA), are constrained by the limits of a home TV. The remaining two modes, 80- by 25-character text and 640- by 200-pixel APA, require a monitor. The color capabilities were determined by the memory we could afford to put on the board — 16K bytes of RAM. That amount of memory allows four colors for the medium-resolution APA and two colors for high resolution.

The organization of the memory, 16K bytes by 8 bits, gave rise to one of the problems of CGA: In 80-column text mode, the adapter had to fetch 160 bytes per line — 80 characters and 80 attributes — leaving no time for the processor to read from or write to the display. Any program that went directly to the display memory quickly filled the screen with "snow". The read and write routines in the BIOS waited for horizontal retrace before accessing the memory. The scroll routine in the BIOS, which had to move lots of data, simply turned off the display, did the move, and then turned the display back on. There was a noticeable blink as the screen scrolled, but it was less objectionable than the blizzard that would have occurred otherwise.

Cassettes, Then Diskettes

Because we planned on people using the IBM PC at home, we included a port so a cassette could be used as a storage device. The system was available with no disk drives, 16K bytes of RAM, and Cassette BASIC in ROM. With this configuration, you could load and execute BASIC programs from a standard audio cassette tape player. We did optimize the system design for business use, though, with bays for two floppy disk drives and 64K bytes of RAM on the planar.

Disk-based systems far outsold those without, and just about everyone who bought a cassette system eventually upgraded to disks. Although the cassette port was retained on the PC for compatibility, we removed it from the XT when that was designed.

Bus Architecture: DataMaster Descendent

The IBM PC's bus architecture came from two sources: the DataMaster definition and the new requirements of the 8088. We wanted to keep the bus very similar to the DataMaster's, since we had developed several adapter cards for that bus. Keeping the bus similar would make the adaptation very simple — just a new layout of the cards.

The 62-pin connector also came from the DataMaster. The extensions for the 8088 were obvious — a few extra address lines. The DataMaster used the same interrupt controller and a similar DMA controller, so those signals were already on the DataMaster bus. The final definition changed only five of the originally proposed signal lines.

One thing we didn't foresee when we defined the system bus was the proliferation of adapter cards for the PC. Although the variety turned out to be a good thing because it gave customers a wide choice of options, we hadn't allowed enough I/O addresses for all the cards that eventually were developed.

Original expansion cards decoded only a 10-bit address, and many cards used 8 or 16 addresses. Consequently, almost every card ended up with a set of switches to select the I/O address it would respond to and the interrupt line it would use in a given system. While the DIP switches were workable, they required the user to review all the documentation every time another card had to be installed. The answer was a programmable method of device selection, which was one of the reasons for the change to the Micro Channel architecture in the PS/2 family.

Keyboard Control

The IBM PC keyboard came from the DataMaster. We changed the key tops to reflect the general-purpose nature of the PC, replacing labels such as HELP with F4. Since the DataMaster keyboard was inside the system box, it used a parallel connection to the system board. For the IBM PC, we made the keyboard separate and connected it to the system via a serial port and a 6-foot coiled cable.

One of the questions often asked about the IBM PC is why we chose the Ctrl-Alt-Del reset sequence. We proposed Ctrl-Alt-Del as a warm-boot sequence to provide some of the capability of a reset switch. It is difficult to activate by mistake, since the keys are widely separated. By storing a special character in a particular memory location, the warm boot would bypass the memory-test portion of the power-on self test (POST), taking less time than turning the machine off and back on.

The difficulty with Ctrl-Alt-Del, however, is that for the reset to work, the system must be capable of receiving input. If the program has gone completely off into the weeds and has disabled the interrupts, the reset won't work. But production software should not exhibit this kind of behavior.

There were two other concerns with the original keyboard: the placement of the Left Shift and Enter keys, and the lack of indicators for Caps Lock, Num Lock, and Scroll Lock. The keys ended up as they did because we wanted to support the international keyboard, which has several additional keys. We improved the layout with the IBM AT keyboard. That keyboard also had the indicator lights for the shift states.

Firmware and Diagnostics

We intended for the PC's BIOS to serve as a buffer between the hardware and a programmer. Some of the things it handles (e.g., sending a character to the printer) are very simple. Other operations (e.g., decoding the scan codes from the keyboard into the desired characters) are very complex. We wanted a programmer to be free to concentrate on the problem, not the hardware.

Another important part of the IBM PC was its diagnostic strategy. The POST annoyed some users because the system came to life slowly. But we thought it was important to test the system before turning it over to an application, reasoning that it was better to find a hardware problem before it caused a mistake in your data.

Industry Revolution

When we first began development of the IBM PC, we didn't appreciate the potential of the product. The company originally estimated it would market a total of about 250,000 units over a five-year period. As it turned out, there were some months when we built and sold nearly that many systems.

IBM has since delivered millions of PCs to the marketplace. The sales estimates may have been faulty, but the product certainly wasn't. I'm very happy to have been a part of it.

David J. Bradley is the manager of Advanced Processor Design, Entry Systems Division, at IBM (Boca Raton, FL). He was a member of the original team that designed the IBM PC and has a Ph.D. in electrical engineering. He can be reached on BIX c/o "editors".

Content created and/or collected by:
Louis F. Ohland, Peter H. Wendt, David L. Beem, William R. Walsh, Tatsuo Sunagawa, Tomáš Slavotínek, Jim Shorney, Tim N. Clarke, Kevin Bowling, and many others.

Ardent Tool of Capitalism is maintained by Tomáš Slavotínek.
Last update: 08 May 2024 - Changelog | About | Legal & Contact