MSP432E401Y: Recovering a "Locked" microcontroller does not perform a full mass erase

Hello Christian,

I have never encountered this issue. The Unlock sequence should erased the Flash completely.

Can you re-create this issue or is it a one time thing?

Also did you confirm that the updated DBG1 value is committed to the BOOTCFG register? You can confirm by resetting the power to the board (it has to be Power on Reset; that is remove power to the MCU, then power on the MCU) and then trying to access the device via the JTAG.

Thanks,
Sai

Hello Sai,

I'm also working on the same project and am answering in place of Christian.

> Can you re-create this issue or is it a one time thing?

We have recreated the issue multiple times with two different MSP432E401Y.

> Also did you confirm that the updated DBG1 value is committed to the BOOTCFG register?

Yes, we did. JTAG access does not work as expected and we also execute the following code at the beginning of "main()" to check if DBG1 is 0:

uint32_t bootConfig = HWREG(FLASH_BOOTCFG);
if(bootConfig & 3)
{
//Blink LEDs
//This is NOT executed on reboot after setting BOOTCFG.
}

But regardless if BOOTCFG is correctly set or not, is it correct that a mass erase should be performed when we execute the unlock sequence?

Best regards,

Sathya Laufer

Hello Sathya,

You are right! Irrespective of the BOOTCFG settings , unlock sequence should erase the flash. In fact that's the first step before restoring the nonvolatile registers. The following is the relevant section from the TRM:

I will work on this mid next week. To be sure can you provide the exact steps to re-create this issue?

Thanks,

Sai

Hello Sai,

it wasn't easy to create a minimal project, but here it is :-):

flashtest.tar.gz

And the source code:

#include <msp.h>
#include "driverlib/driverlib.h"
#include "driverlib/inc/hw_flash.h"

#include <string>
#include <memory>
#include <array>

#include <iomanip> //<-- Causing the error
#include <sstream> //<-- Causing the error

constexpr size_t FLASH_SECTOR_SIZE = 0x4000;
constexpr uint32_t FLASH_NAME_ADDRESS = 0xE6580;
constexpr size_t FLASH_NAME_SIZE = 0x100;

constexpr uint32_t _ledPeripheral = SYSCTL_PERIPH_GPIOK;
constexpr uint32_t _ledPort = GPIO_PORTK_BASE;
constexpr uint8_t _ledGreenValue = (1 << 4);
constexpr uint8_t _ledOrangeValue = (1 << 5);

#define I32_TO_U8CARRAY(a, pos, n) {a[pos] = (uint8_t)(((n) >> 24) & 0xFF);a[pos + 1] = (uint8_t)(((n) >> 16) & 0xFF);a[pos + 2] = (uint8_t)(((n) >> 8) & 0xFF);a[pos + 3] = (uint8_t)((n) & 0xFF);}
#define U8CARRAY_TO_I32(a, size, pos) (pos + 4 > size ? 0 : (((uint32_t)a[pos]) << 24) | (((uint32_t)a[pos + 1]) << 16) | (((uint32_t)a[pos + 2]) << 8) | ((uint32_t)a[pos + 3]))

uint32_t _clockFrequency = 0;

bool eraseSector(uint32_t address)
{
    if(address % FLASH_SECTOR_SIZE != 0) return false;
    return FlashErase(address) == 0;
}

bool writeSlot(uint32_t areaAddress, uint32_t slotSize, uint8_t* data, size_t dataSize)
{
    if(dataSize == 0 || data == nullptr || dataSize > slotSize - 4) return false;

    //{{{ Load sector into memory
    uint32_t sectorAddress = areaAddress - (areaAddress % FLASH_SECTOR_SIZE);
    std::array<uint8_t, FLASH_SECTOR_SIZE> sectorData;
    std::copy((uint8_t*)sectorAddress, (uint8_t*)sectorAddress + FLASH_SECTOR_SIZE, sectorData.begin());
    //}}}

    if(!eraseSector(sectorAddress)) return false;

    //{{{ Overwrite old slot data
    uint32_t slotOffset = areaAddress - sectorAddress;
    std::fill(sectorData.begin() + slotOffset, sectorData.begin() + slotOffset + slotSize, 0);
    //}}}

    uint32_t metadata = (((uint32_t)1) << 24) | (dataSize & 0xFFFF);
    I32_TO_U8CARRAY(sectorData, slotOffset, metadata);
    std::copy(data, data + dataSize, sectorData.begin() + slotOffset + 4);

    return FlashProgram((uint32_t*)sectorData.data(), sectorAddress, sectorData.size()) == 0;
}

inline void lock()
{
    // See chapter 7.5.2 and 7.2.3.12
    uint32_t bootConfig = HWREG(FLASH_BOOTCFG);
    if(bootConfig & 3)
    {
        HWREG(FLASH_FMA) = 0x75100000;
        HWREG(FLASH_FMD) = 0x7FFFFFFC;
        HWREG(FLASH_FMC) = FLASH_FMC_WRKEY | FLASH_FMC_COMT;
        while(HWREG(FLASH_FMC) & FLASH_FMC_COMT); //Wait for completion
        for(int32_t i = 0; i < 100; i++) //Blink both LEDs for 10 seconds
        {
            GPIOPinWrite(_ledPort, _ledGreenValue | _ledOrangeValue, _ledGreenValue | _ledOrangeValue);
            SysCtlDelay(_clockFrequency / (20 * 4)); //50ms
            GPIOPinWrite(_ledPort, _ledGreenValue | _ledOrangeValue, 0);
            SysCtlDelay(_clockFrequency / (20 * 4)); //50ms
        }

        while(true);
    }
    else
    {
        GPIOPinWrite(_ledPort, _ledGreenValue, _ledGreenValue);
        SysCtlDelay(_clockFrequency / (1 * 4)); //1s
        GPIOPinWrite(_ledPort, _ledGreenValue, 0);
        SysCtlDelay(_clockFrequency / (1 * 4)); //1s
    }
}

