The Wireless Gecko portfolio of SoCs (EFR32) includes Mighty
Gecko (EFR32MG14), Blue Gecko (EFR32BG14), and Flex
Gecko (EFR32FG14) families. With support for Zigbee®, Thread,
Bluetooth Low Energy (BLE) and proprietary protocols, the WireÂless Gecko portfolio is ideal for enabling energy-friendly wireless
networking for IoT devices.
The single-die solution provides industry-leading energy efficiency, ultra-fast wakeup
times, a scalable high-power amplifier, an integrated balun and no-compromise MCU
features.
Core / Memory
TM
ARM Cortex
with DSP extensions, FPU and MPU
Debug InterfaceRAM MemoryLDMA Controller
M4 processor
Flash Program
Memory
Clock Management
H-F Crystal
Oscillator
Auxiliary H-F RC
Oscillator
L-F Crystal
Oscillator
H-F
RC Oscillator
L-F
RC Oscillator
Ultra L-F RC
Oscillator
KEY FEATURES
• 32-bit ARM® Cortex-M4 core with 40 MHz
maximum operating frequency
• Scalable Memory and Radio configuration
options available in several footprint
compatible QFN packages
• 12-channel Peripheral Reflex System
enabling autonomous interaction of MCU
peripherals
• Autonomous Hardware Crypto Accelerator
and True Random Number Generator
• Integrated balun for 2.4 GHz and
integrated PA with up to 19 dBm transmit
power for 2.4 GHz and 20 dBm transmit
power for Sub-GHz radios
This document contains reference material for the EFR32 devices. All modules and peripherals in the EFR32 devices are described in
general terms. Not all modules are present in all devices and the feature set for each device might vary. Such differences, including
pinout, are covered in the device data sheets and applicable errata documents.
1.2 Conventions
Register Names
Register names are given with a module name prefix followed by the short register name:
TIMERn_CTRL - Control Register
The "n" denotes the module number for modules which can exist in more than one instance.
Some registers are grouped which leads to a group name following the module prefix:
GPIO_Px_DOUT - Port Data Out Register
The "x" denotes the different ports.
Bit Fields
Registers contain one or more bit fields which can be 1 to 32 bits wide. Bit fields wider than 1 bit are given with start (x) and stop (y) bit
[y:x].
Bit fields containing more than one bit are unsigned integers unless otherwise is specified.
Unspecified bit field settings must not be used, as this may lead to unpredictable behaviour.
Address
The address for each register can be found by adding the base address of the module found in the Memory Map (see Figure 4.2 Sys-
tem Address Space With Core and Code Space Listing on page 43), and the offset address for the register (found in module Register
Map).
Access Type
The register access types used in the register descriptions are explained in Table 1.1 Register Access Types on page 26.
Table 1.1. Register Access Types
Access TypeDescription
RRead only. Writes are ignored
RWReadable and writable
RW1Readable and writable. Only writes to 1 have effect
(R)W1Sometimes readable. Only writes to 1 have effect. Currently only
used for IFC registers (see 3.3.1.2 IFC Read-clear Operation)
W1Read value undefined. Only writes to 1 have effect
WWrite only. Read value undefined.
RWHReadable, writable, and updated by hardware
RW(nB), RWH(nB), etc."(nB)" suffix indicates that register explicitly does not support pe-
ripheral bit set or clear (see 4.2.3 Peripheral Bit Set and Clear)
RW(a), R(a), etc."(a)" suffix indicates that register has actionable reads (see
6.3.6 Debugger Reads of Actionable Registers)
Number format
silabs.com | Building a more connected world.Rev. 1.1 | 26
Page 27
Reference Manual
About This Document
0x prefix is used for hexadecimal numbers
0b prefix is used for binary numbers
Numbers without prefix are in decimal representation.
Reserved
Registers and bit fields marked with reserved are reserved for future use. These should be written to 0 unless otherwise stated in the
Register Description. Reserved bits might be read as 1 in future devices.
Reset Value
The reset value denotes the value after reset.
Registers denoted with X have unknown value out of reset and need to be initialized before use. Note that read-modify-write operations
on these registers before they are initialized results in undefined register values.
Pin Connections
Pin connections are given with a module prefix followed by a short pin name:
CMU_CLKOUT1 (Clock management unit, clock output pin number 1)
The location for the pin names given in the module documentation can be found in the device-specific data sheet.
1.3 Related Documentation
Further documentation on the EFR32 devices and the ARM Cortex-M4 can be found at the Silicon Labs and ARM web pages:
www.silabs.com
www.arm.com
silabs.com | Building a more connected world.Rev. 1.1 | 27
Page 28
2. System Overview
43210
Reference Manual
System Overview
Quick Facts
What?
The EFR32 Wireless Gecko is a highly integrated,
configurable and low power wireless System-onÂChip (SoC) with a robust set of MCU and radio peÂripherals.
Why?
The radio enables support for zigbee, Thread, BlueÂtooth Low Energy (BLE) and proprietary protocols in
2.4 GHz and sub-GHz frequency bands while the
MCU system allows customized protocols and appliÂcations to run efficiently.
How?
Dynamic or fixed packet lengths, optional address
recognition, and flexible CRC and crypto schemes
makes the EFR32 ideal for many low power wireless
IoT applications. High performance analog and digiÂtal peripherals allows complete applications to run
on the EFR32 SoC.
2.1 Introduction
The high level features of EFR32 include:
• High performance radio transceiver
• Dual-band operation
• Low power consumption in transmit, receive, and standby modes
• Excellent receiver performance, including sensitivity, selectivity and blocking
• Excellent transmitter performance, including programmable output power, low phase noise and PA ramping
• Ultra Low Energy RF Detection for wake-up from any Energy Mode, through RFSENSE
• Configurable protocol support, including standards and customer developed protocols
• Preamble and frame synchronization insertion in transmit and recovery in receive
• Flexible CRC support, including configurable polynomial and multiple CRCs for single data frames
• Basic address filtering performed in hardware
• High performance, low power MCU system
• High Performance 32-bit ARM Cortex-M4 CPU
• Flexible and efficient energy management
• Complete set of digital peripherals
• Peripheral Reflex System (PRS)
• Precision analog interfaces
• Low external component count
• Fully integrated 2.4 GHz BALUN
• Integrated tunable crystal loading capacitors
A further introduction to the MCU and radio system is included in the following sections.
Note:
Detailed performance numbers, current consumption, pinout etc. is available in the device data sheet.
silabs.com | Building a more connected world.Rev. 1.1 | 28
Page 29
Reference Manual
System Overview
2.2 Block Diagrams
The block diagram for the EFR32 System-On-Chip series is shown in (Figure 2.1 EFR32 System-On-Chip Block Diagram on page
• 2 Watchdog Timers with dedicated RC oscillator
• Ultra Low Power Precision Analog Peripherals
• 12-bit 1 Msamples/s Analog to Digital Converter
• All APORT input channels available
• On-chip temperature sensor
• Single ended or differential operation
• Conversion tailgating for predictable latency
• 12-bit 500 ksps Digital to Analog Converter
• 2 single ended channels/1 differential channel
• Up to 2 Operational Amplifiers
• Supports rail-to-rail inputs and outputs
• Programmable gain
• Current Digital to Analog Converter
• Source or sink a configurable constant current
• 2 Analog Comparator
• Programmable speed/current
• Analog Port
• Low-Energy Sensor Interface
• Autonomous sensor monitoring in deep sleep mode
• Wide range of supported sensors, including LC sensors and capacitive touch switches
• Ultra Efficient Power-on Reset and Brown-Out Detector
• Debug Interface
• 4-pin Joint Test Action Group (JTAG) interface
• 2-pin serial-wire debug (SWD) interface
Reference Manual
System Overview
silabs.com | Building a more connected world.Rev. 1.1 | 31
Page 32
2.4 Oscillators and Clocks
EFR32 has six different oscillators integrated, as shown in Table 2.1 EFR32 Oscillators on page 32.
Table 2.1. EFR32 Oscillators
Reference Manual
System Overview
OscillatorFrequencyOptional?External
Description
components
HFXO38 MHz - 40 MHzNoCrystalHigh accuracy, low jitter high frequency crystal oscillator. Tun-
able crystal loading capacitors are fully integrated. The HFXO
is required for all types of RF communication to be active.
HFRCO1 MHz - 38 MHzNo-Medium accuracy RC oscillator, typically used for timing dur-
ing startup of the HFXO and as a clock source as long as no
RF communication is active.
AUXHFRCO1 MHz - 38 MHzNo-Medium accuracy RC oscillator, typically used as alternative
clock source for Analog to Digital Converter or Debug Trace.
LFRCO32768 HzNo-Medium accuracy frequency reference typically used for medi-
um accuracy RTCC timing.
LFXO32768 HzYesCrystalHigh accuracy frequency reference typically used for high ac-
curacy RTCC timing. Tunable crystal loading capacitors are
fully integrated.
ULFRCO1000 HzNo-Ultra low frequency oscillator typically used for the watchdog
timer.
The RC oscillators can be calibrated against either of the crystal oscillators in order to compensate for temperature and voltage supply
variations. Hardware support is included to measure the frequency of various oscillators against each other.
Oscillator and clock management is available through the Clock Management Unit (CMU), see section 11. CMU - Clock Management
Unit for details.
2.5 RF Frequency Synthesizer
The Fractional-N RF Frequency Synthesizer (SYNTH) provides a low phase noise LO signal to be used in both receive and transmit
modes.
The capabilities of the SYNTH include:
• High performance, low phase noise
• Fast frequency settling
• Fast and fully automated calibration
• Sub 100 Hz frequency resolution across the supported frequency bands
2.6 Modulation Modes
EFR32 supports a wide range of modulation modes in transmit and receive:
• Configurable Direct Sequence Spread Spectrum (DSSS), with spread sequences up to 32 chips encoding up to 4 information bits
• Configurable 4-FSK symbol encoding
silabs.com | Building a more connected world.Rev. 1.1 | 32
Page 33
Reference Manual
System Overview
2.7 Transmit Mode
In transmit mode EFR32 performs the following functionality:
• Automatic PA power ramping during the start and end of a frame transmit
• Programmable output power
• Optional preamble and synchronization word insertion
• Accurate transmit frame timing to support time synchronized radio protocols
• Optional Carrier Sense Multiple Access - Collision Avoidance (CSMA-CA) or Listen Before Talk (LBT) hardware support
• Integrated transmit test modes, as described in 2.17 RF Test Modes
2.8 Receive Mode
In receive mode EFR32 performs the following functionality:
• A single-ended (2.4 GHz) or differential (Sub-GHz) LNA amplifies the input RF signal. The amplified signal is then mixed to a low-IF
signal through the quadrature down-coversion mixer. Further signal filtering is performed before conversion to a digital signal
through the I/Q ADC.
• Digitally configurable receiver bandwidth from 100 Hz to 2.5 MHz
• Timing recovery on received data, including simultaneous support for two different frame synchronization words
• Automatic frequency offset compensation, to compensate for carrier frequency offset between the transmitter and receiver
• Support for a wide range of modulation formats as described in section 2.6 Modulation Modes
2.9 Data Buffering
EFR32 supports buffered transmit and receive modes through its buffer controller (BUFC), with four individually configurable buffers.
The BUFC uses the system RAM as storage, and each buffer can be individually configured with parameters such as:
• Buffer size
• Buffer interrupt thresholds
• Buffer RAM location
• Overflow and underflow detection
In receive mode, data following frame synchronization is moved directly from the demodulator to the buffer storage.
In transmit mode, data following the inserted preamble and synchronization word is moved directly from the buffer storage to the moduÂlator.
2.10 Unbuffered Data Transfer
For most system designs it is recommended to use the data buffering within EFR32 to provide a convenient user interface.
In cases where data buffering within EFR32 is not desired, it is possible to set up direct unbuffered data transfers using a single-pin or
two-pin interface on EFR32. A bit clock output is provided on the Serial Clock (SC) output pin, and a serial bitstream is provided to
EFR32 in a transmit mode and from EFR32 in a receive mode.
In unbuffered data transfer modes the hardware support provided by EFR32 to perform preamble and frame synchronization insertion
in transmit mode and detection in receive mode can still optionally be used.
2.11 Frame Format Support
EFR32 has an extensive support for frame handling in transmit and receive modes, which allows effective handling of even advanced
protocols. The support includes:
• Preamble and frame synchronization inserted into transmitted frames
• Full frame synchronization of received frames
• Simple address matching of received frames in hardware, further configurable address and frame filtering supported through seÂquencer
• Support for variable length frames
• Automated CRC calculation and verification
• Configurable bit ordering, with the most or least significant bit transmitted and received first
The frame format support is controlled by the Frame Controller (FRC).
silabs.com | Building a more connected world.Rev. 1.1 | 33
Page 34
Reference Manual
System Overview
2.12 Hardware CRC Support
EFR32 supports a configurable CRC generation in transmit and verification in receive mode:
• 8, 16, 24 or 32 bit CRC value
• Configurable polynomial and initialization value
• Optional inversion of CRC value over air
• Configurable CRC byte ordering
• Support for multiple CRC values calculated and verified per transmitted or received frame
• The CRC module is typically controlled by the Frame Controller (FRC) for in-line operations in transmit and receive modes. AlternaÂtively, the CRC module may be accessed directly from software to calculate and verify CRC data.
2.13 Convolutional Encoding / Decoding
EFR32 includes hardware support for convolutional encoding and decoding, for forward error correction (FEC). This feature is perÂformed by the Frame Controller (FRC) module:
• Constraint length configurable up to 7, for the highest robustness
• Configurable puncturing, to achieve rates between 1/2 rate and full rate
• Configurable soft decision or hard decision decoding
• Convolutional coding may be used together with the symbol interleaver to improve robustness against burst errors
2.14 Binary Block Encoding / Decoding
EFR32 includes hardware support for binary block encoding and decoding, both performed real-time in the the transmit and receive
path. This is performed in the Frame Controller (FRC) module:
The block coding works on blocks of up to 16 bits of data and adds parity bits to be capable of single or multiple bit corrections by the
receiver.
• One or more parity bits can be added and verified
• Bit error correction
• Lookup-codes can be used to implement virtually any block coding scheme
silabs.com | Building a more connected world.Rev. 1.1 | 34
Page 35
Reference Manual
System Overview
2.15 Data Encryption and Authentication
EFR32 has hardware support for AES encryption, decryption and authentication modes. These security operations can be performed
on data in RAM or any data buffer, without further CPU intervention. The key size is 128 bits.
AES modes of operations directly supported by the EFR32 hardware are listed in Table 2.2 AES Modes of Operation With Hardware
Support on page 35. In addition to these modes, other modes can also be implemented by using combinations of modes. For exam-
ple, the CCM mode can be implemented using the CTR and CBC-MAC modes in combination.
Table 2.2. AES Modes of Operation With Hardware Support
The CRYPTO module can operate directly on data buffers provided by the BUFC module. It is also possible to provide data directly
from the embedded Cortex-M4 or via DMA.
A True Random Number Generator (TRNG) module is also included for additional security. The TRNG is a non-deterministic random
number generator based on a full hardware solution, and is suitable for cryptographic key generation.
silabs.com | Building a more connected world.Rev. 1.1 | 35
Page 36
2.16 Timers
EFR32 includes multiple timers, as can be seen from Table 2.3 EFR32 Timers Overview on page 36.
Table 2.3. EFR32 Timers Overview
TimerNumber of instancesTypical clock sourceOverview
Reference Manual
System Overview
RTCC1 (2)Low frequency (LFXO or
LFRCO)
PROTIMER1High frequency (HFXO or
HFRCO)
TIMER2High frequency (HFXO or
HFRCO)
WTIMER2High frequency (HFXO or
HFRCO)
Systick timer1High frequency (HFXO or
HFRCO)
WDOG1Low frequency (LFXO, LFRCO
or ULFRCO)
32 bit Real Time Counter and
Calendar, typically used to enaÂble wakeup on compare match.
A second RTC module is used
by the radio software drivers for
accurately timing inactive periÂods in the radio communication
protocol.
16+16+32 bit Protocol Timer,
typically used to accurately conÂtrol detailed RF protocol timing
in transmit and receive modes.
16 bit general purpose timer.
32 bit general purpose timer.
32 bit systick timer integrated in
the Cortex-M4. Typically used
as an Operating System timer.
Watch dog timer. Once enabled,
this module must be periodically
accessed. If not, this is considÂered an error and the EFR32 is
reset in order to recover the
system.
LETIMER1Low frequency (LFXO, LFRCO
or ULFRCO)
Low energy general purpose
timer.
Advanced interconnect features allows synchronization between timers. This includes:
• Start / stop any high frequency timer synchronized with the RTCC
• Trigger RSM state transitions based on compare timer compare match, for instance to provide clock cycle accuracy on frame transÂmit timing
2.17 RF Test Modes
EFR32 supports a wide range of RF test modes typically used for characterization and regulation compliance testing, including:
• Unmodulated carrier transmit
• Modulated carrier transmit, with internal configurable pseudo random data generator
• Continuous data reception for Bit Error Rate (BER) measurements
• Storing of raw receiver data to RAM
• Transmit of raw frequency data from RAM
silabs.com | Building a more connected world.Rev. 1.1 | 36
Page 37
3. System Processor
43210
CM4 Core
Reference Manual
System Processor
Quick Facts
What?
The industry leading Cortex-M4 processor from
ARM is the CPU in the EFR32 devices.
Why?
The ARM Cortex-M4 is designed for exceptionally
short response time, high code density, and high 32Âbit throughput while maintaining a strict cost and
power consumption budget.
3.1 Introduction
32-bit ALU
Hardware divider
Control LogicDSP extensions
Floating-Point Unit
Instruction InterfaceData Interface
NVIC Interface
Single cycle
32-bit multiplier
Thumb & Thumb-2
Decode
Memory Protection Unit
How?
Combined with the ultra low energy peripherals
available in EFR32 devices, the Cortex-M4 processÂor's Harvard architecture, 3 stage pipeline, single cyÂcle instructions, Thumb-2 instruction set support,
and fast interrupt handling make it perfect for 8-bit,
16-bit, and 32-bit applications.
The ARM Cortex-M4 32-bit RISC processor provides outstanding computational performance and exceptional system response to interÂrupts while meeting low cost requirements and low power consumption.
The ARM Cortex-M4 implemented is revision r0p1.
silabs.com | Building a more connected world.Rev. 1.1 | 37
Page 38
Reference Manual
System Processor
3.2 Features
• Harvard architecture
• Separate data and program memory buses (No memory bottleneck as in a single bus system)
• 3-stage pipeline
• Thumb-2 instruction set
• Enhanced levels of performance, energy efficiency, and code density
• Single cycle multiply and hardware divide instructions
• 32-bit multiplication in a single cycle
• Signed and unsigned divide operations between 2 and 12 cycles
• Atomic bit manipulation with bit banding
• Direct access to single bits of data
• Two 1MB bit banding regions for memory and peripherals mapping to 32MB alias regions
• Atomic operation, cannot be interrupted by other bus activities
• 1.25 DMIPS/MHz
• Memory Protection Unit
• Up to 8 protected memory regions
• 24 bits System Tick Timer for Real Time OS
• Excellent 32-bit migration choice for 8/16 bit architecture based designs
• Simplified stack-based programmer's model is compatible with traditional ARM architecture and retains the programming simpliciÂty of legacy 8-bit and 16-bit architectures
• Alligned or unaligned data storage and access
• Contiguous storage of data requiring different byte lengths
• Data access in a single core access cycle
• Integrated power modes
• Sleep Now mode for immediate transfer to low power state
• Sleep on Exit mode for entry into low power state after the servicing of an interrupt
• Ability to extend power savings to other system components
• Optimized for low latency, nested interrupts
3.3 Functional Description
For a full functional description of the ARM Cortex-M4 implementation in the EFR32 family, the reader is referred to the ARM Cortex-M4
documentation provided by ARM.
silabs.com | Building a more connected world.Rev. 1.1 | 38
Page 39
3.3.1 Interrupt Operation
ModuleCortex-M NVIC
Reference Manual
System Processor
IFS[n]IFC[n]
IEN[n]
SETENA[n]/CLRENA[n]
Interrupt
condition
setclear
IF[n]
Active interrupt
IRQ
setclear
Interrupt
request
SETPEND[n]/CLRPEND[n]
Software generated interrupt
Figure 3.1. Interrupt Operation
The interrupt request (IRQ) lines are connected to the Cortex-M4. Each of these lines (shown in Table 3.1 Interrupt Request Lines (IRQ)
on page 40) is connected to one or more interrupt flags in one or more modules. The interrupt flags are set by hardware on an inter-
rupt condition. It is also possible to set/clear the interrupt flags through the IFS/IFC registers. Each interrupt flag is then qualified with its
own interrupt enable bit (IEN register), before being OR'ed with the other interrupt flags to generate the IRQ. A high IRQ line will set the
corresponding pending bit (can also be set/cleared with the SETPEND/CLRPEND bits in ISPR0/ICPR0) in the Cortex-M4 NVIC. The
pending bit is then qualified with an enable bit (set/cleared with SETENA/CLRENA bits in ISER0/ICER0) before generating an interrupt
request to the core. Figure 3.1 Interrupt Operation on page 39 illustrates the interrupt system. For more information on how the interÂrupts are handled inside the Cortex-M4, the reader is referred to the ARM Cortex-M4 Technical Reference Manual.
3.3.1.1 Avoiding Extraneous Interrupts
There can be latencies in the system such that clearing an interrupt flag could take longer than leaving an Interrupt Service Routine
(ISR). This can lead to the ISR being re-entered as the interrupt flag has yet to clear immediately after leaving the ISR. To avoid this,
when clearing an interrupt flag at the end of an ISR, the user should execute ARM's Data Synchronization Barrier (DSB) instruction.
Another approach is to clear the interrupt flag immediately after identifying the interrupt source and then service the interrupt as shown
in the pseudo-code below. The ISR typically is sufficiently long to more than cover the few cycles it may take to clear the interrupt staÂtus, and also allows the status to be checked for further interrupts before exiting the ISR.
irqXServiceRoutine() {
do {
clearIrqXStatus();
serviceIrqX();
} while(irqXStatusIsActive());
}
3.3.1.2 IFC Read-clear Operation
In addition to the normal interrupt setting and clearing operations via the IFS/IFC registers, there is an additional atomic Read-clear
operation that can be enabled by setting IFCREADCLEAR=1 in the MSC_CTRL register. When enabled, reads of peripheral IFC regisÂters will return the interrupt vector (mirroring the IF register), while at the same time clearing whichever interrupt flags are set. This operÂation is functionally equivalent to reading the IF register and then writing the result immediately back to the IFC register.
silabs.com | Building a more connected world.Rev. 1.1 | 39
Page 40
3.3.2 Interrupt Request Lines (IRQ)
Table 3.1. Interrupt Request Lines (IRQ)
IRQ #Source(s)
0EMU
2WDOG0
3WDOG1
9LDMA
10GPIO_EVEN
11TIMER0
12USART0_RX
13USART0_TX
14ACMP0
ACMP1
Reference Manual
System Processor
15ADC0
16IDAC0
17I2C0
18GPIO_ODD
19TIMER1
20USART1_RX
21USART1_TX
22LEUART0
23PCNT0
24CMU
25MSC
26CRYPTO0
27LETIMER0
31RTCC
33CRYOTIMER
35FPUEH
36SMU
37WTIMER0
38VDAC0
39LESENSE
40TRNG0
silabs.com | Building a more connected world.Rev. 1.1 | 40
Page 41
4. Memory and Bus System
43210
ARM Cortex-M
DMA Controller
Flash
RAM
Radio
Peripherals
Reference Manual
Memory and Bus System
Quick Facts
What?
A low latency memory system including low energy
Flash and RAM with data retention which makes the
energy modes attractive.
Why?
RAM retention reduces the need for storing data in
Flash and enables frequent use of the ultra low enÂergy modes EM2 Deep Sleep and EM3 Stop.
How?
Low energy and non-volatile Flash memory stores
program and application data in all energy modes
and can easily be reprogrammed in system. Low
leakage RAM with data retention in EM0 Active to
EM3 Stop removes the data restore time penalty,
and the DMA ensures fast autonomous transfers
with predictable response time.
silabs.com | Building a more connected world.Rev. 1.1 | 41
Page 42
Reference Manual
Memory and Bus System
4.1 Introduction
The EFR32 contains an AMBA AHB Bus system to allow bus masters to access the memory mapped address space. A multilayer AHB
bus matrix connects the 5 master bus interfaces to the AHB slaves (Figure 4.1 EFR32 Bus System on page 42). The bus matrix alÂlows several AHB slaves to be accessed simultaneously. An AMBA APB interface is used for the peripherals, which are accessed
through an AHB-to-APB bridge connected to the AHB bus matrix. The 5 AHB bus masters are:
• Cortex-M4 ICode: Used for instruction fetches from Code memory (valid address range: 0x00000000 - 0x1FFFFFFF)
• Cortex-M4 DCode: Used for debug and data access to Code memory (valid address range: 0x00000000 - 0x1FFFFFFF)
• Cortex-M4 System: Used for data and debug access to system space. It can access entire memory space except Code memory
(valid address range: 0x20000000 - 0xFFFFFFFF)
• DMA: Can access the entire memory space except the internal core memory region and the DMEM code region
• Sequencer Code: Used for instruction fetches and data accesses. Instruction fetches still come from data memory. (valid address
range: 0x00000000 - 0x0FFFFFFF, 0x20000000 - 0x3FFFFFFF)
• Sequencer System: Can access entire memory space except internal core memory region and RAM code space (valid address
range: 0x00000000 - 0x0FFFFFFF, 0x20000000 - 0xDFFFFFFF)
• BUFC: Can access general purpose SRAM (valid address range: 0x20000000 - 0x20FFFFFF)
• FRC: Can access general purpose SRAM (valid address range: 0x20000000 - 0x20FFFFFF)
Cortex-M
Sequencer
BUFC
FRC
DMA
ICode
DCode
System
Code
System
AHB Multilayer
Bus Matrix
Flash
RAM0
RAMn
SEQ_RAM
CRYPTO
AHB/APB
Bridge
Figure 4.1. EFR32 Bus System
Peripheral 0
Peripheral n
silabs.com | Building a more connected world.Rev. 1.1 | 42
Page 43
Reference Manual
Memory and Bus System
4.2 Functional Description
The memory segments are mapped together with the internal segments of the Cortex-M4 into the system memory map shown by Fig-
ure 4.2 System Address Space With Core and Code Space Listing on page 43.
Figure 4.2. System Address Space With Core and Code Space Listing
Additionally, the peripheral address map is detailed by Figure 4.3 System Address Space With Peripheral Listing on page 44.
silabs.com | Building a more connected world.Rev. 1.1 | 43
Page 44
Reference Manual
Memory and Bus System
Figure 4.3. System Address Space With Peripheral Listing
The embedded SRAM is located at address 0x20000000 in the memory map of the EFR32. When running code located in SRAM startÂing at this address, the Cortex-M4 uses the System bus interface to fetch instructions. This results in reduced performance as the CorÂtex-M4 accesses stack, other data in SRAM and peripherals using the System bus interface. To be able to run code from SRAM effiÂciently, the SRAM is also mapped in the code space at address 0x10000000.
When running code from this space, the Cortex-M4 fetches instructions through the I/D-Code bus interface, leaving the System bus
interface for data access.
The SRAM mapped into the code space can however only be accessed by the CPU and not any other bus masters, e.g. DMA. See
4.5 SRAM for more detailed info on the system SRAM.
The Sequencer RAM is used by the Sequencer for both instructions and data. This RAM is also available for general use by most AHB
masters.
silabs.com | Building a more connected world.Rev. 1.1 | 44
Page 45
Reference Manual
Memory and Bus System
4.2.1 Peripheral Non-Word Access Behavior
When writing to peripheral registers, all accesses are treated as 32-bit accesses. This means that writes to a register need to be large
enough to cover all bits of register, otherwise, any uncovered bits may become corrupted from the partial-word transfer. Thus, the safest
practice is to always do 32-bit writes to peripheral registers.
When reading, there is generally no issue with partial word accesses, however, note that any read action (e.g. FIFO popping) will be
triggered regardless of whether the actual FIFO bit-field was included in the transfer size.
Note: The implementation of bit-banding in the core is such that bit-band accesses forward the transfer size info into the actual bus
transfer size, so the same restrictions apply to bit-band accesses as apply to normal read/write accesses.
4.2.2 Bit-banding
The SRAM bit-band alias and peripheral bit-band alias regions are located at 0x22000000 and 0x42000000 respectively. Read and
write operations to these regions are converted into masked single-bit reads and atomic single-bit writes to the embedded SRAM and
peripherals of the EFR32.
Note: Bit-banding is only available through the CPU. No other AHB masters (e.g. DMA) can perform Bit-banding operations.
Using a standard approach to modify a single register or SRAM bit in the aliased regions, would require software to read the value of
the byte, half-word or word containing the bit, modify the bit, and then write the byte, half-word or word back to the register or SRAM
address. Using bit-banding, this can be done in a single operation, consuming only two bus cycles. As read-writeback, bit-masking and
bit-shift operations are not necessary in software, code size is reduced and execution speed improved.
The bit-band regions allow each bit in the SRAM and Peripheral areas of the memory map to be addressed. To set or clear a bit in the
embedded SRAM, write a 1 or a 0 to the following address:
silabs.com | Building a more connected world.Rev. 1.1 | 45
Page 46
Reference Manual
Memory and Bus System
4.2.3 Peripheral Bit Set and Clear
The EFR32 supports bit set and bit clear access to all peripherals except those listed in Table 4.1 Peripherals that Do Not Support Bit
Set and Bit Clear on page 46. The bit set and bit clear functionality (also called Bit Access) enables modification of bit fields (single bit
or multiple bit wide) without the need to perform a read-modify-write (though it is functionally equivalent). Also, the operation is conÂtained within a single bus access (for HF peripherals), unlike the Bit-banding operation described in section 4.2.2 Bit-banding which
consumes two bus accesses per operation. All AHB masters can utilize this feature.
The bit clear aliasing region starts at 0x44000000 and the bit set aliasing region starts at 0x46000000. Thus, to apply a bit set or clear
operation, write the bit set or clear mask to the following addresses:
bit_clear_address = address + 0x04000000
bit_set_address = address + 0x06000000
For bit set operations, bit locations that are 1 in the bit mask will be set in the destination register:
register = (register OR mask)
For bit clear operations, bit locations that are 1 in the bit mask will be cleared in the destination register:
register = (register AND (NOT mask))
Note: It is possible to combine bit clear and bit set operations in order to arbitrarily modify multi-bit register fields, without affecting other
fields in the same register. In this case, care should be taken to ensure that the field does not have intermediate values that can lead to
erroneous behavior. For example, if bit clear and bit set operations are used to change an analog tuning register field from 25 to 26, the
field would initially take on a value of zero. If the analog module is active at the time, this could lead to undesired behavior.
The peripherals listed in Table 4.1 Peripherals that Do Not Support Bit Set and Bit Clear on page 46 do not support Bit Access for any
registers. All other peripherals do support Bit Access, however, there may be cases of certain registers that do not support it. Such
registers have a note regarding this lack of support.
Table 4.1. Peripherals that Do Not Support Bit Set and Bit Clear
Module
EMU
RMU
CRYOTIMER
TRNG0
silabs.com | Building a more connected world.Rev. 1.1 | 46
Page 47
Reference Manual
Memory and Bus System
4.2.4 Peripherals
The peripherals are mapped into the peripheral memory segment, each with a fixed size address range according to Table 4.2 Periph-
erals on page 47, Table 4.3 Low Energy Peripherals on page 47 , and Table 4.4 Core Peripherals on page 47.
Table 4.2. Peripherals
Address RangeModule Name
0x400E6000 - 0x400E6400PRS
0x40022000 - 0x40022400SMU
0x4001E000 - 0x4001E400CRYOTIMER
0x4001D000 - 0x4001D400TRNG0
0x4001C000 - 0x4001C400GPCRC
0x4001A000 - 0x4001A400WTIMER0
0x40018400 - 0x40018800TIMER1
0x40018000 - 0x40018400TIMER0
0x40010400 - 0x40010800USART1
0x40010000 - 0x40010400USART0
0x4000C000 - 0x4000C400I2C0
0x4000A000 - 0x4000B000GPIO
0x40008000 - 0x40008400VDAC0
0x40006000 - 0x40006400IDAC0
0x40002000 - 0x40002400ADC0
0x40000400 - 0x40000800ACMP1
0x40000000 - 0x40000400ACMP0
Table 4.3. Low Energy Peripherals
Address RangeModule Name
0x40055000 - 0x40055400LESENSE
0x40052400 - 0x40052800WDOG1
0x40052000 - 0x40052400WDOG0
0x4004E000 - 0x4004E400PCNT0
0x4004A000 - 0x4004A400LEUART0
0x40046000 - 0x40046400LETIMER0
0x40042000 - 0x40042400RTCC
Table 4.4. Core Peripherals
Address RangeModule Name
0xE0000000 - 0xE0040000CM4
0x400F0000 - 0x400F0400CRYPTO0
silabs.com | Building a more connected world.Rev. 1.1 | 47
Page 48
Reference Manual
Memory and Bus System
Address RangeModule Name
0x400E2000 - 0x400E3000LDMA
0x400E1000 - 0x400E1400FPUEH
0x400E0000 - 0x400E0800MSC
4.2.5 Bus Matrix
The Bus Matrix connects the memory segments to the bus masters as detailed in 4.1 Introduction.
4.2.5.1 Arbitration
The Bus Matrix uses a round-robin arbitration algorithm which enables high throughput and low latency, while starvation of simultaneÂous accesses to the same bus slave are eliminated. Round-robin does not assign a fixed priority to each bus master. The arbiter does
not insert any bus wait-states during peak interaction. However, one wait state is inserted for master accesses occurring after a proÂlonged inactive time. This wait state allows for increased power efficiency during master idle time.
4.2.5.2 Peripheral Access Performance
The Bus Matrix is a multi-layer energy optimized AMBA AHB compliant bus with an internal bandwidth of 5x a single AHB interface.
The Cortex-M4, DMA Controller, and peripherals (not peripherals in the low frequency clock domain) run on clocks which can be preÂscaled separately. Clocks and prescaling are described in more detail in 11. CMU - Clock Management Unit . This section describes the
expected bus wait states for a peripheral based on its frequency relative to the HFCLK frequency. For this discussion, PERCLK refers
to a selected peripheral's clock frequency, which is some integer division of the HFCLK frequency.
Another factor that effects the cycle latency of peripheral accesses is the Peripheral Access Wait Mode (WAITMODE in MSC_CTRL)
configuration, which is present in some parts in the EFR32 series. For instance, when set to WS0, a higher throughput (in terms of
HFCLK cycles) is possible than with a higher wait state setting. However, this family of parts does not have configurable wait states.
Instead, refer to the access performance information for WS0 for this device family.
silabs.com | Building a more connected world.Rev. 1.1 | 48
Page 49
Reference Manual
Memory and Bus System
4.2.5.2.1 WS0 Mode
In general, when accessing a peripheral, the latency in number of HFCLK cycles, not including master arbitration, is given by:
where N
slave cycles
N
bus cycles
N
bus cycles
N
bus cycles
N
bus cycles
is the throughput of the slave's bus interface in number of PERCLK cycles per transfer, including any wait cycles
= (N
= (N
= N
= N
slave cycles
slave cycles
slave cycles
slave cycles
+ 1) ∙ f
+ 1) ∙ f
∙ f
HFCLK/fPERCLK
∙ f
HFCLK/fPERCLK
HFCLK/fPERCLK
HFCLK/fPERCLK
, best-case write accesses
+ 1, best-case read accesses
- 1, worst-case write accesses
, worst-case read accesses
introduced by the slave.
Figure 4.4. Bus Access Latency (General Case)
Note that a latency of 1 cycle corresponds to 0 wait states.
Additionally, for back-to-back accesses to the same peripheral, the throughput in number of cycles per transfer is given by:
N
bus cycles
N
bus cycles
= N
= (N
slave cycles
slave cycles
∙ f
HFCLK/fPERCLK
+ 1) ∙ f
HFCLK/fPERCLK
, write accesses
, read accesses
Figure 4.5. Bus Access Throughput (Back-to-Back Transfers)
Lastly, in the highest performing case, where PERCLK equals HFCLK and the slave does not introduce any additional wait states, the
access latency in number of cycles is given by:
N
bus cycles
= 1, write accesses
N
bus cycles
= 2, read accesses
Figure 4.6. Bus Access Latency (Max Performance)
silabs.com | Building a more connected world.Rev. 1.1 | 49
Page 50
Reference Manual
Memory and Bus System
4.2.5.2.2 WS1 Mode
In general, when accessing a peripheral, the latency in number of HFCLK cycles, not including master arbitration, is given by:
where N
slave cycles
N
bus cycles
N
bus cycles
N
bus cycles
N
bus cycles
is the throughput of the slave's bus interface in number of PERCLK cycles per transfer, including any wait cycles
= (N
= (N
= N
slave cycles
= N
slave cycles
slave cycles
slave cycles
∙ f
HFCLK/fPERCLK
∙ f
HFCLK/fPERCLK
+ 1) ∙ f
+ 1) ∙ f
HFCLK/fPERCLK
HFCLK/fPERCLK
+ 2, best-case write accesses
+ 1, best-case read accesses
+ 1, worst-case write accesses
, worst-case read accesses
introduced by the slave.
Figure 4.7. Bus Access Latency (General Case)
Note that a latency of 1 cycle corresponds to 0 wait states.
Additionally, for back-to-back accesses to the same peripheral, the throughput in number of cycles per transfer is given by:
N
bus cycles
= max{f
N
bus cycles
HFCLK/fPERCLK
= (N
, 2} + N
slave cycles
slave cycles
+ 1) ∙ f
∙ f
HFCLK/fPERCLK
HFCLK/fPERCLK
, write accesses
, read accesses
Figure 4.8. Bus Access Throughput (Back-to-Back Transfers)
Lastly, in the highest performing case, where PERCLK equals HFCLK and the slave does not introduce any additional wait states, the
access latency in number of cycles is given by:
N
bus cycles
= 3, write accesses
N
bus cycles
= 2, read accesses
Figure 4.9. Bus Access Latency (Max Performance)
4.2.5.2.3 Core Access Latency
Note that the cycle counts in the equations above is in terms of the HFCLK. When the core is prescaled from the bus clock, the core will
see a reduced number of latency cycles given by:
N
core cycles
= ceiling( N
bus cycles
∙ f
HFCORECLK/fHFCLK
)
where master arbitration is not included.
Figure 4.10. Core Access Latency
silabs.com | Building a more connected world.Rev. 1.1 | 50
Page 51
Reference Manual
Memory and Bus System
4.2.5.3 Bus Faults
System accesses from the core can receive a bus fault in the following condition(s):
• The core attempts to access an address that is not assigned to any peripheral or other system device. These faults can be enabled
or disabled by setting the ADDRFAULTEN bit appropriately in MSC_CTRL.
• The core attempts to access a peripheral or system device that has its clock disabled. These faults can be enabled or disabled by
setting the CLKDISFAULTEN bit appropriately in MSC_CTRL.
• The bus times out during an access. For example, this could happen while trying to synchronize volatile read data during an LE
peripheral access. See 11.3.1.1 HFCLK - High Frequency Clock. These faults can be enabled or disabled by setting the TIMEOUTÂFAULTEN bit appropriately in MSC_CTRL.
In addition to any condition-specific bus fault control bits, the bus fault interrupt itself can be enabled or disabled in the same way as all
other internal core interrupts.
Note: The icache flush is not triggered at the event of a bus fault. As a result, when an instruction fetch results in a bus fault, invalid
data may be cached. This means that the next time the instruction that caused the bus fault is fetched, the processor core will get the
invalid cached data without any bus fault. In order to avoid invalid cached data propagation to the processor core, software should manÂually invalidate cache by writing 1 to MSC_CMD_INVCACHE bitfield at the event of a bus fault.
4.3 Access to Low Energy Peripherals (Asynchronous Registers)
The Low Energy Peripherals are capable of running when the high frequency oscillator and core system is powered off, i.e. in energy
mode EM2 Deep Sleep and in some cases also EM3 Stop. This enables the peripherals to perform tasks while the system energy conÂsumption is minimal.
The Low Energy Peripherals are listed in Table 4.3 Low Energy Peripherals on page 47.
All Low Energy Peripherals are memory mapped, with automatic data synchronization. Because the Low Energy Peripherals are runÂning on clocks asynchronous to the high frequency system clock, there are some constraints on how register accesses are performed,
as described in the following sections.
silabs.com | Building a more connected world.Rev. 1.1 | 51
Page 52
Reference Manual
Memory and Bus System
4.3.1 Writing
Every Low Energy Peripheral has one or more registers with data that needs to be synchronized into the Low Energy clock domain to
maintain data consistency and predictable operation. There are two different synchronization mechanisms on the EFR32, immediate
synchronization, and delayed synchronization. Immediate synchronization is available for the RTCC, LESENSE and LETIMER, and reÂsults in an immediate update of the target registers. Delayed synchronization is used for the remaining Low Energy Peripherals, and for
these peripherals, a write operation requires 3 positive edges of the clock on the Low Energy Peripheral being accessed. Registers
requiring synchronization are marked "Async Reg" in their description header.
Note: On the Gecko series of devices, all LE peripherals are subject to delayed synchronization.
Write request [0:n]
High Frequency Clock Domain
High Frequency Clock
Write request 0
Write request 1
Write request n
Set 0
Set 1
Set n
Register 0
Register 1
.
.
.
Register n
Syncbusy Register 0
Syncbusy Register 1
.
.
.
Syncbusy Register n
Figure 4.11. Write Operation to Low Energy Peripherals
Clear 0
Clear 1
Clear n
Freeze
Low Frequency Clock Domain
Low Frequency ClockLow Frequency Clock
Synchronizer 0
Synchronizer 1
.
.
.
Synchronizer n
Synchronization Done
Register 0 Sync
Register 1 Sync
Register n Sync
.
.
.
silabs.com | Building a more connected world.Rev. 1.1 | 52
Page 53
Reference Manual
Memory and Bus System
4.3.1.1 Delayed Synchronization
After writing data to a register which value is to be synchronized into the Low Energy Peripheral using delayed synchronization, a correÂsponding busy flag in the <module_name>_SYNCBUSY register (e.g. LETIMER_SYNCBUSY) is set. This flag is set as long as synÂchronization is in progress and is cleared upon completion.
Note: Subsequent writes to the same register before the corresponding busy flag is cleared is not supported. Write before the busy flag
is cleared may result in undefined behavior. In general the SYNCBUSY register only needs to be observed if there is a risk of multiple
write access to a register (which must be prevented). It is not required to wait until the relevant flag in the SYNCBUSY register is
cleared after writing a register. E.g., EM2 Deep Sleep can be entered directly after writing a register.
See Figure 4.12 Write Operation to Low Energy Peripherals on page 53 for an overview of the writing mechanism operation.
Write request [0:n]
High Frequency Clock Domain
High Frequency Clock
Write request 0
Write request 1
Write request n
Set 0
Set 1
Set n
Register 0
Register 1
.
.
.
Register n
Syncbusy Register 0
Syncbusy Register 1
.
.
.
Syncbusy Register n
Freeze
Clear 0
Clear 1
Clear n
Low Frequency Clock Domain
Low Frequency ClockLow Frequency Clock
Synchronizer 0
Synchronizer 1
.
.
.
Synchronizer n
Synchronization Done
Register 0 Sync
Register 1 Sync
Register n Sync
.
.
.
Figure 4.12. Write Operation to Low Energy Peripherals
4.3.1.2 Immediate Synchronization
In contrast to the peripherals with delayed synchronization, peripherals with immediate synchronization do not experience a delay from
a value is written to it takes effect in the peripheral. They are updated immediately on the peripheral write access. If such a write is done
close to an edge on the clock of the peripheral, the write is delayed to after the clock edge. This will introduce wait-states on the periphÂeral access.
Peripherals with immediate synchronization each have a SYNCBUSY register. Commands written to a peripheral with immediate synÂchronization are not executed before the first peripheral clock after the write. In this period, the SYNCBUSY flag for the command regisÂter is set, indicating that the command has not yet been performed. Secondly, to maintain compatibility with the Gecko series, the rest
of the SYNCBUSY registers are also present, but these are always 0, indicating that register writes are always safe.
Note: If compatibility with the Gecko series is a requirement for a given application, the rules that apply to delayed synchronization with
respect to SYNCBUSY should also be followed for the peripherals that support immediate synchronization.
silabs.com | Building a more connected world.Rev. 1.1 | 53
Page 54
Reference Manual
Memory and Bus System
4.3.2 Reading
When reading from a Low Energy Peripheral, the data read is synchronized regardless if it originates in the Low Energy clock domain
or High Frequency clock domain. See Figure 4.13 Read Operation From Low Energy Peripherals on page 54 for an overview of the
reading operation.
Note: Writing a register and then immediately reading the new value of the register may give the impression that the write operation is
complete. This may not be the case. Refer to the SYNCBUSY register for correct status of the write operation to the Low Energy PeÂripheral.
High Frequency Clock DomainLow Frequency Clock Domain
High Frequency Clock
Freeze
Low Frequency ClockLow Frequency Clock
Register 0
Register 1
.
.
.
Register n
Read
Synchronizer
Read Data
Synchronizer 0
Synchronizer 1
.
.
.
Synchronizer n
HW Status Register 0
HW Status Register 1
.
.
.
HW Status Register m
Register 0 Sync
Register 1 Sync
.
.
.
Register n Sync
Low Energy
Peripheral
Main
Function
Figure 4.13. Read Operation From Low Energy Peripherals
4.3.3 FREEZE Register
In all Low Energy Peripheral with delayed synchronization there is a <module_name>_FREEZE register (e.g. RTCC_FREEZE). The
register contains a bit named REGFREEZE. If precise control of the synchronization process is required, this bit may be utilized. When
REGFREEZE is set, the synchronization process is halted allowing the software to write multiple Low Energy registers before starting
the synchronization process, thus providing precise control of the module update process. The synchronization process is started by
clearing the REGFREEZE bit.
Note: The FREEZE register is also present on peripherals with immediate synchronization, but there it has no effect
4.4 Flash
The Flash retains data in any state and typically stores the application code, special user data and security information. The Flash
memory is typically programmed through the debug interface, but can also be erased and written to from software.
• Up to 256 KB of memory
• Page size of 2 KB (minimum erase unit)
• Minimum 10K erase cycles endurance
• Greater than 10 years data retention at 85 °C
• Lock-bits for memory protection
• Data retention in any state
silabs.com | Building a more connected world.Rev. 1.1 | 54
Page 55
Reference Manual
Memory and Bus System
4.5 SRAM
The primary task of the SRAM memory is to store application data. Additionally, it is possible to execute instructions from SRAM, and
the DMA may be set up to transfer data between the SRAM, Flash and peripherals.
• Up to 32 KB of memory
• Bit-band access support
• Set of RAM blocks may be powered down when not in use
• Data retention of the entire memory in EM0 Active to EM3 Stop
Note: The individual RAM sections may be smaller on some parts, however, the RAM AHB slaves maintain a contiguous address map.
For example, if RAM0 is half-size on a part, then RAM1 is relocated to begin immediately after RAM0's last address. Using the provided
software header files and linker scripts allows handling of this remapping in an autonomous manner.
silabs.com | Building a more connected world.Rev. 1.1 | 55
Page 56
Reference Manual
Memory and Bus System
4.6 DI Page Entry Map
The DI page contains production calibration data as well as device identification information. See the peripheral chapters for how each
calibration value is to be used with the associated peripheral.
The offset address is relative to the start address of the DI page (see 7.3 Functional Description).
OffsetNameTypeDescription
0x000CALROCRC of DI-page and calibration temperature
0x020EXTINFOROExternal Component description
0x028EUI48LROEUI48 OUI and Unique identifier
0x02CEUI48HROOUI
0x030CUSTOMINFOROCustom information
0x034MEMINFOROFlash page size and misc. chip information
0x040UNIQUELROLow 32 bits of device unique number
0x044UNIQUEHROHigh 32 bits of device unique number
0x048MSIZEROFlash and SRAM Memory size in kB
0x04CPARTROPart description
0x050DEVINFOREVRODevice information page revision
0x054EMUTEMPROEMU Temperature Calibration Information