Understanding Flash ECC Correction disabled

The issue here is that you cannot  inject an real error in Flash for normal Flash access. The Flash ECC is validated as follows.

(1) Create an working Flash image.

(2) Create an ECC image for the Flash image.

(3) Introduce error in the original Flash image.

(4) Program the Flash image in (3) and ECC image in (2).

(5) Run the test. You will see the expected behavior: signal bit error causes abort when the correction is disabled.

Thanks and regards,

Zhaohong

Hello Guilherme,

  I think what might have happened is that the first time you read 0x701F8 a single bit error is detected. There is a hardware error cache built inside the CPU. The address 0x701F8 is getting cached. The reason for this hardware error cache is to avoid repeating retrying the same address over and over again if there is a hard fault in the memory. The second time you read 0x701FC is actually the upper 32-bit word from 0x701F8 so from the cache tag address comparison it is a match and the CPU simply reads from the cache without reading the flash memory. What you can try is to read the 0x701FC first and see if you can get a double bit ECC error.   

I've managed to create a single and a double bit error inside the flash memory, using linker. Both generates a data_abort. Single bit generate  group 1 channel 6 error, and double bit generates a group 3 channel 7 error, as expected. It wasn't easy, though.

I had to modify the linker to link with the following.

/*----------------------------------------------------------------------------*/
/* Linker Settings                                                            */

/* USER CODE BEGIN (1) */
--retain="*(.intvecs)"
--unused_section_elimination=off
/* USER CODE END */

/*----------------------------------------------------------------------------*/
/* Memory Map                                                                 */

MEMORY
{

    VECTORS (X)  : origin=0x00000000 length=0x00000020
    FLASH0  (RX) : origin=0x00000020 length=0x0017FF00 vfill=0xFFFFFFFF
    ERR_INJ  (RX) : origin=0x0017FF20 length=0x000000C0 vfill=0xFFFFFFFF
    FLASH1  (RX) : origin=0x00180000 length=0x00180000 vfill=0xFFFFFFFF
    STACKS  (RW) : origin=0x08000000 length=0x00001500
    RAM     (RW) : origin=0x08001500 length=0x0003EB00
	ECC_VEC  : origin=0xf0400000 length=0x000004 ECC={ input_range=VECTORS }
    ECC_FLA0 : origin=0xf0400004 length=0x02FFE0 ECC={ input_range=FLASH0  }
	ECC_ERR  (RX) : origin=0xf0400004+0x02FFE0 length=0x00000018 ECC={ input_range=ERR_INJ  }
    ECC_FLA1 : origin=0xf0430000 length=0x030000 ECC={ input_range=FLASH1  }

/* USER CODE BEGIN (2) */
/* USER CODE END */
}

// 196604

/* USER CODE BEGIN (3) */
ECC {
   algoR4F021 : address_mask = 0x003ffff8 /* Address Bits 21:3 */
                 hamming_mask = R4         /* Use R4 build in Mask */
                 parity_mask  = 0x0c       /* Set which ECC bits are Even and Odd parity */
                 mirroring    = F021       /* RM4x and TMS570LSx are build in F021 */
}
/* USER CODE END */


/*----------------------------------------------------------------------------*/
/* Section Configuration                                                      */

SECTIONS
{
    .intvecs : {} > VECTORS
    .text    : {} > FLASH0 | FLASH1
    .const   : {} > FLASH0 | FLASH1
    .cinit   : {} > FLASH0 | FLASH1
    .pinit   : {} > FLASH0 | FLASH1
    .ErrInj  : {} > ERR_INJ
    .bss     : {} > RAM
    .data    : {} > RAM
	.sysmem  : {} > RAM
	

/* USER CODE BEGIN (4) */

/* USER CODE END */
}



/* USER CODE BEGIN (5) */
--ecc:data_error=0x0017FF20,0x01
--ecc:data_error=0x0017FF28,0x03
/* USER CODE END */

The --unused_section_elimination=off saved my life. Linker keeps giving "uninitialized data" error. Then, I've created two variables with single and a double bit errors, at section .ErrInj, as attributes. 

const unsigned long long __attribute__((section(".ErrInj"))) test  = 3;
const unsigned long long __attribute__((section(".ErrInj"))) test2  = 83;

When reading test, single bit ecc error is generated. When reading test2, double bit ECC error is generated.