Predicament

Developer would like to append an *.s (assembly) file to ARM Cortex M based MCU project in Simplicity Studio. The compilation will be performed by GCC toolchain.

Solution

In general, Simplicity Studio projects with GCC toolchain can compile the assembly files. An example for this characteristic is the startup files which have been written in assembly code. More description about the startup file: https://www.silabs.com/community/mcu/32-bit/knowledge-base.entry.html/2018/11/11/understand_the_gnua-zyam Therefore, the developer should add the assembly file to the project and the toolchain will handle it.

Steps

Step 1

Right click on the desired folder of the project -> New -> File

Give name and extension (.s) to the file, then click Finish

Step 2

Compile the project, after the compilation a new object file will appear in the compilation related folder.

I see in the CMU chapter that two clocks are present for the PDM (Pulse Density Modulation) interface. There is HFCLK_PDM and HFPERCLK_PDM. what is the difference between these two clocks as their names are very similar?

Despite their similar names and use by the PDM interface, the HFCLK_PDM and HFPERCLK_PDM have entirely different purposes. HFCLK_PDM is the clock source for the PDM receiver core just as a synchronous serial audio interface (e.g. I2S/SSI) will have its own specific clock that is usually some multiple of the audio sampling clock.  The CMU PDM Control Register (CMU_PDMCTRL) allows you to select this clock , which can be asynchronous to the main system clock. In Figure 42.1 of the Giant Gecko 12 Reference Manual, this is the clock labeled hfpdm_clk.

HFPERCLK_PDM is the PDM module bus clock. It clocks all of the register and power management logic in the PDM block. You would disable the PDM module by disabling the HFPERCLK_PDM in the CMU_HFPERCLKEN0 register, which is the reset state when you power up. Before the PDM can be used, you must enable HFPERCLK_PDM, then enable HFCLK_PDM.

Abbreviations

• KBA - Knowledge Base Article
• SDIO Driver - Low level software package for SDIO and SD Card
• Host Spec - SD Host Controller Simplified Specification Ver3.00 standard Jump to the Standard
• Card Spec - Physical Layer Simplified Specification Ver 6.00 Jump to the Standard

Short introduction

The purpose of this KBA is to make an initial, low level function library (hereinafter: SDIO driver) for the SDIO peripheral of the EFM32GG11B Giant Gecko STK and then a short example code will demonstrate its operation. Furthermore, this KBA's primary role is to give a good base for further development and it can perform easy operations between memory card and the MCU. Low "level function" means that the SDIO Driver uses just the MCU and the SDIO peripheral related registers and the implemented example will not use higher level software, e.g.: FAT handler software package. Initial means that the implementation from SD Host Controller Simplified Specification Ver3.00 (hereinafter: Host Spec) and from the Physical Layer Simplified Specification Ver 6.00 (hereinafter: Card Spec) is not holistic. In other words, the necessary relevant parts of the previously mentioned specifications are implemented. The further sections will describe these parts.

Figure 1 - High Level description

Figure 1 gives a high-level schematic about the used things (HW and SW) and newly implemented codes. The previously available things are marked with grey color and what this KBA implements are marked with green and orange color.

What can the reader expect from the example code

The whole example section is realized in the 'main.c' file. This example will perform basic, low level operations between the MCU and the memory card. Basic means that for addressing the memory card, the example code will use direct SD card section's address to perform the write and read operations (no FAT table).

What can the reader expect from the SDIO driver

The reader will get an initial, low level driver for the SDIO host and for the memory card with the following features:

• 4 lines DATA width for read/write operation
• adjustable SD clock speed (tested on 100kHz and 400kHz)
• uses processor to read/write data (no DMA)
• for read/write operations the software uses single section read/write functionality
• does not support SDIO devices (e.g.: SDIO Bluetooth, GPS)

Description of the SDIO driver

Base information for the proper understanding and for further development is that the EFM32GG11B related SDIO peripheral and the SDIO host peripheral (which is described in the Host Spec) are the same peripheral. Therefore, you can use Host Spec documentation for using the SDIO peripherals. It is good news for developers because the efm32gg11b reference manual's section about the SDIO peripheral is just 60 pages, but Host spec is much more, nearly 160 pages. Both specifications (Host Spec and Card Spec) give a very good and easily understandable description about the operation of the SDIO and the memory card. Therefore, the primary role of this chapter is not copy paste sections from the specifications. Instead of that, it will give a passage between the implemented SDIO driver and the used specifications.

