Freescale Semiconductor
Technical Information Center, CH370
1300 N. Alma School Road
Chandler, Arizona 85224
(800) 521-6274
480-768-2130
support@freescale.com
Headquarters
ARCO Tower 15F
1-8-1, Shimo-Meguro, Meguro-ku
Tokyo 153-0064, Japan
0120 191014
+81 2666 8080
support.japan@freescale.com
Asia/Pacific:
Freescale Semiconductor Hong Kong Ltd.
Technical Information Center
2 Dai King Street
Tai Po Industrial Estate,
Tai Po, N.T., Hong Kong
+800 2666 8080
support.asia@freescale.com
For Literature Requests Only:
Freescale Semiconductor
Literature Distribution Center
P.O. Box 5405
Denver, Colorado 80217
(800) 441-2447
303-675-2140
Fax: 303-675-2150
LDCForFreescaleSemiconductor
@hibbertgroup.com
Information in this document is provided solely to enable system and software
implementers to use Freescale Semiconductor products. There are no express or
implied copyright licenses granted hereunder to design or fabricate any integrated
circuits or integrated circuits based on the information in this document.
Freescale Semiconductor reserves the right to make changes without further notice to
any products herein. Freescale Semiconductor makes no warranty, representation or
guarantee regarding the suitability of its products for any particular purpose, nor does
Freescale Semiconductor assume any liability arising out of the application or use of
any product or circuit, and specifically disclaims any and all liability, including without
limitation consequential or incidental damages. “Typical” parameters which may be
provided in Freescale Semiconductor data sheets and/or specifications can and do
vary in different applications and actual performance may vary over time. All operating
parameters, including “Typicals” must be validated for each customer application by
customer’s technical experts. Freescale Semiconductor does not convey any license
under its patent rights nor the rights of others. Freescale Semiconductor products are
not designed, intended, or authorized for use as components in systems intended for
surgical implant into the body, or other applications intended to support or sustain life,
or for any other application in which the failure of the Freescale Semiconductor product
could create a situation where personal injury or death may occur. Should Buyer
purchase or use Freescale Semiconductor products for any such unintended or
unauthorized application, Buyer shall indemnify and hold Freescale Semiconductor
and its officers, employees, subsidiaries, affiliates, and distributors harmless against all
claims, costs, damages, and expenses, and reasonable attorney fees arising out of,
directly or indirectly, any claim of personal injury or death associated with such
unintended or unauthorized use, even if such claim alleges that Freescale
Semiconductor was negligent regarding the design or manufacture of the part.
Freescale™ and the Freescale logo are trademarks of Freescale Semiconductor, Inc. The described
product is a PowerPC microprocessor. The PowerPC name is a trademark of IBM Corp. and used
under license. All other product or service names are the property of their respective owners.
A-60PowerPC Instruction Set Legend......................................................................................... A-76
B-132-Bit Instructions Not Implemented by the MPC7450 .........................................................B-1
C-1PowerPC SPR Encodings Ordered by Decimal Value............................................................C-1
C-2PowerPC SPR Encodings Ordered by Register Name............................................................C-5
Page
Number
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductorxlv
Tables
Table
NumberTitle
Page
Number
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
xlviFreescale Semiconductor
About This Book
The primary objective of this reference manual is to describe the functionality of the MPC7450 for
software and hardware developers. The MPC7450 is a PowerPC™ microprocessor. In addition, this
manual supports the MPC7441, MPC7445, MPC7451, MPC7455, MPC7457, MPC7447, MPC7447A,
and MPC7448. This book is written from t he perspective of the MPC7450, and unless otherwise noted, the
information applies also to the MPC7441, MPC7445, MPC7451, MPC7455, MPC7457, MPC7447,
MPC7447A, and MPC7448. The MPC7450 has the same functionality as the MPC7451 and any
differences in data regarding bus timing, signal behavior, and AC, DC, and thermal characteristics are in
the hardware specifications. The differences between the various processors are summarized in
Section 1.5, “Differences Between MPC7441/MPC7451 and MPC7445/MPC7455,”Section 1.6,
“Differences Between MPC7441/MPC7451 and MPC7447/MPC7457,”Section 1.7, “Differences
Between MPC7447 and MPC7447A,” and Section 1.8, “Differences Between MPC7447A and
MPC7448.”
This book is intended as a companion to the Programming Environments Manual for 32-Bit Implementations of the PowerPC Architecture (referred to as the Programming Environments Manual).
NOTE
About the Companion
This manual, which describes MPC7450 features not defined by the
architecture, is to be used with the Programming Environments Manual.
Programming Environments Manual
Because the PowerPC architecture definition is flexible to support a broad
range of processors, the Programming Environments Manual describes
generally those features common to these processors and indicates which
features are optional or may be implemented differently in the design of
each processor.
Note that the Pr ogramming Environments Manual describes only PowerPC
architecture features for 32-bit implementations.
Go to www .freescale.com or contact a local sales representative for a copy
of the Programming Environments Manual.
This manual and the Programming Environments Manual distinguish between the three levels, or
programming environments, of the PowerPC architecture, which are as follows:
•PowerPC user instruction set architecture (UISA)—The UISA defines the architecture level to
which user-level software should conform. The UISA defines the base user-level instruction set,
user-level registers, data types, memory conventions, and the memory and programming models
seen by application programmers.
•PowerPC virtual environment architecture (VEA)—The VEA, which is the smallest component of
the PowerPC architecture, defines additional user-level functionality that falls outside typical
user-level software requirements. The VEA describes the memory model for an environment in
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductorxlvii
About This Book
which multiple processors or other devices can access external memory and defines aspects of the
cache model and cache control instructions from a user-level perspective. VEA resources are
particularly useful for optimizing memory accesses and for managing resources in an environment
in which other processors and other devices can access external memory.
Implementations that conform to the VEA also conform to the UISA but may not necessarily
adhere to the OEA.
•PowerPC operating environment architecture (OEA)—The OEA defines supervisor-level
resources typically required by an operating system. It defines the memory management model,
supervisor-level registers, and the exception model.
Implementations that conform to the OEA also conform to the UISA and VEA.
Note that some resources are defined more generally at one level in the architecture and more specifically
at another. For example, conditions that cause a floating-point exception are defined by the UISA, but the
exception mechanism itself is defined by the OEA.
Because it is important to distinguish between the levels of the architecture to ensure compatibility across
multiple platforms, those distinctions are shown clearly throughout this book.
For ease in reference, topics in this book are presented in the same order as the Programming Envir onments Manual. Topics build on one another, beginning with a description and complete summary of the
MPC7450 programming model (registers and instructions) and progressing to more specific,
architecture-based topics regarding the cache, exception, and memory management models. As such,
chapters may include information from multiple levels of the architecture. For example, the discussion of
the cache model uses information from both the VEA and the OEA.
Additionally, the MPC7450 implements the AltiVec™ technology resources. The following two books
describe the AltiVec technology:
•AltiVec Technology Programming Environments Manual (AltiVec PEM) is a reference guide for
programmers. The AltiVec PEM uses a standardized format instruction to describe each
instruction, showing syntax, instruction format, register translation language (RTL) code that
describes how the instruction works, and a listing of which, if any, registers are affected. At the
bottom of each instruction entry is a figure that shows the operations on elements within source
operands and where the results of those operations are placed in the destination operand.
•AltiVec Technology Programming Interface Manual (AltiVec PIM) describes how programmers
can access AltiVec functionality from programming languages such as C and C++. The AltiVec
PIM describes the high-level language interface and application binary interface for System V and
embedded applications for use with the AltiVec instruction set extension to the PowerPC
architecture.
The PowerPC Ar chitectur e: A Spec ification for a New Family of RISC Pr ocess ors defines the architecture
from the perspective of the three programming environments and remains the defining document for the
PowerPC architecture. For information on ordering Freescale documentation, see “Related
Documentation,” on page l.
Information in this book is subject to change without notice, as described in the disclaimers on the title
page of this book. As with any technical documentation, it is the readers’ responsibility to be sure they are
using the most recent version of the documentation.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
xlviiiFreescale Semiconductor
Audience
To locate any published errata or updates for this document, refer to the world-wide web at
http://www.freescale.com.
A list of the major differences between revisions of this manual is provided in Appendix D, “Revision
History.”
Audience
This manual is intended for system software and hardware developers and applications programmers who
want to develop products for the MPC7441, MPC7445, MPC7450, MPC7451, MPC7455, MPC7457,
MPC7447, MPC7447A, and MPC7448. It is assumed that the reader understands operating systems,
microprocessor system design, basic principles of RISC processing, and details of the PowerPC
architecture.
Organization
The following is a summary and a brief description of the chapters in this manual:
•Chapter 1, “Overview,” is useful for readers who want a general understanding of the features and
functions of the PowerPC architecture and the MPC7450. This chapter describes the flexible nature
of the PowerPC architecture definition and provides an overview of how the PowerPC architecture
defines the register set, operand conventions, addressing modes, instruction set, cache model,
exception model, and memory management model.
•Chapter 2, “Programming Model,” is useful for software engineers who need to understand the
MPC7450-specific registers, operand conventions, and details regarding how PowerPC
instructions are implemented on the MPC7450. Instructions are organized by function.
•Chapter 3, “L1, L2, and L3 Cache Operation,” discusses the cache and memory model as
implemented on the MPC7450.
•Chapter 4, “Exceptions,” describes the exception model defined in the OEA and the specific
exception model implemented on the MPC7450.
•Chapter 5, “Memory Management,” describes the implementation of the memory management
unit on the MPC7450 as specified by the OEA.
•Chapter 6, “Instruction Timing,” provides information about latencies, interlocks, special
situations, and various conditions that help make programming more efficient. This chapter is of
special interest to software engineers and system designers.
•Chapter 7, “AltiVec Technology Implementation,” summarizes the features and functionality
provided by the implementation of the AltiVec technology.
•Chapter 8, “Signal Descriptions,” provides descriptions of individual signals of the MPC7450.
•Chapter 9, “System Interface Operation,” describes signal timings for various operations. It also
provides information for interfacing to the MPC7450.
•Chapter 10, “Power and Thermal Management,” provides information about power saving and
thermal management for the MPC7450.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductorxlix
About This Book
•Chapter 11, “Performance Monitor,” describes the operation of the performance monitor
diagnostic tool incorporated in the MPC7450.
•Appendix A, “MPC7450 Instruction Set Listings,” lists all PowerPC instruct ions while indicating
those instructions that are not implemented by the MPC7450; it also includes the instructions that
are specific to the MPC7450. Instructions are grouped according to mnemonic, opcode, function,
and form. Also included is a quick reference table that contains general information, such as the
architecture level, privilege level, and form, and indicates if the instruction is 64-bit and optional.
•Appendix B, “Instructions Not Implemented,” provides a list of the 32- and 64-bit PowerPC
instructions not implemented in the MPC7450.
•Appendix C, “Special-Purpose Registers,” lists all MPC7450 SPRs.
•Appendix D, “Revision History,” lists the major differences between revisions of the MPC7450 RISC Microprocessor Reference Manual.
•This manual also includes a glossary and an index.
Suggested Reading
This section lists additional reading that provides background for the information in this manual as well as
general information about the PowerPC architecture.
General Information
The following documentation, available through Morgan-Kaufmann Publishers, 340 Pine Street, Sixth
Floor, San Francisco, CA, provides useful information about the PowerPC architecture and computer
architecture in general:
•The PowerPC Archite cture: A Specification for a New Family of RISC Pr ocessors, Second Edition,
by International Business Machines, Inc.
For updates to the specification, see http://www.austin.ibm.com/tech/ppc-chg.html.
•PowerPC Microprocessor Common Hardware Reference Platform: A System Architecture, by
Apple Computer, Inc., International Business Machines, Inc., and Motorola, Inc.
•Computer Architectur e: A Quantitative Appr oach, Third Edition, by John L. Hennessy and David
A. Patterson.
•Computer Organization and Design: The Har dwar e/Softwar e Interface, Second Edition, David A.
Patterson and John L. Hennessy.
Related Documentation
Freescale documentation is available from the sources listed on the back cover of this manual; the
document order numbers are included in parentheses for ease in ordering:
•Programming Environments Manual for 32-Bit Implementations of the PowerPC Architecture
(MPCFPE32B/AD)—Describes resources defined by the PowerPC architecture.
•Reference manuals—These books provide details about individual implementations and are
intended for use with the Programming Environments Manual.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
lFreescale Semiconductor
Conventions
•Addenda/errata to reference manuals—Because some processors have follow-on parts, an
addendum is provided that describes additional features and functi onality changes. These addenda
are intended for use with the corresponding reference manuals.
•Hardware specifications—Hardware specifications provide specific data regarding bus timing,
signal behavior, and AC, DC, and thermal characteristics, as well as other design considerations.
Separate hardware specifications are provided for each part described in this book (MPC7441,
MPC7445, MPC7447, MPC7450, MPC7451, MPC7455, MPC7457, MPC7447A, and MPC7448).
Note that when referring to the hardware specifications throughout this book, make sure to refer to
the appropriate hardware specifications for the part being used.
•Technical summaries—Each device has a technical summary that provides an overview of its
features. This document is roughly the equivalent to the overview (Chapter 1) of an
implementation’s reference manual.
•The Programmer’s Reference Guide for the PowerPC Architecture (MPCPRG)—This concise
reference includes the register summary, memory control model, exception vectors, and the
PowerPC instruction set.
•The Programmer’s Pocket Refer ence Guide for the PowerPC Ar chitectur e (MPCPRGREF)—This
foldout card provides an overview of PowerPC registers, instructions, and exceptions for 32-bit
implementations.
•Application notes—These short documents address specific design issues useful to programmers
and engineers working with Freescale processors.
Additional literature is published as new processors become available. For a current list of documentation,
refer to http://www.freescale.com.
Conventions
This manual uses the following notational conventions:
cleared/setWhen a bit takes the value zero, it is said to be cleared; when it takes a value of
one, it is said to be set.
mnemonicsInstruction mnemonics are shown in lowercase bold
italicsItalics indicate variable command parameters, for example, bcctrx
Book titles in text are set in italics
Internal signals are set in italics, for example, qual BG
0x0Prefix to denote hexadecimal number
0b0Prefix to denote binary number
rA, rBInstruction syntax used to identify a source GPR
rDInstruction syntax used to identify a destination GPR
frA, frB, frCInstruction syntax used to identify a source FPR
frDInstruction syntax used to identify a destination FPR
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductorli
About This Book
REG[FIELD]Abbreviations for registers are shown in uppercase text. Specific bits, fields, or
ranges appear in brackets. For example, MSR[LE] refers to the littl e-endian mode
enable bit in the machine state register.
xIn some contexts, such as signal encodings, an unitalicized x indicates a don’t
care.
xAn italicized x indicates an alphanumeric variable
nAn italicized n indicates an numeric variable
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductorlvii
About This Book
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
lviiiFreescale Semiconductor
Chapter 1
Overview
This chapter provides an overview of the MPC7450 microprocessor features and includes a block diagram
that shows the major functional components. The MPC7450 is a PowerPC™ microprocessor. This chapter
also provides information about how the MPC7450 implementation complies with the PowerPC and
AltiVec™ architecture definitions. In addition, this manual supports the MPC7441, MPC7445, MPC7451,
MPC7455, MPC7457, MPC7447, MPC7447A, and MPC7448. Any differences between the MPC7450
and the other microprocessors, including the MPC7451, are noted in the reference manual.
1.1MPC7450 Microprocessor Overview
This section describes the features and general operation of the MPC7450 and provides a block diagram
showing the major functional units. The MPC7450 implements the PowerPC architecture and is a reduced
instruction set computer (RISC) microprocessor. The MPC7450 consists of a processor core, 32-Kbyte
separate L1 instruction and data caches, a 256-Kbyte L2 cache (512-Kbyte for MPC7457 and 1 Mbyte for
the MPC7448), and an internal L3 controller with tags that support a glueless backside L3 cache through
a dedicated high-bandwidth interface. The MPC7441, MPC7445, MPC7447, MPC7447A, and MPC7448
do not support the L3 cache and the L3 interface. The core is a high-performance superscalar design
supporting multiple execution units, including four independent units that execute AltiVec instructions.
The MPC7450 implements the 32-bit portion of the PowerPC architecture, which provides 32-bit effective
addresses, integer data types of 8, 16, and 32 bits, and floating-point data types of 32 and 64 bits. The
MPC7450 provides virtual memory support for up to 4 Petabytes (252) of virtual memory and real me mory
support for up to 64 Gigabytes (236) of physical memory.
The MPC7450 also implements the AltiVec instruction set architectural extension. The MPC7450 is a
superscalar processor that can dispatch and complete three instructions s imultaneously. It incorporates the
following execution units:
•64-bit floating-point unit (FPU)
•Branch processing unit (BPU)
•Load/store unit (LSU)
•Four integer units (IUs):
— Three shorter latency IUs (IU1a–IU1c)—execute all integer instructions except multiply,
divide, and move to/from special-purpose register (SPR) instructions.
— Longer latency IU (IU2)—executes miscellaneous instructions including condition register
(CR) logical operations, integer multiplication and division instructions, and move to/from
SPR instructions.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-1
Overview
•Four vector units that support AltiVec instructions:
— Vector permute unit (VPU)
— Vector integer unit 1 (VIU1)—performs shorter latency integer calculations
— Vector integer unit 2 (VIU2)—performs longer latency integer calculations
— Vector floating-point unit (VFPU)
The ability to execute several instructions in parallel and the use of simple instructions with rapid
execution times yield high efficiency and throughput for MPC7450-based systems. Most integer
instructions (including VIU1 instructions) have a one-clock cycle execution latency.
Several execution units feature multiple-stage pipelines; that is, the tasks they perform are broken into
subtasks executed in successive stages. Typically, instructions follow one another through the stages, so a
four-stage unit can work on four instructions when its pipeline is full. So, although an instruction m ay have
to pass through several stages, the execution unit can achieve a throughput of one instruction per clock
cycle.
AltiVec computational instructions are exe cuted in four independent, pipelined AltiVec execution units. A
maximum of two AltiVec instructions can be issued in order to any combination of AltiVec execution units
per clock cycle. Moreover, the VIU2, VFPU, and VPU are pipelined, so they can operate on multiple
instructions. The VPU has a two-stage pipeline; the VIU2 and VFPU each have four-stage pipelines. As
many as ten AltiVec instructions can be executing concurrently. In the MPC7448, a maximum of two
AltiVec instructions can be issued out-of-order to any combination of AltiVec execution units per clock
cycle from the bottom two VIQ entries (VIQ1–VIQ0). This means an instruction in VIQ1 destined for
VIU1 does not have to wait for an instruction in VIQ0 that is stalled behind an instruction waiting for
operand availability.
Note that for the MPC7450, double- and single-precision versions of floating-point instructions have the
same latency. For example, a floating-point multiply-add instruction take s 5 cycle s to exe cute, re gardl ess
of whether it is single (fmadds) or double precision (fmadd).
The MPC7450 has independent on-chip, 32-Kbyte, eight-way set-associative, physically addressed L1
(level-one) caches for instructions and data, and independent instruction and data memory management
units (MMUs). Each MMU has a 128-entry, two-way set-associative translation lookaside buffer (DTLB
and ITLB) that saves recently used page address translations. Block address translation is implemented
with the four-entry instruction and data block address translation (IBAT and DBA T) arrays defined by the
PowerPC architecture. During block translation, effective addresses are compared simultaneously with all
BA T entries, as described in Chapter 5, “Memory Management.” For information about the L1 caches, see
Chapter 3, “L1, L2, and L3 Cache Operation.”
The MPC7450 L2 cache is implemented with an on-chip, 256-Kbyte, eight-way set-associative physically
addressed memory available for storing data, instructions, or both. In the MPC7447, MPC7457, and
MPC7447A the L2 cache is 512 Kbytes. In the MPC7448, the L2 cache is 1 Mbyte. The L2 cache supports
parity generation and checking for both tags and data. It responds with a 9-cycle load latency for an L1
miss that hits in L2. In the MPC7448, the L2 load access time is 1 1 cycles with ECC disabled and 12 cycles
with ECC enabled. The L2 cache is fully pipelined for single-cycle throughput in the MPC7450 (2-cycle
throughput in the MPC7448). For information about the L2 cache implementation, see Chapter 3, “L1, L2,
and L3 Cache Operation.”
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-2Freescale Semiconductor
Overview
The L3 cache is implemented with an on-chip, eight-way set-associative tag memory, and with external,
synchronous SRAMs for storing data, instructions, or both. The external SRAMs are accessed through a
dedicated L3 cache port that supports a single bank of 1 or 2 Mbytes of synchronous SRAMs for L3 cache
data. The L3 data bus is 64-bits wide and provides multiple SRAM options as well as quick quad-word
forwarding to reduce latency . Alternately , the L3 interface can be configured to use half or all of the SRAM
area as a direct-mapped, private memory space. For information about the L3 cache implementation, see
Chapter 3, “L1, L2, and L3 Cache Operation.” Note that the MPC7441, MPC7445, MPC7447,
MPC7447A, and MPC7448 do not support the L3 cache or L3 cache interface.
The MPC7450 has three power-saving modes, nap, sleep, and deep sleep, which progressively reduce
power dissipation. When functional units are idle, a dynamic power management mode causes those units
to enter a low-power mode automatically without affecting operational performance, software execution,
or external hardware. Section 1.2.10, “Power and Thermal Management,” describes how the power
management can be used to reduce power consumption when the processor, or portions of it, are idle. It
also describes how the instruction cache throttling mechanism reduces the instruction dispatch rate. The
information in these sections are des cribed more fully in Chapter 10, “Power and Thermal Management.”
The performance monitor facility provides the ability to monitor and count predefined events such as
processor clocks, misses in the instruction cache, data cache, or L2 cache, types of instructions dispatched,
mispredicted branches, and other occurrences. The count of such events (which may be an approximation)
can be used to trigger the performance monitor exception. Section 1.2.11, “Performance Monitor,”
describes the operation of the performance monitor diagnostic tool. This functionality is fully described in
Chapter 11, “Performance Monitor.”
Figure 1-1 shows the parallel organization of the execution units (shaded in the diagram) and the
instruction unit fetches, dispatches, and predicts branch instructions. Note that this is a conceptual model
showing basic features rather than an attempt to show how features are implemented physically. Figure 1-2
shows the organization of the MPC7448 execution units.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
The Castout Queue itself is limited to 9 entries, ensuring 1 entry will be available for a push.
The Castout Queue and Push Queue share resources such for a combined total of 10 entries.
otes:
Figure 1-2. MPC7448 Microprocessor Block Diagram
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-5
Overview
1.1.1MPC7451 Microprocessor Overview
The functionality between the MPC7451 and the MPC7450 is the same. This manual describes the
functionality of the MPC7450, and any differences in data regarding bus timing, signal behavior , and AC,
DC, and thermal characteristics can be found in the hardware specifications.
1.1.2MPC7441 Microprocessor Overview
The MPC7441 is a lower-pin-count device that operates identically to the MPC7451, except that it does
not support the L3 cache and the L3 cache interface. This manual also describes the functionality of the
MPC7441. All information herein applies to the MPC7441, except where otherwise noted (in particular,
the L3 cache information does not apply to the MPC7441).
1.1.3MPC7455 Microprocessor Overview
The MPC7455 operates similarly to the MPC7451. However, the following changes are visible to the
programmer or system designer. These changes include:
•Four additional IBAT and four additional DBAT registers
•Additional HID0 bits (HID0[HIGH_BAT_EN] and HID0[XBSEN]
•Four additional SPRG registers
The additional IBAT s and DBATs provide mapping for more regions of memory. For more information on
new features, see Section 5.3, “Block Address Translation.”
The SPRGs provide additional registers to be used by system software for table software searching. If the
SPRGs are not used for software table searches, they can be used by other supervisor programs.
1.1.4MPC7445 Microprocessor Overview
The MPC7445 is a lower-pin-count device that operates identically to the MPC7455, except that it does
not support the L3 cache and the L3 cache interface. This manual also describes the functionality of the
MPC7445. All information herein applies to the MPC7445, except where otherwise noted (in particular,
the L3 cache information does not apply to the MPC7445).
1.1.5MPC7457 Microprocessor Overview
The MPC7457 operates similarly to the MPC7455. However, the following changes are visible to the
programmer or system designer. These changes include:
•Larger L2 cache (512 Kbytes)
•Additional support for L3 private memory size (4 Mbytes)
•An additional L3_ADDR signal (L3_ADDR[18])
•Modifications to bits in the L3 control register (L3CR)
All information that applies to the MPC7455 also complies to the MPC7457, except where otherwise noted
(in particular, the increased L2 cache and the additional L3 cache support is new for the MPC7457).
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-6Freescale Semiconductor
Overview
1.1.6MPC7447 Microprocessor Overview
The MPC7447 is a lower-pin-count device that operates identically to the MPC7457, except that it does
not support the L3 cache and the L3 cache interface. This manual also describes the functionality of the
MPC7447. All information herein applies to the MPC7447, except where otherwise noted (in particular,
the L3 cache information does not apply to the MPC7447).
1.1.7MPC7447A Microprocessor Overview
There are no micro-architectural differences between the MPC7447A and the MPC7447. The MPC7447A
provides new functionality to reduce the power consumption on the microprocessor. The following
features were also added to the MPC7447A:
•Additional bits to the HID1 register for dynamic frequency switching (DFS)
•Temperature diode
Other than the new features, the MPC7447A supports the same functionality as the MPC7447.
1.1.8MPC7448 Microprocessor Overview
The MPC7448 operates similarly to the MPC7447A. However, the MPC7448 has a number of changes
over the core in the MPC7447A. Some of these changes are feature improvements and some are
performance changes: improvements or changes necessary for feature improvements. The following
changes were added to the MPC7448:
•Larger L2 cache (1 Mbyte)
•L2 data error correction code (ECC)
•Extended L2 pipeline
•Expanded DFS capability (DFS2 and DFS4 mode)
•Out-of-order issue of AltiVec instructions
•Second cacheable store miss
•Additional bits to the HID1 register for dynamic frequency switching (DFS) and PLL
configuration
•Signals with new functionality: DFS2, DFS4, PLL_CFG[5], BVSEL[1], and LVRAM
This manual also describes the functionality of the MPC7448. All information herein applies to the
MPC7448, except where otherwise noted (in particular, the L3 cache information does not apply to the
MPC7448, which does not support the L3 cache or the L3 cache interface).
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-7
Overview
1.2MPC7450 Microprocessor Features
This section describes the features of the MPC7450. The interrelationships of these features are shown in
Figure 1-1.
1.2.1Overview of the MPC7450 Microprocessor Features
Major features of the MPC7450 are as follows:
•High-performance, superscalar microprocessor
— As many as 4 instructions can be fetched from the instruction cache at a time
— As many as 3 instructions can be dispatched to the issue queues at a time
— As many as 12 instructions can be in the instruction queue (IQ)
— As many as 16 instructions can be at some stage of execution simultaneously
— Single-cycle execution for most instructions
— One-instruction throughput per clock cycle for most instructions
— Seven-stage pipeline control
•Eleven independent execution units and three register files
— Branch processing unit (BPU) features static and dynamic branch prediction
of branch instructions that have been encountered in branch/loop code sequences. If a target
instruction is in the BTIC, it is fetched into the instruction queue a cycle sooner than it can
be made available from the instruction cache. Typically, a fetch that hits the BTIC provides
the first 4 instructions in the target stream.
– 2048-entry branch history table (BHT) with 2 bits per entry for four levels of
prediction—not-taken, strongly not-taken, taken, strongly taken
– Up to three outstanding speculative branches
– Branch instructions that do not update the count register (CTR) or link register (LR) are
often removed from the instruction stream.
– Eight-entry link register stack to predict the target address of Branch Conditional to Link
Register (bclr) instructions
— Four integer units (IUs) that share 32 GPRs for integer operands
– Three identical IUs (IU1a, IU1b, and IU1) can execute all integer instructions except
multiply, divide, and move to/from special-purpose register instructions.
– IU2 executes miscellaneous instructions including the CR logical operations, integer
multiplication and division instructions, and move to/from special-purpose register
instructions.
— 64-bit floating-point unit (FPU)
– Five-stage FPU
– Fully IEEE 754-1985 compliant FPU for both single- and double-precision operations
– Supports non-IEEE mode for time-critical operations
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-8Freescale Semiconductor
– Hardware support for denormalized numbers
– Thirty-two 64-bit FPRs for single- or double-precision operands
— Four vector units and 32-entry vector register file (VRs)
– Vector permute unit (VPU)
– Vector integer unit 1 (VIU1) handles short-latency AltiVec integer instructions, such as
vector add instructions (for example, vaddsbs, vaddshs, and vaddsws)
– Vector integer unit 2 (VIU2) handles longer-latency AltiVec integer instructions, such as
vector multiply add instructions (for example, vmhaddshs, vmhraddshs, and
vmladduhm).
– Vector floating-point unit (VFPU)
— Three-stage load/store unit (LSU)
– Supports integer, floating-point and vector instruction load/store traffic
– Four-entry vector touch queue (VTQ) supports all four architected AltiVec data stream
operations
– Three-cycle GPR and AltiVec load latency (byte, half word, word, vector) with single-cycle
– No additional delay for misaligned access within double-word boundary
– Dedicated adder calculates effective addresses (EAs)
– Supports store gathering
– Performs alignment, normalization, and precision conversion for floating-point data
– Executes cache control and TLB instructions
– Performs alignment, zero padding, and sign extension for integer data
– Supports hits under misses (multiple outstanding misses)
– Supports both big- and little-endian modes, including misaligned little-endian accesses
•Three issue queues, FIQ (floating-point issue queue), VIQ (vector issue queue), and GIQ (general
purpose issue queue), can accept as many as one, two, and three instructions, respectively, in a
cycle. Instruction dispatch requires the following:
— Instructions can be dispatched only from the three lowest IQ entries—IQ0, IQ1, and IQ2.
— A maximum of three instructions can be dispatched to the issue queues per clock cycle.
— Space must be available in the completion queue (CQ) for an instruction to dispatch (this
includes instructions that are assigned a space in the CQ but not in an issue queue).
•Dispatch unit—The decode/dispatch stage fully decodes each instruction.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-9
Overview
•Completion unit
— The completion unit retires a n instruction from the 16-entry CQ when a ll instructions ahe ad of
it have been completed, the instruction has finished execution, and no exceptions are pending.
— Guarantees sequential programming model (precise exception model)
— Monitors all dispatched instructions and retires them in order
— Tracks unresolved branches and flushes instructions after a mispredicted branch
— Retires as many as three instructions per clock cycle
•L1 cache has the following characteristics:
— Two separate 32-Kbyte instruction and data caches (Harvard architecture)
— Instruction and data caches are eight-way set-associative
— Instruction and data caches have 32-byte cache blocks. A cache block is the block of memory
that a coherency state describes—it corresponds to a cache line for the L1 data cache.
— Cache directories are physically addressed. The physical (real) address tag is stored in the
cache directory.
— The caches implement a pseudo least-recently-used (PLRU) replacement algorithm within
each way.
— Cache write-back or write-through operation is programmable on a per-page or per-block basis.
— Instruction cache can provide four instructions per clock cycle; data cache can provide four
words per clock cycle
– Two-cycle latency and single-cycle throughput for instruction or data cache accesses
— Caches can be disabled in software
— Caches can be locked in software
— Supports a four-state modified/exclusive/shared/invalid (MESI) coherency protocol
– A single coherency status bit for each instruction cache block allows encoding for the
following two possible states:
Invalid (INV)
Valid (VAL)
– Two status bits (MESI[0–1]) for each data cache block allow encoding for coherency, as
11 = modified (M)
— Separate copy of data cache tags for efficient snooping
— Both L1 caches support parity generation and checking (enabled through bits in the ICTRL
register) as follows:
– Instruction cache—one parity bit per instruction
– Data cache—one parity bit per byte of data
— No snooping of instruction cache except for icbi instruction
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-10Freescale Semiconductor
— Caches implement a pseudo least-recently-used (PLRU) replacement algorithm within each
way
— Data cache supports AltiVec LRU and transient instructions, as described in Section 1.3.2.2,
“AltiVec Instruction Set”
— Critical double- and/or quad-word forwarding is performed as needed. Critical quad-word
forwarding is used for AltiVec loads and instruction fetches. Other accesses use critical
double-word forwarding.
•On-chip level 2 (L2) cache has the following features:
— Integrated 256-Kbyte, eight-way set-associative unified instruction and data cache (512-Kbyte
for the MPC7457, MPC7447, and MPC7447A, 1-Mbyte for the MPC7448).
— Fully pipelined to provide 32 bytes per clock cycle to the L1 caches.
— T otal latency of 9 processor cycles for L1 data cache miss that hits in the L2. In the MPC7448,
total latency of 11 processor cycles for L1 data cache miss that hits in the L2 with ECC
disabled, 12 cycles when ECC is enabled
— Uses one of two random replacement algorithms (selectable through L2CR)
— Cache write-back or write-through operation programmable on a per-page or per-block basis
— Organized as 32 bytes/block and 2 bl ocks (sec tors)/line (a cache bl ock is the block of memory
that a coherency state describes).
Overview
— In the MPC7448, supports error correction and detection using a SECDED (single-error
correction, double-error detection) protocol. Every 64 bits of data comes with 8 bits of error
detection/correction, which can be programmed as ECC across the 64 bits of data, byte parity,
or no error detection/correction.
— Supports parity generation and checking for both tags and data (enabled through L2CR). In the
MPC7448, tag parity is enabled separately in the L2ERRDIS register, and data parity can be
enabled through L2CR only when ECC is disabled.
— In the MPC7448, error injection modes provided for testing
•Level 3 (L3) cache interface (not supported on the MPC7441, MPC7445, MPC7447, MPC7447A,
and MPC7448)
— Provides critical double-word forwarding to the requesting unit
— On-chip tags support 1 or 2 Mbytes of external SRAM that is eight-way set-associative
— Maintains instructions, data, or both instructions and data (selectable through L3CR)
— Cache write-back or write-through operation programmable on a per-page or per-block basis
— Organized as 64 bytes/line configured as 2 blocks (sectors) with separate status bits per line for
1-Mbyte configuration.
— Organized as 128 bytes/line configured as 4 blocks (sectors) with separate status bits per line
for 2-Mbyte configuration.
— 1, 2, or 4 Mbytes (4 Mbytes is only for the MPC7457) of the L3 SRAM can be designated as
private memory.
— Supports same four-state (MESI) coherency protocol as L1 and L2 caches
— Supports parity generation and checking for both tags and data (enabled through L3CR)
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-11
Overview
— Same choice of two random replacement algorithms used by L2 cache (selectable through
L3CR)
— Configurable core-to-L3 frequency divisors
— 64-bit external L3 data bus sustains 64 bits per L3 clock cycle
— Supports MSUG2 dual data rate (DDR) synchronous burst SRAMs, PB2 pipelined
synchronous burst SRAMs, and pipelined (register-register) late-write synchronous burst
SRAMs
•Separate memory management units (MMUs) for instructions and data
— 52-bit virtual address; 32- or 36-bit physical address
— Address translation for 4-Kbyte pages, variable-sized blocks, and 256-Mbyte segments
— Memory programmable as write-back/write-through, caching-inhibited/caching-allowed, and
memory coherency enforced/memory coherency not enforced on a page or block basis
— Separate IBATs and DBATs (four each) also defined as SPRs. Eight IBATs and eight DBATS
in the MPC7455, MPC7445, MPC7457, MPC7447, MPC7447A, and MPC7448.
— Separate instruction and data translation lookaside buffers (TLBs)
– Both TLBs are 128-entry, two-way set-associative, and use LRU replacement algorithm
– TLBs are hardware or software reloadable (that is, on a TLB miss a page table search is
performed in hardware or by system software)
•Efficient data flow
— Although the VR/LSU interface is 128 bits, the L1/L2/L3 bus interface allows up to 256 bits.
— The L1 data cache is fully pipelined to provide 128 bits/cycle to or from the VRs.
— L2 cache is fully pipelined to provide 32 bytes per processor clock cycle to the L1 cache. In the
MPC7448, the L2 cache is pipelined to provide 32 bytes every other clock cycle to the L1
cache.
— As many as eight outstanding, out-of-order cache misses are allowed between the L1 data
cache and L2/L3 bus.
— As many as 16 out-of-order transactions can be present on the MPX bus.
— Store merging for multiple store misses to the same line. Only coherency action taken
(address-only) for store misses merged to all 32 bytes of a cache block (no data tenure needed)
— Support for a second cacheable store miss
— Three-entry finished store queue and five-entry completed store queue between the LSU and
the L1 data cache
— Separate additional queues for efficient buffering of outbound data (such as castouts and
write-through stores) from the L1 data cache and L2 cache
•Multiprocessing support features include the following:
— Hardware-enforced, MESI cache coherency protocols for data cache
— Load/store with reservation instruction pair for atomic memory references, semaphores, and
other multiprocessor operations
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-12Freescale Semiconductor
Overview
•Power and thermal management
— The following three power-saving modes are available to the system:
– Nap—Instruction fetching is halted. Only those clocks for the time base, decrementer, and
JTAG logic remain running. The part goes into the doze state to snoop memory operations
on the bus and then back to nap using a QREQ
/QACK processor-system handshake
protocol.
– Sleep—Power consumption is further reduced by disabling bus snooping, leaving only the
PLL in a locked and running state. All internal functional units are disabled.
– Deep sleep—When the part is in the sleep state, the system can disable the PLL. The system
can then disable the SYSCLK source for greater system power savings. Power-on reset
procedures for restarting and relocking the PLL must be followed upon exiting the deep
sleep state.
— In the MPC7447A and MPC7448, DFS (dynamic frequency switching) conserves power by
lowering processor operating frequency. The MPC7447A has the ability to divide the
processor-to-system bus ratio by two during normal functional operation. The MPC7448 has
the additional ability to divide by four.
— Instruction cache throttling provides control of instruction fetching to limit device temp erature.
•Performance monitor can be used to help debug system designs and improve software efficiency
•In-system testability and debugging features through JTAG boundary-scan capability
•Reliability and serviceability
— Parity checking on system bus and L3 cache bus
— Parity checking on L1, L2, and L3 cache arrays
1.2.2Instruction Flow
As shown in Figure 1-1, the MPC7450 instruction unit provides centralized control of instruction flow to
the execution units. The instruction unit contains a sequential fetcher, 12-entry instruction queue (IQ),
dispatch unit, and branch processing unit (BPU). It determines the address of the next instruction to be
fetched based on information from the sequential fetcher and from the BPU.
See Chapter 6, “Instruction Timing,” for a detailed discussion of instruction timing.
The sequential fetcher loads instructions from the instruction cache into the instruction queue. The BPU
extracts branch instructions from the sequential fetcher. Branch instructions that cannot be resolved
immediately are predicted using either the MPC7450-specific dynamic branch prediction or the
architecture-defined static branch prediction.
Branch instructions that do not affect the LR or CTR are often removed from the instruction stream.
Section 6.4.1.1, “Branch Folding and Removal of Fall-Through Branch Instructions,” describes when a
branch can be removed from the instruction stream.
Instructions dispatched beyond a predicted branch do not complete execution until the branch is resolved,
preserving the programming model of sequential execution. If branch prediction is incorrect, the
instruction unit flushes all predicted path instructions, and instructions are fetched from the correct path.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-13
Overview
1.2.2.1Instruction Queue and Dispatch Unit
The instruction queue (IQ), shown in Figure 1-1, holds as many as 12 instructions and loads as many as 4
instructions from the instruction cache during a single processor clock cycle.
The fetcher attempts to initiate a new fetch every cycle. The two fetch stages are pipelined, so as many as
four instructions can arrive to the IQ every cycle. All instructions except branch (bx), Return from
Exception (rfi), System Call (sc), Instruction Synchronize (isync), and no-op instructions are dispatched
to their respective issue queues from the bottom three positions in the instruction queue (IQ0–IQ2) at a
maximum rate of three instructions per clock cycle. Reservation stations are provided for the three IU1s,
IU2, FPU, LSU, VPU, VIU2, VIU1, and VFPU. The dispatch unit checks for source and destination
register dependencies, determines whether a position is available in the CQ, and inhibits subsequent
instruction dispatching as required.
Branch instruction can be detected, decoded, and predicted from entries IQ0–IQ7. See Section 6.3.3,
“Dispatch, Issue, and Completion Considerations.”
1.2.2.2Branch Processing Unit (BPU)
The BPU receives branch instructions from the IQ and executes them early in the pipeline, achieving the
effect of a zero-cycle branch in some cases.
Branches with no outstanding dependencies (CR, LR, or CTR unresolved) can be processed and resolved
immediately . For branches in which only the direction is unresolved due to a CR or CTR dependency , the
branch path is predicted using either architecture-defined static branch prediction or MPC7450-specific
dynamic branch prediction. Dynamic branch prediction is enabled if HID0[BHT] is set. For bclr branches
where the target address is unresolved due to a LR dependency, the branch target can be predicted using
the hardware link stack. Link stack prediction is enabled if HID0[LRSTK] is set.
When a prediction is made, instruction fetching, dispatching, and execution continue from the predicted
path, but instructions cannot complete and write back results to architected registers until the prediction is
determined to be correct (resolved). When a prediction is incorrect, the instructions from the incorrect path
are flushed from the processor and processing begins from the correct path.
Dynamic prediction is implemented using a 2048-entry branch history table (BHT), a cache that provides
two bits per entry that together indicate four levels of prediction for a branch instruction—not-taken,
strongly not-taken, taken, strongly taken. When dynamic branch prediction is disabled, the BPU uses a bit
in the instruction encoding to predict the direction of the conditional branch. Therefore, when an
unresolved conditional branch instruction is encountered, the MPC7450 executes instructions from the
predicted target stream although the results are not committed to architected registers until the conditional
branch is resolved. Unresolved branches are held in a three-entry branch queue. When the branch queue
is full, no further conditional branches can be processed until one of the conditions in the branch queue is
resolved.
When a branch is taken or predicted as taken, instructions from the untaken path must be flushed and the
target instruction stream must be fetched into the IQ. The BTIC is a 128-entry, four-way set associative
cache that contains the most recently used branch target instructions (up to four instructions per entry) for
b and bc branches. When a taken branch instruction of this type hits in the BTIC, th e instruction s arri ve in
the instruction queue 2 clock cycles later , a clock cycle sooner than they would arrive from the instruction
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-14Freescale Semiconductor
Overview
cache. Additional instructions arrive from the instruction cache in the next clock cycle. The BTIC reduces
the number of missed opportunities to dispatch instructions and gives the processor a 1-cycle head start on
processing the target stream.
The BPU contains an adder to compute branch target addresses and three user-accessible registers—the
link register (LR), the count register (CTR), and the condition register (CR). The BPU calculates the return
pointer for subroutine calls and saves it in the LR for certain types of branch instructions. The LR also
contains the branch target address for Branch Conditional to Link Register (bclrx) instructions. The CTR
contains the branch target address for Branch Conditional to Count Register (bcctrx) instructions. Because
the LR and CTR are SPRs, their contents can be copied to or from any GP R. Also, because the BPU uses
dedicated registers rather than GPRs or FPRs, execution of branch instructions is largely independent from
execution of integer and floating-point instructions.
1.2.2.3Completion Unit
The completion unit operates closely with the instruction unit. Instructions are fetched and dispatched in
program order. At the point of dispatch, the program order is maintained by assigning each dispatched
instruction a successive entry in the 16-entry CQ. The completion unit tracks instructions from dispatch
through execution and retires them in program order from the three bottom CQ entries (CQ0–CQ2).
Instructions cannot be dispatched to an execution unit unless there is a CQ vacancy.
Branch instructions that do not update the CTR or LR are often removed from the instruction stream.
Those that are removed do not take a CQ entry. Branches that are not removed from the instruction stream
follow the same dispatch and completion procedures as non-branch instructions but are not dispatched to
an issue queue.
Completing an instruction commits executi on results to archi tected regist ers (GPRs, FPRs, VRs, LR, and
CTR). In-order completion ensures the correct architectural state when the MPC7450 must recover from
a mispredicted branch or any exception. An instruction is retired as it is removed from the CQ.
For a more detailed discussion of instruction completion, see Section 6.3.3, “Dispatch, Issue, and
Completion Considerations.”
1.2.2.4Independent Execution Units
In addition to the BPU, the MPC7450 provides the ten execution units described in the following sections.
1.2.2.4.1AltiVec Vector Permute Unit (VPU)
The VPU executes permutation instructions such as pack, unpack, merge, splat, and permute on vector
operands.
1.2.2.4.2AltiVec Vector Integer Unit 1 (VIU1)
The VIU1 executes simple vector integer computational instructions, such as addition, subtraction,
maximum and minimum comparisons, averaging, rotation, shifting, comparisons, and boolean operations.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-15
Overview
1.2.2.4.3AltiVec Vector Integer Unit 2 (VIU2)
The VIU2 executes longer-latency vector integer instructions, such as multiplication,
multiplication/addition, and sum-across with saturation.
1.2.2.4.4AltiVec Vector Floating-Point Unit (VFPU)
The VFPU executes all vector floating-point instructions.
A maximum of two AltiVec instructions can be issued in order to any combination of AltiVec execution
units per clock cycle. In the MPC7448, a maximum of two AltiVec instructions can be issued out of order
to any combination of AltiVec execution units per clock cycle from the bottom two VIQ entries
(VIQ1–VIQ0). An instruction in VIQ1 destined for VIU1 does not have to wait for an instruction in VIQ0
that is stalled behind an instruction waiting for operand availability . Moreover , the VIU2, VFPU, and VPU
are pipelined, so they can operate on multiple instructions.
1.2.2.4.5Integer Units (IUs)
The integer units (three IU1s and IU2) are shown in Figure 1-1. The IU1s execute shorter latency integer
instructions, that is, all integer instructions except multiply, divide, and move to/from special-purpose
register instructions. IU2 executes integer instructions with latencies of 3 cycles or more.
IU2 has a 32-bit integer multiplier/divider and a unit for executing CR logical operations and move to/from
SPR instructions. The multiplier supports early exit for operations that do not require full 32
* 32-bit
multiplication.
1.2.2.4.6Floating-Point Unit (FPU)
The FPU, shown in Figure 1-1, is designed such that double-precision operations require only a single
pass, with a latency of 5 cycles. As instructions are dispatched to the FPUs reservation station, source
operand data can be accessed from the FPRs or from the FPR rename buffers. Results in turn are written
to the rename buffers and are made available to subsequent instructions. Instructions start execution from
the bottom reservation station only and execute in program order.
The FPU contains a single-precision multiply-add array and the floating-point status and control register
(FPSCR). The multiply-add array allows the MPC7450 to efficiently implement multiply and
multiply-add operations. The FPU is pipelined so that one single- or double-precision instruction can be
issued per clock cycle.
Note that an execution bubble occurs after four consecutive, independent floating-point arithmetic
instructions execute to allow for a normalizat ion special case. Thirty-two 64-bit floating-point registers are
provided to support floating-point operations. Stalls due to contention for FPRs are minimized by
automatic allocation of the 16 floating-point rename registers. The MPC7450 writes the contents of the
rename registers to the appropriate FPR when floating-point instructions are retired by the completion unit.
The MPC7450 supports all IEEE 754 floating-point data types (normalized, denormalized, NaN, zero, and
infinity) in hardware, eliminating the latency incurred by software exception routines.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-16Freescale Semiconductor
Overview
1.2.2.4.7Load/Store Unit (LSU)
The LSU executes all load and store instructions as well as AltiVec LRU and transient instructions and
provides the data transfer interface between the GPRs , FPRs, VRs, and the cache/memory subsystem. The
LSU also calculates effective addresses and aligns data.
Load and store instructions are issued and translated in program order; however, some memory accesses
can occur out-of-order. Synchronizing instructions can be used to enforce strict ordering. When there are
no data dependencies and the guarded bit for the page or block is cleared, a maximum of one out-of-order
cacheable load operation can execute per clock cycle from the perspective of the LSU. Loads to FPRs
require a 4-cycle total latency. Data returned from the cache is held in a rename register until the
completion logic commits the value to a GPR, FPR, or VR. Stores cannot be executed out -of-order and are
held in the store queue until the completion logic signals that the store operation is to be completed to
memory. The MPC7450 executes store instructions with a maximum throughput of one per clock cycle
and a 3-cycle total latency to the data cache. The time required to perform the load or store operation
depends on the processor:bus clock ratio and whether the operation involves the on-chip caches, the L3
cache, system memory, or an I/O device.
1.2.3Memory Management Units (MMUs)
The MPC7450’s MMUs support up to 4 Petabytes (252) of virtual memory and 64 Gigabytes (236) of
physical memory for instructions and data. The MMUs control access privileges for these spaces on block
and page granularities. Referenced and changed status is maintained by the processor for each page to
support demand-paged virtual memory systems. The memory management units are contained within the
load/store unit.
The LSU calculates effective addresses for data loads and stores; the instruction unit calculates effective
addresses for instruction fetching. The MMU translates the effective address to determine the correct
physical address for the memory access.
The MPC7450 supports the following types of memory translation:
•Real addressing mode—In this mode, translation is disabled by clearing bits in the machine state
register (MSR): MSR[IR] for instruction fetching or MSR[DR] for data accesses. When address
translation is disabled, the physical address is identical to the effective address. When extended
addressing is disabled (HID0[XAEN] = 0) a 32-bit physical address is used, PA[4–35]. For more
details, see Section 5.1.3, “Address Translation Mechanisms.”
•Page address translation—translates the page frame address for a 4-Kbyte page size
•Block address translation—translates the base address for blocks: 128 Kbytes to 256 Mbytes
(MPC7441, MPC7450, MPC7451) or 4 GBytes (MPC7445, MPC7455, MPC7457, MPC7447,
MPC7447A, MPC7448).
If translation is enabled, the appropriate MMU translates the higher-order bits of the effective address into
physical address bits. Lower-order address bits are untranslated and so are the same for both logical and
physical addresses. These bits are directed to the on-chip caches where they form the index into the
eight-way set-associative tag array. After translating the address, the MMU passes the higher-order
physical address bits to the cache and the cache lookup completes. For caching-inhibited accesses or
accesses that miss in the cache, the untranslated lower-order address bits are concatenated with the
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-17
Overview
translated higher-order address bits; the resulting 32- or 36-bit physical address is used by the memory
subsystem and the bus interface unit to access external memory.
The TLBs store page address translations for recent memory accesses. For each access, an effective
address is presented for page and block translation simultaneously. If a translation is found in bot h the TLB
and the BAT array, the block address translation in the BAT array is used. Usually the translation is in a
TLB and the physical address is readily available to the on-chip cache. When a page address translation is
not in a TLB, hardware or system software searches for one in the page table following the model defined
by the PowerPC architecture.
Instruction and data TLBs provide address translation in parallel with the on-chip cache access, incurring
no additional time penalty in the event of a TLB hit. The MPC7450 instruction and data TLBs are
128-entry, two-way set-associative caches that contain address translations. The MPC7450 can initiate a
hardware or system software search of the page tables in memory on a TLB miss.
1.2.4On-Chip L1 Instruction and Data Caches
The MPC7450 implements separate L1 instruction and data caches. Each cache is 32-Kbyte eight-way
set-associative. As defined by the PowerPC architecture, they are physically indexed. Each cache block
contains eight contiguous words from memory that are loaded from an eight-word boundary (that is, bits
EA[27–31] are zeros); thus, a cache block never crosses a page boundary. An entire cache block can be
updated by a four-beat burst load across a 64-bit system bus. Misaligned accesses across a page boundary
can incur a performance penalty. The data cache is a nonblocking, write-back cache with hardware support
for reloading on cache misses. The critical double word is transferred on the first beat and is forwarded to
the requesting unit, minim izing stalls due to load delays. For vector loads, the critical quad word is handled
similarly but is transferred on the second beat. The cache being loaded is not blocked to internal accesses
while the load completes.
The MPC7450 L1 cache organization is shown in Figure 1-3.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-18Freescale Semiconductor
128 Sets
Overview
Block 0
Block 1
Block 2
Block 3
Block 4
Block 5
Block 6
Block 7
Address Tag 0
Address Tag 1
Address Tag 2
Address Tag 3
Address Tag 4
Address Tag 5
Address Tag 6
Address Tag 7
Status
Status
Status
Status
Status
Status
Status
Status
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
8 Words/Block
Figure 1-3. L1 Cache Organization
The instruction cache provides up to four instructions per clock cycle to the instruction queue. The
instruction cache can be invalidated entirely or on a cache-block basis. It is invalidated and disabled by
setting HID0[ICFI] and then clearing HID0[ICE]. The instruction cache can be locked by setting
HID0[ILOCK]. The instruction cache supports only the valid/invalid states.
The data cache provides four words per clock cycle to the LSU. Like the instruction cache, the data cache
can be invalidated all at once or on a per-cache-block basis. The data cache can be invalidated and disabled
by setting HID0[DCFI] and then clearing HID0[DCE]. The data cache can be locked by setting
HID0[DLOCK]. The data cache tags are dual-ported, so a load or store can occur simultaneously with a
snoop.
The MPC7450 also implements a 128-entry (32-set, four-way set-associative) branch target instruction
cache (BTIC). The BTIC is a cache of branch instructions that have been encountered in branch/loop code
sequences. If the target instruction is in the BTIC, it is fetched into the instruction queue a cycle sooner
than it can be made available from the instruction cache. Typically, the BTIC contains the first four
instructions in the target stream.
The BTIC can be disabled and invalidated through software. As with other aspects of MPC7450
instruction timing, BTIC operation is optimized for cache-line alignment. If the first target instruction is
one of the first five instructions in the cache block, the BTIC entry holds four instructions. If the first target
instruction is the last instruction before the cache block boundary, it is the only instruction in the
corresponding BTIC entry . If the next-to-last instruction in a cache block is the target, the BTIC entry holds
two valid target instructions, as shown in Figure 1-4.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-19
Overview
Branch Target
Instruction Cache Block
BTIC Entry
Instruction Cache Block
BTIC Entry
Figure 1-4. Alignment of Target Instructions in the BTIC
T0T2T4T5T6T7T1T3
T2T4T5T3
Branch Target
T0T2T4T5T6T7T1T3
T6——T7
BTIC ways are updated using a FIFO algorithm.
For more information and timi ng examples showing cache hit and cache m iss latencies, se e Section 6.3.2,
“Instruction Fetch Timing.”
1.2.5L2 Cache Implementation
The L2 cache is a unified cache that receives memory requests from both the L1 instruction and data
caches independently. The integrated L2 cache on the MPC7450 is a unified (containing both instructions
and data) 256-Kbyte on-chip cache. In the MPC7447, MPC7457, and MPC7447A, the L2 cache has been
increased to a 512-Kbyte on-chip cache. In the MPC7448, the L2 cache is 1 Mbyte. It is eight-way
set-associative and organized with 32-byte blocks and two blocks/line.
Each line consists of 64 bytes of data organized as two blocks (also called sectors). Although all 16 words
in a cache line share the same address tag, each block maintains the three separate status bits for the
8 words of the cache block, the unit of memory at which coherency is maintained. Thus, each cache line
can contain 16 contiguous words from memory that are read or written as 8-word operations.
The MPC7450 integrated L2 cache organization is shown in Figure 1-5.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-20Freescale Semiconductor
512 Sets
Overview
Line 0
Line 1
Line 2
Line 3
Line 4
Line 5
Line 6
Line 7
Address Tag 0
Address Tag 1
Address Tag 2
Address Tag 3
Address Tag 4
Address Tag 5
Address Tag 6
Address Tag 7
Status
Status
Status
Status
Status
Status
Status
Status
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Block 0
Status
Status
Status
Status
Status
Status
Status
Status
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Block 1
Figure 1-5. L2 Cache Organization for MPC7450
The integrated L2 cache organization of the MPC7457, MPC7447, MPC7447A, and MPC7448 is shown
in Figure 1-6.
1024 Sets
Line 0
Line 1
Line 2
Line 3
Line 4
Line 5
Line 6
Line 7
Address Tag 0
Address Tag 1
Address Tag 2
Address Tag 3
Address Tag 4
Address Tag 5
Address Tag 6
Address Tag 7
Status
Status
Status
Status
Status
Status
Status
Status
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Block 0
Status
Status
Status
Status
Status
Status
Status
Status
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Block 1
Figure 1-6. L2 Cache Organization for the MPC7457, MPC7447, and MPC7447A
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-21
Overview
The MPC7448 integrated L2 cache organization is shown in Figure 1-7.
2048 Sets
Line 0
Line 1
Line 2
Line 3
Line 4
Line 5
Line 6
Line 7
Address Tag 0
Address Tag 1
Address Tag 2
Address Tag 3
Address Tag 4
Address Tag 5
Address Tag 6
Address Tag 7
Status
Status
Status
Status
Status
Status
Status
Status
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Words [0–7]
Block 0
Status
Status
Status
Status
Status
Status
Status
Status
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Words [8–15]
Block 1
Figure 1-7. L2 Cache Organization for the MPC7448
The L2 cache controller contains the L2 cache control register (L2CR), which:
•Includes bits for enabling parity checking on the L2
•Provides for instruction-only and data-only modes
•Provides hardware flushing for the L2
•Selects between two available replacement algorithms for the L2 cache
The L2 implements the MESI cache coherency protocol using three status bits per sector.
Requests from the L1 cache generally result from instruction misses, data load or store misses,
write-through operations, or cache management instructions. Requests from the L1 cache are compared
against the L2 tags and serviced by the L2 cache if they hit; i f they miss in the L2 cache, t hey are forwarded
to the L3 cache.
The L2 cache tags are fully pipelined and non-blocking for efficient operation. Thus the L2 cache can be
accessed internally while a load for a miss is pending (allowing hits under misses). A reload for a cache
miss is treated as a normal access and blocks other accesses for only 1 cycle.
For more information, see Chapter 3, “L1, L2, and L3 Cache Operation.”
1.2.6L3 Cache Implementation
The unified L3 cache receives memory requests from L1 and L2 instruction and data caches independently .
The L3 cache interface is implemented with an on-chip, two-way set associative tag memory with 2,048
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-22Freescale Semiconductor
Overview
(2K) tags per way and a dedicated interface with support for up to 2 Mbytes of external synchronous
SRAMs. Note that the L3 cache is not supported on the MPC7441, MPC7445, MPC7447, MPC7447A,
and the MPC7448
T ags are sectored to support either two or four cache blocks per tag entry, depending on the L2 cache size.
Each sector (32-byte cache block) in the L3 cache has three status bits that are used to implement the MESI
cache coherency protocol. Accesses to the L3 cache can be designated as write-back or write-through, and
the L3 maintains cache coherency through snooping.
The L3 interface can be configured to use 1 or 2 Mbytes of the SRAM area as a private memory space.
The MPC7457 in particular can support 1,2, or 4 Mbytes of private memory. Accesses to private memory
do not propagate to the system bus. The MPC7450 can also be configured to use 1 Mbyte of SRAM as L3
cache and a second Mbyte as private memory. Also, in this case, private memory accesses do not propagate
to the L3 cache or the external system bus.
The private memory space provides a low-latency, high-bandwidth area for critical data or instructions.
Accesses to the private memory space do not propagate to the L3 cache nor are they visible to the external
system bus. The private memory space is also not snooped, so the coherency of its contents must be
maintained by software or not at all. For more information, see Chapter 3, “L1, L2, and L3 Cache
Operation.”
The L3 cache control register (L3CR) provides control of L3 cache configuration and interface timi ng. The
L3 private memory control register (L3PM) configures the private memory feature.
The L3 cache interface provides two clock outputs that allow the clock inputs of the SRAMs to be driven
at select frequency divisions of the processor core frequency. For the MPC7457, the L3 cache interface
provides two sets of two differential clock outputs.
Requests from the L3 cache generally result from instruction misses, data load or store misses,
write-through operations, or cache management instructions. Requests from the L1 and L2 cache are
compared against the L3 tags and serviced by the L3 cache if they hit; if they miss in the L3 cache, they
are forwarded to the bus interface. Note that the MPC7441, MPC7445, MPC7447, MPC7447A, and
MPC7448 do not support the L3 cache and the L3 interface.
1.2.7System Interface
The MPC7450 supports two interface protocols—MPX bus protocol and a subset of the 60 x bus protocol.
Note that although this protocol is implemented by the MPC603e, MPC604e, MPC740, and MPC750
processors, it is referred to as the 60x bus interface. The MPX bus protocol is derived from the 60x bus
protocol. The MPX bus interface includes several additional features that provide higher memory
bandwidth than the 60x bus and more efficient use of the system bus in a multiprocessing environment.
Because the MPC7450’s performance is optimized for the MPX bus, use of the MPX bus is recommended
over the 60x bus.
The MPC7450 bus interface includes a 64-bit data bus with 8 bit s of data parity, a 36-bit address bus with
5 bits of address parity, and additional control signals to allow for unique system level optimizations.
The bus interface protocol is configured using the BMODE0 configuration signal at reset. If BMODE0 is
asserted at the negation of HRESET, the MPC7450 uses the MPX bus protocol; if BMODE0 is negated
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-23
Overview
during the negation of HRESET , the MPC7450 uses a limited subset of the 60x bus protocol. Note that the
inverse state of BMODE
[0:1] at the negation of HRESET is saved in MSSCR0[BMODE].
1.2.8MPC7450 Bus Operation Features
The MPC7450 has a separate address and data bus, each with its own set of arbitration and control signals.
This allows for decoupling the data tenure from the address tenure of a transaction and provides for a wide
range of system-bus implementations including:
•Non-pipelined bus operation
•Pipelined bus operation
•Split transaction operation
The MPC7450 supports only the normal memory-mapped address segments defined in the PowerPC
architecture. Access to direct store segments results in a DSI exception.
1.2.8.1MPX Bus Features
The MPX bus has the following features:
•Extended 36-bit address bus plus 5 bits of odd parity (41 bits total)
•64-bit data bus plus 8 bits of odd parity (72 bits total); a 32-bit data bus mode is not supported
•Support for a four-state (MESI) cache coherence protocol
•On-chip snooping to maintain L1 data cache, L2, and L3 cache coherency for multiprocessing
applications and DMA environments
•Support for address-only transfers (useful for a variety of broadcast operations in multiprocessor
applications)
•Address pipelining
•Support for up to 16 out-of-order transactions using 4 data transaction index (DTI[0:3]) signals
•Full data streaming
•Support for data intervention in multiprocessor systems
1.2.8.260x Bus Features
The following list summarizes the 60x bus interface features:
•Extended 36-bit address bus plus 5 bits of odd parity (41 bits total)
•64-bit data bus plus 8 bits of odd parity (72 bits total); a 32-bit data bus mode is not supported
•Support for a four-state (MESI) cache coherence protocol
•On-chip snooping to maintain L1 data cache, L2, and L3 cache coherency for multiprocessing
applications and DMA environments
•Support for address-only transfers (useful for a variety of broadcast operations in multiprocessor
applications)
•Address pipelining
•Support for up to 16 outstanding transactions. No reordering is supported.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-24Freescale Semiconductor
Overview
1.2.9Overview of System Interface Accesses
The system interface includes address register queues, prioritization logic, and a bus control unit. The
system interface latches snoop addresses for snooping in the L1 data, L2, and L3 caches, the memory
hierarchy address register queues, and the reservation controlled by the Load Word and Reserve Indexed
(lwarx) and Store Word Conditional Indexed (stwcx.) instructions. Accesses are prioritized with load
operations preceding store operations. Note that the L3 cache interface is not supported on the MPC7441,
MPC7445, MPC7447, MPC7447A, and MPC7448.
Instructions are automatically fetched from the memory system into the instruction unit where they are
issued to the execution units at a peak rate of three instructions per clock cycle. Conversely, load and store
instructions explicitly specify the movement of operands to and from the integer, floating-point, and
AltiVec register files and the memory system.
When the MPC7450 encounters an instruction or data access, it calculates the effective address and uses
the lower-order address bits to check for a hit in the on-chip, 32-Kbyte L1 instruction and data caches.
During L1 cache lookup, the instruction and data memory management units (MMUs) use the higher-order
address bits to calculate the virtual address, from which they calculate the physical (real) address. The
physical address bits are then compared with the corresponding cache tag bits to determine if a cache hit
occurred in the L1 instruction or data cache. If the access misses in the corresponding cache, the
transaction is sent to L1 load miss queue or the L1 store miss queue. L1 load miss queue transactions are
sent to the internal 256-Kbyte L2 cache (512-Kbyte for MPC7447, MPC7457, and MPC7447A, 1-Mbyte
for the MPC7448) and L3 cache controller simultaneously. S tore miss queue transactions are queued up in
the L2 cache controller and sent to the L3 cache if necessary. If no match is found in the L2 or L3 cache
tags, the physical address is used to access system memory.
In addition to loads, stores, and instruction fetches, the MPC7450 performs hardware table search
operations following TLB misses; L1, L2, and L3 cache castout operations; and cache-line snoop push
operations when a modified cache line detects a snoop hit from another bus master.
1.2.9.1System Interface Operation
The primary activity of the MPC7450 system interface is transferring data and instructions between the
processor and system memory. There are three types of transfer accesses:
•Single-beat transfers—These memory accesses allow transfer sizes of 1, 2, 3, 4, or 8 bytes in one
bus clock cycle. Single-beat transactions are caused by uncacheable read and write operations that
access memory directly (that is, when caching is disabled), cache-inhibited accesses, and stores in
write-through mode.
•T wo-beat burst (16-byte) data transfers—Generated to support caching-inhibited or write-through
AltiVec loads and stores (only generated in MPX bus mode) and for caching-inhibited instruction
fetches in MPX mode.
•Four-beat burst (32-byte) data transfers—Initiated when an entire cache block is transferred into or
out of the internal caches. Because the first-level caches on the MPC7450 are write-back caches,
burst-read memory operations are the most common memory accesses, followed by burst-write
memory operations, and single-beat (caching-inhibited or write-through) memory read and write
operations.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-25
Overview
Memory accesses can occur in single-beat (1, 2, 3, 4, and 8 bytes), double-beat (16 bytes), and four-beat
(32 bytes) burst data transfers. For memory accesses, the address and data buses are independent to support
pipelining and split transactions. The bus interface can pipeline as many as 16 transactions and, in MPX
bus mode, supports full out-of-order split-bus transactions. The MPC7450 bursts out of reset in MPX bus
mode, fetching eight instructions on the MPX bus at a time.
Access to the system interface is granted through an ex ternal arbitration me chanism that allo ws devices to
compete for bus mastership. This arbitration mechanism is flexible, allowing the MPC7450 to be
integrated into systems that implement various fairness and bus-parking procedures to avoid arbitration
overhead.
Typically, memory accesses are weakly ordered to maximize the efficiency of the bus without sacrificing
coherency of the data. The MPC7450 allows load operations to bypass store operations (except when a
dependency exists). Because the processor can dynamically optimize run-time ordering of load/store
traffic, overall performance is improved.
Note that the synchronize (sync) and enforce in-order execution of I/O (eieio) instructions can be used to
enforce strong ordering.
The system interface is synchronous. All MPC7450 inputs are sampled and all outputs are driven on the
rising edge of the bus clock cycle. The hardware specifications gives timing information. The system
interface is specific for each microprocessor that implements the PowerPC architecture.
1.2.9.2Signal Groupings
Signals are provided for implementing the bus protocol, clocking, and control of the L3 caches, as well as
separate L3 address and data buses. Test and control signals provide diagnostics for selected internal
circuits.
The MPC7450 MPX and 60x bus interface protocol signals are grouped as follows:
•Address arbitration—The MPC7450 uses these signals to arbitrate for address bus mastership.
•Address transfer start—These signals indicate that a bus master has begun a transaction on the
address bus.
•Address transfer—These signals include the address bus and address parity signals. They are used
to transfer the address and to ensure the integrity of the transfer.
•Transfer attribute—These signals provide information about the type of transfer, such as the
transfer size and whether the transaction is bursted, write-through, or cache-inhibited.
•Address transfer termination—These signals are used to acknowledge the end of the address phase
of the transaction. They also indicate whether a condition exists that requires the address phase to
be repeated.
•Data arbitration—The MPC7450 uses these signals to arbitrate for data bus mastership.
•Data transfer—These signals, which consist of the data bus and data parity signals, are used to
transfer the data and to ensure the integrity of the transfer.
•Data transfer termination—Data termination signals are required after each data beat in a data
transfer. In a single-beat transaction, data termination signals also indicate the end of the tenure. In
burst accesses, data termination signals apply to individual beats and indicate the end of the tenure
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-26Freescale Semiconductor
Overview
only after the final data beat. Data termination signals also indicate whether a co ndition exists that
requires the data phase to be repeated.
Many other MPC7450 signals control and affect other aspects of the device, aside from the bus protocol.
They are as follows:
•L3 cache address/data—The MPC7450 has separate address and data buses for accessing the L3
cache. Note that the L3 cache interface is not supported by the MPC7441, MPC7445, MPC7447,
MPC7447A, and MPC7448.
•L3 cache clock/control—These signals provide clocking and control for the L3 cache. Note that
the L3 cache interface is not supported by the MPC7441, MPC7445, MPC7447, MPC7447A, and
MPC7448.
•Interrupts/resets—These signals include the external interrupt signal, checkstop signals, and both
soft reset and hard reset signals. They are used to interrupt and, under various conditions, to reset
the processor.
•Processor status and control—These signals enable the time-base facility and are used to select the
bus mode and control sleep mode.
•Clock control—These signals determine the system clock frequency. They are also used to
synchronize multiprocessor systems.
•Test interface—The JTAG (IEEE 1149.1a-1993) interface and the common on-chip processor
(COP) unit provide a serial interface to the system for performing board-level boundary-scan
interconnect tests.
•Voltage selection—These signal control the electrical characteristics of the I/O circuitry of the
device as appropriate to support various signaling levels.
NOTE
Active-low signals are shown with overbars. For example, ARTRY (address
retry) and TS (transfer start). Active-low signals are referred to as asserte d
(active) when they are low and negated when they are high. Signals that are
not active low, such as AP[0:4] (address bus parity signals) and TT[0:4]
(transfer type signals) are referred to as asserted when they are high and
negated when they are low.
1.2.9.3MPX Bus Mode Functional Groupings
Figure 1-8 illustrates the signal configuration in MPX bus mode for the MPC7450, MPC7451, MPC7441,
MPC7455, and MPC7445, showing how the signals are grouped. A pinout diagram and tables showing pin
numbers are included in the hardware specifications. Note that the left side of each figure depicts the
signals that implement the MPX bus protocol and the right side of each figure shows the remaining signals
on the MPC7450 (not part of the bus protocol).
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-27
Overview
Address
Arbitration
Address
Tr an s fe r
Address
Tr an s fe r
Attributes
Address
Tr an s fe r
Termination
Data
Arbitration
Data
Tr an s fe r
Data
Tr an s fe r
Termination
L3_ADDR[17:0]
L3_DATA[0:63]
L3_DP[0:7]
8
L3_VSEL
1
L3_CLK[0:1]
2
L3_ECHO_CLK[0:3]
4
L3_CNTL
2
INT
1
SMI
1
MCP
1
SRESET
1
HRESET
1
CKSTP_IN
1
CKSTP_OUT
1
TBEN
1
QREQ
1
QACK
1
BVSEL
1
BMODE[0:1]
2
PMON_IN
1
PMON_OUT
1
SYSCLK
1
PLL_CFG[0:4]
5
EXT_QUAL
1
CLK_OUT
1
TCK
1
TDI
1
TDO
1
TMS
1
TRST
1
AV
DD
GV
DD
GND
[0:1]
L3 Cache
Address/Data
Note: L3 cache interface is
not supported in the
MPC7441 or the MPC7445.
L3 Cache
Clock/
Control
Interrupts/
Resets
Processor
Status/
Control
Clock
Control
Te st
Interface
(JTAG)
BR
BG
A[0:35]
AP[0:4]
TS
TT[0:4]
TBST
TSIZ[0:2]
GBL
WT
CI
AACK
ARTRY
SHD0/SHD1
HIT
DBG
DTI[0:3]
DRDY
D[0:63]
DP[0:7]
TA
TEA
V
OV
DD
DD
1
1
36
5
1
5
1
3
1
1
1
MPC7450,
MPC7451,
1
MPC7441,
1
MPC7455,
MPC7445
2
1
(MPX)
1
4
1
64
8
1
1
18
64
Figure 1-8. MPX Bus Signal Groups in the MPC7450, MPC7451, MPC7441,
MPC7455, and MPC7445
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-28Freescale Semiconductor
Overview
Figure 1-9 illustrates the signal configuration in MPX bus mode for the MPC7447 and the MPC7457.
Address
Arbitration
Address
Tr an s fe r
Address
Tr an s fe r
Attributes
BR
BG
A[0:35]
AP[0:4]
TS
TT[0:4]
TBST
TSIZ[0:2]
GBL
WT
CI
1
1
36
5
1
5
1
3
1
1
1
MPC7447/
AACK
Address
Tr an s fe r
Termination
ARTRY
SHD0/SHD1
HIT
DBG
Data
Arbitration
Data
Tr an s fe r
Data
Tr an s fe r
DTI[0:3]
DRDY
D[0:63]
DP[0:7]
TA
TEA
Termination
V
DD
OV
DD
1
For the MPC7457, there are 19 L3_ADDR signals, (L3_ADDR[0:18]).
MPC7457
1
(MPX)
1
2
1
1
4
1
64
8
1
1
18
64
L3_ADDR[17:0]
L3_DATA[0:63]
L3_DP[0:7]
8
L3_VSEL
1
L3_CLK[0:1]
2
L3_ECHO_CLK[0:3]
4
L3_CNTL
2
INT
1
SMI
1
MCP
1
SRESET
1
HRESET
1
CKSTP_IN
1
CKSTP_OUT
1
TBEN
1
QREQ
1
QACK
1
BVSEL
1
BMODE[0:1]
2
PMON_IN
1
PMON_OUT
1
SYSCLK
1
PLL_CFG[0:4]
5
EXT_QUAL
1
CLK_OUT
1
TCK
1
TDI
1
TDO
1
TMS
1
TRST
1
AV
DD
GV
DD
GND
[0:1]
1
L3 Cache
Address/Data
Note: L3 cache interface is
not supported in the
MPC7447.
L3 Cache
Clock/
Control
Interrupts/
Resets
Processor
Status/
Control
Clock
Control
Te st
Interface
(JTAG)
Figure 1-9. MPX Bus Signal Groups in the MPC7447 and MPC7457
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-29
Overview
Figure 1-10 illustrates the signal configuration in MPX bus mode for the MPC7447A.
Address
Arbitration
Address
Tr an s fe r
Address
Tr an s fe r
Attributes
Address
Tr an s fe r
Termination
Data
Arbitration
BR
BG
A[0:35]
AP[0:4]
TS
TT[0:4]
TBST
TSIZ[0:2]
GBL
WT
CI
AACK
ARTRY
SHD0/SHD1
HIT
DBG
DTI[0:3]
DRDY
1
1
36
5
1
5
1
3
1
1
1
MPC7447A
1
(MPX)
1
2
1
1
4
1
INT
1
SMI
1
MCP
1
SRESET
1
HRESET
1
CKSTP_IN
1
CKSTP_OUT
1
TBEN
1
QREQ
1
QACK
1
BVSEL
1
2
1
1
SYSCLK
1
PLL_CFG[0:4]
5
EXT_QUAL
1
CLK_OUT
1
BMODE[0:1]
PMON_IN
PMON_OUT
Interrupts/
Resets
Processor
Status/
Control
Clock
Control
Data
Tr an s fe r
Data
Tr an s fe r
Termination
D[0:63]
DP[0:7]
TA
TEA
V
VDD_SENSE
OV
OVDD_SENSE
DD
DD
64
8
1
1
1
1
1
1
1
TCK
TDI
TDO
TMS
TRST
AV
DD
GV
DD
GND
GND_SENSE
Te st
Interface
(JTAG)
Figure 1-10. MPX Bus Signal Groups in the MPC7447A
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-30Freescale Semiconductor
Figure 1-11illustrates the signal configuration in MPX bus mode for the MPC7448.
Overview
Address
Arbitration
Address
Tr an s fe r
Address
Tr an s fe r
Attributes
Address
Tr an s fe r
Termination
BR
BG
A[0:35]
AP[0:4]
TS
TT[0:4]
TBST
TSIZ[0:2]
GBL
WT
CI
AACK
ARTRY
SHD0/SHD1
HIT
1
1
36
5
1
5
1
3
1
1
1
MPC7448
1
(MPX)
1
2
1
1
1
1
1
1
1
1
1
1
1
2
1
1
1
1
1
2
INT
SMI
MCP
SRESET
HRESET
CKSTP_IN
CKSTP_OUT
TBEN
QREQ
QACK
BMODE[0:1]
PMON_IN
PMON_OUT
DFS2
DFS4
LV RA M
BVSEL[0:1]
Interrupts/
Reset/
Processor
Status/
Control
Data
Arbitration
Data
Tr an s fe r
Data
Tr an s fe r
Termination
DBG
DTI[0:3]
DRDY
D[0:63]
DP[0:7]
TA
TEA
V
VDD_SENSE
OV
OVDD_SENSE
DD
DD
1
4
1
64
8
1
1
1
4
1
1
1
1
1
1
1
SYSCLK
PLL_CFG[0:5]
EXT_QUAL
CLK_OUT
TCK
TDI
TDO
TMS
TRST
AV
DD
GV
DD
GND
GND_SENSE
Clock
Control
Te st
Interface
(JTAG)
Figure 1-11. MPX Bus Signal Groups in the MPC7448
Signal functionality is described in detail in Chapter 8, “Signal Descriptions,” and Chapter 9, “System
Interface Operation.”
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-31
Overview
1.2.9.3.1Clocking
For functional operation, the MPC7450 uses a single clock input signal, SYSCLK, from which clocking
is derived for the processor core, the L3 interface, and the MPX bus interface. Additionally, internal clock
information is made available at the pins to support debug and development.
The MPC7450’s clocking structure supports a wide range of processor-to-bus clock ratios. The internal
processor core clock is synchronized to SYSCLK with the aid of a VCO-based PLL. The PLL_CFG[0:4]
signals (PLL_CFG[0:5] in the MPC7448) are used to program the internal clock rate to a multiple of
SYSCLK as defined in the hardware specifications. The bus clock is maintained at the same frequency as
SYSCLK. SYSCLK does not need to be a 50% duty-cycle signal.
The MPC7450 generates the clock for the external L3 synchronous data RAMs. The clock frequency for
the RAMs is divided down from (and phase-locked to) the MPC7450 core clock frequency using a divisor
selected through L3CR[L3CLK]. Note that the MPC7441, MPC7445, MPC7447, MPC7447A, and
MPC7448 do not support the L3 cache or the L3 cache interface.
1.2.10Power and Thermal Management
The MPC7450 is designed for low-power operation. It provides both automatic and program-controlled
power reduction modes. If an MPC7450 functional unit is idle, it automatically goes into a low-power
mode. This mode does not affect operational performance. Dynamic power management automatically
supplies or withholds power to execution units individually, based upon the contents of the instruction
stream. The operation of dynamic power management is transparent to software or any external hardware.
The following three programmable power modes are available to the system:
•Nap—Instruction fetching is halted. Only those clocks for time base, decrementer, and JT AG logic
remain running. The MPC7450 goes into the doze state to snoop memory operations on the bus and
then back to nap using a QREQ/QACK processor-system handshake protocol.
•Sleep—Power consumption is further reduced by disabling bus snooping, leaving only the PLL in
a locked and running state. All internal functional units are disabled.
•Deep sleep—The system can disable the PLL. The system can then disable the SYSCLK source
for greater system power savings. Power-on reset procedures for restarting and relocking the PLL
must be followed upon exiting deep sleep.
The dynamic frequency switching (DFS) feature in the MPC7447A conserves power by lowering
processor operating frequency . The MPC7447A adds the ability to di vide the processor-to-system bus ratio
by two during normal functional operation. With the introduction of DFS4 mode in the MPC7448, the
processor-to-system bus ratio can also be divided by four . Section 10.2.5, “Dynamic Frequency Switching
(DFS),” provide information on power saving with DFS in the MPC7447A and the MPC7448.
The MPC7450 also provides an instruction cache throttling mechanism to effectively reduce the
instruction execution rate without the complexity and overhead of dynamic clock control. When used with
the dynamic power management, instruction cache throttling provides the system designer with a flexible
way to control device temperature while allowing the processor to continue operating. For thermal
management, the MPC7450 provides a supervisor-level instruction cache throttling control register
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-32Freescale Semiconductor
Overview
(ICTC). Chapter 10, “Power and Thermal Management,” provides information about how to configure the
ICTC register for the MPC7450.
1.2.11Performance Monitor
The MPC7450 incorporates a performance monitor facility that system designers can use to help bring up,
debug, and optimize software performance. The performance monitor counts events during execution of
instructions related to dispatch, execution, completion, and memory accesses.
The performance monitor incorporates several registers that can be read and written to by supervisor-level
software. User-level versions of these registers provide read-only access for user-level applications. These
registers are described in Section 1.3.1, “PowerPC Registers and Programming Model.” Performance
monitor control registers, MMCR0, MMCR1, and MMCR2 can be used to specify which events are to be
counted and the conditions for which a performance monitoring exception is taken. Additionally, the
sampled instruction address register, SIAR (USIAR), holds the address of the first instruction to complete
after the counter overflowed.
Attempting to write to a user-level read-only performance monitor register causes a program exception,
regardless of the MSR[PR] setting.
When a performance monitor exception occurs, program execution continues from vector offset 0x00F00.
Chapter 11, “Performance Monitor,” describes the operation of the performance monitor diagnostic tool
The PowerPC architecture consists of three layers. Adherence to the PowerPC architecture can be
described in terms of which of the following levels of the architecture is implemented:
•PowerPC user instruction set architecture (UISA)—Defines the base user-level instruction set,
user-level registers, data types, floating-point exception model, memory models for a uniprocessor
environment, and programming model for a uniprocessor environment
•PowerPC virtual environment architecture (VEA)—Describes the memory model for a
multiprocessor environment, defines cache control instructions, and describes other aspects of
virtual environments. Implementations that conform to the VEA also adhere to the UISA but may
not necessarily adhere to the OEA.
•PowerPC operating environment architecture (OEA)—Defines the memory management model,
supervisor-level registers, synchronization requirements, and the exception model.
Implementations that conform to the OEA also adhere to the UISA and the VEA.
The MPC7450 implementation supports the three levels of the architecture described above. For more
information about the PowerPC architecture, see PowerPC Microprocessor Family: the Programming Environments. Specific MPC7450 features are listed in Section 1.2, “MPC7450 Microprocessor
Features.”
This section describes the PowerPC architecture in general, and specific details about the implementation
of the MPC7450 as a low-power, 32-bit device that implements this architecture. The structure of this
section follows the reference manual organization; each subsection provides an overview of that chapter.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-33
Overview
•Registers and programming model—Section 1.3.1, “PowerPC Registers and Programming
Model,” describes the registers for the operating environment architecture common among
processors of this family and describes the programming model. It also describes the registers that
are unique to the MPC7450.
Instruction set and addressing modes—Section , “Some registers can be accessed both explicitly
and implicitly. In the MPC7450, all SPRs are 32 bits wide. Table 2-1 describes registers
implemented by the MPC7450.,” describes the PowerPC instruction set and addressing modes for
the PowerPC operating environment architecture, and defines and describes the PowerPC
instructions implemented in the MPC7450. The information in this section is described more fully
in Chapter 2, “Programming Model.”
•Cache implementation—Section 1.3.3, “On-Chip Cache Implementation,” describes the cache
model that is defined generally by the virtual environment architecture. It also provides specific
details about the MPC7450 cache implementation. The information in this section is described
more fully in Chapter 3, “L1, L2, and L3 Cache Operation.”
•Exception model—Section 1.3.4, “Exception Model,” describes the exception model of the
PowerPC operating environment architecture and the differences in the MPC7450 exception
model. The information in this section is described more fully in Chapter 4, “Exceptions.”
•Memory management—Section 1.3.5, “Memory Management,” describes generally the
conventions for memory management. This section also describes the MPC7450’s implementation
of the 32-bit PowerPC memory management specification. The information in this section is
described more fully in Chapter 5, “Memory Management.”
•Instruction timing—Section 1.3.6, “Instruction Timing,” provides a general description of the
instruction timing provided by the superscalar, parallel execution supported by the PowerPC
architecture and the MPC7450. The information in this section is described more fully in
Chapter 6, “Instruction Timing.”
•AltiVec implementation—Section 1.3.7, “AltiVec Implementation,” points out that the MPC7450
implements AltiVec registers, instructions, and exceptions as described in the AltiVec Technology
The PowerPC architecture defines register-to-register operations for most computational instructions.
Source operands for these instructions are accessed from the registers or are provided as immediate values
embedded in the instruction opcode. The three-register instruction format allows specification of a target
register distinct from the two source operands. Load and store instructions trans fer data between registers
and memory.
The PowerPC architecture also defines two levels of privilege—supervisor mode of operation (typically
used by the operating system) and user mode of operation (used by the application software). The
programming models incorporate 32 GPRs, 32 FPRs, SPRs, and several miscellaneous registers. The
AltiVec extensions to the PowerPC architecture augment the programming model with 32 VRs, 1 status
and control register, and 1 save and restore register. Each processor that implements the PowerPC
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-34Freescale Semiconductor
Overview
architecture also has a unique set of implementation-specific registers to support functionality that may not
be defined by the PowerPC architecture.
Having access to privileged instructions, registers, and other resources allows the operating system to
control the application environment (providing virtual memory and protecting operating-system and
critical machine resources). Instructions that control the state of the processor, the address translation
mechanism, and supervisor registers can be executed only when the processor is operating in supervisor
mode.
Figure 1-12 through Figure 1-13 show all the MPC7450 registers available at the user and supervisor level.
The numbers to the right of the SPRs indicate the number that is used in the syntax of the instruction
operands to access the register. For more information, see Chapter 2, “Programming Model.”
The OEA defines numerous SPRs that serve a variety of functions, such as providing controls, indicating
status, configuring the processor, and performing special operati ons. During normal execution, a program
can access the registers shown in Figure 1-12 through Figure 1-13, depending on the program’s access
privilege (supervisor or user, determined by the privilege-level bit, MSR[PR]). GPRs, FPRs, and VRs are
accessed through operands that are part of the instructions. Access to registers can be explicit (that is,
through the use of specific instructions for that purpose such as Move to Special-Purpose Register (mtspr)
and Move from Special-Purpose Register (mfspr) instructions) or implicit, as the part of the execution of
an instruction.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-35
Overview
Figure 1-12 shows the MPC7441 and MPC7451 register set.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-38Freescale Semiconductor
Overview
Some registers can be accessed both explicitly and implicitly . In the MPC7450, all SPRs are 32 bits wide.
Table 2-1 describes registers implemented by the MPC7450.
1.3.2Instruction Set
All PowerPC instructions are encoded as single-word (32-bit) opcodes. Instruction formats are consistent
among all instruction types, permitting efficient decoding to occur in parallel with operand accesses. This
fixed instruction length and consistent format greatly simplifies instruction pipelining.
For more information, see Chapter 2, “Programming Model.”
1.3.2.1PowerPC Instruction Set
The PowerPC instructions are divided into the following categories:
•Integer instructions—These include computational and logical instructions.
— Integer arithmetic instructions
— Integer compare instructions
— Integer logical instructions
— Integer rotate and shift instructions
•Floating-point instructions—These include floating-point computational instructions, as well as
instructions that affect the FPSCR.
— Floating-point arithmetic instructions
— Floating-point multiply/add instructions
— Floating-point rounding and conversion instructions
— Floating-point compare instructions
— Floating-point status and control instructions
•Load and store instructions—These include integer and floating-point load and store instructions.
— Integer load and store instructions
— Integer load and store multiple instructions
— Floating-point load and store instructions
— Primitives used to construct atomic memory operations (lwarx and stwcx. instructions)
•Flow control instructions—These include branching instructions, condition register logical
instructions, trap instructions, and other instructions that affect the instruction flow.
— Branch and trap instructions
— Condition register logical instructions
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-39
Overview
•Processor control instructions—These instructions are used for synchronizing memory accesses
and management of caches, TLBs, and the segment registers.
— Move to/from SPR instructions
— Move to/from MSR
— Synchronize
— Instruction synchronize
— Order loads and stores
•Memory control instructions—These instructions provide control of caches, TLBs, and SRs.
— Supervisor-level cache management instructions
— User-level cache instructions
— Segment register manipulation instructions
— Translation lookaside buffer management instructions
This grouping does not indicate the execution unit that executes a particular instruction or group of
instructions.
Integer instructions operate on byte, half-word, and word operands. Floating-point instructions operate on
single-precision (one word) and double-precision (one double word) floating-point operands. The
PowerPC architecture uses instructions that are four bytes long and word-aligned. It provides for byte,
half-word, and word operand loads and stores between memory and a set of 32 GPRs. It also provides for
word and double-word operand loads and stores between memory and a set of 32 floating-point registers
(FPRs).
Computational instructions do not modify memory. To use a memory operand in a computation and then
modify the same or another memory location, the memory contents must be loaded into a register,
modified, and then written back to the target location with distinct instructions.
Processors that implement the PowerPC architecture follow the program flow when they are in the normal
execution state. However, the flow of instructions can be interrupted directly by the execution of an
instruction or by an asynchronous event. Either kind of exception may cause one of several components
of the system software to be invoked.
Effective address computations for both data and instruction accesses use 32-bit unsigned binary
arithmetic. A carry from bit 0 is ignored in 32-bit implementations.
1.3.2.2AltiVec Instruction Set
The AltiVec instructions are divided into the following categories:
•Vector integer arithmetic instructions—These include arithmetic, logical, compare, rotate, and
shift instructions.
•V ector floating-point arithmetic instructions—These include floating-poin t arithmetic instructions,
as well as a discussion on floating-point modes.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-40Freescale Semiconductor
Overview
•Vector load and store instructions—These include load and store instructions for vector registers.
The AltiVec technology defines LRU and transient type instructions that can be used to optimize
memory accesses.
— LRU instructions. The AltiVec architecture specifies that the lvxl and stvxl instructions differ
from other AltiVec load and store instructions in that they leave cache entries in a
least-recently-used (LRU) state instead of a most-recently-used state.
— Transient instructions. The AltiVec architecture describes a difference between static and
transient memory accesses. A static memory access should have some reasonable degree of
locality and be referenced several times or reused over some reasonably long period of time. A
transient memory reference has poor locality and is likely to be referenced a very few times or
over a very short period of time.
The following instructions are interpreted to be transient:
– dstt and dststt (transient forms of the two data stream touch instructions)
– lvxl and stvxl
•Vector permutation and formatting instructions—These include pack, unpack, merge, splat,
permute, select, and shift instructions, described in Section 2.6.5, “Vector Permutation and
Formatting Instructions.”
•Processor control instructions—These instructions are used to read and write from the AltiVec
status and control register, described in Section 2.4.4.6, “Processor Control Instructions.”
•Memory control instructions—These instructions are used for managing of caches (user level and
supervisor level), described in Section 2.4.5.3, “Memory Control Instructions.”
1.3.2.3MPC7450 Microprocessor Instruction Set
The MPC7450 instruction set is defined as follows:
•The MPC7450 provides hardware support for all 32-bit PowerPC instructions.
•The MPC7450 implements the following instructions optional to the PowerPC architecture:
— External Control In Word Indexed (eciwx)
— External Control Out Word Indexed (ecowx)
— Data Cache Block Allocate (dcba)
— Floating Select (fsel)
— Floating Reciprocal Estimate Single-Precision (fres)
— Floating Reciprocal Square Root Estimate (frsqrte)
— Store Floating-Point as Integer Word (stfiwx)
— Load Data TLB Entry (tlbld)
— Load Instruction TLB Entry (tlbli)
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
Freescale Semiconductor1-41
Overview
1.3.3On-Chip Cache Implementation
The following subsections describe the PowerPC architecture’s treatment of cache in general, and the
MPC7450-specific implementation, respectively. A detailed description of the MPC7450 cache
implementation is provided in Chapter 3, “L1, L2, and L3 Cache Operation.”
1.3.3.1PowerPC Cache Model
The PowerPC architecture does not define hardware aspects of cache implementations. For example,
processors that implement the PowerPC architecture can have unified caches, separate L1 instruction and
data caches (Harvard architecture), or no cache at all. These microprocessors control the following
memory access modes on a page or block basis:
•Write-back/write-through mode
•Caching-inhibited/caching-allowed mode
•Memory coherency required/memory coherency not required mode
The caches are physically addressed, and the data cache can operate in either write-back or write-through
mode as specified by the PowerPC architecture.
The PowerPC architecture defines the term ‘cache block’ as the cacheable unit. The VEA and OEA define
cache management instructions a programmer can use to affect cache contents.
The MPC7450 cache implementation is described in Section 1.2.4, “On-Chip L1 Instruction and Data
Caches,”Section 1.2.5, “L2 Cache Implementation,” and Section 1.2.6, “L3 Cache Implementation.” The
BPU also contains a 128-entry BTIC that provides immediate access to cached target instructions. For
more information, see Section 1.2.2.2, “Branch Processing Unit (BPU).”
1.3.4Exception Model
The following sections describe the PowerPC exception model and the MPC7450 implementation. A
detailed description of the MPC7450 exception model is provided in Chapter 4, “Exceptions.”
1.3.4.1PowerPC Exception Model
The OEA portion of the PowerPC architecture defines the mech anism by which processors that implement
the PowerPC architecture invoke exceptions. Exception conditions may be defined at other levels of the
architecture. For example, the UISA defines conditions that may cause floating-point exceptions; the OEA
defines the mechanism by which the exception is taken.
The PowerPC exception mechanism allows the processor to change to supervisor state as a result of
unusual conditions arising in the execution of instructions and from external signals, bus errors, or various
internal conditions. When exceptions occur, information about the state of the processor is saved to certain
registers and the processor begins execution at an address (exception vector) predetermined for each
exception. Processing of exceptions begins in supervisor mode.
MPC7450 RISC Microprocessor Family Reference Manual, Rev. 5
1-42Freescale Semiconductor
Loading...
+ hidden pages
You need points to download manuals.
1 point = 1 manual.
You can buy points or you can get point for every manual you upload.