Motorola 68000 series
The Motorola 68000 series (also known as 680x0, m68000, m68k, or 68k) is a family of 32-bit complex instruction set computer (CISC) microprocessors. During the 1980s and early 1990s, they were popular in personal computers and workstations and were the primary competitors of Intel's x86 microprocessors. They were best known as the processors used in the early Apple Macintosh, the Sharp X68000, the Commodore Amiga, the Sinclair QL, the Atari ST, the Sega Genesis (Mega Drive), the Capcom System I (Arcade), the AT&T Unix PC, the Tandy Model 16/16B/6000, the Sun Microsystems Sun-1, Sun-2 and Sun-3, the NeXT Computer, NeXTcube, NeXTstation, and NeXTcube Turbo, the Texas Instruments TI-89/TI-92 calculators, the Palm Pilot (all models running Palm OS 4.x or earlier) and the Space Shuttle.  Although no modern desktop computers are based on processors in the 680x0 series, derivative processors are still widely used in embedded systems.

Motorola ceased development of the 680x0 series architecture in 1994, replacing it with the PowerPC RISC architecture, which was developed in conjunction with IBM and Apple Computer as part of the AIM alliance.

Family members
 Generation one (internally 16/32-bit, and produced with 8-, 16-, and 32-bit interfaces)
 Motorola 68000
 Motorola 68EC000
 Motorola 68SEC000
 Motorola 68HC000
 Motorola 68008
 Motorola 68010
 Motorola 68012
 Generation two (internally fully 32-bit)
 Motorola 68020
 Motorola 68EC020
 Motorola 68030
 Motorola 68EC030
 Generation three (pipelined)
 Motorola 68040
 Motorola 68EC040
 Motorola 68LC040
 Generation four (superscalar)
 Motorola 68060
 Motorola 68EC060
 Motorola 68LC060
 Others
 Freescale 683XX (CPU32 aka 68330, 68360 aka QUICC)
 Freescale ColdFire
 Freescale DragonBall
 Philips 68070

Improvement history
68010:
 Virtual memory support (restartable instructions)
 'loop mode' for faster string and memory library primitives
 multiply instruction uses 14 clock ticks less

68020:
 32-bit address & arithmetic logic unit (ALU)
 Three stage pipeline
 Instruction cache of 256 bytes
 Unrestricted word and longword data access (see alignment)
 8× multiprocessing ability
 Larger multiply (32×32 -> 64 bits) and divide (64÷32 -> 32 bits quotient and 32 bits remainder) instructions, and bit field manipulations
 Addressing modes added scaled indexing and another level of indirection
 Low cost, EC = 24-bit address

68030:
 Split instruction and data cache of 256 bytes each
 On-chip memory management unit (MMU) (68851)
 Low cost EC = No MMU
 Burst Memory Interface

68040:
 Instruction and data caches of 4 KB each
 Six stage pipeline
 On-chip floating-point unit (FPU)
 FPU lacks IEEE transcendental function ability
 FPU emulation works with 2E71M and later chip revisions
 Low cost LC = No FPU
 Low cost EC = No FPU or MMU

68060:
 Instruction and data caches of 8 KB each
 10 stage pipeline
 Two cycle integer multiplication unit
 Branch prediction
 Dual instruction pipeline
 Instructions in the address generation unit (AGU) and thereby supply the result two cycles before the ALU
 Low cost LC = No FPU
 Low cost EC = No FPU or MMU

Feature map

Main uses

The 680x0 line of processors has been used in a variety of systems, from modern high-end Texas Instruments calculators (the TI-89, TI-92, and Voyage 200 lines) to all of the members of the Palm Pilot series that run Palm OS 1.x to 4.x (OS 5.x is ARM-based), and even radiation-hardened versions in the critical control systems of the Space Shuttle.

However, the 680x0 CPU family became most well known as the processors powering advanced desktop computers and video game consoles such as the Apple Macintosh, the Commodore Amiga, the Sinclair QL, the Atari ST, the SNK NG AES/Neo Geo CD, Atari Jaguar, Commodore CDTV, and several others.  The 680x0 were also the processors of choice in the 1980s for Unix workstations and servers such as AT&T's UNIX PC, Tandy's Model 16/16B/6000, Sun Microsystems' Sun-1, Sun-2, Sun-3, NeXT Computer, Silicon Graphics (SGI), and numerous others. There was a 68000 version of CP/M called CP/M-68K, which was initially proposed to be the Atari ST operating system, but Atari chose Atari TOS instead.  Many system specific ports of CP/M-68K were available, for example, TriSoft offered a port of the CP/M-68K for the Tandy Model 16/16B/6000.

