Motorola 68000

Last updated

Motorola 68000 architecture
Designer Motorola
Bits16/32-bit
Introduced1979;43 years ago (1979)
Design CISC
Branching Condition code
Endianness Big
Registers
  • 8× 32-bit data registers
  • 7× 32-bit address registers
  • stack pointer (address register 7)
Motorola 68000 CPU
General information
Launched1979
DiscontinuedJune 1, 1996;26 years ago (1996-06-01)
Designed byMotorola
Performance
Max. CPU clock rate 4 MHz to 16.67 MHz
Data width16 bits
Address width24 bits
Architecture and classification
Instruction set Motorola 68000 series
Physical specifications
Transistors
Package(s)
  • 64-pin DIP
History
Successor Motorola 68010

The Motorola 68000 (sometimes shortened to Motorola 68k or m68k and usually pronounced "sixty-eight-thousand") [2] [3] is a 16/32-bit complex instruction set computer (CISC) microprocessor, introduced in 1979 by Motorola Semiconductor Products Sector.

Contents

The design implements a 32-bit instruction set, with 32-bit registers and a 16-bit internal data bus. [4] The address bus is 24 bits and does not use memory segmentation, which made it easier to program for. Internally, it uses a 16-bit data arithmetic logic unit (ALU) and two more 16-bit ALUs used mostly for addresses, [4] and has a 16-bit external data bus. [5] For this reason, Motorola termed it a 16/32-bit processor.

As one of the first widely available processors with a 32-bit instruction set, and running at relatively high speeds for the era, the 68k was a popular design through the 1980s. It was widely used in a new generation of personal computers with graphical user interfaces, including the Macintosh, Amiga, Atari ST, and X68000. The 1988 Sega Genesis/Mega Drive console is also powered by a 68000.

The 68000 was followed by additional processors implementing full 32-bit ALUs as part of the growing Motorola 68000 series. The original 68k is generally software forward-compatible with the rest of the line despite being limited to a 16-bit wide external bus. [4]

Pre-release XC68000 chip made in 1979 XC68000.agr.jpg
Pre-release XC68000 chip made in 1979
Die of Motorola 68000 Motorola 68000 die.JPG
Die of Motorola 68000

After 43 years in production, the 68000 architecture is still in use. [6] [7]

Development

Motorola MC68000 (leadless chip carrier (CLCC) package) KL Motorola MC68000 CLCC.jpg
Motorola MC68000 (leadless chip carrier (CLCC) package)
Motorola MC68000 (plastic leaded chip carrier (PLCC) package) Nedap ESD1 - mainboard - Motorola MC68HC000FN8-0695.jpg
Motorola MC68000 (plastic leaded chip carrier (PLCC) package)

Motorola's first widely-produced CPU was the Motorola 6800. Although a capable design, it was eclipsed by more powerful designs, such as the Zilog Z80, and less expensive designs, such as the MOS Technology 6502. [8] As the sales prospects of the 6800 dimmed, Motorola began a new design to replace it. This became the Motorola Advanced Computer System on Silicon project (MACSS), begun in 1976 under the direction of Tom Gunter, its principal architect. The MACSS aimed to develop an entirely new architecture without backward compatibility with the 6800. It ultimately does retain a bus protocol compatibility mode for existing 6800 peripheral devices, and a version with an 8-bit data bus was produced. However, the designers mainly focused on the future, or forward compatibility, which gives the 68000 design a head start against later 32-bit instruction set architectures (ISAs). For instance, the CPU registers are 32 bits wide, though few self-contained structures in the processor itself operate on 32 bits at a time. The MACSS team drew heavily on the influence of minicomputer processor design, such as the PDP-11 and VAX systems, which are similarly microcode-based. [9] [10]

In the mid 1970s, the 8-bit microprocessor manufacturers raced to introduce the 16-bit generation. National Semiconductor was first with its IMP-16 and PACE processors in 1973 and 1974, respectively, but these had issues with speed. [11] [12] Intel had worked on their advanced 16/32-bit Intel iAPX 432 (alias 8800) since 1975 and their Intel 8086 since 1976 (it was introduced in 1978 but became widespread in the form of the almost identical 8088 in the IBM PC a few years later). Arriving late to the 16-bit arena affords the new processor more transistors (roughly 40,000[ citation needed ] active versus 20,000 active in the 8086), 32-bit macroinstructions, and acclaimed general ease of use.

The original MC68000 was fabricated using an HMOS process with a 3.5  µm feature size. Formally introduced in September 1979, [13] initial samples were released in February 1980, with production chips available over the counter in November. [14] Initial speed grades are 4, 6, and 8  MHz. 10 MHz chips became available during 1981, [15] and 12.5 MHz chips by June 1982. [14] The 16.67 MHz "12F" version of the MC68000, the fastest version of the original HMOS chip, was not produced until the late 1980s.

Variants

In 1982, the 68000 received a minor update to its instruction set architecture (ISA) to support virtual memory and to conform to the Popek and Goldberg virtualization requirements. The updated chip is called the 68010. [16] It also adds a new "loop mode" which speeds up small loops, and increases overall performance by about 10% at the same clock speeds. A further extended version, which exposes 31 bits of the address bus, was also produced in small quantities as the 68012.

To support lower-cost systems and control applications with smaller memory sizes, Motorola introduced the 8-bit compatible MC68008, also in 1982. This is a 68000 with an 8-bit data bus and a smaller (20-bit) address bus. After 1982, Motorola devoted more attention to the 68020 and 88000 projects.