int main(void)
{
    _clockFrequency = SysCtlClockFreqSet((SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000);
    IntMasterEnable();

    SysCtlPeripheralEnable(_ledPeripheral);
    GPIOPinTypeGPIOOutput(_ledPort, _ledGreenValue | _ledOrangeValue);

    lock();

    //{{{ iomanip
        // Without this code block and the include of iomanip and sstream the mass erase works
        auto fromEpoch = SysTickValueGet() + 3600; //Some value
        tm* fromTime = localtime(&fromEpoch);
        std::ostringstream fromStringStream;
        fromStringStream << (fromTime->tm_year + 1900) << std::setfill('0') << std::setw(2) << (fromTime->tm_mon + 1) << std::setw(2) << fromTime->tm_mday << std::setw(2) << fromTime->tm_hour << std::setw(2) << fromTime->tm_min << "00";
        std::string fromString = fromStringStream.str();
        if(fromString.back() - 4 == '7') GPIOPinWrite(_ledPort, _ledGreenValue, _ledGreenValue);
    //}}}

    //{{{ Test block
        std::string name;
        { //Get name
            uint32_t address = FLASH_NAME_ADDRESS;
            uint32_t metadata = U8CARRAY_TO_I32(((uint8_t*)address), 4, 0);
            uint8_t* data = nullptr;
            size_t dataSize = 0;
            if((metadata >> 24) == 1)
            {
                dataSize = metadata & 0xFFFF;
                if(dataSize > 0 && dataSize <= FLASH_NAME_SIZE - 4)
                {
                    data = (uint8_t*)(address + 4);
                    name = std::string((char*)data, dataSize);
                }
            }
        }

        bool dataExists = (name == "Hello Mellon");
        name = "Hello Mellon";
        if(!writeSlot(FLASH_NAME_ADDRESS, FLASH_NAME_SIZE, (uint8_t*)name.data(), name.size()))
        {
            GPIOPinWrite(_ledPort, _ledOrangeValue, _ledOrangeValue);
            while(true);
        }

        if(dataExists)
        {
            for(int32_t i = 0; i < 10; i++)
            {
                GPIOPinWrite(_ledPort, _ledGreenValue, _ledGreenValue);
                SysCtlDelay(_clockFrequency / (2 * 4));
                GPIOPinWrite(_ledPort, _ledGreenValue, 0);
                SysCtlDelay(_clockFrequency / (2 * 4));
            }

            //Executing the mass erase commands below also erases "Hello Mellon" from flash memory.
            //FLASH_CTRL->FMC = FLASH_FMC_WRKEY | FLASH_FMC_MERASE;
            //while(FLASH_CTRL->FMC & FLASH_FMC_MERASE);
        }
        else
        {
            while(true)
            {
                GPIOPinWrite(_ledPort, _ledOrangeValue, _ledOrangeValue);
                SysCtlDelay(_clockFrequency / (2 * 4));
                GPIOPinWrite(_ledPort, _ledOrangeValue, 0);
                SysCtlDelay(_clockFrequency / (2 * 4));
            }
        }
    //}}}
}

Steps to reproduce the problem:

1. Take a previously unflashed MSP432E401Y and flash it with the program above (with boards I was experimenting with the mass erasing sometimes starts working and then always works).
2. Power on and power off the board until the green LED flashes.
3. Execute the unlock procedure two times using `dbgjtag -f @xds110 -Y unlock,mode=msp432e4`
4. Flash the program above again (the green and orange LED should blink quickly to acknowledge that the locking has completed).
5. Power off and power on the board once.
6. The green LED should flash indicating "Hello Mellon" is still readable from flash memory.
7. Sometimes steps 3 to 5 have to be repeated two times.

I now reproduced the problem on 10 different boards. Not previously flashed boards always seem to show the problem. The triggering cause seems to be the usage of <sstream> and/or <iomanip>. Removing those two include files and the associated source code makes the unlock procedure successfully erase the flash memory again.

A few more information:

The test system has a Intel Core i7-7820X CPU and is running Ubuntu Bionic. The CCS version is 8.3.0.00009, the TI compiler version 18.1.4.LTS. We are flashing our boards with the MSP432E401Y LaunchPad.

Your help is very much appreciated.

Best regards,

Sathya Laufer

Any news?

Hello Sai,

were you able to reproduce the problem? We are building a product where it is really important that data is not recoverable after a mass erase. So it's very important to us to know, what caused the problem to be sure it won't occur again.

Cheers,

Sathya

Hello Sai,

as you can see in the source code, it's not written for the Launchpad. You need to change `SYSCTL_XTAL_16MHZ` to `SYSCTL_XTAL_25MHZ`. So of course it is not locked and no data is ever written to flash ;-)...
I just tried - on my Launchpad I can't reproduce the issue. It might be, because it was used before (as I mentioned earlier the issue can not always be reproduced on non-new microcontrollers). Let me get a new Launchpad and then I will try to reproduce it before posting the updated source here.

Cheers,

Sathya

Hello Sathya,

Any updates on this topic?

Thanks,
Sai