The SDIO driver can be logically divided to 2 sub drivers

• SDIO host driver
• SD card driver

The SD card driver is mostly the memory card command related items in the source code (e.g.: CMD24 macro). The SDIO host driver related items are mostly the 'Sequences' which are defined in the Host Spec on page 92. The border between SDIO host and SD card drivers is melted because both document describe the same sequences, but the descriptions are based on different point of view.

Function structure of the SDIO Driver

The SDIO driver has 2 types of functions:

• public
• private

This kind of classification helps for developers/users which functions are necessary for using of SDIO Driver and which ones contribute for the inner operation of the SDIO Driver. In case of using, the user can see which functions are developed in order to using (public functions) and which functions performs inner operation (private functions, these functions are not directly usable functions). In case of development, the developer can see which functions inner functions are and they can easily modify/delete/create these kinds of functions.
The private functions cannot be called from outside of the SDIO driver. These functions contribute to the simplicity of the module, perform inner mechanism which based on the state of the SDIO/SD registers, etc. Naming convention of these functions is: SDIO_S_comprehensive_name. The public functions can be called from outside of the SDIO driver. These functions realize main desired functionalities. Naming convention of these functions is: SDIO_comprehensive_name. Generally, these functions call and schedule the driver related private functions. The following functions are public functions

• SDIO_Init()
• SDIO_WriteSingleBlock()
• SDIO_ReadSingleBlock()
• SDIO_GetActCardStateType() - (this function will not be used in this example)

The following mapping table (Table 1) will help to establish the connection between the functions of the SDIO driver and the Host/Card Specs.

Table 1 - Mapping Table

Short description about the public functions

void SDIO_Init()

The goal of this function is to initialize the MCU related SDIO peripheral, initialize the SD card and at the end modify the state of the SD card from standby to transfer mode. In transfer mode the SD card can write and read its sections.

void SDIO_ReadSingleBlock() and void SDIO_WriteSingleBlock()

The function will initiate a single read or write operation between the SD card and the MCU. Both functions have 3 parameters:

• SDIO register's address
• SD card related block address
• MCU related memory address

Independently of the direction of the operation, the amount of the data will be 512 bytes which is implemented in the SDIO_Init() function. For the read/write operation the MCU will use its CPU - no DMA support, but it also can be implemented in the SDIO_Init() function.

Description of the example code

Bullet points about the operation:

• reserves 1024byte area from the MCU's RAM
• this reserves area will be filled with 'F' characters
• general MCU initialization
• initialize STK according to use soldered micro SD card slot
• initialize SDIO host and memory card
• Write to memory card (512byte data from reserved memory area)
• Read from memory card (to reserved memory area)
• previous 2 points again

User guide for the example code

• import the project to Simplicity Studio
• insert a memory card to the SD socket of BRD2204A (ATTENTION! MAKE BACKUP BEFORE THE USING OF MEMORY CARD! THE CONTENT OF THE MEMORY CARD CAN BE SPOILED!)
• attach BRD2204A development board to your computer
• start project in Debug mode
• insert break points to the main.c file (around read/write operations)
• check the content of the reserved MCU's RAM array
• at the end check the content of the memory card (insert the memory card to a card reader and check the content with a hex viewer)

At the end of the execution the reserved ram area of the MCU will be filled with the content of the selected memory card's data and the memory card's selected pages will be filled with the content of reserved memory's content. (in the case of example with 'F').

Tested configuration

• Board: EFM32GG11B STK - BRD2204A Rev BD4
• Windows 10 operaion system
• Simplicity Studio V4.
• 32-bit MCU SDK Version: 5.6.1.0
• SD Cards:
  • Samsung MB-MA080 (8GB, SDHC, 6)
  • No name (32GB, SDHC)

Here is an erroneous use case, user intend to set debug lock bits by locating a constant at DLW.

1. Add a LOCKBITS memory region in ld file, and then create a new section called .dlwLockBits.

MEMORY
{
	FLASH (rx) : ORIGIN = 0x00000000, LENGTH = 262144
	RAM (rwx) : ORIGIN = 0x20000020, LENGTH = 32660 
	LOCKBITS (rwx) : ORIGIN = 0x0FE04000, LENGTH = 2048
}
…
  __etext = .;
  
  .dlwLockBits :
  {
    . = . + 508;
    KEEP(*(.dlwLockBits))
  } > LOCKBITS