Also, and perhaps most significantly, the first several versions of Adobe's PostScript interpreters were 68000-based. The 68000 in the Apple LaserWriter and LaserWriter Plus was clocked faster than the version used then in Macintosh computers. A fast 68030 in later PostScript interpreters, including the standard resolution LaserWriter IIntx, IIf and IIg (also 300 dpi), the higher resolution LaserWriter Pro 600 series (usually 600 dpi, but limited to 300 dpi with minimum RAM installed) and the very high resolution Linotronic imagesetters, the 200PS (1500+ dpi) and 300PS (2500+ dpi). Thereafter, Adobe generally preferred a RISC for its processor, as its competitors, with their PostScript clones, had already gone with RISCs, often an AMD 29000-series. The early 68000-based Adobe PostScript interpreters and their hardware were named for Cold War-era U.S. rockets and missiles: Atlas, Redstone, etc.

Today, these systems are either end-of-line (in the case of the Atari), or are using different processors (in the case of Macintosh, Amiga, Sun, and SGI). Since these platforms had their peak market share in the 1980s, their original manufacturers either no longer support an operating system for this hardware or are out of business. However, the Linux, NetBSD and OpenBSD operating systems still include support for 68000 processors.

The 68000 processors were also used in the Sega Genesis (Mega Drive) and SNK Neo Geo consoles as the main CPU. Other consoles such as the Sega Saturn used the 68000 for audio processing and other I/O tasks, while the Atari Jaguar included a 68000 which was intended for basic system control and input processing, but due to the Jaguar's unusual assortment of heterogeneous processors was also frequently used for running game logic. Many arcade boards also used 68000 processors including boards from Capcom, SNK, and Sega.

Microcontrollers derived from the 68000 family have been used in a huge variety of applications. For example, CPU32 and ColdFire microcontrollers have been manufactured in the millions as automotive engine controllers.

Many proprietary video editing systems used 68000 processors. In this category we can name the MacroSystem Casablanca, which was a black box with an easy to use graphic interface (1997). It was intended for the amateur and hobby videographer market. It is also worth noting its earlier, bigger and more professional counterpart, called "DraCo"(1995), The groundbreaking Quantel Paintbox series of early based 24-bit paint and effects system was originally released in 1981 and during its lifetime it used nearly the entire range of 68000 family processors, with the sole exception of the 68060, which was never implemented in its design. Another contender in the video arena, the Abekas 8150 DVE system, used the 680EC30, and the Trinity Play, later renamed Globecaster, uses several 68030s. The Bosch FGS-4000/4500 Video Graphics System manufactured by Robert Bosch Corporation, later BTS (1983), used a 68000 as its main processor; it drove several others to perform 3D animation in a computer that could easily apply Gouraud and Phong shading. It ran a modified Motorola Versados operating system.

Architecture

People who are familiar with the PDP-11 or VAX usually feel comfortable with the 68000 series. With the exception of the split of general-purpose registers into specialized data and address registers, the 68000 architecture is in many ways a 32-bit PDP-11.

It had a more orthogonal instruction set than those of many processors that came before (e.g., 8080) and after (e.g., x86). That is, it was typically possible to combine operations freely with operands, rather than being restricted to using certain addressing modes with certain instructions. This property made programming relatively easy for humans, and also made it easier to write code generators for compilers.

The 68000 series has eight 32-bit general-purpose data registers (D0-D7), and eight address registers (A0-A7). The last address register is the stack pointer, and assemblers accept the label SP as equivalent to A7.

In addition, it has a 16-bit status register. The upper 8 bits is the system byte, and modification of it is privileged. The lower 8 bits is the user byte, also known as the condition code register (CCR), and modification of it is not privileged. The 68000 comparison, arithmetic, and logic operations modify condition codes to record their results for use by later conditional jumps. The condition code bits are "zero" (Z), "carry" (C), "overflow" (V), "extend" (X), and "negative" (N). The "extend" (X) flag deserves special mention, because it is separate from the carry flag. This permits the extra bit from arithmetic, logic, and shift operations to be separated from the carry for flow-of-control and linkage.

