AN1011: Standalone Programmer via the SWD Interface

Key Points

• The Serial Wire Debug (SWD) interface is a two-wire interface used by Silicon Labs EFM32 Gecko, EZR32, and EFR32 Wireless Gecko devices.
• The programmer writes directly to the target device Memory System Controller (MSC) registers over the SWD interface.
• Future Silicon Labs EFM32/EFR32/EZR32 devices can be easily added to the programmer.

1. Hardware Overview

The standalone programmer reads binary data from a Mass Storage Device (MSD) and stores it to the external EBI NAND Flash or SPI NOR Flash for device programming. The programmer uses GPIO to emulate the Serial Wire Debug (SWD) interface to program the target device. The user interface is handled by push buttons, LEDs, and LCD module.

1.1 Hardware Platform

There is a compile option to select the hardware platform for the standalone programmer. The programming firmware supports two hardware topologies: one which is based on the STK boards, and the other which is based on a custom hardware design. These are described in the following sections.

This package can be found on the Silicon Labs website (www.silabs.com/32bit-appnotes) or within Simplicity Studio using the [Application Notes] tile.

1.1.1 EFM32 STK

The EFM32GG_STK3700 and EFM32WG_STK3800 can be used as the EFM32 STK hardware platform of the standalone programmer.

• Handy, plug and run: no host PC is required.
• On board SEGGER JLink debugger and USB virtual COM port (CDC).
• Supports USB host, and MCU can run up to 48 MHz.
• Onboard 32 MB NAND Flash can be used to store the binary image.
• The upper 512 KB internal flash of EFM32GG990F1024 on EFM32GG_STK3700 can also be used as cache to speed up the programming process.
• Minimal hardware is required to build the programmer.

1.2 Expansion Header for External Hardware and Target Device

The 20-pin expansion header (P100) of EFM32 STK is used to connect target device and optional SPI LCD module.

1.1.2 Customized Hardware

Alternatively, the EFM32WG332F64/128/256 and EFM32GG332F1024 devices can be used on a custom hardware platform to implement the standalone programmer.

• PCB layout is required.
• Supports USB host, and MCU can run up to 48 MHz.
• Low pin count 4 MB SPI NOR Flash can be used to store the binary image.
• The upper 512 KB internal flash of EFM32GG332F1024 can be used as a cache to speed up the programming process.
• Supports the option to configure it as a gang programmer to program up to 4 or 8 devices sequentially.

1.2 Memory for Binary Image Storage

There is a compile option to select EBI NAND flash or SPI NOR flash for the binary image storage.

1.2.1 EBI NAND Flash

The on board NAND256W3A NAND flash is organized as 512 bytes per page, 32 pages (16 KB) per block, with the total memory size of 2048 blocks (32 MB). The NAND flash is accessed by the External Bus Interface (EBI) of EFM32GG or EFM32WG.

If the binary image is not a multiple of the flash page size (512 bytes), the remaining bytes are padded with 0xFF to keep the program image aligned with the flash page.

1.2.2 SPI NOR Flash

The selected SPI NOR flash is organized as 256 bytes per page, 4 KB (16 pages) per sector, 64 KB per block and total memory size is 1024 sectors or 64 blocks (4 MB). The SPI flash must support 4 KB sector erase on the entire device, for example, the Macronix MX25L3206E or Cypress/Spansion S25FL132K. The SPI NOR flash is accessed by the SPI interface (USART) of EFM32GG or EFM32WG.

If the binary image is not a multiple of the flash page size (256 bytes), the remaining bytes are padded with 0xFF to keep the program image aligned with the flash page.

1.2.3 Cache

To eliminate the read access from external memory, the programmer uses internal flash memory on the MCU to cache the main flash image from external memory if the image size is less than or equal to 512 kB.

This feature is available on a programmer equipped with 1 MB flash EFM32 Giant Gecko. The lower 512 kB flash is used for the programmer firmware whereas the upper 512 kB flash is available for the target firmware image cache.

1.3 USB Interface

The EFM32 is configured as a USB Host and is designed to communicate with a Mass Storage Device (MSD) USB class (e.g. memory stick).

1.4 LCD Module

The selected LCD module should be controlled by SPI and operated on 3.3 V. The current implementation is 4 x 20 dot matrix LCD module with a Solomon Systech SSD1803 LCD controller and driver.

1.5 Serial Port