…

…
const uint32_t debugLockWord __attribute__ ((section (".dlwLockBits"))) = 0;
…

Fill the section with the initial value 0xFF can avoid the AAP lock. In case that user need to keep some lock bits(like user page lock) should not use this method.

MEMORY
{
	FLASH (rx) : ORIGIN = 0x00000000, LENGTH = 262144
	RAM (rwx) : ORIGIN = 0x20000020, LENGTH = 32660 
	LOCKBITS (rwx) : ORIGIN = 0x0FE04000, LENGTH = 2048
}
…
  __etext = .;
  
  .dlwLockBits :
  {
    . = . + 508;
    KEEP(*(.dlwLockBits))
  } > LOCKBITS = 0xFF
…

MEMORY
{
	FLASH (rx) : ORIGIN = 0x00000000, LENGTH = 262144
	RAM (rwx) : ORIGIN = 0x20000020, LENGTH = 32660 
	LOCKBITS (rwx) : ORIGIN = 0x0FE041FC, LENGTH = 4
}
…
  __etext = .;
  
  .dlwLockBits :
  {
    KEEP(*(.dlwLockBits))
  } > LOCKBITS
…

But it’s not recommended to set debug lock bits in this way. We have a debug lock example (msc\debug_lock) below demonstrates how to lock the debug interface by clearing debug lock bits.

https://github.com/SiliconLabs/peripheral_examples.

Question: How do I configure the ADC to use in EM2 and EM3 mode?

Answer: The following conditions must be met:

1. ADC must be clocked by AUXHFRCO.
2. ADC must operates in asynchronous mode.
3. HFPERCLK must be at least 1.5 times higher than the ADC_CLK (so AUXHFRCO).

If the chip enters EM2/EM3 mode when ADC is busy without using AUXHFRCO, then the ADC clock will stop but the ADC will stay on, resulting in higher supply current. If this occurs, the EM23ERR interrupt flag will be set.

For EM2 DeepSleep or EM3 Stop operation of the ADC, the ADC_CLK must be configured for AUXHFRCO as this is the only available option during EM2 DeepSleep or EM3 Stop. The ADC_CLK source should not be changed as the system enters or exits various energy modes, otherwise measurement inaccuracies will result.

The following example code initializes the ADC as reqired for EM2/EM3 mode:

 void initADC(void) {
  // Enable ADC0 clock
  CMU_ClockEnable(cmuClock_ADC0, true);
   // Select AUXHFRO band
   CMU_AUXHFRCOBandSet(cmuAUXHFRCOFreq_1M0Hz);
   // Select AUXHFRCO for ADC ASYNC mode so that ADC can run on EM2
   CMU->ADCCTRL = CMU_ADCCTRL_ADC0CLKSEL_AUXHFRCO;
   // Make this change to ensure the AUXHFRCO is selected
   ADC0->CTRL = ADC_CTRL_ADCCLKMODE_ASYNC;

  // Declare init structs
  ADC_Init_TypeDef init = ADC_INIT_DEFAULT;
  ADC_InitSingle_TypeDef initSingle = ADC_INITSINGLE_DEFAULT;

  // Modify init structs and initialize
  init.prescale = ADC_PrescaleCalc(40000, 0);
  init.em2ClockConfig=adcEm2ClockOnDemand;

  initSingle.diff = false; // single ended
  initSingle.reference = adcRef2V5; // internal 2.5V reference
  initSingle.resolution = adcRes12Bit; // 12-bit resolution
  initSingle.acqTime = adcAcqTime4; // set acquisition time to meet minimum requirements

  // Select ADC input. (PE11 -> EXP header pin 6)
  initSingle.posSel = adcPosSelAPORT4XCH11;

  ADC_Init(ADC0, &init);
  ADC_InitSingle(ADC0, &initSingle);

  // Enable ADC Single Conversion Complete interrupt
  ADC_IntEnable(ADC0, ADC_IEN_SINGLE);

  // Enable ADC interrupts
  NVIC_ClearPendingIRQ(ADC0_IRQn);
  NVIC_EnableIRQ(ADC0_IRQn);
}

Related articles: ADC in async mode | ADC with AUX clock