While the 68000 had a 'supervisor mode', it did not meet the Popek and Goldberg virtualization requirements due to the single instruction 'MOVE from SR', which copies the status register to another register, being unprivileged but sensitive. In the Motorola 68010 and later, this was made privileged, to better support virtualization software.

The 68000 series instruction set can be divided into the following broad categories:

 Load and store (MOVE)
 Arithmetic (ADD, SUB, MULS, MULU, DIVS, DIVU)
 Bit shifting (ASL, ASR, LSL, LSR)
 Bit rotation (ROR, ROL, ROXL, ROXR)

 Logic operations (AND, OR, NOT, EOR)
 Type conversion (byte to word and vice versa)
 Conditional and unconditional branches (BRA, Bcc - BEQ, BNE, BHI, BLO, BMI, BPL, etc.)
 Subroutine invocation and return (BSR, RTS) 
 Stack management (LINK, UNLK, PEA)
 Causing and responding to interrupts
 Exception handling
 There is no equivalent to the x86 CPUID instruction to determine what CPU or MMU or FPU is present.

The Motorola 68020 added some new instructions that include some minor improvements and extensions to the supervisor state, several instructions for software management of a multiprocessing system (which were removed in the 68060), some support for high-level languages which did not get used much (and was removed from future 680x0 processors), bigger multiply (32×32→64 bits) and divide (64÷32→32 bits quotient and 32 bits remainder) instructions, and bit field manipulations.

The standard addressing modes are:

Register direct
data register, e.g. "D0"
address register, e.g. "A0"
Register indirect
Simple address, e.g. (A0)
Address with post-increment, e.g. (A0)+
Address with pre-decrement, e.g. −(A0)
Address with a 16-bit signed offset, e.g. 16(A0)
Register indirect with index register & 8-bit signed offset e.g. 8(A0,D0) or 8(A0,A1)
Note that for (A0)+ and −(A0), the actual increment or decrement value is dependent on the operand size: a byte access adjusts the address register by 1, a word by 2, and a long by 4.
PC (program counter) relative with displacement
Relative 16-bit signed offset, e.g. 16(PC). This mode was very useful for position-independent code.
Relative with 8-bit signed offset with index, e.g. 8(PC,D2)
Absolute memory location
Either a number, e.g. "$4000", or a symbolic name translated by the assembler
Most assemblers used the "$" symbol for hexadecimal, instead of "0x" or a trailing H.
There were 16 and 32-bit versions of this addressing mode
Immediate mode
Data stored in the instruction, e.g. "#400"
Quick immediate mode
3-bit unsigned (or 8-bit signed with moveq) with value stored in opcode
In addq and subq, 0 is the equivalent to 8
e.g. moveq #0,d0 was quicker than clr.l d0 (though both made D0 equal to 0)

Plus: access to the status register, and, in later models, other special registers.

The Motorola 68020 added a scaled indexing address mode, and added another level of indirection to many of the pre-existing modes.

Most instructions have dot-letter suffixes, permitting operations to occur on 8-bit bytes (".b"), 16-bit words (".w"), and 32-bit longs (".l").

Most instructions are dyadic, that is, the operation has a source, and a destination, and the destination is changed. Notable instructions were:

Arithmetic: ADD, SUB, MULU (unsigned multiply), MULS (signed multiply), DIVU, DIVS, NEG (additive negation), and CMP (a sort of comparison done by subtracting the arguments and setting the status bits, but did not store the result)
Binary-coded decimal arithmetic: ABCD, NBCD, and SBCD
Logic: EOR (exclusive or), AND, NOT (logical not), OR (inclusive or)
Shifting: (logical, i.e. right shifts put zero in the most-significant bit) LSL, LSR, (arithmetic shifts, i.e. sign-extend the most-significant bit) ASR, ASL, (rotates through eXtend and not) ROXL, ROXR, ROL, ROR
Bit test and manipulation in memory or data register: BSET (set to 1), BCLR (clear to 0), BCHG (invert) and BTST (no change). All of these instructions first test the destination bit and set (clear) the CCR Z bit if the destination bit is 0 (1), respectively.
Multiprocessing control: TAS, test-and-set, performed an indivisible bus operation, permitting semaphores to be used to synchronize several processors sharing a single memory
Flow of control: JMP (jump), JSR (jump to subroutine), BSR (relative address jump to subroutine), RTS (return from subroutine), RTE (return from exception, i.e. an interrupt), TRAP (trigger a software exception similar to software interrupt), CHK (a conditional software exception)
Branch: Bcc (where the "cc" specified one of 14 tests of the condition codes in the status register: equal, greater than, less-than, carry, and most combinations and logical inversions, available from the status register). The remaining two possible conditions (always true and always false) have separate instruction mnemonics, BRA (branch always), and BSR (branch to subroutine). 
Decrement-and-branch: DBcc (where "cc" was as for the branch instructions), which, provided the condition was false, decremented the low word of a D-register and, if the result was not -1 ($FFFF), branched to a destination. This use of −1 instead of 0 as the terminating value allowed the easy coding of loops that had to do nothing if the count was 0 to start with, with no need for another check before entering the loop. This also facilitated nesting of DBcc.