When DEBUG_USB_API is turned on and USER_PUTCHAR is defined, useful debugging information will be output on the serial port. Compiling with the DEBUG_EFM_USER flag will also enable all asserts in both emlib and in the USB stack. If asserts are enabled and USER_PUTCHAR defined, assert texts will be output on the serial port.

The serial port can also be used as a display interface when the LCD module is not available. The serial TX data is routed to the STK virtual COM port by setting the EFM_BC_EN line high.

1.6 Gang Programmer Mode

The gang programmer mode is available when using a custom hardware platform design. The DIP switch is used to select x1, x4 or x8 operation mode. Four 1-of-8 FET Multiplexers (for example, Texas Instruments SN74CB3Q3251) are used to route the required signals to different sockets for target device programming.

2. Software Overview

This section covers the software drivers required for the standalone programmer.

The related software modules are found under the Simplicity Studio installation path. Example default locations on Windows for Simplicity Studio V3.3 are:

• C:\SiliconLabs\SimplicityStudio\v3\developer\sdks\efm32\v2\usb\src
• C:\SiliconLabs\SimplicityStudio\v3\developer\sdks\efm32\v2\kits\common\drivers
• C:\SiliconLabs\SimplicityStudio\v3\developer\sdks\efm32\v2\reptile\fatfs
• C:\SiliconLabs\SimplicityStudio\v3\developer\sdks\efm32\v2\kits\EFM32GG_STK3700\examples\nandflash

2.1 USB Host

The programmer uses the USB host stack in the "usb\src" directory and the MSD modules in the "drivers" directory to implement support for Mass Storage Device.

The FAT support for MSD is provided by fatfs in the "reptile\fatfs" directory.

2.2 LCD Module

The SPI LCD driver is used to retarget the printf() function to the LCD module and the retargetio.c file resides in the "drivers" directory is required.

2.3 Serial Port

The serial port driver is modified from the retargetserial.c file in "drivers" directory. It is used to retarget the printf() function to the serial TX. The retargetio.c file resides in the "drivers" directory is required.

2.4 Upload Image

The programmer acts a USB host that can connect to a Mass Storage Device (MSD) such as a memory stick. The programmer searches for a "proginfo.txt" file in the root directory of the USB MSD which contains the filename of the binary image. The programmer then opens the binary file in root directory and reads the firmware image from the MSD and copies it to the external memory and cache (if available) for programming the target device.

The NAND flash driver is modified from the "nandflash" example of the EFM32GG_STK3700 STK.

The SPI NOR flash driver is used to erase the flash page, read data from the flash page and write data to the flash page.

2.5 Program Target Device

There are two main strategies that can be used when programming the target device. The first option is to write directly to the target device's Memory System Controller (MSC) registers over the Serial Wire Debug (SWD) interface.

The second option is to first write a program directly to target device's RAM and then let this program control the MSC registers. Such a program is called a flash-loader.

Program by writing directly to MSC registers is chosen in this application note since this method is simple and easy to upgrade to support new target devices. Through optimizations on flash erase and write operations, the program speed is close to the flash-loader approach.

See "AN0062: Programming Internal Flash over the Serial Wire Debug Interface" for more information on how to access the debug interface of the target device and how to use this interface to program devices.

2.5.1 Bit-Bang

The major overhead on writing directly to MSC registers method is to emulate the SWDIO and SWCLK signals by bit-banging GPIO pins. In order to speed up this process, the GPIOs of SWCLK and SWDIO for the target device must on the same GPIO port group (0-7 or 8-15). The target RESET line and other signals should not be connected to this port since the software writes to the entire port at once when bit-banging the SWCLK and SWDIO signals.

The functions readMem() and writeMem() in utils.c source file are used to read or write one 32-bit word from or to the target device's registers or memory.

2.5.2 Flash Erase

There are three ways to erase the flash of the target device:

Page Erase

• A page erase can be initiated from software using ERASEPAGE in MSC WRITECMD register. The page erase operations require that the address is written into the MSC ADDRB register.

Mass Erase (Not Supported on EFM32 Gecko and EFM32 Tiny Gecko)

• A mass erase can be initiated from software using ERASEMAINO and ERASEMAIN1 in MSC WRITECMD register. The ERASEMAINO is to erase the entire flash or lower half of the flash if device supports read-while-write. The ERASEMAIN1 is to erase the upper half of the flash if device supports read-while-write.

Device Erase