Second-sourcing

Hitachi HD68000 KL Hitachi HD68000.jpg
Hitachi HD68000
Thomson TS68000 KL Thomson TS68000.jpg
Thomson TS68000

Several other companies were second-source manufacturers of the HMOS 68000. These included Hitachi (HD68000), who shrank the feature size to 2.7 µm for their 12.5 MHz version, [14] Mostek (MK68000), Rockwell (R68000), Signetics (SCN68000), Thomson/SGS-Thomson (originally EF68000 and later TS68000), and Toshiba (TMP68000). Toshiba was also a second-source maker of the CMOS 68HC000 (TMP68HC000).

Encrypted variants of the 68000, being the Hitachi FD1089 and FD1094, store decryption keys for opcodes and opcode data in battery-backed memory and were used in certain Sega arcade systems including System 16 to prevent piracy and illegal bootleg games. [17]

CMOS versions

Motorola MC68HC000LC8 Motorola MC68HC000LC8-2413.jpg
Motorola MC68HC000LC8

The 68HC000, the first CMOS version of the 68000, was designed by Hitachi and jointly introduced in 1985. [18] Motorola's version is called the MC68HC000, while Hitachi's is the HD68HC000. The 68HC000 offers speeds of 8–20 MHz. Except for using CMOS circuitry, it behaved identically to the HMOS MC68000, but the change to CMOS greatly reduced its power consumption. The original HMOS MC68000 consumed around 1.35  watts at an ambient temperature of 25  °C, regardless of clock speed, while the MC68HC000 consumed only 0.13 watts at 8 MHz and 0.38 watts at 20 MHz. (Unlike CMOS circuits, HMOS still draws power when idle, so power consumption varies little with clock rate.) Apple selected the 68HC000 for use in the Macintosh Portable.

Motorola replaced the MC68008 with the MC68HC001 in 1990. [19] This chip resembles the 68HC000 in most respects, but its data bus can operate in either 16-bit or 8-bit mode, depending on the value of an input pin at reset. Thus, like the 68008, it can be used in systems with cheaper 8-bit memories.

The later evolution of the 68000 focused on more modern embedded control applications and on-chip peripherals. The 68EC000 chip and SCM68000 core remove the M6800 peripheral bus, and exclude the MOVE from SR instruction from user mode programs, making the 68EC000 and 68SEC000 the only 68000 CPUs not 100% object code compatible with previous 68000 CPUs when run in User Mode. When run in Supervisor Mode, there is no difference. [20] In 1996, Motorola updated the standalone core with fully static circuitry, drawing only 2  µW in low-power mode, calling it the MC68SEC000. [21]

Motorola ceased production of the HMOS MC68000, as well as the MC68008, MC68010, MC68330, and MC68340 in on June 1, 1996, [22] [23] but its spin-off company Freescale Semiconductor was still producing the MC68HC000, MC68HC001, MC68EC000, and MC68SEC000, as well as the MC68302 and MC68306 microcontrollers and later versions of the DragonBall family. The 68000's architectural descendants, the 680x0, CPU32, and Coldfire families, were also still in production. More recently, with the Sendai fab closure, all 68HC000, 68020, 68030, and 68882 parts have been discontinued, leaving only the 68SEC000 in production. [24]

As a microcontroller core

Since being succeeded by "true" 32-bit microprocessors, the 68000 is used as the core of many microcontrollers. In 1989, Motorola introduced the MC68302 communications processor. [25]

Applications

Two Hitachi 68HC000 CPUs being used on an arcade-game PCB Burning force pcb.PNG
Two Hitachi 68HC000 CPUs being used on an arcade-game PCB

IBM considered the 68000 for the IBM PC but chose the Intel 8088 because the 68000 was not ready; Walden C. Rhines wrote that thus "Motorola, with its superior technology, lost the single most important design contest of the last 50 years". [26] (IBM Instruments briefly sold the 68000-based IBM System 9000 laboratory computer systems.) The 68k instruction set is particularly well suited to implement Unix, [27] and the 68000 and its successors became the dominant CPUs for Unix-based workstations including Sun workstations and Apollo/Domain workstations.

In 1981, Motorola introduced the Motorola 68000 Educational Computer Board, a single-board computer for educational and training purposes which in addition to the 68000 itself contained memory, I/O devices, programmable timer and wire-wrap area for custom circuitry. The board remained in use in US colleges as a tool for learning assembly programming until the early 1990s. [28]

At its introduction, the 68000 was first used in high-priced systems, including multiuser microcomputers like the WICAT 150, [29] early Alpha Microsystems computers, Sage II / IV, Tandy 6000 / TRS-80 Model 16, and Fortune 32:16; single-user workstations such as Hewlett-Packard's HP 9000 Series 200 systems, the first Apollo/Domain systems, Sun Microsystems' Sun-1, and the Corvus Concept; and graphics terminals like Digital Equipment Corporation's VAXstation 100 and Silicon Graphics' IRIS 1000 and 1200. Unix systems rapidly moved to the more capable later generations of the 68k line, which remained popular in that market throughout the 1980s.

By the mid-1980s, falling production cost made the 68000 viable for use in personal and home computers, starting with the Apple Lisa and Macintosh, and followed by the Commodore Amiga, Atari ST, and Sharp X68000.