68050 and 68070

There was no 68050, though at one point it was a project within Motorola. Odd-numbered releases had always been reactions to issues raised within the prior even numbered part; hence, it was generally expected that the 68050 would have reduced the 68040's power consumption (and thus heat dissipation), improved exception handling in the FPU, used a smaller feature size and optimized the microcode in line with program use of instructions. Many of these optimizations were included with the 68060 and were part of its design goals. For any number of reasons, likely that the 68060 was in development, that the Intel 80486 was not progressing as quickly as Motorola assumed it would, and that 68060 was a demanding project, the 68050 was cancelled early in development.

There is also no revision of the 68060, as Motorola was in the process of shifting away from the 68000 and 88k processor lines into its new PowerPC business, so the 68070 was never developed. Had it been, it would have been a revised 68060, likely with a superior FPU (pipelining was widely speculated upon on Usenet).

Motorola mainly used even numbers for major revisions to the CPU core such as 68000, 68020, 68040 and 68060. The 68010 was a revised version of the 68000 with minor modifications to the core, and likewise the 68030 was a revised 68020 with some more powerful features, none of them significant enough to classify as a major upgrade to the core.

There was a CPU with the 68070 designation, which was a licensed and somewhat slower version of the 16/32-bit 68000 with a basic DMA controller, I²C host and an on-chip serial port. This 68070 was used as the main CPU in the Philips CD-i. This CPU was, however, produced by Philips and not officially part of Motorola's 680x0 lineup.

Last generation
The 4th-generation 68060 provided equivalent functionality (though not instruction-set-architecture compatibility) to most of the features of the Intel P5 microarchitecture.

Other variants
The Personal Computers XT/370 and AT/370 PC-based IBM-compatible mainframes each included two modified Motorola 68000 processors with custom microcode to emulate S/370 mainframe instructions.

After the mainline 68000 processors' demise, the 68000 family has been used to some extent in microcontroller and embedded microprocessor versions. These chips include the ones listed under "other" above, i.e. the CPU32 (aka 68330), the ColdFire, the QUICC and the DragonBall.

With the advent of FPGA technology an international team of hardware developers have re-created the 68000 with many enhancements as an FPGA core. Their core is known as the 68080 and is used in Vampire-branded Amiga accelerators.

Magnetic Scrolls used a subset of the 68000's instructions as a base for the virtual machine in their text adventures.

Competitors

Desktop
During the 1980s and early 1990s, when the 68000 was widely used in desktop computers, it mainly competed against Intel's x86 architecture used in IBM PC compatibles. Generation 1 68000 CPUs competed against mainly the 16-bit 8086, 8088, and 80286. Generation 2 competed against the 80386 (the first 32-bit x86 processor), and generation 3 against the 80486. The fourth generation competed with the P5 Pentium line, but it was not nearly as widely used as its predecessors, since much of the old 68000 marketplace was either defunct or nearly so (as was the case with Atari and NeXT), or converting to newer architectures (PowerPC for the Macintosh and Amiga, SPARC for Sun, and MIPS for Silicon Graphics (SGI)).

Embedded

There are dozens of processor architectures that are successful in embedded systems. Some are microcontrollers which are much simpler, smaller, and cheaper than the 68000, while others are relatively sophisticated and can run complex software. Embedded versions of the 68000 often compete with processor architectures based on PowerPC, ARM, MIPS, SuperH, and others.

See also
 VMEbus, an external computer bus standard designed for the 68000 series

References

Bibliography
 Howe, Dennis, ed. (1983). Free On-Line Dictionary of Computing. Imperial College, London. http://foldoc.org. Retrieved September 4, 2007.

External links

 BYTE Magazine, September 1986: The 68000 Family

68k architecture
 
32-bit computers