Questions:

A. What is Errata RMU_E103

B. What devices are affected?

C. How can I prevent this issue from affecting my application?

D. Are there plans to fix this issue?

Answers:

A.

Erratum RMU_E103 describes an issue with certain Series 0 EFM32 devices. Affected parts see a gap in the coverage of the brown-out and power-on reset sources around 1.3V . The exact gap in reset coverage will be part specific if present at all. If an affected device is operating in this problematic VDD range, the device will attempt to start up while well below the tested supply voltage for the microcontroller.

The device takes a short amount of time to start up. For a typical part at normal voltages this is 163 µS. If the startup succeeds, the device will then attempt to execute code, but may not be able to do so at low voltage. At this low voltage neither a successful startup or successful code execution is guaranteed.

Note that during fast voltage ramps, e.g. power-on and power down events, VDD will not be at a problematic voltage long enough for the device to start up. However, if VDD is held at around 1.3V for a sufficient duration, the device may enter this undefined state where code is being executed below tested voltages.

The workaround to this issue is to assert a pin reset during the low VDD event. If a pin reset is asserted, the device cannot attempt to start up. The reset pin should be driven low prior to VDD falling below the BOD reset threshold.

B.

RMU_E103 is an erratum that effects some devices from the following EFM32 Series 0 products:

• EFM32 Zero Gecko
• EFM32 Happy Gecko
• EFM32 Wonder Gecko
• EFM32 Leopard Gecko
• EFM32 Tiny Gecko (Series 0 only)
• EZR32 Happy Gecko
• EZR32 Wonder Gecko
• EZR32 Leopard Gecko

This erratum does not affect EFM32 Gecko, Giant gecko, or any EFM32 Series 1 devices.

C.

Steps can be taken to both detect if RMU_E103 is occurring on a specific device, and to prevent code from executing at low voltage.

• To detect a gap in reset source coverage, Measure the current consumption of the device while gradually lowering VDD. If the device attempts to start up at low voltage, current consumption will increase. The diagram below shows an example VDD waveform that can test for code execution at low voltage and the corresponding spike in current consumption. Note that the current and voltage values are approximate and will vary across parts, applications, and environments.

Figure 1. VDD Test for RMU_E103 Current Consumption

• To avoid code execution at low voltage, avoid slow VDD ramps during normal operation. If the application is likely to experience a slow VDD ramp or see low supply voltage for any significant duration of time, use an external device or user input to assert a pin reset at some VDD level > 1.96V (with sufficient time to engage the internal reset before VDD reaches 1.96V).

Questions:

A. What is Errata RMU_E102?

B. What devices are affected?

C. How can I prevent this issue from affecting my application?

D. Are there plans to fix this issue?

Answers:

A.

Erratum RMU_E102 describes an issue with certain Series 0 EFM32 devices. Affected parts may see voltage regulator failure when subjected to the following scenario:

1. VDD begins to fall due to some external event
2. VDD and Regulator output (DECOUPLE) voltage decay to 0.8-1.2V
3. Power supply to VDD is restored and VDD returns to a nominal value  prior to VDD and DECOUPLE reaching < 0.8V 

In this type of sequence mentioned above , the voltage regulator may fail to re-initialize. If this occurs, the DECOUPLE pin will continue to decay to 0V, even after VDD has recovered. In this state, the core logic is not powered, and the device will be unable to execute code or respond to a pin reset. An affected device will successfully recover from this state if power cycled.

Additionally, if a pin reset is applied prior to the Brown out detector (BOD) asserting reset, the regulator will always re-initialize successfully. The BOD threshold varies between 1.74-1.96V, so a pin reset should be asserted before VDD drops below 1.96V. The pin-reset should be held low until VDD is >1.98V, which is the maximum power-on reset threshold.

The diagrams below demonstrate an example VDD waveform that can cause the regulator initialization to fail.

Figure 1. VDD Decay and Recovery

This figure shows the proper recovery sequence, or what will happen to a working device (not affected by RMU_E102) when VDD falls to 0.9V. Here, the regulator restarts after VDD is restored, and the DECOUPLE voltage returns to 1.8V.

Figure 2. VDD Decay and DECOUPLE failure

This figure shows the failure mode for a device affected by RMU_E102 when VDD falls to 0.9V. As you can see the regulator fails to re-initialize properly, and the DECOUPLE voltage continues to fall until reaching 0V. At this point a power-on reset must be performed to recover the device.