• Device erase is issued over the Authentication Access Port (AAP) interface and erases all flash, SRAM, the Lock Bit (LB) page, and the User data page Lock Word (ULW). This method is not used in this application note.

The flash erase timing (page and mass erase) is grouped into two categories.

• Page and mass erase time is 20-20.8ms
  EFM32 Gecko Series 0 and EZR32 Series 0 devices (variable newFamily = false).
• Page and mass erase time is 20-40ms
  EFM32 Gecko Series 1 and EFR32 Wireless Gecko Series 1 devices (variable newFamily = true).

To reduce time for flash erase process, the programmer should avoid erasing the target main flash page by page especially for devices with larger flash memories and smaller page sizes. The EFM32 Gecko and EFM32 Tiny Gecko do not support mass erase so their device flash erase operation is time consuming.

2.5.3 Combine Bootloader with Application Binary File

The mass erase can only be used on an application binary image with start address equal to 0x00000000.

There are cases the program start address is not 0x00000000 and the time-consuming page erase process must be used.

• Keep the pre-programmed bootloader and program the application firmware on a flash page size boundary address.
• Program the bootloader at 0x00000000, then program the application firmware on a flash page size boundary address.

The solution is to combine the bootloader and application firmware into one binary file so the program start address can be set to 0x00000000 for mass erase.

To achieve this, it needs a tool called Simplicity Commander, installed along with Simplicity Studio in a subfolder of the install folder (c:\SiliconLabs\SimplicityStudio\v3\SimplicityCommander). See UG162: “Simplicity Commander Reference Guide” for more information.

Extract the Simplicity Commander from Commander_pkg_0.14.0.zip to the current folder or another folder (e.g. C:\SiliconLabs\Simplicity Commander) to execute the command line interface.

Connect any EFM32 STK with enough flash memory for the bootloader firmware to a PC, invoke the Command-Line Interface (CLI) of Simplicity Commander. To execute the command of Simplicity Commander, start a Windows command window and change to the Simplicity Commander directory (e.g. C:\SiliconLabs\Simplicity Commander).

For simplicity, put all related binary files in the Simplicity Commander directory and execute a mass erase for the device on the STK.

> commander device masserase

Flash the bootloader image (e.g. bootloader-giantgecko.bin from AN0003) to the target device, starting at 0x00000000.

> commander flash bootloader-giantgecko.bin --address 0x0

Read the flash contents from 0x0 to the start address of the application firmware (e.g. 0x1000, which must align with a target device flash page size boundary) and store it to a binary file (e.g. giantbl4k.bin).

The address range is non-inclusive, meaning that all bytes from 0x0 up to and including 0xFFF are read out.

> commander readmem --range 0x0:0x1000 --outfile giantbl4k.bin

The entire flash was erased before program the bootloader image so the gap between bootloader and application firmware is filled with 0xFF.

Use the MSDOS copy command to combine output binary file (giantbl4k.bin) and application firmware (e.g. giantapp.bin).

> copy giantbl4k.bl.bin/b + giantapp.bin/b ggblapp.bin/b

The combined binary file (ggblapp.bin) can now be used for device programming with program start address at 0x00000000.

2.5.4 Flash Write

The write operation requires the address to be written into the MSC ADDRB register. After each 32 bit word is written, the internal address register will be incremented automatically by 4 (except EFM32 Gecko family). When a word is written to the MSC WDATA register, the WDATAREADY bit of the MSC STATUS register is cleared. When this status bit is set, software can write the next word.

The EFM32 Giant Gecko devices have the ability to do double writes to the flash. This is enabled by setting the WDOUBLE bit in the MSC WRITECTRL register, and only has effect on the main pages of the flash. When double writes are enabled, MSC WDATA accepts two 32-bit words before a flash write is started.

The flash write timing can be grouped into two categories.

• Flash write time is 20 µs minimum
  EFM32 Gecko Series 0 and EZR32 Series 0 devices (variable newFamily = false).
• Flash write time is 20-40 µs
  EFM32 Gecko Series 1 and EFR32 Wireless Gecko Series 1 devices (variable newFamily = true).

To reduce the time for the flash write process, the programmer should try to skip polling the WDATAREADY bit in MSC STATUS register after writing each 32 or 64-bit word since the register read process is time consuming (~65 µs). The alternative is to add a fixed micro second delay between each write to make sure the maximum write time can be met. The EFM32 Gecko family does not support auto address increment so it needs to load new address into the MSC ADDRB register prior to writing each 32 bit word.

