MSP432P401R: flash erase hangs.

/* --COPYRIGHT--,BSD
 * Copyright (c) 2017, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * --/COPYRIGHT--*/
/*******************************************************************************
 * MSP432 Flash Controller - Mass Erase
 *
 * Description: This example shows the functionality of the mass erase API in
 * DriverLib. At the start of the example, flash bank 1 sectors 30 and 31 are
 * unprotected (0x3E000 - 0x3FFFF) and then programmed with filler data. Sector
 * 31 is then protected and a mass erase is performed. Since the mass erase
 * will only erase unprotected sectors, after the mass erase finishes only
 * the data in sector 30 will be erased (as can be observed through the memory
 * browser in the debugger).
 *
 *
 *
 * I am using the msp432p401r bga in a custom design.  When I try to erase a 4K
 * sector in the top part of the 1st bank the erase hangs. I doing an erase of
 * 0x0001e000, length 0x1000.  that is the 2nd to last sector of bank 0 for a
 * size of 4096 (1 sector). I am changing the protect bit in BANK0_MAIN_WEPROT
 *  to 0xbfffffff then calling MAP_FlashCtl_performMassErase() to do the erase.
 *  But it hangs.  Note that the area being erased is already erased.
 *  But it should still work.
 *
 * Here is where it is hanging:
 *
 * While the burst read hasn't finished
 *   while ((FLCTL->RDBRST_CTLSTAT & FLCTL_RDBRST_CTLSTAT_BRST_STAT_MASK)
 *   != FLCTL_RDBRST_CTLSTAT_BRST_STAT_3)
 *   {
 *       __no_operation();
 *   }
 *
 *   this is from driverlib/flash.c
 *
 *                MSP432P401
 *             ------------------
 *         /|\|                  |
 *          | |                  |
 *          --|RST               |
 *            |                  |
 *            |                  |
 *            |                  |
 *            |                  |
 *            |                  |
 *
 ******************************************************************************/
/* DriverLib Includes */
#include <ti/devices/msp432p4xx/driverlib/driverlib.h>

/* Standard Includes */
#include <stdint.h>
#include <stdbool.h>
#include <string.h>

/*
 * Main Memory
 * 0x0000_0000 - 0x0004_0000
 *
 * The flash main memory on MSP432P401x MCUs can be up to 256KB. Flash main
 * memory consists of up to 64 sectors of 4KB each, with a minimum erase
 * granularity of 4KB (1 sector). The main memory can be viewed as two
 * independent identical banks of up to 128KB each, allowing simultaneous read
 * or execute from one bank while the other bank is undergoing a program or
 * erase operation.
 *
 * Block 0
 * 0x0000_0000 0x0001_FFFF
 *
 * Sector 30    1E000 - 1EFFF
 * Sector 31    1F000 - 1FFFF
 *
 * Block 1
 * 0x0002_0000 0x0003_FFFF
 *
 * Sector 30    3E000 - 3EFFF
 * Sector 31    3F000 - 3FFFF
 *
 */

#define BANK1_S30 0x3E000
#define BANK0_S30 0x1E000

/* Statics */
uint8_t patternArray[4096];

int main(void)
{
    /*
     * Since this program has a huge buffer that simulates the calibration data,
     * halting the watch dog is done in the reset ISR to avoid a watchdog 
     * timeout during the zero 
     */

    /* Setting our MCLK to 48MHz for faster programming */
    MAP_PCM_setCoreVoltageLevel(PCM_VCORE1);
    MAP_FlashCtl_setWaitState(FLASH_BANK0, 1);
    MAP_FlashCtl_setWaitState(FLASH_BANK1, 1);
//    MAP_CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_48);

    /*
     * Setting up clocks
     * MCLK = MCLK = 48MHz
     * SMCLK = MCLK/2 = 24Mhz
     * ACLK = REFO = 32Khz
     */
    MAP_CS_setDCOFrequency(16000000);
    MAP_CS_initClockSignal(CS_ACLK, CS_REFOCLK_SELECT, CS_CLOCK_DIVIDER_1);
    MAP_CS_initClockSignal(CS_SMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_2);
    MAP_CS_initClockSignal(CS_MCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1);

    /* Initializing our buffer to a pattern of 0xA5 */
    memset(patternArray, 0xA5, 4096);
    
    //![Simple Flash Config]
    //
    //
    /* Unprotecting User Bank 0, Sectors 30  */
    MAP_FlashCtl_unprotectSector(FLASH_MAIN_MEMORY_SPACE_BANK0,
            FLASH_SECTOR30);

    /*
     * I am changing the protect bit in BANK0_MAIN_WEPROT to 0xbfffffff then
     * calling MAP_FlashCtl_performMassErase() to do the erase.
     * 1011b ...... PROT30 is cleared
     */

    /* Trying a mass erase. Since we unprotected User Bank 0,
     * sector 30, this should erase these sectors. If it fails, we
     * trap inside an infinite loop.
     */
    if(!MAP_FlashCtl_performMassErase())
        while(1);
    //![Simple Flash Config]
    
    /* Trying to program the filler data. If it fails, trap inside an infinite
       loop */
    if(!MAP_FlashCtl_programMemory (patternArray, (void*) BANK0_S30, 4096))
        while(1);

    /* Setting  sector 31 back to protected  */
//    MAP_FlashCtl_protectSector(FLASH_MAIN_MEMORY_SPACE_BANK1,FLASH_SECTOR31);

    /* Performing the mass erase again. Now, since we protected Sector31, only
     * Sector 30 (0x3E000 - 0x3EFFF) should be erased. Set a breakpoint
     * after this call to observe the memory in the debugger.
     */
//    if(!MAP_FlashCtl_performMassErase())
//        while(1);

    /* Deep Sleeping when not in use */
    while (1);
//    {
//        MAP_PCM_gotoLPM3();
//    }
}