As mentioned above, there are two workarounds to the issue.

• For a device that is already in lock-up, perform a power cycle to recover to a normal state. To do this VDD must be driven to 0V before powering back on.
• For a device that may experience a drop in VDD to 0.8-1.2V, use an external device or user input to assert a pin reset at some VDD level > 1.96V (with sufficient time to engage the internal reset before VDD reaches 1.96V). Additionally, the reset should be held low until power is reconnected and VDD is greater than 1.98V.

B.

RMU_E102 is an erratum that effects some devices from the following EFM32 Series 0 products:

• EFM32 Zero Gecko
• EFM32 Happy Gecko
• EFM32 Wonder Gecko
• EFM32 Leopard Gecko
• EFM32 Tiny Gecko (Series 0 only)
• EZR32 Happy Gecko
• EZR32 Wonder Gecko
• EZR32 Leopard Gecko

This erratum does not affect EFM32 Gecko, Giant Gecko, or any EFM32 Series 1 devices.

C.

To avoid issues caused by RMU_E102, the following precautions should be taken.

• Avoid and check for intermittent battery or power supply connections to VDD. The issue was originally discovered in situations where a loose battery connection during assembly caused VDD to repeatedly drop to ~.9V and then recover to a nominal value. This represents a worst-case scenario for inducing RMU_E102, as multiple VDD disconnections occurred within a very short time frame.
• If your application is likely to experience frequent disconnects from the power supply, ensure that the reset pin is driven low prior to disconnecting.

Interrupts are a commonly used technique in microcontrollers allowing CPU-external systems to indicate the need of CPU attention immediately. When an Interrupt Request (IRQ) is received, the CPU will store its current state and then switch to the Interrupt Service Routine (ISR).

In EFM32, each IRQ has its own ISR and the starting address of each ISR is stored in the interrupt vector table. When an interrupt is triggered, the CPU automatically jumps to the corresponding address in the vector table which contains an address to the relevant ISR.

By default, the assembler startup file (for e.g. startup_efm32gg11b.S) only defined the handler for reset, that will be executed after power up or a warm reset for system initialization. And all of the other interrupts handlers are exported as “weak”, and the default handlers of the interrupts are relocated to “Default_Handler” which implemented as an endless loop by the directive “b .”

    .align  1
    .thumb_func
    .weak   Default_Handler
    .type   Default_Handler, %function
Default_Handler:
    b       .
    .size   Default_Handler, . - Default_Handler

Question:

If I want to generate an event with a period equal to ‘n’ LFCLK cycles, what should I set the TOP value to when using the EFM32 series 0/1 LETIMER or EFM32 series 1 RTCC?

Answer:

When using the EFM32 series 1 RTCC and generating an event (i.e. interrupt or PRS pulse) on a compare match value, the period of the event will be n+1, where n is the RTCC_CCx_CCV value for the channel being used.  This is illustrated in the following figure (Figure 12.3, EFM32JG12 reference manual, page 367):

When using the EFM32 series 0/1 LETIMER to generate an event (i.e. interrupt or PRS pulse) on a counter underflow event, the period of the event will also be n+1, where n is the COMP0 value (when COMP0 is used as the counter TOP value).  This is illustrated in the following figure (Figure 20.8. LETIMER Simple Waveforms Output, EFM32JG12 reference manual, page 713):

Question:

Is there a way that I can obtain older 32-bit MCU SDK versions in Simplicity Studio?

Answer:

It should be possible to download and use an older SDK version in Simplicity Studio when developing code for 32-bit EFM32 devices in Simplicity Studio.  The following steps should allow a user to obtain older SDK versions:

1) In the Simplicity Studio [Launcher] perspective, click the [Software Update] button:

2) If necessary, click on [Package Manager]:

3) In the [Package Manager] window, select “32 bit MCU” from the [Categories] dropdown menu and select “All” from the [Version] dropdown menu:

4) Select the desired SDK version and click [Install].  Once installation is complete, that SDK should be available for use in example projects as well as empty C8051/EFM8 projects. 

As of this writing, it appears that 32 bit MCU SDK versions as far back as 32 bit MCU SDK – 4.4.0 and Gecko SDK v4.4.0 – 4.4.0 are available using this method.