2.5.5 Flash Verify

The programmer verifies the target flash contents with external memory or cache (if available) to make sure that no errors occurred during the programming process. The auto increment of Transfer Address Register (TAR) is for burst read within TAR wrap around boundary, the TAR must be initialized at every TAR wrap boundary to setup the next flash read address.

2.5.6 Debug Access and Authentication Access Port (AAP) Access Lock

The debug access to the Cortex core is locked by clearing the Debug Lock Word (DLW, word 127) in the Lock Bits page and resetting the device. When debug access is locked, the debugger can access the AAP registers. However, the connection to the Cortex core and the whole bus system is blocked.

The AAP access is locked by clearing the Authentication Access Port (AAP) lock word (ALW, word 124) of the Lock Bits page. Once the AAP is locked, it is impossible to perform an external mass erase and the AAP lock cannot be reset. The only way to program the device when AAP is locked is through a bootloader or by software already loaded into the flash.

The lock feature can be grouped into two categories:

• Devices support debug access lock only
  EFM32 Gecko Series 0 and EZR32 Series 0 devices (variable newFamily = false).
• Devices support debug access and AAP lock
  EFM32 Gecko Series 1 and EFR32 Wireless Gecko Series 1 devices (variable newFamily = true).

2.6 Compile Options

The programmer has its corresponding header files to setup the software and hardware environment. The hardware environment is configured by the header files as shown in the following table, whereas the software environment is configured by the progconf.h and the related parameters shown in the next table.

2.7 Add a New Silicon Labs EFM32/EFR32/EZR32 Device to the Programmer

The new Silicon Labs EFM32/EFR32/EZR32 device should have a Serial Wire Debug (SWD) interface with a Cortex-M0+, Cortex-M3 or Cortex-M4 core. The known differences between current EFM32/EFR32/EZR32 families are Chip Information (Family Code...) in the Device Information (DI) page, the Memory System Controller (MSC) Base Address, the AAP Identification Register (IDR) value if debug access is locked, the wrap boundary of the Transfer Address Register (TAR) on the AHB-AP, the flash erase timing (see Table 2.2 Device Flash Organization and Erase Timing on page 11 for details) and the flash write timing (see Table 2.3 Device Flash Write Features and Timing on page 15 for details).

If the differences in the new device are identified, the corresponding header files and source files should be modified to support the new device. The parameters for software configuration in Table 2.5 Parameters in progconf.h File for Software Configuration on page 20 may need to be changed to adapt to the new device. The following table is an example showing how to add EFR32MG support to the programmer.

3. User Interface

3.1 Push Buttons

There are two push buttons, PB0 and PB1, on the programmer.

• PB0:
  • Scrolls down in main menu.
  • Returns to main menu from submenu.
• PB1:
  • Executes the selected item.

3.2 LEDs

There are two LEDs, LED0 and LED1, on the programmer.

• LED0:
  • On if an error occurs.
• LED1:
  • On if the programmer is busy, indicating push buttons are ignored.
  LED0 and LED1 are also used to display menu status if an LCD is not available for the programmer.

3.3 Display

There is compile option to select display interface for standalone programmer.

3.3.1 No Display

This is not recommended since the programmer status can only be indicated by LED0 and LED1.

3.3.2 External LCD Module

• For menu operation and display information when programming the device.
• Use the software driver to retarget printf() function to the LCD module.

3.3.3 Serial Interface

• For debugging and menu operation if LCD is not available.
• USB to UART Bridge is not required if using EFM32GG or EFM32WG STK (onboard USB virtual COM port) as programmer.
• Use software driver to retarget printf() function to serial interface (115200 N 8 1).
• PC terminal software is required to display data from serial interface.

4. Operation Flow

4.1 Text File and Binary Image

The programmer retrieves the target binary image from a USB MSD and stores it to external memory (EBI NAND flash or SPI NOR flash) for device programming.

The USB MSD must have a text file (default name is "proginfo.txt") that provides related information for programmer to load the binary file and program the device. The corresponding text (.txt) and binary (.bin) files must be stored in the root directory of the USB MSD.

The content of a text file must be in the following formats:

<Main flash binary file name> <Flash start address> <Lock AAP or Debug access>

<User page binary file name> <User page address>

Long filename (LFN) is not supported on text and binary files. The address is in hexadecimal format (8 digits without "Ox" prefix).

