Freescale Semiconductor
Technical Information Center, CH370
1300 N. Alma School Road
Chandler, Arizona 85224
+1-800-521-6274 or +1-480-768-2130
support@freescale.com
Freescale Semiconductor Japan Ltd.
Headquarters
ARCO Tower 15F
1-8-1, Shimo-Meguro, Meguro-ku,
Tokyo 153-0064, Japan
0120 191014 or +81 3 5437 9125
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 26668334
support.asia@freescale.com
For Literature Requests Only:
Freescale Semiconductor Literature Distribution Center
P.O. Box 5405
Denver, Colorado 80217
1-800-441-2447 or 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 that 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 exper ts. 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 Semico nductor product could
create a situation where personal injury or death may occur. Should Buyer
purchase or use Freescale Semicondu ctor 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. All other product or service names are the property of their
respective owners.
This chapter provides an overview of the major features and functional components of the MCF52211
family of microcontrollers. The MCF52211 family is a highly integrated implementation of the ColdFire®
family of reduced instruction set computing (RISC) microcontrollers that also includes the MCF52210,
MCF52212, and MCF52213. The differences between these parts are summarized in Table 1-1. This
document is written from the perspective of the MCF52211.
The MCF52211 represents a family of highly-integrated 32-bit microcontrollers based on the V2 ColdFire
microarchitecture. Featuring up to 16 Kbytes of internal SRAM and up to 128 Kbytes of flash memory,
four 32-bit timers with DMA request capability , a 4-channel DMA controller , two I2C™ modules, up to 3
UAR T s and a queued SPI, the MCF5221 1 family has been designed for general-purpose industrial control
applications.
This 32-bit device is based on the Version 2 (V2) ColdFire reduced instruction set computing (RISC) core
with a multiply-accumulate unit (MAC) and divider providing 76 Dhrystone 2.1 MIPS at a frequency up
to 80 MHz from internal flash. On-chip modules include the following:
•V2 ColdFire core with multiply-accumulate unit (MAC)
•Up to 16 Kbytes of internal SRAM
•Up to 128 Kbytes of on-chip flash memory
•Universal Serial Bus On-The-Go (USB OTG) full speed/low speed host and device controller
•Up to three universal asynchronous receiver/transmitters (UARTs)
•Two inter-integrated circuit (I2C) bus controllers
•12-bit analog-to-digital converter (ADC)
•Real-time clock
•Queued serial peripheral interface (QSPI) module
•Four-channel, 32-bit direct memory access (DMA) controller
•Four-channel, 32-bit general purpose timers with optional DMA support
•Two 16-bit periodic interrupt timers (PITs)
•Programmable software watchdog timer
•Backup watchdog timer
•Interrupt controller capable of handling up to 63 interrupt sources
•Clock module with 8 MHz on-chip relaxation oscillator and integrated phase-locked loop (PLL)
To locate any published errata or updates for this document, refer to the ColdFire products website at
MCF52210CAE66MCF52210 Microcontroller, 2 UARTs6664 / 1664 LQFP-40 to +85
MCF52210CEP66MCF52210 Microcontroller, 2 UARTs6664 / 1664 QFN-40 to +85
MCF52210CVM66MCF52210 Microcontroller, 2 UARTs6664 / 1681 MAPBGA-40 to +85
MCF52210CVM80MCF52210 Microcontroller, 2 UARTs8064 / 1681 MAPBGA-40 to +85
MCF52211CAE66MCF52211 Microcontroller, 3 UARTs66128 / 1664 LQFP-40 to +85
MCF52211CAF80MCF52211 Microcontroller, 3 UARTs80128 / 16100 LQFP-40 to +85
MCF52211CEP66MCF52211 Microcontroller, 3 UARTs66128 / 1664 QFN-40 to +85
MCF52211CVM66MCF52211 Microcontroller, 3 UARTs66128 / 1681 MAPBGA-40 to +85
MCF52211CVM80MCF52211 Microcontroller, 3 UARTs80128 / 1681 MAPBGA-40 to +85
MCF52212CAE50MCF52212 Microcontroller, 2 UARTs5064 / 864 LQFP-40 to +85
MCF52212AE50MCF52212 Microcontroller, 2 UARTs5064 / 864 LQFP0 to +70
MCF52213CAE50MCF52213 Microcontroller, 2 UARTs50128 / 864 LQFP-40 to +85
MCF52213AE50MCF52213 Microcontroller, 2 UARTs50128 / 864 LQFP0 to +70
Description
Speed
(MHz)
Flash/SRAM
(Kbytes)
Package
Tem p rang e
(°C)
1.2Features
The MCF52211 family includes the following features:
•Version 2 ColdFire variable-length RISC processor core
— Static operation
— 32-bit address and data paths on-chip
— Up to 80 MHz processor core frequency
— 40 MHz and 33 MHz off-platform bus frequency
— Sixteen general-purpose, 32-bit data and address registers
— Implements ColdFire ISA_A with extensions to support the user stack pointer register and four
new instructions for improved bit processing (ISA_A+)
— Multiply-Accumulate (MAC) unit with 32-bit accumulator to support 16×16 → 32 or
32×32 → 32 operations
•System debug support
— Real-time trace for determining dynamic execution path
— Background debug mode (BDM) for in-circuit debugging (DEBUG_B+)
— Real-time debug support, with six hardware breakpoints (4 PC, 1 address and 1 data)
— Up to 16-Kbyte dual-ported SRAM on CPU internal bus, supporting core and DMA access
with standby power supply support
— Up to 128 Kbytes of interleaved flash memory supporting 2-1-1-1 accesses
•Power management
— Fully static operation with processor sleep and whole chip stop modes
— Rapid response to interrupts from the low-power sleep mode (wake-up feature)
— Clock enable/disable for each peripheral when not used (except backup watchdog timer)
— Software controlled disable of external clock output for low-power consumption
•Universal Serial Bus On-The-Go (USB OTG) dual-mode host and device controller
— Full-speed / low-speed host controller
— USB 1.1 and 2.0 compliant full-speed / low speed device controller
— 16 bidirectional end points
— DMA or FIFO data stream interfaces
— Low power consumption
— OTG protocol logic
— 16-bit divider for clock generation
— Interrupt control logic with maskable interrupts
— DMA support
— Data formats can be 5, 6, 7 or 8 bits with even, odd, or no parity
— Up to two stop bits in 1/16 increments
— Error-detection capabilities
— Modem support includes request-to-send (RTS) and clear-to-send (CTS) lines for two UARTs
— Transmit and receive FIFO buffers
•Two I2C modules
— Interchip bus interface for EEPROMs, LCD controllers, A/D converters, and keypads
2
— Fully compatible with industry-standard I
C bus
— Master and slave modes support multiple masters
— Automatic interrupt generation with programmable level
•Queued serial peripheral interface (QSPI)
— Full-duplex, three-wire synchronous transfers
— Up to four chip selects available
— Master mode operation only
— Programmable bit rates up to half the CPU clock frequency
— Up to 16 pre-programmed transfers
•Fast analog-to-digital converter (ADC)
— Eight analog input channels
— 12-bit resolution
— Minimum 1.125 μs conversion time
— Simultaneous sampling of two channels for motor control applications
— Single-scan or continuous operation
— Optional interrupts on conversion complete, zero crossing (sign change), or under/over
low/high limit
— Unused analog channels can be used as digital I/O
•Four 32-bit timers with DMA support
— 12.5 ns resolution at 80 MHz
— Programmable sources for clock input, including an external clock option
— Programmable prescaler
— Input capture capability with programmable trigger edge on input pin
— Output compare with programmable mode for the output pin
— Free run and restart modes
— Maskable interrupts on input capture or output compare
— DMA trigger capability on input capture or output compare
•Four-channel general purpose timer
— 16-bit architecture
— Programmable prescaler
— Output pulse-widths variable from microseconds to seconds
— Single 16-bit input pulse accumulator
— Toggle-on-overflow feature for pulse-width modulator (PWM) generation
— One dual-mode pulse accumulation channel
•Pulse-width modulation timer
— Support for PCM mode (resulting in superior signal quality compared to conventional PWM)
— Operates as eight channels with 8-bit resolution or four channels with 16-bit resolution
— Programmable period and duty cycle
— Programmable enable/disable for each channel
— Software selectable polarity for each channel
— Period and duty cycle are double buffered. Change takes effect when the end of the current
period is reached (PWM counter reaches zero) or when the channel is disabled.
— Programmable center or left aligned outputs on individual channels
— Four clock sources (A, B, SA, and SB) provide for a wide range of frequencies
— Emergency shutdown
•Two periodic interrupt timers (PITs)
— 16-bit counter
— Selectable as free running or count down
— Maintains system time-of-day clock
— Provides stopwatch and alarm interrupt functions
•Software watchdog timer
— 32-bit counter
— Low-power mode support
•Backup watchdog timer (BWT)
— Independent timer that can be used to help software recover from runaway code
— 16-bit counter
— Low-power mode support
•Clock generation features
— One to 48 MHz crystal, 8 MHz on-chip relaxation oscillator, or external oscillator reference
options
— Trimmed relaxation oscillator
— Two to 10 MHz reference frequency for normal PLL mode with a pre-divider programmable
from 1 to 8
— System can be clocked from PLL or directly from crystal oscillator or relaxation oscillator
Overview
— Low power modes supported
—2n (n ≤ 0 ≤ 15) low-power divider for extremely low frequency operation
•Interrupt controller
— Uniquely programmable vectors for all interrupt sources
— Fully programmable level and priority for all peripheral interrupt sources
— Seven external interrupt signals with fixed level and priority
— Unique vector number for each interrupt source
— Ability to mask any individual interrupt source or all interrupt sources (global mask-all)
— Support for hardware and software interrupt acknowledge (IACK) cycles
— Combinatorial path to provide wake-up from low-power modes
•DMA controller
— Four fully programmable channels
— Dual-address transfer support with 8-, 16-, and 32-bit data capability, along with support for
16-byte (4×32-bit) burst transfers
— Source/destination address pointers that can increment or remain constant
— 24-bit byte transfer counter per channel
— Auto-alignment transfers supported for efficient block movement
— Bursting and cycle steal support
— Software-programmable DMA requesters for the UARTs (3) and 32-bit timers (4)
•Reset
— Separate reset in and reset out signals
— Seven sources of reset:
– Power-on reset (POR)
– External
– Software
– Watchdog
– Loss of clock / loss of lock
– Low-voltage detection (LVD)
–JTAG
— Status flag indication of source of last reset
•Chip integration module (CIM)
— System configuration during reset
— Selects one of six clock modes
— Configures output pad drive strength
— Unique part identification number and part revision number
•General purpose I/O interface
— Up to 56 bits of general purpose I/O
— Bit manipulation supported via set/clear functions
— Programmable drive strengths
— Unused peripheral pins may be used as extra GPIO
•JTAG support for system level board testing
1.2.1V2 Core Overview
The version 2 ColdFire processor core is comprised of two separate pipelines decoupled by an instruction
buffer . The two-stage instruction fetch pipeline (IFP) is responsible for instruction-address generation and
instruction fetch. The instruction buffer is a first-in-first-out (FIFO) buffer that holds prefetched
instructions awaiting execution in the operand execution pipeline (OEP). The OEP includes two pipeline
stages. The first stage decodes instructions and selects operands (DSOC); the second stage (AGEX)
performs instruction execution and calculates operand effective addresses, if needed.
The V2 core implements the ColdFire instruction set architecture revision A+ with added support for a
separate user stack pointer register and four new instructions to assist in bit processing. Additionally, the
core includes the multiply-accumulate (MAC) unit for improved signal processing capabilities. The MAC
implements a three-stage arithmetic pipeline, optimized for 16×16 bit operations, with support for one
32-bit accumulator. Supported operands include 16- and 32-bit signed and unsigned integers, signed
fractional operands, and a complete set of instructions to process these data types. The MAC provides
support for execution of DSP operations within the context of a single processor at a minimal hardware
cost.
1.2.2Integrated Debug Module
The ColdFire processor core debug interface is provided to support system debugging with low-cost debug
and emulator development tools. Through a standard debug interface, access to debug information and
real-time tracing capability is provided on 100-lead packages. This allows the processor and system to be
debugged at full speed without the need for costly in-circuit emulators.
The on-chip breakpoint resources include a total of nine programmable 32-bit registers: an address and an
address mask register, a data and a data mask register, four PC registers, and one PC mask register. These
registers can be accessed through the dedicated debug serial communication channel or from the
processor’s supervisor mode programming model. The breakpoint registers can be configured to generate
triggers by combining the address, data, and PC conditions in a variety of single- or dual-level definitions.
The trigger event can be programmed to generate a processor halt or initiate a debug interrupt exception.
The MCF52211 implements revision B+ of the ColdFire Debug Architecture.
The MCF52211’s interrupt servicing options during emulator mode allow real-time critical interrupt
service routines to be serviced while processing a debug interrupt event. This ensure s the system continues
to operate even during debugging.
To support program trace, the V2 debug module provides processor status (PST[3:0]) and debug data
(DDATA[3:0]) ports. These buses and the PSTCLK output provide execution status, captured operand
data, and branch target addresses defining processor activity at the CPU’s clock rate. The MCF52211
includes a new debug signal, ALLPST. This signal is the logical AND of the processor status (PST[3:0])
signals and is useful for detecting when the processor is in a halted state (PST[3:0] = 1111).
The full debug/trace interface is available only on the 100-pin packages. However, every product features
the dedicated debug serial communication channel (DSI, DSO, DSCLK) and the ALLPST signal.
1.2.3JTAG
The MCF52211 supports circuit board test strategies based on the Test Technology Committee of IEEE
and the Joint Test Action Group (JTAG). The test logic includes a test access port (TAP) consisting of a
16-state controller, an instruction register, and three test registers (a 1-bit bypass register, a 256-bit
boundary-scan register, and a 32-bit ID register). The boundary scan register links the device’s pins into
one shift register. Test logic, implemented using static logic design, is independent of the device system
logic.
The MCF52211 implementation can:
•Perform boundary-scan operations to test circuit board electrical continuity
•Sample
boundary scan register
•Bypass the MCF52211 for a given circuit board test by effectively reducing theboundary-scan
register to a single bit
•Disable the output drive to pins during circuit-board testing
•Drive output pins to stable levels
MCF52211systempinsduringoperation and transparently shift out the resultin the
The dual-ported SRAM module provides a general-purpose 8- or 16-Kbyte memory block that the
ColdFire core can access in a single cycle. The location of the memory block can be set to any 8- or
16-Kbyte boundary within the 4-Gbyte address space. This memory is ideal for storing critical code or data
structures and for use as the system stack. Because the SRAM module is physically connected to the
processor's high-speed local bus, it can quickly service core-initiated accesses or memory-referencing
commands from the debug module.
The SRAM module is also accessible by the DMA. The dual-ported nature of the SRAM makes it ideal
for implementing applications with double-buffer schemes, where the processor and a DMA device
operate in alternate regions of the SRAM to maximize system performance.
1.2.4.2Flash Memory
The ColdFire flash module (CFM) is a non-volatile memory (NVM) module that connects to the
processor’s high-speed local bus. The CFM is constructed with up to four banks of 16-Kbyte×16-bit flash
memory arrays to generate up to 128 Kbytes of 32-bit flash memory. These electrically erasable and
programmable arrays serve as non-volatile program and data memory. The flash memory is ideal for
program and data storage for single-chip applications, allowing for field reprogramming without requiring
an external high voltage source. The CFM interfaces to the ColdFire core through an optimized read-only
memory controller that supports interleaved accesses from the 2-cycle flash memory arrays. A backdoor
mapping of the flash memory is used for all program, erase, and verify operations, as well as providing a
read datapath for the DMA. Flash memory may also be programmed via the EzPort, which is a serial flash
memory programming interface that allows the flash memory to be read, erased and programmed by an
external controller in a format compatible with most SPI bus flash memory chips.
1.2.5Power Management
The MCF52211 incorporates several low-power modes of operation entered under program control and
exited by several external trigger events. An integrated power-on reset (POR) circuit monitors the input
supply and forces an MCU reset as the supply voltage rises. The low voltage detector (LVD) monitors the
supply voltage and is configurable to force a reset or interrupt condition if it falls below the L VD trip point.
The RAM standby switch provides power to RAM when the supply voltage to the chip falls below the
standby battery voltage.
1.2.6USB On-The-Go Controller
The MCF52211 includes a Universal Serial Bus On-The-Go (USB OTG) dual-mode controller. USB is a
popular standard for connecting peripherals and portable consumer electronic devices such as digital
cameras and handheld computers to host PCs. The OTG supplement to the USB specification extends USB
to peer-to-peer application, enabling devices to connect directly to each other without the need for a PC.
The dual-mode controller on the MCF52211 can act as a USB OTG host and as a USB device. It also
supports full-speed and low-speed modes.
The MCF52211 has three full-duplex UARTs that function independently. The three UARTs can be
clocked by the system bus clock, eliminating the need for an external clock source. On smaller packages,
the third UART is multiplexed with other digital I/O functions.
1.2.8I2C Bus
The MCF52211 includes two I2C modules. The I2C bus is a two-wire, bidirectional serial bus that provides
a simple, efficient method of data exchange and minimizes the interconnection between devices. This bus
is suitable for applications requiring occasional communications over a short distance between many
devices.
1.2.9QSPI
The queued serial peripheral interface (QSPI) provides a synchronous serial peripheral interface with
queued transfer capability . It allows up to 16 transfers to be queued at once, mi nimizing the need for CPU
intervention between transfers.
1.2.10Fast ADC
The fast ADC consists of an eight-channel input select multiplexer and two independent sample and hold
(S/H) circuits feeding separate 12-bit ADCs. The two separate converters store their results in accessible
buffers for further processing.
The ADC can be configured to perform a single scan and halt, a scan when triggered, or a programmed
scan sequence repeatedly until manually stopped.
The ADC can be configured for sequential or simultaneous conversion. When configured for sequential
conversions, up to eight channels can be sampled and stored in any order specified by the channel list
register. Both ADCs may be required during a scan, depending on the inputs to be sampled.
During a simultaneous conversion, both S/H circuits are used to capture two different channels at the same
time. This configuration requires that a single channel may not be sampled by both S/H circuits
simultaneously.
Optional interrupts can be generated at the end of the scan sequence if a channel is out of range (measures
below the low threshold limit or above the high threshold limit set in the limit registers) or at several
different zero crossing conditions.
1.2.11DMA Timers (DTIM0–DTIM3)
There are four independent, DMA transfer capable 32-bit timers (DTIM0, DTIM1, DTIM2, and DTIM3)
on the MCF52211. Each module incorporates a 32-bit timer with a separate register set for configuration
and control. The timers can be configured to operate from the system clock or from an external clock
source using one of the DTINn signals. If the system clock is selected, it can be divided by 16 or 1. The
input clock is further divided by a user-programmable 8-bit prescaler that clocks the actual timer counter
register (TCRn). Each of these timers can be configured for input capture or reference (output) compare
mode. Timer events may optionally cause interrupt requests or DMA transfers.
1.2.12General Purpose Timer (GPT)
The general purpose timer (GPT) is a four-channel timer module consisting of a 16-bit programmable
counter driven by a seven-stage programmable prescaler . Each of the four channels can be configured for
input capture or output compare. Additionally, channel three, can be configured as a pulse accumulator.
A timer overflow function allows software to extend the timing capability of the system beyond the 16-bit
range of the counter. The input capture and output compare functions allow simultaneous input waveform
measurements and output waveform generation. The input capture function can capture the time of a
selected transition edge. The output compare function can generate output waveforms and timer software
delays. The 16-bit pulse accumulator can operate as a simple event counter or a gated time accumulator.
1.2.13Periodic Interrupt Timers (PIT0 and PIT1)
The two periodic interrupt timers (PIT0 and PIT1) are 16-bit timers that provide interrupts at regular
intervals with minimal processor intervention. Each timer can count down from the value written in its PIT
modulus register or it can be a free-running down-counter.
1.2.14Real-Time Clock (RTC)
The Real-Time Clock (RTC) module maintains the system (time-of-day) clock and provides stopwatch,
alarm, and interrupt functions. It includes full clock features: seconds, minutes, hours, days and supports
a host of time-of-day interrupt functions along with an alarm interrupt.
1.2.15Pulse-Width Modulation (PWM) Timers
The MCF52211 has an 8-channel, 8-bit PWM timer. Each channel has a programmable period and duty
cycle as well as a dedicated counter . Each of the modulators can create independent continuous waveforms
with software-selectable duty rates from 0% to 100%. The timer supports PCM mode, which results in
superior signal quality when compared to that of a conventional PWM. The PWM outputs have
programmable polarity, and can be programmed as left aligned outputs or center aligned outputs. For
higher period and duty cycle resolution, each pair of adjacent channels ([7:6], [5:4], [3:2], and [1:0]) can
be concatenated to form a single 16-bit channel. The module can, therefore, be configured to support 8/0,
6/1, 4/2, 2/3, or 0/4 8-/16-bit channels.
1.2.16Software Watchdog Timer
The watchdog timer is a 32-bit timer that facilitates recovery from runaway code. The watchdog counter
is a free-running down-counter that generates a reset on underflow. To prevent a reset, software must
periodically restart the countdown.
The backup watchdog timer is an independent 16-bit timer that, like the software watchdog timer,
facilitates recovery from runaway code. This timer is a free-running down-counter that generates a reset
on underflow . T o prevent a reset, software must periodically restart the countdown. The backup watchdog
timer can be clocked by either the relaxation oscillator or the system clock.
1.2.18Phase-Locked Loop (PLL)
The clock module contains a crystal oscillator, 8 MHz on-chip relaxation oscillator (OCO), phase-locked
loop (PLL), reduced frequency divider (RFD), low-power divider status/control registers, and control
logic. To improve noise immunity, the PLL, crystal oscillator, and relaxation oscillator have their own
power supply inputs: VDDPLL and VSSPLL. All other circuits are powered by the normal supply pins,
VDD and VSS.
1.2.19Interrupt Controller (INTC)
The MCF52211 has a single interrupt controller that supports up to 63 interrupt sources. There are 56
programmable sources, 49 of which are assigned to unique peripheral interrupt requests. The remaining
seven sources are unassigned and may be used for software interrupt requests.
1.2.20DMA Controller
The direct memory access (DMA) controller provides an efficient way to move blocks of data with
minimal processor intervention. It has four channels that allow byte, word, longword, or 16-byte burst line
transfers. These transfers are triggered by software explicitly setting a DCRn[START] bit or by the
occurrence of certain UART or DMA timer events.
1.2.21Reset
The reset controller determines the source of reset, asserts the appropriate reset signals to the system, and
keeps track of what caused the last reset. There are seven sources of reset:
•External reset input
•Power-on reset (POR)
•Watchdog timer
•Phase locked-loop (PLL) loss of lock / loss of clock
•Software
•Low-voltage detector (LVD)
•JTAG
Control of the LVD and its associated reset and interrupt are managed by the reset controller. Other
registers provide status flags indicating the last source of reset and a control bit for software assertion of
the RSTO pin.
Nearly all pins on the MCF52211 have general purpose I/O capability and are grouped into 8-bit ports.
Some ports do not use all eight bits. Each port has registers that configure, monitor, and control the port
pins.
This chapter describes signals implemented on this device and includes an alphabetical listing of signals
that characterizes each signal as an input or output, defines its state at reset, and identifies whether a
pull-up resistor should be used.
NOTE
The terms assertion and negation are used to avoid confusion when dealing
with a mixture of active-low and active-high signals. The term asserted
indicates that a signal is active, independent of the voltage level. The term
negated indicates that a signal is inactive.
Active-low signals, such as SRAS and TA, are indicated with an overbar.
2.2Overview
Figure 2-1 shows the block diagram of the device with the signal interface.
The PDSR and PSSR registers are described in the General Purpose I/O chapter. All programmable signals default to 2 mA drive and FAST slew rate in
normal (single-chip) mode.
2
All signals have a pull-up in GPIO mode.
3
These signals are multiplexed on other pins.
4
For primary and GPIO functions only.
5
Only when JTAG mode is enabled.
6
CLKMOD0 and CLKMOD1 have internal pull-down resistors; however, the use of external resistors is very strongly recommended.
7
When these pins are configured for USB signals, they should use the USB transceiver’s internal pull-up/pull-down resistors (see the description of the
OTG_CTRL register). If these pins are not configured for USB signals, each pin should be pulled down externally using a 10 kΩ resistor.
8
For secondary and GPIO functions only.
9
RSTI has an internal pull-up resistor; however, the use of an external resistor is very strongly recommended.
10
For GPIO function. Primary Function has pull-up control within the GPT module.
The serial flash programming mode is entered by asserting the
RCON
pin (with the TEST pin negated) as the chip comes out of
reset. During this mode, the EzPort has access to the flash memory
which can be programmed from an external device.
should be connected to VSS to prevent unintentional activation of
test functions.
I
2-8Freescale Semiconductor
Table 2-5. Clocking Modes
CLKMOD[1:0]XTALConfigure the Clock Mode
000PLL disabled, clock driven by external oscillator
001PLL disabled, clock driven by on-chip oscillator
01N/APLL disabled, clock driven by crystal
100PLL in normal mode, clock driven by external oscillator
101PLL in normal mode, clock driven by on-chip oscillator
11N/APLL in normal mode, clock driven by crystal
2.7External Interrupt Signals
Table 2-6 describes the external interrupt signals.
Table 2-6. External Interrupt Signals
Signal NameAbbreviationFunctionI/O
External InterruptsIRQ[7:1]External interrupt sources. I
Signal Descriptions
2.8Queued Serial Peripheral Interface (QSPI)
Table 2-7 describes the QSPI signals.
Table 2-7. Queued Serial Peripheral Interface (QSPI) Signals
Signal NameAbbreviationFunctionI/O
QSPI Synchronous
Serial Output
QSPI Synchronous
Serial Data Input
QSPI Serial ClockQSPI_CLKProvides the serial clock from the QSPI. The polarity and phase of
Synchronous Peripheral
Chip Selects
QSPI_DOUT Provides the serial data from the QSPI and can be programmed to be
driven on the rising or falling edge of QSPI_CLK.
QSPI_DINProvides the serial data to the QSPI and can be programmed to be
sampled on the rising or falling edge of QSPI_CLK.
QSPI_CLK are programmable.
QSPI_CS[3:0] QSPI peripheral chip selects that can be programmed to be active
Table 2-8 describes the I2C serial interface module signals.
Table 2 -8. I2C I/O Signals
Signal NameAbbreviationFunctionI/O
Serial ClockSCLnOpen-drain clock signal for the for the I2C interface. It is driven by the
Serial DataSDAnOpen-drain signal that serves as the data input/output for the I2C
2
C module when the bus is in master mode or it becomes the clock
I
input when the I2C is in slave mode.
interface.
2.10UART Module Signals
Table 2-9 describes the UART module signals.
Table 2-9. UART Module Signals
Signal NameAbbreviationFunctionI/O
Transmit Serial Data OutputUTXDnTransmitter serial data outputs for the UART modules. The output is
held high (mark condition) when the transmitter is disabled, idle, or in
the local loopback mode. Data is shifted out, LSB first, on this pin at
the falling edge of the serial clock source.
Receive Serial Data InputURXDnReceiver serial data inputs for the UART modules. Data is received on
this pin LSB first. When the UART clock is stopped for power-down
mode, any transition on this pin restarts it.
Clear-to-SendUCTS
Request-to-SendURTSnAutomatic request-to-send outputs from the UART modules. This
nIndicate to the UART modules that they can begin data transmission.I
signal can also be configured to be asserted and negated as a
function of the RxFIFO level.
I/O
I/O
O
I
O
2.11DMA Timer Signals
Table 2-10 describes the signals of the four DMA timer modules.
Table 2-10. DMA Timer Signals
Signal NameAbbreviationFunctionI/O
DMA Timer InputDTINnEvent input to the DMA timer modules.I
DMA Timer OutputDTOUTnProgrammable output from the DMA timer modules.O
Test Data InputTDISerial input for test instructions and data. TDI is sampled on the rising
edge of TCLK.
Test Data OutputTDOSerial output for test instructions and data. TDO is three-stateable and
is actively driven in the shift-IR and shift-DR controller states. TDO
changes on the falling edge of TCLK.
Development Serial
Clock
DSCLKDevelopment Serial Clock. Internally synchronized input. (The logic
level on DSCLK is validated if it has the same value on two
consecutive rising bus clock edges.) Clocks the serial communication
port to the debug module during packet transfers. Maximum frequency
is PSTCLK/5. At the synchronized rising edge of DSCLK, the data
input on DSI is sampled and DSO changes state.
BreakpointBKPT
Breakpoint. Input used to request a manual breakpoint. Assertion of
puts the processor into a halted state after the current
BKPT
instruction completes. Halt status is reflected on processor status
signals as the value 0xF.
Development Serial
Input
DSIDevelopment Serial Input. Internally synchronized input that provides
data input for the serial communication port to the debug module after
the DSCLK has been seen as high (logic 1).
Development Serial
Output
DSODevelopment Serial Output. Provides serial output communication for
debug module responses. DSO is registered internally. The output is
delayed from the validation of DSCLK high.
Debug DataDDATA[3:0]Debug data. Displays captured processor data and breakpoint status.
The CLKOUT signal can be used by the development system to know
when to sample DDATA[3:0].
I
O
I
I
I
O
O
Processor Status ClockPSTCLKProcessor Status Clock. Delayed version of the processor clock. Its
rising edge appears in the center of valid PST and DDATA output.
PSTCLK indicates when the development system should sample PST
and DDATA values.
If real-time trace is not used, setting CSR[PCD] keeps PSTCLK, and
PST and DDATA outputs from toggling without disabling triggers.
Non-quiescent operation can be reenabled by clearing CSR[PCD],
although the external development systems must resynchronize with
the PST and DDATA outputs.
PSTCLK starts clocking only when the first non-zero PST value (0xC,
0xD, or 0xF) occurs during system reset exception processing.
Processor Status
Outputs
PST[3:0]Indicate core status. Debug mode timing is synchronous with the
processor clock; status is unrelated to the current bus transfer. The
CLKOUT signal can be used by the development system to know
when to sample PST[3:0].
Table 2-15 contains a list of EzPort external signals
Table 2-15. EzPort Signal Descriptions
Signal NameAbbreviationFunctionI/O
EzPort ClockEZPCKShift clock for EzPort transfersI
Signal Descriptions
EzPort Chip SelectEZPCSChip select for signaling the start and end of
serial transfers
EzPort Serial Data InEZPDEZPD is sampled on the rising edge of EZPCKI
EzPort Serial Data OutEZPQEZPQ transitions on the falling edge of EZPCKO
I
2.17Power and Ground Pins
The pins described in Table 2-16 provide system power and ground to the chip. Multiple pins are provided
for adequate current capability. All power supply pins must have adequate decoupling (bypass
capacitance) for high-frequency noise suppression.
Table 2-16. Power and Ground Pins
Signal NameAbbreviationFunctionI/O
PLL Analog SupplyVDDPLL,
VSSPLL
Positive SupplyVDDThese pins supply positive power to the core logic.I
GroundVSSThis pin is the negative supply (ground) to the chip.
Dedicated power supply signals to isolate the sensitive PLL analog
circuitry from the normal levels of noise present on the digital power
supply.
This section describes the organization of the Version 2 (V2) ColdFire® processor core and an overview
of the program-visible registers. For detailed information on instructions, see the ISA_A+ definition in the
ColdFire Family Programmer’s Reference Manual.
3.1.1Overview
As with all ColdFire cores, the V2 ColdFire core is comprised of two separate pipelines decoupled by an
instruction buffer.
The instruction fetch pipeline (IFP) is a two-stage pipeline for prefetching instructions. The prefetched
instruction stream is then gated into the two-stage operand execution pipeline (OEP), which decodes the
instruction, fetches the required operands and then executes the required function. Because the IFP and
OEP pipelines are decoupled by an instruction buffer serving as a FIFO queue, the IFP is able to prefetch
instructions in advance of their actual use by the OEP thereby minimizing time stalled waiting for
instructions.
The V2 ColdFire core pipeline stages include the following:
•Two-stage instruction fetch pipeline (IFP) (plus optional instruction buffer stage)
— Instruction address generation (IAG) — Calculates the next prefetch address
— Instruction fetch cycle (IC)—Initiates prefetch on the processor’s local bus
— Instruction buffer (IB) — Optional buffer stage minimizes fetch latency effects using FIFO
queue
•Two-stage operand execution pipeline (OEP)
— Decode and select/operand fetch cycle (DSOC)—Decodes instructions and fetches the
required components for effective address calculation, or the operand fetch cycle
— Address generation/execute cycle (AGEX)—Calculates operand address or executes the
instruction
When the instruction buffer is empty, opcodes are loaded directly from the IC cycle into the operand
execution pipeline. If the buffer is not empty, the IFP stores the contents of the fetched instruction in the
IB until it is required by the OEP.
For register-to-register and register-to-memory store operations, the instruction passes through both OEP
stages once. For memory-to-register and read-modify-write memory operations, an instruction is
effectively staged through the OEP twice: the first time to calculate the effective address and initiate the
operand fetch on the processor’s local bus, and the second time to complete the operand reference and
perform the required function defined by the instruction.
The resulting pipeline and local bus structure allow the V2 ColdFire core to deliver sustained high
performance across a variety of demanding embedded applications.
3.2Memory Map/Register Description
The following sections describe the processor registers in the user and supervisor programming models.
The programming model is selected based on the processor privilege level (user mode or supervisor mode)
as defined by the S bit of the status register (SR). Table 3-1 lists the processor registers.
The user-programming model consists of the following registers:
•Two 32-bit memory base address registers (RAMBAR, FLASHBAR)
The supervisor-programming model is intended to be used only by system control software to implement
restricted operating system functions, I/O control, and memory management. All accesses that affect the
control features of ColdFire processors are in the supervisor programming model, which consists of
registers available in user mode as well as the following control registers:
•16-bit status register (SR)
•32-bit supervisor stack pointer (SSP)
•32-bit vector base register (VBR)
Table 3-1. ColdFire Core Programming Model
1
BDM
Load: 0x080
Store: 0x180
Load: 0x081
Store: 0x181
Load: 0x082–7
Store: 0x182–7
Load: 0x088–8E
Store: 0x188–8E
Load: 0x08F
Store: 0x18F
0x804MAC Status Register (MACSR)8R/W0x00No4.2.1/4-2
Table 3-1. ColdFire Core Programming Model (continued)
1
BDM
0xC05RAM Base Address Register (RAMBAR)32R/WSee SectionYes3.2.8/3-8
1
The values listed in this column represent the Rc field used when accessing the core registers via the BDM port. For more
information see Chapter 28, “Debug Module”.
Register
Width
(bits)
AccessReset Value
Written with
MOVEC
Section/Page
3.2.1Data Registers (D0–D7)
D0–D7 data registers are for bit (1-bit), byte (8-bit), word (16-bit) and longword (32-bit) operations; they
can also be used as index registers.
NOTE
Registers D0 and D1 contain hardware configuration details after reset. See
Section 3.3.4.15, “Reset Exception” for more details.
These registers can be used as software stack pointers, index registers, or base address registers. They can
also be used for word and longword operations.
3.2.3Supervisor/User Stack Pointers (A7 and OTHER_A7)
This ColdFire architecture supports two independent stack pointer (A7) registers—the supervisor stack
pointer (SSP) and the user stack pointer (USP). The hardware implementation of these two
program-visible 32-bit registers does not identify one as the SSP and the other as the USP. Instead, the
hardware uses one 32-bit register as the active A7 and the other as OTHER_A7. Thus, the register contents
are a function of the processor operation mode, as shown in the following:
if SR[S] = 1
thenA7 = Supervisor Stack Pointer
OTHER_A7 = User Stack Pointer
elseA7 = User Stack Pointer
OTHER_A7 = Supervisor Stack Pointer
The BDM programming model supports direct reads and writes to A7 and OTHER_A7. It is the
responsibility of the external development system to determine, based on the setting of SR[S], the mapping
of A7 and OTHER_A7 to the two program-visible definitions (SSP and USP).
To support dual stack pointers, the following two supervisor instructions are included in the ColdFire
instruction set architecture to load/store the USP:
move.l Ay,USP;move to USP
move.l USP,Ax;move from USP
These instructions are described in the ColdFire Family Programmer’s Reference Manual. All other
instruction references to the stack pointer, explicit or implicit, access the active A7 register.
NOTE
The USP must be initialized using the move.l Ay,USP instruction before any
entry into user mode.
The SSP is loaded during reset exception processing with the contents of
location 0x0000_0000.
Figure 3-4. Stack Pointer Registers (A7 and OTHER_A7)
Address
Access: A7: User or BDM read/write
OTHER_A7: Supervisor or BDM read/write
3.2.4Condition Code Register (CCR)
The CCR is the LSB of the processor status register (SR). Bits 4–0 act as indicator flags for results
generated by processor operations. The extend bit (X) is also an input operand during multiprecision
arithmetic computations. The CCR register must be explicitly loaded after reset and before any compare
(CMP), Bcc, or Scc instructions are executed.
BDM: LSB of Status Register (SR)Access: User read/write
BDM read/write
76543210
R000
W
Reset:0 0 0 —————
XNZVC
Figure 3-5. Condition Code Register (CCR)
Table 3-2. CCR Field Descriptions
FieldDescription
7–5Reserved, must be cleared.
4
Extend condition code bit. Set to the C-bit value for arithmetic operations; otherwise not affected or set to a specified
X
result.
3
Negative condition code bit. Set if most significant bit of the result is set; otherwise cleared.
N
2
Zero condition code bit. Set if result equals zero; otherwise cleared.
Z
1
Overflow condition code bit. Set if an arithmetic overflow occurs implying the result cannot be represented in operand
V
size; otherwise cleared.
0
Carry condition code bit. Set if a carry out of the operand msb occurs for an addition or if a borrow occurs in a
C
subtraction; otherwise cleared.
3.2.5Program Counter (PC)
The PC contains the currently executing instruction address. During instruction execution and exception
processing, the processor automatically increments contents of the PC or places a new value in the PC, as
appropriate. The PC is a base address for PC-relative operand addressing.
The PC is initially loaded during reset exception processing with the contents of location 0x0000_0004.
The VBR contains the base address of the exception vector table in memory. To access the vector table,
the displacement of an exception vector is added to the value in VBR. The lower 20 bits of the VBR are
The SR stores the processor status and includes the CCR, the interrupt priority mask, and other control
bits. In supervisor mode, software can access the entire SR. In user mode, only the lower 8 bits (CCR) are
accessible. The control bits indicate the following states for the processor: trace mode (T bit), supervisor
or user mode (S bit), and master or interrupt state (M bit). All defined bits in the SR have read/write access
when in supervisor mode. The lower byte of the SR (the CCR) must be loaded explicitly after reset and
before any compare (CMP), Bcc, or Scc instructions execute.
BDM: 0x80E (SR)Access: Supervisor read/write
BDM read/write
System ByteCondition Code Register (CCR)
1514131211109876543210
R
W
Reset00100111000—————
0
T
SM
0
I
000
XNZVC
Figure 3-8. Status Register (SR)
Table 3-3. SR Field Descriptions
FieldDescription
15TTrace enable. When set, the processor performs a trace exception after every instruction.
14Reserved, must be cleared.
13SSupervisor/user state.
0User mode
1 Supervisor mode
12MMaster/interrupt state. Bit is cleared by an interrupt exception and software can set it during execution of the RTE or
3.2.8Memory Base Address Registers (RAMBAR, FLASHBAR)
The memory base address register sare used to specify the base address of the internal SRAM and flash
modules and indicate the types of references mapped to each. Each base address register includes a base
address, write-protect bit, address space mask bits, and an enable bit. FLASHBAR determines the base
address of the on-chip flash, and RAMBAR determines the base address of the on-chip RAM. For more
information, refer to Section 5.2.1, “SRAM Base Address Register (RAMBAR)” and Section 18.3.2,
“Flash Base Address Register (FLASHBAR)”.
IAGICIB
Core Bus
Address
Core Bus
Read Data
Opword
Extension 1
Extension 2
FIFO
IB
+4
Table 3-3. SR Field Descriptions (continued)
FieldDescription
10–8IInterrupt level mask. Defines current interrupt level. Interrupt requests are inhibited for all priority levels less than or
equal to current level, except edge-sensitive level 7 requests, which cannot be masked.
7–0
CCR
Refer to Section 3.2.4, “Condition Code Register (CCR)”.
3.3Functional Description
3.3.1Version 2 ColdFire Microarchitecture
From the block diagram in Figure 3-1, the non-Harvard architecture of the processor is readily apparent.
The processor interfaces to the local memory subsystem via a single 32-bit address and two unidirectional
32-bit data buses. This structure minimizes the core size without compromising performance to a large
degree.
A more detailed view of the hardware structure within the two pipelines is presented in Figure 3-9 and
Figure 3-10 below . In these diagrams, the internal structure of the instruction fetch and operand execution
pipelines is shown:
Figure 3-9. Version 2 ColdFire Processor Instruction Fetch Pipeline Diagram
Figure 3-10. Version 2 ColdFire Processor Operand Execution Pipeline Diagram
DSOCAGEX
Opword
Extension 1
Extension 2
Core Bus
Read Data
Core Bus
Address
Core Bus
Write Data
RGF
ColdFire Core
The instruction fetch pipeline prefetches instructions from local memory using a two-stage structure. For
sequential prefetches, the next instruction address is generated by adding four to the last prefetch address.
This function is performed during the IAG stage and the resulting prefetch address gated onto the core bus
(if there are no pending operand memory accesses which are assigned a higher priority). After the prefetch
address is driven onto the core bus, the instruction fetch cycle accesses the appropriate local memory and
returns the instruction read data back to the IFP during the cycle. If the accessed data is not present in a
local memory (e.g., an instruction cache miss, or an external access cycle is required), the IFP is stalled in
the IC stage until the referenced data is available. As the prefetch data arrives in the IFP, it can be loaded
into the FIFO instruction buffer or gated directly into the OEP.
The V2 design uses a simple static conditional branch prediction algorithm (forward-assumed as
not-taken, backward-assumed as taken), and all change-of-flow operations are calculated by the OEP and
the target instruction address fed back to the IFP.
The IFP and OEP are decoupled by the FIFO instruction buffer , allowing instruction prefetching to occur
with the available core bus bandwidth not used for operand memory accesses. For the V2 design, the
instruction buffer contains three 32-bit locations.
Consider the operation of the OEP for three basic classes of non-branch instructions:
For simple register-to-register instructions, the first stage of the OEP performs the instruction decode and
fetching of the required register operands (OC) from the dual-ported register file, while the actual
instruction execution is performed in the second stage (EX) in one of the execute engines (e.g., ALU,
barrel shifter, divider, EMAC). There are no operand memory accesses associated with this class of
instructions, and the execution time is typically a single machine cycle. See Figure 3-11.
Figure 3-11. V2 OEP Register-to-Register
For memory-to-register (embedded-load) instructions, the instruction is effectively staged through the
OEP twice with a basic execution time of three cycles. First, the instruction is decoded and the components
of the operand address (base register from the RGF and displacement) are selected (DS). Second, the
operand effective address is generated using the ALU execute engine (AG). Third, the memory read
operand is fetched from the core bus, while any required register operand is simultaneously fetched (OC)
from the RGF. Finally, in the fourth cycle, the instruction is executed (EX). The heavily-used 32-bit load
instruction (
move.l <mem>y,Rx) is optimized to support a two-cycle execution time. The following example
in Figure 3-12 shows an effective address of the form <ea> y = (d16,Ay), i.e., a 16-bit signed displacement
added to a base register Ay.
For register-to-memory (store) operations, the stage functions (DS/OC, AG/EX) are effectively performed
simultaneously allowing single-cycle execution. See Figure 3-14 where the effective address is of the form
<ea>x = (d16,Ax), i.e., a 16-bit signed displacement added to a base register Ax.
For read-modify-write instructions, the pipeline effectively combines an embedded-load with a store
operation for a three-cycle execution time.
Figure 3-14. V2 OEP Register-to-Memory
The pipeline timing diagrams of Figure 3-15 depict the execution templates for these three classes of
instructions. In these diagrams, the x-axis represents time, and the various instruction operations are shown
progressing down the operand execution pipeline.
The original ColdFire Instruction Set Architecture (ISA_A) was derived from the M68000 family opcodes
based on extensive analysis of embedded application code. The ISA was optimized for code compiled
from high-level languages where the dominant operand size was the 32-bit integer declaration. This
approach minimized processor complexity and cost, while providing excellent performance for compiled
applications.
After the initial ColdFire compilers were created, developers noted there were certain ISA additions that
would enhance code density and overall performance. Additionally , as users implemented ColdFire-based
designs into a wide range of embedded systems, they found certain frequently-used instruction sequences
that could be improved by the creation of additional instructions.
The original ISA definition minimized support for instructions referencing byte- and word-sized operands.
Full support for the move byte and move word instructions was provided, but the only other opcodes
supporting these data types are clr (clear) and tst (test). A set of instruction enhancements has been
implemented in subsequent ISA revisions, ISA_B and ISA_C. The new opcodes primarily addressed three
areas:
1. Enhanced support for byte and word-sized operands
2. Enhanced support for position-independent code
3. Miscellaneous instruction additions to address new functionality
Table 3-4 summarizes the instructions added to revision ISA_A to form revision ISA_A+. For more details
see the ColdFire Family Programmer’s Reference Manual.
Table 3-4. Instruction Enhancements over Revision ISA_A
InstructionDescription
BITREVThe contents of the destination data register are bit-reversed; that is, new Dn[31] equals old
Dn[0], new Dn[30] equals old Dn[1],..., new Dn[0] equals old Dn[31].
BYTEREVThe contents of the destination data register are byte-reversed; that is, new Dn[31:24] equals
old Dn[7:0],..., new Dn[7:0] equals old Dn[31:24].
FF1The data register, Dn, is scanned, beginning from the most-significant bit (Dn[31]) and ending
with the least-significant bit (Dn[0]), searching for the first set bit. The data register is then
loaded with the offset count from bit 31 where the first set bit appears.
Move from USP USP → Destination register
Move to USPSource register → USP
STLDSRPushes the contents of the status register onto the stack and then reloads the status register
with the immediate data value.
3.3.3Exception Processing Overview
Exception processing for ColdFire processors is streamlined for performance. The ColdFire processors
differ from the M68000 family because they include:
•A simplified exception vector table
•Reduced relocation capabilities using the vector-base register
•A single exception stack frame format
•Use of separate system stack pointers for user and supervisor modes.
All ColdFire processors use an instruction restart exception model. However, Version 2 ColdFire
processors require more software support to recover from certain access errors. See Section 3.3.4.1,
“Access Error Exception” for details.
Exception processing includes all actions from fault condition detection to the initiation of fetch for first
handler instruction. Exception processing is comprised of four major steps:
1. The processor makes an internal copy of the SR and then enters supervisor mode by setting the S
bit and disabling trace mode by clearing the T bit. The interrupt exception also forces the M bit to
be cleared and the interrupt priority mask to set to current interrupt request level.
2. The processor determines the exception vector number. For all faults except interrupts, the
processor performs this calculation based on exception type. For interrupts, the processor performs
an interrupt-acknowledge (IACK) bus cycle to obtain the vector number from the interrupt
controller. The IACK cycle is mapped to special locations within the interrupt controller’s address
space with the interrupt level encoded in the address.
3. The processor saves the current context by creating an exception stack frame on the system stack.
The exception stack frame is created at a 0-modulo-4 address on top of the system stack pointed to
by the supervisor stack pointer (SSP). As shown in Figure 3-16, the processor uses a simplified
fixed-length stack frame for all exceptions. The exception type determines whether the program
counter placed in the exception stack frame defines the location of the faulting instruction (fault)
or the address of the next instruction to be executed (next).
4. The processor calculates the address of the first instruction of the exception handler. By definition,
the exception vector table is aligned on a 1 Mbyte boundary . This inst ruction address is generated
by fetching an exception vector from the table located at the address defined in the vector base
register . The index into the exception table is calculated as (4 × vector number). After the exception
vector has been fetched, the vector contents determine the address of the first instruction of the
desired handler. After the instruction fetch for the first opcode of the handler has initiated,
exception processing terminates and normal instruction processing continues in the handler.
All ColdFire processors support a 1024-byte vector table aligned on any 1 Mbyte address boundary (see
Table 3-5). The table contains 256 exception vectors; the first 64 are defined for the core and the remaining
192 are device-specific peripheral interrupt vectors. See Chapter 14, “Interrupt Controller Module” for
details on the device-specific interrupt sources.
Fault refers to the PC of the instruction that caused the exception. Next refers to the PC
of the instruction that follows the instruction that caused the fault.
Vector
Offset (Hex)
Stacked
Program
Counter
Assignment
All ColdFire processors inhibit interrupt sampling during the first instruction of all exception handlers.
This allows any handler to disable interrupts effectively, if necessary, by raising the interrupt mask level
contained in the status register. In addition, the ISA_A+ architecture includes an instruction (STLDSR)
that stores the current interrupt mask level and loads a value into the SR. This instruction is specifically
intended for use as the first instruction of an interrupt service routine that services multiple interrupt
requests with different interrupt levels. For more details, see ColdFire Family Programmer’s Reference Manual.
3.3.3.1Exception Stack Frame Definition
Figure 3-16 shows exception stack frame. The first longword contains the 16-bit format/vector word (F/V)
and the 16-bit status register, and the second longword contains the 32-bit program counter address.
The 16-bit format/vector word contains three unique fields:
•A 4-bit format field at the top of the system stack is always written with a value of 4, 5, 6, or 7 by
the processor, indicating a two-longword frame format. See Table 3-6.
Table 3-6. Format Field Encodings
Original SSP @ Time
of Exception, Bits 1:0
00Original SSP - 80100
01Original SSP - 90101
10Original SSP - 100110
11Original SSP - 110111
SSP @ 1st
Instruction of
Handler
Format Field
•There is a 4-bit fault status field, FS[3:0], at the top of the system stack. This field is defined for
access and address errors only and written as zeros for all other exceptions. See Table 3-7.
•The 8-bit vector number, vector[7:0], defines the exception type and is calculated by the processor
for all internal faults and represents the value supplied by the interrupt controller in case of an
interrupt. See Table 3-5.
3.3.4Processor Exceptions
3.3.4.1Access Error Exception
The exact processor response to an access error depends on the memory reference being performed. For
an instruction fetch, the processor postpones the error reporting until the faulted reference is needed by an
instruction for execution. Therefore, faults during instruction prefetches followed by a change of
instruction flow do not generate an exception. When the processor attempts to execute an instruction with
a faulted opword and/or extension words, the access error is signaled and the instruction aborted. For this
type of exception, the programming model has not been altered by the instruction generating the access
error.
If the access error occurs on an operand read, the processor immediately aborts the current instruction’s
execution and initiates exception processing. In this situation, any address register updates attributable to
the auto-addressing modes, (for example, (An)+,-(An)), have already been performed, so the programming
model contains the updated An value. In addition, if an access error occurs during a MOVEM instruction
loading from memory, any registers already updated before the fault occurs contain the operands from
memory.
The V2 ColdFire processor uses an imprecise reporting mechanism for access errors on operand writes.
Because the actual write cycle may be decoupled from the processor’s issuing of the operation, the
signaling of an access error appears to be decoupled from the instruction that generated the write.
Accordingly , the PC contained in the exception stack fra me merely represents the location in the program
when the access error was signaled. All programming model updates associated with the write instruction
are completed. The NOP instruction can collect access errors for writes. This instruction delays its
execution until all previous operations, including all pending write operations, are complete. If any
previous write terminates with an access error, it is guaranteed to be reported on the NOP instruction.
3.3.4.2Address Error Exception
Any attempted execution transferring control to an odd instruction address (that is, if bit 0 of the target
address is set) results in an address error exception.
Any attempted use of a word-sized index register (Xn.w) or a scale factor of eight on an indexed effective
addressing mode generates an address error, as does an attempted execution of a full-format indexed
addressing mode, which is defined by bit 8 of extension word 1 being set.
If an address error occurs on a JSR instruction, the Version 2 ColdFire processor calculates the target
address then the return address is pushed onto the stack.If an address error occurs on an RTS instruction,
the Version 2 ColdFire processor overwrites the faulting return PC with the address error stack frame.
3.3.4.3Illegal Instruction Exception
The ColdFire variable-length instruction set architecture supports three instruction sizes: 16, 32, or 48 bits.
The first instruction word is known as the operation word (or opword), while the optional words are known
as extension word 1 and extension word 2. The opword is further subdivided into three sections: the upper
four bits segment the entire ISA into 16 instruction lines, the next 6 bits define the operation mode
(opmode), and the low-order 6 bits define the effective address. See Figure 3-17. The opword line
definition is shown in Table 3-8.
1514131211109876543210
LineOpModeEffective Address
ModeRegister
Figure 3-17. ColdFire Instruction Operation Word (Opword) Format
Table 3-8. ColdFire Opword Line Definition
Opword[Line]Instruction Class
0x0Bit manipulation, Arithmetic and Logical Immediate
0x1Move Byte
0x2Move Long
0x3Move Word
0x4Miscellaneous
0x5Add (ADDQ) and Subtract Quick (SUBQ), Set according to Condition Codes (Scc)
0x6PC-relative change-of-flow instructions
Conditional (Bcc) and unconditional (BRA) branches, subroutine calls (BSR)
0x7Move Quick (MOVEQ), Move with sign extension (MVS) and zero fill (MVZ)
In the original M68000 ISA definition, lines A and F were effectively reserved for user-defined operations
(line A) and co-processor instructions (line F). Accordingly, there are two unique exception vectors
associated with illegal opwords in these two lines.
Any attempted execution of an illegal 16-bit opcode (except for line-A and line-F opcodes) generates an
illegal instruction exception (vector 4). Additionally , any attempted execution of any non-MAC line-A and
most line-F opcodes generate their unique exception types, vector numbers 10 and 11, respectively.
ColdFire cores do not provide illegal instruction detection on the extension words on any instruction,
including MOVEC.
3.3.4.4Divide-By-Zero
Attempting to divide by zero causes an exception (vector 5, offset equal 0x014).
3.3.4.5Privilege Violation
The attempted execution of a supervisor mode instruction while in user mode generates a privilege
violation exception. See ColdFire Programmer’s Reference Manual for a list of supervisor-mode
instructions.
There is one special case involving the HALT instruction. Normally, this opcode is a supervisor mode
instruction, but if the debug module's CSR[UHE] is set, then this instruction can be also be executed in
user mode for debugging purposes.
3.3.4.6Trace Exception
To aid in program development, all ColdFire processors provide an instruction-by-instruction tracing
capability. While in trace mode, indicated by setting of the SR[T] bit, the completion of an instruction
execution (for all but the stop instruction) signals a trace exception. This functionality allows a debugger
to monitor program execution.
The stop instruction has the following effects:
1. The instruction before the stop executes and then generates a trace exception. In the exception stack
frame, the PC points to the stop opcode.
2. When the trace handler is exited, the stop instruction executes, loading the SR with the immediate
operand from the instruction.
3. The processor then generates a trace exception. The PC in the exception stack frame points to the
instruction after the stop, and the SR reflects the value loaded in the previous step.
If the processor is not in trace mode and executes a stop instruction where the immediate operand sets
SR[T], hardware loads the SR and generates a trace exception. The PC in the exception stack frame points
to the instruction after the stop, and the SR reflects the value loaded in step 2.
Because ColdFire processors do not support any hardware stacking of multiple exceptions, it is the
responsibility of the operating system to check for trace mode after processing other exception types. As
an example, consider a TRAP instruction execution while in trace mode. The processor initiates the trap
exception and then passes control to the corresponding handler . If the system requires that a trace exception
be processed, it is the responsibility of the trap exception handler to check for this condition (SR[T] in the
exception stack frame set) and pass control to the trace handler before returning from the original
exception.
3.3.4.7Unimplemented Line-A Opcode
A line-A opcode is defined when bits 15-12 of the opword are 0b1010. This exception is generated by the
attempted execution of an undefined line-A opcode.
3.3.4.8Unimplemented Line-F Opcode
A line-F opcode is defined when bits 15-12 of the opword are 0b1111. This exception is generated when
attempting to execute an undefined line-F opcode.
3.3.4.9Debug Interrupt
See Chapter 28, “Debug Module,” for a detailed explanation of this exception, which is generated in
response to a hardware breakpoint register trigger. The processor does not generate an IACK cycle, but
rather calculates the vector number internally (vector number 12). Additionally , SR[M,I] are unaffected by
the interrupt.
3.3.4.10RTE and Format Error Exception
When an RTE instruction is executed, the processor first examines the 4-bit format field to validate the
frame type. For a ColdFire core, any attempted R TE execution (where the format is not equal to {4,5,6,7})
generates a format error. The exception stack frame for the format error is created without disturbing the
original RTE frame and the stacked PC pointing to the RTE instruction.
The selection of the format value provides some limited debug support for porting code from M68000
applications. On M68000 family processors, the SR was located at the top of the stack. On those
processors, bit 30 of the longword addressed by the system stack pointer is typically zero. Thus, if an RTE
is attempted using this old format, it generates a format error on a ColdFire processor.
If the format field defines a valid type, the processor: (1) reloads the SR operand, (2) fetches the second
longword operand, (3) adjusts the stack pointer by adding the format value to the auto-incremented address
after the fetch of the first longword, and then (4) transfers control to the instruction address defined by the
second longword operand within the stack frame.
The TRAP #n instruction always forces an exception as part of its execution and is useful for implementing
system calls. The TRAP instruction may be used to change from user to supervisor mode.
3.3.4.12Unsupported Instruction Exception
If execution of a valid instruction is attempted but the required hardware is not present in the processor , an
unsupported instruction exception is generated. The instruction functionality can then be emulated in the
exception handler, if desired.
All ColdFire cores record the processor hardware configuration in the D0 register immediately after the
negation of RESET. See Section 3.3.4.15, “Reset Exception,” for details.
3.3.4.13Interrupt Exception
Interrupt exception processing includes interrupt recognition and the fetch of the appropriate vector from
the interrupt controller using an IACK cycle. See Chapter 14, “Interrupt Controller Module,” for details
on the interrupt controller.
3.3.4.14Fault-on-Fault Halt
If a ColdFire processor encounters any type of fault during the exception processing of another fault, the
processor immediately halts execution with the catastrophic fault-on-fault condition. A reset is required to
force the processor to exit this halted state.
3.3.4.15Reset Exception
Asserting the reset input signal (RESET) to the processor causes a reset exception. The reset exception has
the highest priority of any exception; it provides for system initialization and recovery from catastrophic
failure. Reset also aborts any processing in progress when the reset input is recognized. Processing cannot
be recovered.
The reset exception places the processor in the supervisor mode by setting the SR[S] bit and disables
tracing by clearing the SR[T] bit. This exception also clears the SR[M] bit and sets the processor’s SR[I]
bit to the highest level (level 7, 0b111). Next, the VBR is initialized to zero (0x0000_0000). The control
registers specifying the operation of any memories (e.g., cache and/or RAM modules) connected directly
to the processor are disabled.
NOTE
Other implementation-specific registers are also affected. Refer to each
module in this reference manual for details on these registers.
After the processor is granted the bus, it performs two longword read-bus cycles. The first longword at
address 0x0000_0000 is loaded into the supervisor stack pointer and the second longword at address
0x0000_0004 is loaded into the program counter. After the initial instruction is fetched from memory,
program execution begins at the address in the PC. If an access error or address error occurs before the first
instruction is executed, the processor enters the fault-on-fault state.
ColdFire processors load hardware configuration information into the D0 and D1 general-purpose
registers after system reset. The hardware configuration information is loaded immediately after the
reset-in signal is negated. This allows an emulator to read out the contents of these registers via the BDM
to determine the hardware configuration.
Information loaded into D0 defines the processor hardware configuration as shown in Figure 3-18.
BDM: Load: 0x080 (D0)
Store: 0x180 (D0)
31302928272625242322212019181716
RPFVERREV
W
Reset1100111100100000
1514131211109876543210
R MACDIVEMACFPUMMU000ISADEBUG
W
Reset1100000010001001
Access: User read-only
BDM read-only
Figure 3-18. D0 Hardware Configuration Info
Table 3-9. D0 Hardware Configuration Info Field Description
FieldDescription
31–24PFProcessor family. This field is fixed to a hex value of 0xCF indicating a ColdFire core is present.
23–20
VER
ColdFire core version number. Defines the hardware microarchitecture version of ColdFire core.
0001 V1 ColdFire core
0010 V2 ColdFire core (This is the value used for this device.)
0011 V3 ColdFire core
0100 V4 ColdFire core
0101 V5 ColdFire core
Else Reserved for future use.
19–16
REV
MAC
EMAC
FPU
3-22Freescale Semiconductor
Processor revision number. The default is 0b0000.
15
MAC present. This bit signals if the optional multiply-accumulate (MAC) execution engine is present in processor core.
0 MAC execute engine not present in core.
1 MAC execute engine is present in core. (This is the value used for this device.)
14
Divide present. This bit signals if the hardware divider (DIV) is present in the processor core.
DIV
0 Divide execute engine not present in core.
1 Divide execute engine is present in core. (This is the value used for this device.)
13
EMAC present. This bit signals if the optional enhanced multiply-accumulate (EMAC) execution engine is present in
processor core.
0 EMAC execute engine not present in core. (This is the value used for this device.)
1 EMAC execute engine is present in core.
12
FPU present. This bit signals if the optional floating-point (FPU) execution engine is present in processor core.
0 FPU execute engine not present in core. (This is the value used for this device.)
1 FPU execute engine is present in core.
Table 3-9. D0 Hardware Configuration Info Field Description (continued)
FieldDescription
11
MMU present. This bit signals if the optional virtual memory management unit (MMU) is present in processor core.
MMU
10–8Reserved.
DEBUG
0 MMU execute engine not present in core. (This is the value used for this device.)
1 MMU execute engine is present in core.
7–4
ISA revision. This 4-bit field defines the instruction-set architecture (ISA) revision level implemented in ColdFire
ISA
processor core.
0000 ISA_A
0001 ISA_B
0010 ISA_C
1000 ISA_A+ (This is the value used for this device.)
Else Reserved
3–0
Debug module revision number. This 4-bit field defines revision level of the debug module used in the ColdFire
processor core.
0000 DEBUG_A
0001 DEBUG_B
0010 DEBUG_C
0011 DEBUG_D
0100 DEBUG_E
1001 DEBUG_B+ (This is the value used for this device.)
1011 DEBUG_D+
Else Reserved
ColdFire Core
Information loaded into D1 defines the local memory hardware configuration as shown in the figure below .
Table 3-10. D1 Hardware Configuration Information Field Description
FieldDescription
31–30
CLSZ
29–28
CCAS
27–24
CCSZ
23–20
FLASHSZ
Cache line size. This field is fixed to a hex value of 0x0 indicating a 16-byte cache line size.
Configurable cache associativity.
00Four-way
01Direct mapped (This is the value used for this device)
Else Reserved for future use
Configurable cache size. Indicates the amount of instruction/data cache.The cache configuration options available
are 50% instruction/50% data, 100% instruction, or 100% data, and are specified in the CACR register.
0000 No configurable cache (This is the value used for this device)
0001 512B configurable cache
0010 1KB configurable cache
0011 2KB configurable cache
0100 4KB configurable cache
0101 8KB configurable cache
0110 16KB configurable cache
0111 32KB configurable cache
Else Reserved
Flash bank size.
0000-0111 No flash
1000 64-Kbyte flash
1001 128-Kbyte flash
1010 256-Kbyte flash (This is the value used for this device)
1011 512-Kbyte flash
Else Reserved for future use.
19–16Reserved
15–14
MBSZ
Bus size. Defines the width of the ColdFire master bus datapath.
0032-bit system bus datapath (This is the value used for this device)
0164-bit system bus datapath
Else Reserved
13–8Reserved, resets to 0b010000
7–4
SRAMSZ
SRAM bank size.
0000 No SRAM
0001 512 bytes
0010 1 Kbytes
0011 2 Kbytes
0100 4 Kbytes
0101 8 Kbytes
0110 16 Kbytes
0111 32 Kbytes (This is the value used for this device)
1000 64 Kbytes
1001 128 Kbytes
Else Reserved for future use
This section presents processor instruction execution times in terms of processor-core clock cycles. The
number of operand references for each instruction is enclosed in parentheses following the number of
processor clock cycles. Each timing entry is presented as C(R/W) where:
•C is the number of processor clock cycles, including all applicable operand fetches and writes, and
all internal core cycles required to complete the instruction execution.
•R/W is the number of operand reads (R) and writes (W) required by the instruction. An operation
performing a read-modify-write function is denoted as (1/1).
This section includes the assumptions concerning the timing values and the execution time details.
3.3.5.1Timing Assumptions
For the timing data presented in this section, these assumptions apply:
1. The OEP is loaded with the opword and all required extension words at the beginning of each
instruction execution. This implies that the OEP does not wait for the IFP to supply opwords and/or
extension words.
2. The OEP does not experience any sequence-related pipeline stalls. The most common example of
stall involves consecutive store operations, excluding the MOVEM instruction. For all STORE
operations (except MOVEM), certain hardware resources within the processor are marked as busy
for two clock cycles after the final decode and select/operand fetch cycle (DSOC) of the store
instruction. If a subsequent STORE instruction is encountered within this 2-cycle window, it is
stalled until the resource again becomes available. Thus, the maximum pipeline stall involving
consecutive STORE operations is two cycles. The MOVEM instruction uses a different set of
resources and this stall does not apply.
3. The OEP completes all memory accesses without any stall conditions caused by the memory itself.
Thus, the timing details provided in this section assume that an infinite zero-wait state memory is
attached to the processor core.
4. All operand data accesses are aligned on the same byte boundary as the operand size; for example,
16-bit operands aligned on 0-modulo-2 addresses, 32-bit operands aligned on 0-modulo-4
addresses.
The processor core decomposes misaligned operand references into a series of aligned accesses as
shown in Table 3-11.
Table 3-12 lists execution times for MOVE.{B,W} instructions; Table 3-13 lists timings for MOVE.L.
NOTE
For all tables in this section, the execution time of any instruction using the
PC-relative effective addressing modes is the same for the comparable
An-relative mode.
ET with {<ea> = (d16,PC)}equals ET with {<ea> = (d16,An)}
ET with {<ea> = (d8,PC,Xi*SF)}equals ET with {<ea> = (d8,An,Xi*SF)}
The nomenclature xxx.wl refers to both forms of absolute addressing, xxx.w
and xxx.l.
This chapter describes the functionality, microarchitecture, and performance of the multiply-accumulate
(MAC) unit in the ColdFire family of processors.
4.1.1Overview
The MAC design provides a set of DSP operations that can improve the performance of embedded code
while supporting the integer multiply instructions of baseline ColdFire architecture.
The MAC provides functionality in three related areas:
1. Signed and unsigned integer multiplication
2. Multiply-accumulate operations supporting signed and unsigned integer operands as well as
signed, fixed-point, fractional operands
3. Miscellaneous register operations
The MAC features a three-stage execution pipeline optimized for 16-bit operands, with a 16x16 multiply
array and a single 32-bit accumulator.
The three areas of functionality are addressed in detail in following sections. The logic required to support
this functionality is contained in a MAC module (Figure 4-1).
4.1.1.1Introduction to the MAC
The MAC is an extension of the basic multiplier in most microprocessors. It is typically implemented in
hardware within an architecture and supports rapid execution of signal processing algorithms in fewer
cycles than comparable non-MAC architectures. For example, small digital filters can tolerate some
variance in an algorithm’s execution time, but larger, more complicated algorithms such as orthogonal
transforms may have more demanding speed requirements beyond scope of any processor architecture and
may require full DSP implementation.
To balance among speed, size, and functionality, the ColdFire MAC is optimized for a small set of
operations that involve multiplication and cumulative additions. Specifically, the multiplier array is
optimized for single-cycle pipelined operations with a possible accumulation after product generation.
This functionality is common in many signal processing applications. The ColdFire core architecture is
also modified to allow an operand to be fetched in parallel with a multiply , increasing overall performance
for certain DSP operations.
Consider a typical filtering operation where the filter is defined as in Equation 4-1.
Eqn. 4-1
Here, the output y(i) is determined by past output values and past input values. This is the general form of
an infinite impulse response (IIR) filter. A finite impulse response (FIR) filter can be obtained by setting
coefficients a(k) to zero. In either case, the operations involved in computing such a filter are multiplies
and product summing. To show this point, reduce Equation 4-1 to a simple, four-tap FIR filter, shown in
Equation 4-2, in which the accumulated sum is a past data values and coefficients sum.
Eqn. 4-2
4.2Memory Map/Register Definition
The following table and sections explain the MAC registers:
Table 4-1. MAC Memory Map
1
BDM
0x804MAC Status Register (MACSR)32R/W0x0000_00004.2.1/4-2
The values listed in this column represent the Rc field used when accessing the core registers via the BDM port. For more
information see Chapter 28, “Debug Module.”
Register
4.2.1MAC Status Register (MACSR)
The MAC status register (MACSR) contains a 4-bit operational mode field and condition flags.
Operational mode bits control whether operands are signed or unsigned and whether they are treated as
integers or fractions. These bits also control the overflow/saturation mode and the way in which rounding
is performed. Negative, zero, and overflow condition flags are also provided.
Overflow saturation mode. Enables or disables saturation mode on overflow. If set, the accumulator is set
to the appropriate constant on any operation that overflows the accumulator. After saturation, the
accumulator remains unaffected by any other MAC or MSAC instructions until the overflow bit is cleared or
the accumulator is directly loaded.
Signed/unsigned operations.
In integer mode:
S/U determines whether operations performed are signed or unsigned. It also determines the accumulator
value during saturation, if enabled.
0 Signed numbers. On overflow, if OMC is enabled, the accumulator saturates to the most positive
(0x7FFF_FFFF) or the most negative (0x8000_0000) number, depending on the instruction and the
product value that overflowed.
1 Unsigned numbers. On overflow, if OMC is enabled, the accumulator saturates to the smallest value
(0x0000_0000) or the largest value (0xFFFF_FFFF), depending on the instruction.
In fractional mode:
S/U controls rounding while storing the accumulator to a general-purpose register.
0 Move accumulator without rounding to a 16-bit value. Accumulator is moved to a general-purpose
register as a 32-bit value.
1 The accumulator is rounded to a 16-bit value using the round-to-nearest (even) method when moved to
a general-purpose register. See Section 4.3.1.1, “Rounding”. The resulting 16-bit value is stored in the
lower word of the destination register. The upper word is zero-filled. This rounding procedure does not
affect the accumulator value.
Fractional/integer mode. Determines whether input operands are treated as fractions or integers.
0 Integers can be represented in signed or unsigned notation, depending on the value of S/U.
1 Fractions are represented in signed, fixed-point, two’s complement notation. Values range from -1 to
-15
for 16-bit fractions and -1 to 1 - 2
1-2
-31
for 32-bit fractions. See Section 4.3.4, “Data
Representation."
4
R/T
Round/truncate mode. Controls rounding procedure for MSAC.L instructions when in fractional mode.
0 Truncate. The product’s lsbs are dropped before it is combined with the accumulator.
1 Round-to-nearest (even). The 64-bit product of two 32-bit, fractional operands is rounded to the nearest
32-bit value. If the low-order 32 bits equal 0x8000_0000, the upper 32 bits are rounded to the nearest
even (lsb = 0) value. See Section 4.3.1.1, “Rounding”.
3
N
2
Z
Negative. Set if the msb of the result is set, otherwise cleared. N is affected only by MAC, MSAC, and load
operations; it is not affected by MULS and MULU instructions.
Zero. Set if the result equals zero, otherwise cleared. This bit is affected only by MAC, MSAC, and load
operations; it is not affected by MULS and MULU instructions.
Overflow. Set if an arithmetic overflow occurs, implying that the result cannot be represented in the operand
size. After set, V remains set until the accumulator register is loaded with a new value or MACSR is directly
loaded. MULS and MULU instructions do not change this value.
Table 4-3 summarizes the interaction of the MACSR[S/U,F/I,R/T] control bits.
Table 4-3. Summary of S/U, F/I, and R/T Control Bits
S/UF/IR/TOperational Modes
00xSigned, integer
010Signed, fractional
Truncate on MAC.L and MSAC.L
No round on accumulator stores
011Signed, fractional
Round on MAC.L and MSAC.L
No round on accumulator stores
10xUnsigned, integer
110Signed, fractional
Truncate on MAC.L and MSAC.L
Round-to-16-bits on accumulator stores
111Signed, fractional
Round on MAC.L and MSAC.L
Round-to-16-bits on accumulator stores
4.2.2Mask Register (MASK)
The 32-bit MASK implements the low-order 16 bits to minimize the alignment complications involved
with loading and storing only 16 bits. When the MASK is loaded, the low-order 16 bits of the source
operand are actually loaded into the register. When it is stored, the upper 16 bits are all forced to ones.
This register performs a simple AND with the operand address for MAC instructions. That is, the
processor calculates the normal operand address and, if enabled, that address is then ANDed with
{0xFFFF , MASK[15:0]} to form the final address. Therefore, with certain MASK bits cleared, the operand
address can be constrained to a certain memory region. This is used primarily to implement circular queues
with the (An)+ addressing mode.
This minimizes the addressing support required for filtering, convolution, or any routine that implements
a data array as a circular queue. For MAC + MOVE operations, the MASK contents can optionally be
included in all memory effective address calculations. The syntax is as follows:
mac.sz Ry,RxSF,<ea>y&,Rw
The & operator enables the MASK use and causes bit 5 of the extension word to be set. The exact
algorithm for the use of MASK is:
if extension word, bit [5] = 1, the MASK bit, then
if <ea> = (An)
oa = An & {0xFFFF, MASK}
if <ea> = (An)+
oa = An
An = (An + 4) & {0xFFFF, MASK}
if <ea> =-(An)
oa = (An - 4) & {0xFFFF, MASK}
An = (An - 4) & {0xFFFF, MASK}
if <ea> = (d16,An)
oa = (An + se_d16) & {0xFFFF0x, MASK}
Here, oa is the calculated operand address and se_d16 is a sign-extended 16-bit displacement. For
auto-addressing modes of post-increment and pre-decrement, the updated An value calculation is also
shown.
Use of the post-increment addressing mode, {(An)+} with the MASK is suggested for circular queue
implementations.
The MAC speeds execution of ColdFire integer-multiply instructions (MULS and MULU) and provides
additional functionality for multiply-accumulate operations. By executing MULS and MULU in the MAC,
execution times are minimized and deterministic compared to the 2-bit/cycle algorithm with early
termination that the OEP normally uses if no MAC hardware is present.
The added MAC instructions to the ColdFire ISA provide for the multiplication of two numbers, followed
by the addition or subtraction of the product to or from the value in the accumulator. Optionally, the
product may be shifted left or right by 1 bit before addition or subtraction. Hardware support for saturation
arithmetic can be enabled to minimize software overhead when dealing with potential overflow conditions.
Multiply-accumulate operations support 16- or 32-bit input operands these formats:
•Signed integers
•Unsigned integers
•Signed, fixed-point, fractional numbers
The MAC is optimized for 16-bit multiplications to keep the area consumption low. Two 16-bit operands
produce a 32-bit product. Longword operations are performed by reusing the 16-bit multiplier array at the
expense of a small amount of extra control logic. Again, the product of two 32-bit operands is a 32-bit
result. For longword integer operations, only the least significant 32 bits of the product are calculated. For
fractional operations, the entire 64-bit product is calculated and then truncated or rounded to a 32-bit result
using the round-to-nearest (even) method.
Because the multiplier array is implemented in a three-stage pipeline, MAC instructions have an effective
issue rate of 1 cycle for word operations, 3 cycles for longword integer operations, and 4 cycles for 32-bit
fractional operations.
All arithmetic operations use register-based input operands, and summed values are stored in the
accumulator. Therefore, an additional MOVE instruction is needed to store data in a general-purpose
register.
The need to move large amounts of data presents an obstacle to obtaining high throughput rates in DSP
engines. New and existing ColdFire instructions can accommodate these requirements. A MOVEM
instruction can efficiently move large data blocks by generating line-sized burst references. The ability to
load an operand simultaneously from memory into a register and execute a MAC instruction makes some
DSP operations such as filtering and convolution more manageable.
The programming model includes a mask register (MASK), which can optionally be used to generate an
operand address during MAC + MOVE instructions. The register application with auto-increment
addressing mode supports efficient implementation of circular data queues for memory operands.
This section describes behavior when the fractional mode is used (MACSR[F/I] is set).
4.3.1.1Rounding
When the processor is in fractional mode, there are two operations during which rounding can occur:
1. The 32-bit accumulator is moved into a general purpose register. If MACSR[S/U] is cleared, the
accumulator is stored as is in the destination register; if it is set, the 32-bit value is rounded to a
16-bit value using the round-to-nearest (even) method. The resulting 16-bit number is stored in the
lower word of the destination register. The upper word is zero-filled. The accumulator value is
unaffected by this rounding procedure.
2. Execution of a MAC (or MSAC) instruction with 32-bit operands. If MACSR[R/T] is zero,
multiplying two 32-bit numbers creates a 64-bit product truncated to the upper 32 bits; otherwise,
it is rounded using round-to-nearest (even) method.
T o understand the round-to-nearest-even method, consider the following example involving the rounding
of a 32-bit number, R0, to a 16-bit number. Using this method, the 32-bit number is rounded to the closest
16-bit number possible. Let the high-order 16 bits of R0 be named R0.U and the low-order 16 bits be R0.L.
•If R0.L is less than 0x8000, the result is truncated to the value of R0.U.
•If R0.L is greater than 0x8000, the upper word is incremented (rounded up).
•If R0.L is 0x8000, R0 is half-way between two 16-bit numbers. In this case, rounding is based on
the lsb of R0.U, so the result is always even (lsb = 0).
— If the lsb of R0.U equals 1 and R0.L equals 0x8000, the number is rounded up.
— If the lsb of R0.U equals 0 and R0.L equals 0x8000, the number is rounded down.
This method minimizes rounding bias and creates as statistically correct an answer as possible.
The rounding algorithm is summarized in the following pseudocode:
if R0.L < 0x8000
then Result = R0.U
else if R0.L > 0x8000
then Result = R0.U + 1
else if lsb of R0.U = 0 /* R0.L = 0x8000 */
then Result = R0.U
else Result = R0.U + 1
The round-to-nearest-even technique is also known as convergent rounding.
4.3.1.2Saving and Restoring the MAC Programming Model
The presence of rounding logic in the MAC output datapath requires that special care during the MAC’s
save/restore process. In particular, any result rounding modes must be disabled during the save/restore
process so the exact bit-wise contents of the MAC registers are accessed. Consider the memory structure
containing the MAC programming model:
The following assembly language routine shows the proper sequence for a correct MAC state save. This
code assumes all Dn and An registers are available for use, and the memory location of the state save is
defined by A7.
MAC_state_save:
move.l macsr,d7; save the macsr
clr.l d0; zero the register to ...
move.l d0,macsr; disable rounding in the macsr
move.l acc,d5; save the accumulator
move.l mask,d6; save the address mask
movem.l #0x00e0,(a7); move the state to memory
This code performs the MAC state restore:
MAC_state_restore:
movem.l (a7),#0x00e0; restore the state from memory
move.l #0,macsr; disable rounding in the macsr
move.l d5,acc; restore the accumulator
move.l d6,mask; restore the address mask
move.l d7,macsr; restore the macsr
Executing this sequence type can correctly save and restore the exact state of the MAC programming
model.
4.3.1.3MULS/MULU
MULS and MULU are unaffected by fractional-mode operation; operands remain assumed to be integers.
4.3.1.4Scale Factor in MAC or MSAC Instructions
The scale factor is ignored while the MAC is in fractional mode.
4.3.2MAC Instruction Set Summary
Table 4-6 summarizes MAC unit instructions.
Table 4-6. MAC Instruction Summary
CommandMnemonicDescription
Multiply Signedmuls <ea>y,DxMultiplies two signed operands yielding a signed result
Multiply Unsignedmulu <ea>y,DxMultiplies two unsigned operands yielding an unsigned result
Multiply Accumulatemac Ry,RxSF
msac Ry,RxSF
Multiply Accumulate
with Load
mac Ry,RxSF,Rw
msac Ry,RxSF,Rw
Multiplies two operands, then adds/subtracts the product
to/from the accumulator
Multiplies two operands, combines the product to the
accumulator while loading a register with the memory
operand
Load Accumulatormove.l {Ry,#imm},ACCLoads the accumulator with a 32-bit operand
Store Accumulatormove.l ACC,RxWrites the contents of the accumulator to a CPU register
Load MACSRmove.l {Ry,#imm},MACSRWrites a value to MACSR
Store MACSRmove.l MACSR,RxWrite the contents of MACSR to a CPU register
Store MACSR to CCRmove.l MACSR,CCRWrite the contents of MACSR to the CCR
Load MAC Mask Regmove.l {Ry,#imm},MASKWrites a value to the MASK register
Store MAC Mask Regmove.l MASK,RxWrites the contents of the MASK to a CPU register
4.3.3MAC Instruction Execution Times
The instruction execution times for the MAC can be found in Section 3.3.5.6, “MAC Instruction Execution
Times”.
4.3.4Data Representation
MACSR[S/U,F/I] selects one of the following three modes, where each mode defines a unique operand
type:
1. Two’s complement signed integer: In this format, an N-bit operand value lies in the range -2
< operand < 2
(N-1)
- 1. The binary point is right of the lsb.
2. Unsigned integer: In this format, an N-bit operand value lies in the range 0 < operand < 2N - 1. The
binary point is right of the lsb.
(N-1)
3. T wo’s complement, signed fractional: In an N-bit number , the first bit is the sign bit. The remaining
bits signify the first N-1 bits after the binary point. Given an N-bit number , a
N-1aN-2aN-3
... a2a1a0,
its value is given by the equation in Equation 4-3.
Eqn. 4-3
This format can represent numbers in the range -1 < operand < 1-2
(N-1)
.
For words and longwords, the largest negative number that can be represented is -1, whose internal
representation is 0x8000 and 0x8000_0000, respectively . The largest positive word is 0x7FFF or (1 - 2
-31
the most positive longword is 0x7FFF_FFFF or (1 - 2
).
4.3.5MAC Opcodes
MAC opcodes are described in the ColdFire Programmer’s Reference Manual.
Remember the following:
•Unless otherwise noted, the value of MACSR[N,Z] is based on the result of the final operation that
involves the product and the accumulator.
•The overflow (V) flag is managed differently . It is set if the complete product cannot be represented
as a 32-bit value (this applies to 32 × 32 integer operations only) or if the combination of the
product with the accumulator cannot be represented in the given number of bits. This indicator is
treated as a sticky flag, meaning after set, it remains set until the accumulator or the MACSR is
directly loaded. See Section 4.2.1, “MAC Status Register (MACSR)”.
•The optional 1-bit shift of the product is specified using the notation {<< | >>} SF, where <<1
indicates a left shift and >>1 indicates a right shift. The shift is performed before the product is
added to or subtracted from the accumulator. W ithout this operator , the product is not shifted. If the
MAC is in fractional mode (MACSR[F/I] is set), SF is ignored and no shift is performed. Because
a product can overflow, the following guidelines are implemented:
— For unsigned word and longword operations, a zero is shifted into the product on right shifts.
— For signed, word operations, the sign bit is shifted into the product on right shifts unless the
product is zero. For signed, longword operations, the sign bit is shifted into the product unless
an overflow occurs or the product is zero, in which case a zero is shifted in.
— For all left shifts, a zero is inserted into the lsb position.
The following pseudocode explains basic MAC or MSAC instruction functionality. This example is
presented as a case statement covering the three basic operating modes with signed integers, unsigned
integers, and signed fractionals. Throughout this example, a comma-separated list in curly brackets, {},
indicates a concatenation operation.
switch (MACSR[6:5])/* MACSR[S/U, F/I] */
{
case 0:/* signed integers */
if (MACSR.OMC == 0 || MACSR.V == 0)
then {
MACSR.V = 0
/* select the input operands */
if (sz == word)
This chapter describes the on-chip static RAM (SRAM) implementation, including general operations,
configuration, and initialization. It also provides information and examples showing how to minimize
power consumption when using the SRAM.
5.1.1Overview
The SRAM module provides a general-purpose memory block that the ColdFire processor can access in a
single cycle. The location of the memory block can be specified to any 0-modulo-16K address. The
memory is ideal for storing critical code or data structures or for use as the system stack. Because the
SRAM module is physically connected to the processor's high-speed local bus, it can service
processor-initiated accesses or memory-referencing commands from the debug module.
The SRAM is dual-ported to provide access. The SRAM is partitioned into two physical memory arrays
to allow simultaneous access to arrays by the processor core and another bus master . For more information
see Chapter 12, “System Control Module (SCM).”
5.1.2Features
The major features includes:
•One 16 Kbyte SRAM
•Single-cycle access
•Physically located on the processor's high-speed local bus
•Memory location programmable on any 0-modulo-16 Kbyte address
•Byte, word, and longword address capabilities
5.2Memory Map/Register Description
The SRAM programming model shown in Table 5-1 includes a description of the SRAM base address
register (RAMBAR), SRAM initialization, and power management.
The values listed in this column represent the Rc field used when accessing the core registers via the BDM port. For more
information see Chapter 28, “Debug Module.”
1
0xC05RAM Base Address Register (RAMBAR)32R/WSee SectionYes5.2.1/5-2
Register
Supervisor Access Only Registers
Width
(bits)
AccessReset Value
Written
w/ MOVEC
Section/Page
5.2.1SRAM Base Address Register (RAMBAR)
The configuration information in the SRAM base-address register (RAMBAR) controls the operation of
the SRAM module.
•The RAMBAR holds the SRAM base address. The MOVEC instruction provides write-only access
to this register.
•The RAMBAR can be read or written from the debug module.
•All undefined bits in the register are reserved. These bits are ignored during writes to the
RAMBAR and return zeroes when read from the debug module.
•A reset clears the RAMBAR’s valid bit. This invalidates the processor port to the SRAM (The
RAMBAR must be initialized before the core can access the SRAM.) All other bits are unaffected.
The RAMBAR contains several control fields. These fields are shown in Figure 5-1.
Priority Bit. PRIU determines if DMA or CPU has priority in the upper 16K bank of memory. PRIL determines
if DMA or CPU has priority in the lower 16K bank of memory. If a bit is set, the CPU has priority. If a bit is
cleared, DMA has priority. Priority is determined according to the following table:
Note: The recommended setting (maximum performance) for the priority bits is 00.
Secondary port valid. Allows access by DMA.
0 DMA access to memory is disabled.
1 DMA access to memory is enabled.
Note: The SPV bit in the second RAMBAR register must also be set to allow dual port access to the SRAM.
For more information, see Section 12.5.2, “Memory Base Address Register (RAMBAR).”
Write Protect. Allows only read accesses to the SRAM. When this bit is set, any attempted write access
from the core generates an access error exception to the ColdFire processor core.
0 Allows core read and write accesses to the SRAM module
1 Allows only core read accesses to the SRAM module
Note: This bit does not affect non-core write accesses.
Address Space Masks (ASn). These five bit fields allow types of accesses to be masked or inhibited from
accessing the SRAM module. The address space mask bits are:
C/I = CPU space/interrupt acknowledge cycle mask
SC = Supervisor code address space mask
SD = Supervisor data address space mask
UC = User code address space mask
UD = User data address space mask
For each address space bit:
0 An access to the SRAM module can occur for this address space
1 Disable this address space from the SRAM module. If a reference using this address space is made, it
is inhibited from accessing the SRAM module and is processed like any other non-SRAM reference.
These bits are useful for power management as detailed in Section 5.3.2, “Power Management.” In most
applications, the C/I bit is set
0
V
Valid. When set, this bit enables the SRAM module; otherwise, the module is disabled. A hardware reset
clears this bit.
0 Contents of RAMBAR are not valid
1 Contents of RAMBAR are valid
5.3Initialization/Application Information
After a hardware reset, the SRAM module contents are undefined. The valid bit of the RAMBAR is
cleared, disabling the processor port into the memory . If the SRAM requires initialization with instructions
or data, perform the following steps:
1. Load the RAMBAR, mapping the SRAM module to the desired location within the address space.
2. Read the source data and write it to the SRAM. Various instructions support this function,
including memory-to-memory move instructions, or the MOVEM opcode. The MOVEM
instruction is optimized to generate line-sized burst fetches on 0-modulo-16 addresses, so this
opcode generally provides maximum performance.
3. After the data loads into the SRAM, it may be appropriate to load a revised value into the
RAMBAR with a new set of attributes. These attributes consist of the write-protect and address
space mask fields.
The ColdFire processor or an external debugger using the debug module can perform these initialization
functions.
5.3.1SRAM Initialization Code
The following code segment describes how to initialize the SRAM. The code sets the base address of the
SRAM at 0x2000_0000 and initializes the SRAM to zeros.
RAMBASE EQU 0x20000000 ;set this variable to 0x20000000
RAMVALID EQU 0x00000001
move.l #RAMBASE+RAMVALID,D0;load RAMBASE + valid bit into D0.
movec.l D0, RAMBAR;load RAMBAR and enable SRAM
The following loop initializes the entire SRAM to zero:
lea.l RAMBASE,A0;load pointer to SRAM
move.l#8192,D0;load loop counter into D0 (SRAM size/4)
SRAM_INIT_LOOP:
clr.l (A0)+ ;clear 4 bytes of SRAM
clr.l (A0)+ ;clear 4 bytes of SRAM
clr.l (A0)+ ;clear 4 bytes of SRAM
clr.l (A0)+ ;clear 4 bytes of SRAM
subq.l #4,D0;decrement loop counter
bne.b SRAM_INIT_LOOP;if done, then exit; else continue looping
5.3.2Power Management
If the SRAM is used only for data operands, setting the ASn bits associated with instruction fetches can
decrease power dissipation. Additionally, if the SRAM contains only instructions, masking operand
accesses can reduce power dissipation. Table 5-3 shows examples of typical RAMBAR settings.
The clock module allows the device to be configured for one of several clocking methods. Clocking modes
include internal phase-locked loop (PLL) clocking with an external clock reference or an external crystal
reference supported by an internal crystal amplifier. The PLL can also be disabled and an external
oscillator can be used to clock the device directly. The clock module contains the following:
•Crystal amplifier and oscillator (OSC)
•Phase-locked loop (PLL)
•Reduced frequency divider (RFD)
•Status and control registers
•Control logic
•Real-time clock (RTC) oscillator
6.2Features
Features of the clock module include the following:
•1- to 48-MHz crystal, 8-MHz on-chip relaxation oscillator , or e xternal oscillator reference options
•2- to 10-MHz reference crystal oscillator for normal PLL mode
•External RTC/backup oscillator (nominal frequency 32.768 kHz)
•System can be clocked from PLL or directly from crystal oscillator or relaxation oscillator
•Support for low-power modes
•Separate clock out signal
n
(0 ≤ n ≤ 15) low-power divider for extremely low frequency operation
•2
6.3Modes of Operation
The clock module can be operated in backup watchdog timer mode, RTC mode, normal PLL mode
(default), 1:1 PLL mode, or external clock mode (PLL disabled).
6.3.1Backup Watchdog Timer Mode
In this mode, the backup watchdog timer is disabled after POR (power on reset), and the clock input to this
timer is the system clock. The selection of the clock source for the secondary watchdog timer module can
occur only once per POR. Thus, if the relaxation oscillator is selected as the timer’s input source,
subsequent attempts to select the relaxation oscillator as the system clock’s source are blocked until the
next POR. If the relaxation oscillator was already selected as the system clock’ s source and is subsequently
selected as the timer’s input source, the system and the timer can use the oscillator as the source.
6.3.2RTC Mode
A dedicated R TC oscillator can be selected to run the RTC circuitry. In normal operation, this oscillator is
powered by the VDDPLL and VSSPLL pins. When the part is shut down, this oscillator is powered by the
VSTBY pin. The nominal expected frequency for the RTC oscillator is 32.768 kHz, but can range from
32 kHz to 38.4 kHz.
6.3.3Normal PLL Mode
In normal PLL mode, the PLL is fully programmable. It can synthesize frequencies ranging from 1x to 18x
the reference frequency and has a post divider capable of reducing this synthesized frequency without
disturbing the PLL. The PLL reference can be a crystal oscillator or an external clock.
6.3.41:1 PLL Mode
In 1:1 PLL mode, the PLL synthesizes a frequency equal to the external clock input reference frequency.
The post divider is not active.
6.3.5External Clock Mode
In external clock mode, the PLL is bypassed, and the external clock is applied to EXTAL. The resulting
operating frequency is equal to the external clock frequency.
6.4Low-Power Mode Operation
This subsection describes the operation of the clock module in low-power and halted modes of operation.
Low-power modes are described in Chapter 8, “Power Management.”Table 6-1 shows the clock module
operation in low-power modes.
Table 6-1. Clock Module Operation in Low-power Modes
Low-power ModeClock OperationMode Exit
WaitClocks sent to peripheral modules onlyExit not caused by clock module, but normal
clocking resumes upon mode exit
DozeClocks sent to peripheral modules onlyExit not caused by clock module, but normal
clocking resumes upon mode exit
StopAll system clocks disabledExit not caused by clock module, but clock
sources are re-enabled and normal clocking
resumes upon mode exit
HaltedNormalExit not caused by clock module
In wait and doze modes, the system clocks to the peripherals are enabled and the clocks to the CPU and
SRAM are stopped. Each module can disable its clock locally at the module level.
In stop mode, all system clocks are disabled. There are several options for enabling or disabling the PLL
or crystal oscillator in stop mode, compromising between stop mode current and wakeup recovery time.
The PLL can be disabled in stop mode, but requires a wakeup period before it can relock. The oscillator
can also be disabled during stop mode, but requires a wakeup period to restart.
When the PLL is enabled in stop mode (STPMD[1:0]), the external CLKOUT signal can support systems
using CLKOUT as the clock source.
There is also a fast wakeup option for quickly enabling the system clocks during stop recovery. This
eliminates the wakeup recovery time but at the risk of sending a potentially unstable clock to the system.
To prevent a non-locked PLL frequency overshoot when using the fast wakeup option, change the RFD
divisor to the current RFD value plus one before entering stop mode.
In external clock mode, there are no wakeup periods for oscillator startup or PLL lock.
6.5Block Diagram
Figure 6-1 shows a block diagram of the entire clock module.
The clock module signals are summarized in Table 6-2 and a brief description follows. For more detailed
information, refer to Chapter 2, “Signal Descriptions.”
Table 6-2. Signal Properties
NameFunction
EXTALOscillator or clock input
XTALOscillator output
CLKOUTSystem clock output
CLKMOD[1:0]Clock mode select inputs
RSTO
Reset signal from reset controller
6.6.1EXTAL
This input is driven by an external clock except when used as a connection to the external crystal when
using the internal oscillator.
6.6.2XTAL
This output is an internal oscillator connection to the external crystal. If CLKMOD0 is driven low during
reset, XTAL is sampled to determine clocking mode.
6.6.3CLKOUT
This output reflects the internal system clock.
6.6.4CLKMOD[1:0]
These inputs are used to select the clock mode during chip configuration as described in Table 6-3.
Table 6-3. Clocking Modes
CLKMOD[1:0]XTALClocking Mode
000PLL disabled, clock driven by external oscillator
001PLL disabled, clock driven by on-chip oscillator
01N/APLL disabled, clock driven by external crystal
100PLL in normal mode, clock driven by external oscillator
101PLL in normal mode, clock driven by on-chip oscillator
11N/APLL in normal mode, clock driven by external crystal
•FRCRSTOUT bit in the reset control status register (RCR); see Section 10.5.1, “Reset Control
Register (RCR).”
6.7Memory Map and Registers
The clock module programming model shown in Table 6-4 consists of registers that define clock operation
and status as well as additional peripheral power management registers.
Table 6-4. Clock Module Memory Map
IPSBAR
1
Offset
0x12_0000Synthesizer Control Register (SYNCR)16R/W0x10026.7.1.1/6-7
0x12_0002Synthesizer Status Register (SYNSR)8R0x006.7.1.2/6-9
0x12_0004Relaxation Oscillator Control Register (ROCR)16R/WSee note
0x12_0007Low Power Divider Register (LPDR)8R/W0x006.7.1.4/6-11
0x12_0008Clock Control High Register (CCHR)8R/W0x056.7.1.5/6-12
0x12_0009Clock Control Low Register (CCLR)8R/WSee note
0x12_000AOscillator Control High Register (OCHR)8R/WSee note
0x12_000BOscillator Control Low Register (OCLR)8R/WSee note
0x12_0012Real Time Clock Control Register (RTCCR)8R/W0x006.7.1.9/6-15
0x12_0013Backup Watchdog Timer Control Register (BWCR)8R/W0x00
0x000CPeripheral Power Management Register High (PPMRH)
0x0018Peripheral Power Management Register Low (PPMRL)
1
Addresses not assigned to a register and undefined register bits are reserved for expansion.
2
The reset value for ROCR is loaded during reset from the flash information row (bits [9:0]). The bits reset to 0b10_0000_0000
during Power-On Reset.
3
CCLR reset state determined during reset configuration.
4
OCHR reset state determined during reset configuration.
5
OCLR reset state determined during reset configuration.
6
The contents of BWCR are reset only during Power-On Reset; they are preserved during a warm reset.
7
See Section 8.2.1, “Peripheral Power Management Registers (PPMRH, PPMRL).”
Register
Supervisor Mode Access Only
Width
(bits)
7
7
Access Reset Value Section/Page
2
3
4
5
6
32R/W0x008.2.1/8-2
32R/W0x018.2.1/8-2
6.7.1.3/6-11
6.7.1.6/6-12
6.7.1.7/6-13
6.7.1.8/6-14
6.7.1.10/6-16
6.7.1Register Descriptions
This subsection provides a description of the clock module registers.