I have several applications where I store application specific information in the microcontroller FLASH memory (see “Configuration Data: Using the Internal FLASH instead of an external EEPROM“). I have run into issues recently with the Segger J-Link GDB server as by default it does *not* erase all the FLASH memory. So the question is: How can I erase all (or part) of the FLASH memory with GDB (e.g. in Kinetis Design Studio or in Eclipse)?

Erase in CodeWarrior?

In CodeWarrior for MCU this problem is solved with an extension (see “Flashing with a Button (and a Magic Wand)“): I have the ability to erase the full device:

Erase with GDB?

However, such an option does not exist in GDB :-(.  Actually with using the P&E GDB server my problem of not-erased sectors did not come up, as P&E seems always to do an erase of the full device anyway. This is different with the Segger J-Link: the J-Link only erases the sectors which needs to be programmed. This is smart as it reduces the download time needed, but leaves parts of the device un-erased. And there is no option for erasing the device in the GNU ARM Eclipse debugger plugins.

Erase with Segger J-Flash Utility?

Segger has a separate utility named J-Flash which would do exactly what I would need (and even has more advanced capabilities):

However, that feature is not free and needs a license :-(. The J-Flash is definitely a cool tool, but maybe I can erase the device in another way? Yes, I have found a way. As always: either invest some money to buy something, or invest some time to do it yourself 😉

Erase with Jlink

The Segger J-Link installation files come with a utility Jlink.exe (JinkExe on Linux) which comes with many command line options, and one of it is ‘erase’:

Tu use it, I have first to specify the microcontroller I’m using. The the supported microcontroller are listed on https://www.segger.com/jlink_supported_devices.html

With

device MKL25Z128xxx4

I select the device I use. And with

erase

The device gets erased.

Many thanks to Liviu for providing this tip!

How to Erase with GDB

The idea is to have a project to create a binary with all 0xFF in it (every byte erased), then download that program to effectively erase the device :-).

For this, create a new project for your device you want to erase. I show here an example with Kinetis Design Studio, but it is applicable to any Eclipse project with GDB.

All what we will need is

1. an assembly file which will fill the FLASH memory with 0xFF (erased)
2. a GNU linker file

Cleaning up the project

So remove all not needed files from the project, only keep the linker file (*.ld):

Linker File

As we do not need any startup code/etc, the linker file can be cleaned up too. What remains is are the MEMORY, the SECTIONS with interrupts, flash_config and the .text:

/* Linker file for GNU C Compiler */

/* Specify the memory areas */
MEMORY
{
  m_interrupts          (RX)  : ORIGIN = 0x00000000, LENGTH = 0x00000100
  m_flash_config        (RX)  : ORIGIN = 0x00000400, LENGTH = 0x00000010
  m_text                (RX)  : ORIGIN = 0x00000410, LENGTH = 0x0001FBF0
  m_data                (RW)  : ORIGIN = 0x1FFFF000, LENGTH = 0x00004000
}

/* Define output sections */
SECTIONS
{
  /* The startup code goes first into internal flash */
  .interrupts :
  {
    __VECTOR_TABLE = .;
    . = ALIGN(4);
    KEEP(*(.isr_vector))     /* Startup code */
    . = ALIGN(4);
  } > m_interrupts


  .flash_config :
  {
    . = ALIGN(4);
    KEEP(*(.FlashConfig))    /* Flash Configuration Field (FCF) */
    . = ALIGN(4);
  } > m_flash_config

  /* The program code and other data goes into internal flash */
  .text :
  {
    . = ALIGN(4);
    *(.text)                 /* .text sections (code) */
    *(.text*)                /* .text* sections (code) */
    *(.rodata)               /* .rodata sections (constants, strings, etc.) */
    *(.rodata*)              /* .rodata* sections (constants, strings, etc.) */
    *(.glue_7)               /* glue arm to thumb code */
    *(.glue_7t)              /* glue thumb to arm code */
    *(.eh_frame)
    KEEP (*(.init))
    KEEP (*(.fini))
    . = ALIGN(4);
  } > m_text

  .ARM.attributes 0 : { *(.ARM.attributes) }
}

I explicitly keep the flash configuration part for the Kinetis devices (so it does NOT get erased), to avoid that my device gets secured and potentially bricked (see “How (not) to Secure my Microcontroller“).

Assembly File

As only source file I add an assembly file Erase.S to the project:

The assembly file has the following content:

/*
 * erase.S
 *
 *  Created on: 14.11.2014
 *      Author: Erich Styger
 *
 * This is an assembly file which is used to erase the FLASH of the device
 * It uses the .space directive:
 * .space <size>[,pattern]
 */
.section .isr_vector, "a"
.space 0x100, 0xff

.text
.space 0x1FBF0, 0xff
.end

The assembly file contains two things: one section for the interrupt vector table, and one for the text/code. This because the linker file has it splitted up too, with the flash configuration in between:
MEMORY
{
  m_interrupts          (RX)  : ORIGIN = 0x00000000, LENGTH = 0x00000100
  m_flash_config        (RX)  : ORIGIN = 0x00000400, LENGTH = 0x00000010
  m_text                (RX)  : ORIGIN = 0x00000410, LENGTH = 0x0001FBF0
  m_data                (RW)  : ORIGIN = 0x1FFFF000, LENGTH = 0x00004000
}

The .space GNU assembler directive is used to fill the memory with the pattern after the comma. The first argument of .space is the size in bytes. Here I use the number of my device, taken from the linker file.
Linker Settings
If I compile the project, I will see that actually something is missing: my sections have not been taken into account (see “Printing Code Size Information in Eclipse” how to create that code size information):
'Invoking: Cross ARM GNU Print Size'
arm-none-eabi-size --format=berkeley "FRDM-KL25Z_Erase.elf"
   text       data        bss        dec        hex    filename
    280          0          0        280        118    FRDM-KL25Z_Erase.elf
'Finished building: FRDM-KL25Z_Erase.siz'
The problem is: by default the linker will strip of any unused sections. So I need to tell the linker to be less smart ;-). In the linker options I tell the linker not to use any default libraries and startup code, and not to remove unused sections:
Unsmarting the Linker
Now things look the way I want it: FLASH is full with 0xff :-):
'Invoking: Cross ARM GNU Print Size'
arm-none-eabi-size --format=berkeley "FRDM-KL25Z_Erase.elf"
   text       data        bss        dec        hex    filename
 130288          0          0     130288      1fcf0    FRDM-KL25Z_Erase.elf
'Finished building: FRDM-KL25Z_Erase.siz'
S19 File as Check
If I generate an S19 file (see “Binary (and S19) Files for the mbed Bootloader with Eclipse and GNU ARM Eclipse Plugins“), I see that everything is filled with 0xff:
S19 File with everything to be erased
Download (well, Debug) Configuration
The debug configuration to download the generated application is a normal one, except that I have disabled breakpoints, Pre-run reset and halt, and the Continue option:
Segger J-Link Launch Configuration Settings
Then, with the debugger I flash the file to the target. With the Memory view I can now see that all my memory has been erased 🙂 :
Memory Monitor with Erased Flash
Summary
There is no ‘erase device’ command in GDB (or at least I’m not aware of it). However, creating a simple application with a single assembly file, some linker option changes and I can erase my microcontroller that way. This approach of course works as well if you only want to erase some areas of your flash memory: in that case adopt the assembly file and the linker file.
The project created in this tutorial is available on GitHub.
Happy Erasing 🙂

		
	
			

			
			
Share this:
Print
Email
Twitter
Facebook
LinkedIn
Tumblr
Pinterest
Pocket
WhatsApp
Telegram
Like Loading...


	
Related