The Sinclair QL microcomputer, along with its derivatives, such as the ICL One Per Desk business terminal, was the most commercially important utilisation of the 68008. Helix Systems (in Missouri, United States) designed an extension to the SWTPC SS-50 bus, the SS-64, and produced systems built around the 68008 processor.

While the adoption of RISC and x86 displaced the 68000 series as desktop/workstation CPU, the processor found substantial use in embedded applications. By the early 1990s, quantities of 68000 CPUs could be purchased for less than 30  USD per part.[ citation needed ]

The 68000 also saw great success as an embedded controller. As early as 1981, laser printers such as the Imagen Imprint-10 were controlled by external boards equipped with the 68000. The first HP LaserJet, introduced in 1984, came with a built-in 8 MHz 68000. Other printer manufacturers adopted the 68000, including Apple with its introduction of the LaserWriter in 1985, the first PostScript laser printer. The 68000 continued to be widely used in printers throughout the rest of the 1980s, persisting well into the 1990s in low-end printers.

The 68000 was successful in the field of industrial control systems. Among the systems benefited from having a 68000 or derivative as their microprocessor were families of programmable logic controllers (PLCs) manufactured by Allen-Bradley, Texas Instruments and subsequently, following the acquisition of that division of TI, by Siemens. Users of such systems do not accept product obsolescence at the same rate as domestic users, and it is entirely likely that despite having been installed over 20 years ago, many 68000-based controllers will continue in reliable service well into the 21st century.

In a number of digital oscilloscopes from the 80s, [30] the 68000 has been used as a waveform display processor; some models including the LeCroy 9400/9400A [31] also use the 68000 as a waveform math processor (including addition, subtraction, multiplication, and division of two waveforms/references/waveform memories), and some digital oscilloscopes using the 68000 (including the 9400/9400A) can also perform fast Fourier transform functions on a waveform.

The 683XX microcontrollers, based on the 68000 architecture, are used in networking and telecom equipment, television set-top boxes, laboratory and medical instruments, and even handheld calculators. The MC68302 and its derivatives have been used in many telecom products from Cisco, 3com, Ascend, Marconi, Cyclades and others. Past models of the Palm PDAs and the Handspring Visor used the DragonBall, a derivative of the 68000. AlphaSmart used the DragonBall family in later versions of its portable word processors. Texas Instruments used the 68000 in its high-end graphing calculators, the TI-89 and TI-92 series and Voyage 200.

A modified version of the 68000 formed the basis of the IBM XT/370 hardware emulator of the System 370 processor.

Video games

Video game manufacturers used the 68000 as the backbone of many arcade games and home game consoles: Atari's Food Fight , from 1982, was one of the first 68000-based arcade games. Others included Sega's System 16, Capcom's CP System and CPS-2, and SNK's Neo Geo. By the late 1980s, the 68000 was inexpensive enough to power home game consoles, such as Sega's Mega Drive/Genesis console and also the Mega CD attachment for it (A Mega CD system has three CPUs, two of them 68000s). The 1993 multi-processor Atari Jaguar console used a 68000 as a support chip, although some developers used it as the primary processor due to familiarity. The 1994 multi-processor Sega Saturn console used the 68000 as a sound co-processor (much as the Mega Drive/Genesis uses the Z80 as a co-processor for sound and/or other purposes).[ citation needed ] In October 1995, the 68000 made it into a handheld game console, Sega's Genesis Nomad, as its CPU. [32]

Certain arcade games (such as Steel Gunner and others based on Namco System 2) use a dual 68000 CPU configuration, [33] and systems with a triple 68000 CPU configuration also exist (such as Galaxy Force and others based on the Sega Y Board), [34] along with a quad 68000 CPU configuration, which has been used by Jaleco (one 68000 for sound has a lower clock rate compared to the other 68000 CPUs) [35] for games such as Big Run and Cisco Heat ; another, fifth 68000 (at a different clock rate than the other 68000 CPUs) was used in the Jaleco arcade game Wild Pilot for input/output (I/O) processing. [36]

Architecture

Motorola 68000 registers
31...23...15...07...00(bit position)
Data registers
D0Data 0
D1Data 1
D2Data 2
D3Data 3
D4Data 4
D5Data 5
D6Data 6
D7Data 7
Address registers
 A0Address 0
 A1Address 1
 A2Address 2
 A3Address 3
 A4Address 4
 A5Address 5
 A6Address 6
Stack pointers
 A7 / USPStack Pointer (user)
 A7' / SSPStack Pointer (supervisor)
Program counter
 PCProgram Counter
Condition Code Register
 15141312111009080706050403020100(bit position)
 TSM0I000X N Z V C CCR

Address bus

The 68000 has a 24-bit external address bus and two byte-select signals "replaced" A0. These 24 lines can therefore address 16 MB of physical memory with byte resolution. Address storage and computation uses 32 bits internally; however, the 8 high-order address bits are ignored due to the physical lack of device pins. This allows it to run software written for a logically flat 32-bit address space, while accessing only a 24-bit physical address space. Motorola's intent with the internal 32-bit address space was forward compatibility, making it feasible to write 68000 software that would take full advantage of later 32-bit implementations of the 68000 instruction set. [4]

However, this did not prevent programmers from writing forward incompatible software. "24-bit" software that discarded the upper address byte, or used it for purposes other than addressing, could fail on 32-bit 68000 implementations. For example, early (pre-7.0) versions of Apple's Mac OS used the high byte of memory-block master pointers to hold flags such as locked and purgeable. Later versions of the OS moved the flags to a nearby location, and Apple began shipping computers which had "32-bit clean" ROMs beginning with the release of the 1989 Mac IIci.