The following example text file programs "main flash only" from "mainprog.bin" at address "0x00000000" with "debug access lock":

mainprog 00000000 Y

The following example text file programs "main flash only" from "mainprog.bin" at address "0x00000000" with "AAP lock":

mainprog 00000000 A

The following example text file programs "user page" only from "userprog.bin" at address "0x0fe00000":

userprog 0fe00000

The following example programs "main flash” from “mainprog.bin" at address "0x00001000" and "user page" from "userprog.bin" at address "0x0fe00000" "without debug access lock":

mainprog 00001000 N
userprog 0fe00000

4.2 Menu Operation

4.2.1 Main Menu

Press PB0 to scroll down, PB1 to select.

• >Program Flash (LEDO and LED1 off if no LCD display)
• Upload Image (LEDO on and LED1 off if no LCD display)
• Erase Main Flash (LED0 off and LED1 on if no LCD display)
• Erase User Page (LEDO on and LED1 on if no LCD display)

4.2.2 Program Flash Submenu

This menu displays the current valid binary image information in external memory. "S:" is the binary file size in bytes, and "C:" is the binary file checksum (CRC16) in hexadecimal.

mainprog 00000000 N
S:524288 C:4196

Displays "No binary in memory" if no valid binary image is in external memory.

Press PB1 to program target, PB0 to return to main menu.

Displays the target device information, current process and LED1 turns on during operation.

EFM32GG990F1024
ERASE/PROG/VER MAIN

Displays the programming time and device count (#n) if no errors occurred during the operation.

Time:8.99s #21

Displays error message(s) if the programming fails, and also turns on LEDO.

In gang programming mode, the four or eight target devices are programmed sequentially.

Press PB0 to program again, PB1 to return to main menu.

4.2.3 Upload Image Submenu

This menu starts by waiting for the user to plug the USB MSD device in.

Plug in USB MSD
Wait...

If a USB MSD is not detected within the timeout interval (default is 5 seconds), it will display an error code:

No device plug-in

Press PB1 to retry, PB0 to return to main menu.

Displays the binary image information similarly to the program flash submenu, if a valid binary file is successfully uploaded from USB MSD to the external memory.

mainprog 00000000 N
S:524288 C:4196

Displays error message(s) if the upload image process fails.

Press PB1 to upload the image again, PB0 to return to main menu.

4.2.4 Erase Main Flash Submenu

This menu will display the target device information and turn LED1 on during the operation.

EFM32ZG222F32

Displays the following message if no error occurs during the main flash erase.

Erase Main done

Displays error message(s) and turns LEDO on if the erase main flash operation fails.

In gang program mode, the main flash of four or eight target devices are erased sequentially.

Press PB0 to erase main flash again, PB1 to return to main menu.

4.2.5 Erase User Page Submenu

This menu displays the target device information and turns LED1 on during the operation.

EFM32ZG222F32

Displays the following message if no error occurs during the user page erase.

Erase User done

Displays error message(s) and turns LEDO on if the erase user page fails.

In gang program mode, the user page of four or eight target devices are erased sequentially.

Press PB0 to erase user page again, PB1 to return to main menu.

5. Testing

5.1 Test Setup

The interconnection diagram used with the programmer is shown in the figure below. The programmer is the EFM32GG_STK3700 or EFM32WG_STK3800 and the target device is EFM32 STK or EFR32 WSTK or EZR32 WSTK.

The corresponding signals on different target STK and WSTK are shown in the table below. The pin or pad location can be found in the schematic and assembly drawing of the associated STK or WSTK.

The target device on STK or WSTK is powered by the programmer so the power switch (the slide switch in the lower left corner of the board) of STK or WSTK should be in the BAT position.

5.2 Test Results

The binary files for testing are saved in the "testbin" folder of this application note and the test results in the table below are based on following conditions.

• SDK is EFM32 SDK v4.4.0
• Erase, program and verify main flash only
• Compile options of progconfig.h are set to default values (SKIP_POLLING = TRUE, WRITE_DELAY = 10 for EFM32GG_STK3700 and WRITE_DELAY = 11 for EFM32GG_STK3800)
• Software is compiled with -03 optimization (release build) in Simplicity IDE
• External memory is on board NAND flash, and internal cache is available on EFM32GG_STK3700

6. Document Revision History

Revision 0.1

July 26, 2016

Initial release.