The 68000 family stores multi-byte integers in memory in big-endian order.

Internal registers

The CPU 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. This was a good number of registers at the time in many ways. It was small enough to allow the 68000 to respond quickly to interrupts (even in the worst case where all 8 data registers D0–D7 and 7 address registers A0–A6 needed to be saved, 15 registers in total), and yet large enough to make most calculations fast, because they could be done entirely within the processor without keeping any partial results in memory. (Note that an exception routine in supervisor mode can also save the user stack pointer A7, which would total 8 address registers. However, the dual stack pointer (A7 and supervisor-mode A7') design of the 68000 makes this normally unnecessary, except when a task switch is performed in a multitasking system.)

Having the two types of registers allows one 32-bit address and one 16-bit data calculation to take place at the one time. This results in reduced instruction execution time as addresses and data can be processed in parallel. [4]

Status register

The 68000 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 multiprecision arithmetic. [37]

Instruction set

The designers attempted to make the assembly language orthogonal. That is, instructions are divided into operations and address modes, and almost all address modes are available for almost all instructions. There are 56 instructions and a minimum instruction size of 16 bits. Many instructions and addressing modes are longer to include more address or mode bits.

Privilege levels

The CPU, and later the whole family, implements two levels of privilege. User mode gives access to everything except privileged instructions such as interrupt level controls. [38] Supervisor privilege gives access to everything. An interrupt always becomes supervisory. The supervisor bit is stored in the status register, and is visible to user programs. [38]

An advantage of this system is that the supervisor level has a separate stack pointer. This permits a multitasking system to use very small stacks for tasks, because the designers do not have to allocate the memory required to hold the stack frames of a maximum stack-up of interrupts.

Interrupts

The CPU recognizes seven interrupt levels. Levels 1 through 5 are strictly prioritized. That is, a higher-numbered interrupt can always interrupt a lower-numbered interrupt. In the status register, a privileged instruction allows setting the current minimum interrupt level, blocking lower or equal priority interrupts. For example, if the interrupt level in the status register is set to 3, higher levels from 4 to 7 can cause an exception. Level 7 is a level triggered non-maskable interrupt (NMI). Level 1 can be interrupted by any higher level. Level 0 means no interrupt. The level is stored in the status register, and is visible to user-level programs.

Hardware interrupts are signalled to the CPU using three inputs that encode the highest pending interrupt priority. A separate encoder is usually required to encode the interrupts, though for systems that do not require more than three hardware interrupts it is possible to connect the interrupt signals directly to the encoded inputs at the cost of more software complexity. The interrupt controller can be as simple as a 74LS148 priority encoder, or may be part of a very large-scale integration (VLSI) peripheral chip such as the MC68901 Multi-Function Peripheral (used in the Atari ST range of computers and Sharp X68000), which also provides a UART, timer, and parallel I/O.

The "exception table" (interrupt vector table interrupt vector addresses) is fixed at addresses 0 through 1023, permitting 256 32-bit vectors. The first vector (RESET) consists of two vectors, namely the starting stack address, and the starting code address. Vectors 3 through 15 are used to report various errors: bus error, address error, illegal instruction, zero division, CHK and CHK2 vector, privilege violation (to block privilege escalation), and some reserved vectors that became line 1010 emulator, line 1111 emulator, and hardware breakpoint. Vector 24 starts the real interrupts: spurious interrupt (no hardware acknowledgement), and level 1 through level 7 autovectors, then the 16 TRAP vectors, then some more reserved vectors, then the user defined vectors.

Since the starting code address vector must always be valid on reset, systems commonly included some nonvolatile memory (e.g. ROM) starting at address zero to contain the vectors and bootstrap code. However, for a general purpose system it is desirable for the operating system to be able to change the vectors at runtime. This was often accomplished by either pointing the vectors in ROM to a jump table in RAM, or through use of bank switching to allow the ROM to be replaced by RAM at runtime.

The 68000 does not meet the Popek and Goldberg virtualization requirements for full processor virtualization because it has a single unprivileged instruction, "MOVE from SR", which allows user-mode software read-only access to a small amount of privileged state. The 68EC000 and 68SEC000, which are later derivatives of the 68000, do meet the requirements as the "MOVE from SR" instruction is privileged. The same change was introduced on the 68010 and later CPUs.

The 68000 is also unable to easily support virtual memory, which requires the ability to trap and recover from a failed memory access. The 68000 does provide a bus error exception which can be used to trap, but it does not save enough processor state to resume the faulted instruction once the operating system has handled the exception. Several companies did succeed in making 68000-based Unix workstations with virtual memory that worked by using two 68000 chips running in parallel on different phased clocks. When the "leading" 68000 encountered a bad memory access, extra hardware would interrupt the "main" 68000 to prevent it from also encountering the bad memory access. This interrupt routine would handle the virtual memory functions and restart the "leading" 68000 in the correct state to continue properly synchronized operation when the "main" 68000 returned from the interrupt.

These problems were fixed in the next major revision of the 68k architecture with the release of the MC68010. The Bus Error and Address Error exceptions push a large amount of internal state onto the supervisor stack in order to facilitate recovery, and the "MOVE from SR" instruction was made privileged. A new unprivileged "MOVE from CCR" instruction is provided for use in its place by user mode software; an operating system can trap and emulate user mode "MOVE from SR" instructions if desired.

Instruction set details

The standard addressing modes are:

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

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

Like many CPUs of its era the cycle timing of some instructions varied depending on the source operand(s). For example, the unsigned multiply instruction takes (38+2n) clock cycles to complete where 'n' is equal to the number of bits set in the operand. [39] To create a function that took a fixed cycle count required the addition of extra code after the multiply instruction. This would typically consume extra cycles for each bit that wasn't set in the original multiplication operand.

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

68EC000

Motorola 68EC000 controller KL Motorola 68EC000 PLCC.jpg
Motorola 68EC000 controller

The 68EC000 is a low-cost version of the 68000 with a slightly different pinout, designed for embedded controller applications. The 68EC000 can have either a 8-bit or 16-bit data bus, switchable at reset. [40]

The processors are available in a variety of speeds including 8 and 16  MHz configurations, producing 2,100 and 4,376  Dhrystones each. These processors have no floating-point unit, and it is difficult to implement an FPU coprocessor (MC68881/2) with one because the EC series lacks necessary coprocessor instructions.

The 68EC000 was used as a controller in many audio applications, including Ensoniq musical instruments and sound cards, where it was part of the MIDI synthesizer. [41] On Ensoniq sound boards, the controller provided several advantages compared to competitors without a CPU on board. The processor allowed the board to be configured to perform various audio tasks, such as MPU-401 MIDI synthesis or MT-32 emulation, without the use of a terminate-and-stay-resident program. This improved software compatibility, lowered CPU usage, and eliminated host system memory usage.

The Motorola 68EC000 core was later used in the m68k-based DragonBall processors from Motorola/Freescale.

It also was used as a sound controller in the Sega Saturn game console and as a controller for the HP JetDirect Ethernet controller boards for the mid-1990s HP LaserJet printers.

Example code

The 68000 assembly code below is for a subroutine named strtolower, which copies a null-terminated string of 8-bit characters to a destination string, converting all alphabetic characters to lower case.

                                                                                                                                                                                 00100000           00100000  4E56 0000 00100004  306E 0008 00100008  326E 000C 0010000C  1018 0010000E  0C40 0041 00100012  6500 000E 00100016  0C40 005A 0010001A  6200 0006 0010001E  0640 0020 00100022  12C0 00100024  66E6 00100026  4E5E 00100028  4E75 0010002A 
; strtolower:; Copy a null-terminated ASCII string, converting; all alphabetic characters to lower case.;; Entry parameters:;   (SP+0): Source string address;   (SP+4): Target string addressorg$00100000;Start at 00100000strtolowerpubliclinka6,#0;Set up stack framemovea8(a6),a0;A0 = src, from stackmovea12(a6),a1;A1 = dst, from stackloopmove.b(a0)+,d0;Load D0 from (src), incr srccmpi#'A',d0;If D0 < 'A',blocopy;skipcmpi#'Z',d0;If D0 > 'Z',bhicopy;skipaddi#'a'-'A',d0;D0 = lowercase(D0)copymove.bd0,(a1)+;Store D0 to (dst), incr dstbneloop;Repeat while D0 <> NULunlka6;Restore stack framerts;Returnend

The subroutine establishes a call frame using register A6 as the frame pointer. This kind of calling convention supports reentrant and recursive code and is typically used by languages like C and C++. The subroutine then retrieves the parameters passed to it (src and dst) from the stack. It then loops, reading an ASCII character (one byte) from the src string, checking whether it is a capital alphabetic character, and if so, converting it into a lower-case character, otherwise leaving it as it is, then writing the character into the dst string. Finally, it checks whether the character was a null character; if not, it repeats the loop, otherwise it restores the previous stack frame (and A6 register) and returns. Note that the string pointers (registers A0 and A1) are auto-incremented in each iteration of the loop.

In contrast, the code below is for a stand-alone function, even on the most restrictive version of AMS for the TI-89 series of calculators, being kernel-independent, with no values looked up in tables, files or libraries when executing, no system calls, no exception processing, minimal registers to be used, nor the need to save any. It is valid for historical Julian dates from 1 March 1 AD, or for Gregorian ones. In less than two dozen operations it calculates a day number compatible with ISO 8601 when called with three inputs stored at their corresponding LOCATIONS:

; ;  WDN, an address - for storing result d0 ; FLAG, 0 or 2 - to choose between Julian or Gregorian, respectively ; DATE, year0mda - date stamp as binary word&byte&byte in basic ISO-format ;(YEAR, year ~ YEAR=DATE due to big-endianness) ;      move.lDATE,d0move.ld0,d1 ; ; Apply step 1 - Lachman's congruence andi.l#$f00,d0divu#100,d0addi.w#193,d0andi.l#$ff,d0divu#100,d0; d0 has the month index i in the upper word (mod 100) ; ; Apply step 2 - Finding spqr as the year of the Julian leap day preceding DATE      swapd0andi.l#$ffff,d0add.bd1,d0add.wYEAR,d0subi.l#$300,d1lsr#2,d1swapd1add.wd1,d0; spqr/4 + year + i + da ; ; (Apply step 0 - Gregorian adjustment)      muluFLAG,d1divu#50,d1mulu#25,d1lsr#2,d1add.wd1,d0add.wFLAG,d0; (sp32div16) + spqr/4 + year + i + da ;      divu#7,d0swapd0;  d0.w becomes the day number ;      move.wd0,WDN; returns the day number to address WDNrts ; ; Days of the week correspond to day numbers of the week as: ; Sun=0  Mon=1  Tue=2  Wed=3  Thu=4  Fri=5  Sat=6 ;

See also

Related Research Articles

<span class="mw-page-title-main">Intel 8086</span> 16-bit microprocessor

The 8086 is a 16-bit microprocessor chip designed by Intel between early 1976 and June 8, 1978, when it was released. The Intel 8088, released July 1, 1979, is a slightly modified chip with an external 8-bit data bus, and is notable as the processor used in the original IBM PC design.

<span class="mw-page-title-main">MOS Technology 6502</span> 8-bit microprocessor

The MOS Technology 6502 is an 8-bit microprocessor that was designed by a small team led by Chuck Peddle for MOS Technology. The design team had formerly worked at Motorola on the Motorola 6800 project; the 6502 is essentially a simplified, less expensive and faster version of that design.

<span class="mw-page-title-main">Motorola 68020</span>

The Motorola 68020 is a 32-bit microprocessor from Motorola, released in 1984. A lower cost version was also made available, known as the 68EC020. In keeping with naming practices common to Motorola designs, the 68020 is usually referred to as the "020", pronounced "oh-two-oh" or "oh-twenty".

<span class="mw-page-title-main">Motorola 6809</span> 8-bit microprocessor

The Motorola 6809 ("sixty-eight-oh-nine") is an 8-bit microprocessor with some 16-bit features. It was designed by Motorola's Terry Ritter and Joel Boney and introduced in 1978. Although source compatible with the earlier Motorola 6800, the 6809 offered significant improvements over it and 8-bit contemporaries like the MOS Technology 6502, including a hardware multiplication instruction, 16-bit arithmetic, system and user stack registers allowing re-entrant code, improved interrupts, position-independent code and an orthogonal instruction set architecture with a comprehensive set of addressing modes.

<span class="mw-page-title-main">Motorola 68HC11</span> 8-bit microcontroller

The 68HC11 is an 8-bit microcontroller (µC) family introduced by Motorola in 1984. Now produced by NXP Semiconductors, it descended from the Motorola 6800 microprocessor by way of the 6801. The 68HC11 devices are more powerful and more expensive than the 68HC08 microcontrollers, and are used in automotive applications, barcode readers, hotel card key writers, amateur robotics, and various other embedded systems. The MC68HC11A8 was the first microcontroller to include CMOS EEPROM.

x86 Family of instruction set architectures

x86 is a family of complex instruction set computer (CISC) instruction set architectures initially developed by Intel based on the Intel 8086 microprocessor and its 8088 variant. The 8086 was introduced in 1978 as a fully 16-bit extension of Intel's 8-bit 8080 microprocessor, with memory segmentation as a solution for addressing more memory than can be covered by a plain 16-bit address. The term "x86" came into being because the names of several successors to Intel's 8086 processor end in "86", including the 80186, 80286, 80386 and 80486 processors.

<span class="mw-page-title-main">Zilog Z80</span> 8-bit microprocessor

The Z80 is an 8-bit microprocessor introduced by Zilog as the startup company's first product. The Z80 was conceived by Federico Faggin in late 1974 and developed by him and his 11 employees starting in early 1975. The first working samples were delivered in March 1976, and it was officially introduced on the market in July 1976. With the revenue from the Z80, the company built its own chip factories and grew to over a thousand employees over the following two years.

The NS32000, sometimes known as the 32k, is a series of microprocessors produced by National Semiconductor. The first member of the family came to market in 1982, briefly known as the 16032 before becoming the 32016. It was the first 32-bit general-purpose microprocessor on the market: the Motorola 68000 could process 32-bit data and use 32-bit addresses but had a 16-bit ALU, whereas the 32000 series was described in 1983 as the only microprocessor available at that time with 32-bit internal data paths and ALU. However, the 32016 contained a large number of bugs and often could not be run at its rated speed. These problems, and the presence of the similar Motorola 68000 which had been available since 1980, led to little use in the market.

<span class="mw-page-title-main">Motorola 68010</span>

The Motorola MC68010 processor is a 16/32-bit microprocessor from Motorola, released in 1982 as the successor to the Motorola 68000. It fixes several small flaws in the 68000, and adds a few features.

The Motorola 68000 series 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, 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 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.

<span class="mw-page-title-main">Motorola 68008</span>

The Motorola 68008 is an 8/32-bit microprocessor introduced by Motorola in 1982. It is a version of 1979's Motorola 68000 with an 8-bit external data bus, as well as a smaller address bus. The 68008 was available with 20 or 22 address lines which allowed 1 MB or 4 MB address space versus the 16 MB addressable on the 68000. The 68008 was designed to work with lower cost and simpler 8-bit memory systems. Because of its smaller data bus, it was roughly half as fast as a 68000 of the same clock speed. It was still faster than competing 8-bit microprocessors, because internally the 68008 behaves identically to the 68000 and has the same microarchitecture.

<span class="mw-page-title-main">Zilog Z8000</span>

The Z8000 is a 16-bit microprocessor introduced by Zilog in early 1979. The architecture was designed by Bernard Peuto while the logic and physical implementation was done by Masatoshi Shima, assisted by a small group of people. In contrast to most designs of the era, the Z8000 did not use microcode which allowed it to be implemented in only 17,500 transistors.

A processor register is a quickly accessible location available to a computer's processor. Registers usually consist of a small amount of fast storage, although some registers have specific hardware functions, and may be read-only or write-only. In computer architecture, registers are typically addressed by mechanisms other than main memory, but may in some cases be assigned a memory address e.g. DEC PDP-10, ICT 1900.

Addressing modes are an aspect of the instruction set architecture in most central processing unit (CPU) designs. The various addressing modes that are defined in a given instruction set architecture define how the machine language instructions in that architecture identify the operand(s) of each instruction. An addressing mode specifies how to calculate the effective memory address of an operand by using information held in registers and/or constants contained within a machine instruction or elsewhere.

The zero page or base page is the block of memory at the very beginning of a computer's address space; that is, the page whose starting address is zero. The size of a page depends on the context, and the significance of zero page memory versus higher addressed memory is highly dependent on machine architecture. For example, the Motorola 6800 and MOS Technology 6502 processor families treat the first 256 bytes of memory specially, whereas many other processors do not.

Introduced in June 1976, the TMS9900 was one of the first commercially available, single-chip 16-bit microprocessors. It implemented Texas Instruments' TI-990 minicomputer architecture in a single-chip format, and was initially used for low-end models of that lineup.

In computer engineering, an orthogonal instruction set is an instruction set architecture where all instruction types can use all addressing modes. It is "orthogonal" in the sense that the instruction type and the addressing mode vary independently. An orthogonal instruction set does not impose a limitation that requires a certain instruction to use a specific register so there is little overlapping of instruction functionality.

TLCS is a prefix applied to microcontrollers made by Toshiba. The product line includes multiple families of CISC and RISC architectures. Individual components generally have a part number beginning with "TMP". E.g. the TMP8048AP is a member of the TLCS-48 family.

The 9S08 is a 8-bit microcontroller (µC) family originally produced by Motorola, later by Freescale Semiconductor, and currently by NXP, descended from the Motorola 6800 microprocessor. It is a CISC microcontroller. A slightly extended variant of the 68HC08, it shares upward compatibility with the aging 68HC05 microcontrollers, and is found in almost any type of embedded systems. The larger members offer up to 128 KiB of flash, and 8 KiB of RAM via a simple MMU which allows bank-switching 16 KiB of the address space and an address/data register pair which allows data fetches from any address. The paging scheme used allows for a theoretical maximum of 4MB of flash.

In computer architecture, 16-bit integers, memory addresses, or other data units are those that are 16 bits wide. Also, 16-bit central processing unit (CPU) and arithmetic logic unit (ALU) architectures are those that are based on registers, address buses, or data buses of that size. 16-bit microcomputers are microcomputers that use 16-bit microprocessors.

References

  1. Heath, Steve (1995). Microprocessor Architectures and Systems: RISC, CISC, and DSP (Second ed.). p. 13. ISBN   0-7506-2303-9. Archived from the original on April 16, 2021. Retrieved October 12, 2019.
  2. Granlund, Torbjörn (November 14, 2020). The GNU Multiple Precision Arithmetic Library (PDF) (Ed. 6.2.1 ed.). GNU Project. p. 13. Archived (PDF) from the original on July 28, 2022. Retrieved July 29, 2022.
  3. Heid, Jim; Norton, Peter (1989). Inside the Apple Macintosh. Simon & Schuster. p. 530. ISBN   0-13-467622-X. Archived from the original on July 29, 2022. Retrieved July 29, 2022.
  4. 1 2 3 4 5 Starnes, Thomas W. (April 1983). "Design Philosophy Behind Motorola's MC68000". Byte . Vol. 8, no. 4. Archived from the original on July 24, 2018. Retrieved June 19, 2018.
  5. Motorola M68000 Family Programmer's Reference Manual (PDF). Phoenix, Arizona: Motorola. 1992. p. 1-1. ISBN   0-13-723289-6. Archived (PDF) from the original on September 24, 2015. Retrieved August 12, 2005.
  6. "MC68000: Low Cost 32-Bit Microprocessor (Including HC000, HC001, EC000 and SEC000)". NXP Semiconductor. Archived from the original on April 14, 2021. Retrieved March 24, 2021.
  7. Turley, Jim (August 10, 2020). "Wallowing in 68K Nostalgia Want to Build a New, 40-year-old Computer?". Electronic Engineering Journal. Archived from the original on April 11, 2021. Retrieved March 24, 2021.
  8. Tooley, Michael (1988). Servicing Personal Computers (Second ed.). Heinemann. p. 8. ISBN   0-434-91975-6. Archived from the original on July 29, 2022. Retrieved July 29, 2022.
  9. Tooley, Michael (1992). Servicing Personal Computers (Third ed.). Newnes. p. 264–265. ISBN   0-7506-0374-7. Archived from the original on July 29, 2022. Retrieved July 29, 2022.
  10. Andersson, Sven (March 24, 2014). "The Microprocessor (R)evolution". EE Times . p. 2. Archived from the original on July 29, 2022. Retrieved July 29, 2022.
  11. Kent, Allen; Williams, James G. (1991). Encyclopedia of Microcomputers – Evolution of Computerized Maintenance Management to Generation of Random Numbers. Vol. 7. Marcel Dekker. p. 336. ISBN   0-8247-2706-1. Archived from the original on July 29, 2022. Retrieved July 29, 2022.
  12. Zaks, Rodnay (1981). From Chips to Systems: An Introduction to Microprocessors. Sybex. p. 242. ISBN   0-89588-063-6 . Retrieved July 29, 2022.
  13. Ken Polsson. "Chronology of Microprocessors". Processortimeline.info. Archived from the original on August 19, 2012. Retrieved September 27, 2013.
  14. 1 2 3 DTACK GROUNDED, The Journal of Simple 68000/16081 Systems, March 1984, p. 9, archived from the original on March 10, 2016, retrieved October 31, 2011.
  15. "Motorola was the rival to beat, and its 68000 its greatest success". tekdeeps. Archived from the original on September 13, 2022. Retrieved September 13, 2022.
  16. Faynberg, Igor; Lu, Hui-Lan; Skuler, Dor (2016). Cloud Computing: Business Trends and Technologies. Wiley. p. 53. ISBN   978-1-118-50121-4. Archived from the original on July 29, 2022. Retrieved July 29, 2022.
  17. "FD1094 – Sega Retro". segaretro.org. October 19, 2017. Archived from the original on September 28, 2013. Retrieved October 27, 2015.
  18. "Company Briefs" Archived November 14, 2007, at the Wayback Machine , The New York Times, September 21, 1985, available from TimesSelect (subscription).
  19. "68HC001 obsoletes 68008". Microprocessor Report . June 20, 1990.
  20. "Motorola streamlines 68000 family; "EC" versions of 68000, '020, '030, and '040, plus low-end 68300 chip"". Microprocessor Report. April 17, 1991.
  21. "Motorola reveals MC68SEC000 processor for low power embedded applications" (Press release). Motorola. November 18, 1996. Archived from the original on March 28, 1997.
  22. "HIPPO Q495" (PDF). High-Performance Internal Product Portfolio Overview. Motorola (10). Fourth Quarter 1995. Archived from the original on September 14, 2022. Retrieved July 29, 2022.
  23. comp.sys.m68k Usenet posting Archived November 14, 2007, at the Wayback Machine , May 16, 1995; also see other posts in thread. The end-of-life announcement was in late 1994; according to standard Motorola end-of-life practice, final orders would have been in 1995, with final shipments in 1996.
  24. "Freescale 150mm Sendai Fab Closure-General Product Discontinuance". November 24, 2010. Archived from the original on March 9, 2014. Retrieved March 9, 2014.
  25. "Multiprotocol processor marries 68000 and RISC". ESD: The Electronic System Design Magazine. November 1, 1989 via AccessMyLibrary.
  26. Rhines, Walden C. (June 22, 2017). "The Inside Story of Texas Instruments' Biggest Blunder: The TMS9900 Microprocessor". IEEE Spectrum. Archived from the original on May 25, 2020. Retrieved June 16, 2020.
  27. Rood, Andrew L.; Cline, Robert C.; Brewster, Jon A. (September 1986). "UNIX and the MC68000". Byte . p. 179.
  28. The Atmel AVR Microcontroller: MEGA and XMEGA in Assembly and C. Han-Way Huang. January 14, 2013. ISBN   978-1285500089. Archived from the original on April 10, 2022. Retrieved November 18, 2021.
  29. "museum ~ WICAT 150". Old-computers.com. Archived from the original on October 12, 2012. Retrieved September 27, 2013.
  30. Philips PM3320 250 MS/s Dual Channel Digital Storage Oscilloscope Service Manual, Section 8.6, ordering code 4822 872 05315.
  31. LeCroy 9400/9400A Digital Oscilloscope Service Manual, Section 1.1.1.3 Microprocessor, August 1990.
  32. Hunt, Stuart (October 6, 2009). "Retroinspection: Sega Nomad". Retro Gamer . No. 69. p. 47.
  33. "Google Code Archive - Long-term storage for Google Code Project Hosting". code.google.com. Archived from the original on September 14, 2022. Retrieved January 15, 2016.
  34. "openlase-mame/segaybd.c at master - jv4779/openlase-mame". GitHub. Archived from the original on December 9, 2021. Retrieved January 15, 2016.
  35. "Google Code Archive - Long-term storage for Google Code Project Hosting". code.google.com. Archived from the original on September 14, 2022. Retrieved January 15, 2016.
  36. "historic-mess/cischeat.c at master - mamedev/historic-mess". GitHub. Archived from the original on January 25, 2022. Retrieved January 15, 2016.
  37. Ford, William; Topp, William R. (1997). Assembly Language and Systems Programming for the M68000 Family (Second ed.). Jones and Bartlett Publishers. pp. 149–151. ISBN   0-7637-0357-5. Archived from the original on July 29, 2022. Retrieved July 29, 2022.
  38. 1 2 M68000 8-/16-/32-Bit Microprocessors User's Manual Ninth Edition (PDF). Motorola. 1993. p. 6-2. Archived (PDF) from the original on April 14, 2022. Retrieved February 28, 2022.
  39. "Standard Instruction Execution Times". oldwww.nvg.ntnu.no. Archived from the original on September 9, 2016. Retrieved August 4, 2017.
  40. Boys, Robert (January 6, 1996). "M68k Frequently Asked Questions (FAQ), comp.sys.m68k". Archived from the original on July 16, 2012. Retrieved May 3, 2010.
  41. Soundscape Elite Specs. from Fax Sheet Archived January 30, 2010, at the Wayback Machine , Google Groups, April 25, 1995.

Further reading

Datasheets and manuals
Books