MIMXRT1064 INTERNAL FLASH

[sandeepc]

hi i want store some kmph data to the internal flash of the mimxrt1064 i gone through the nxp community i got to know that we can use evkmimxrt1064_flexspi_nor_polling_transfer example to understand so while going through that 

link 1: 

https://community.nxp.com/t5/i-MX-RT-Knowledge-Base/How-to-use-the-RT1064-on-chip-flash-as-NVM/ta-p/...

==> the example is used flexspi1 i.e external flash so internal flash is connected flexspi2

==> the ROM bootloader will configure the pins of this FlexSPI interface  So flexspi configuration is it required or not

                   ==> where can i get Flash size and example sector means

==> i didnt get what is meant by  customLUT? and also i didnt get meaning of these two lines

1. Erase sector command of the on-chip flash is 0x20 instead of 0xD7. 
2. Exchange the FLEXSPI command index for NOR_CMD_LUT_SEQ_IDX_READ_FAST_QUAD and NOR_CMD_LUT_SEQ_IDX_READ_NORMAL to align with XIP settings.

i gone at the last provided link i didnt get api reference manal to understan what it is actually api mean and its argumentsf ew api iam mentionning 

1) status = flexspi_nor_get_vendor_id(EXAMPLE_FLEXSPI, &vendorID);

2)  status = flexspi_nor_enable_quad_mode(EXAMPLE_FLEXSPI);

3) status = flexspi_nor_flash_erase_sector(EXAMPLE_FLEXSPI, EXAMPLE_SECTOR * SECTOR_SIZE);

4)  status =
flexspi_nor_flash_page_program(EXAMPLE_FLEXSPI, EXAMPLE_SECTOR * SECTOR_SIZE, (void *)s_nor_program_buffer);

few more are there where can i found this api maual 

and in which section will be helpfull understand well i.MX RT1064 Processor Reference
Manual
Document Number: IMXRT1064RM
Rev. 2,

@kerryzhou @IMXRT1050 

[kerryzhou]

Hi @sandeepc ,

  You make things complicate, and refer to the wrong code for the internal flash.

  Please refer to this code:

SDK_2_13_0_EVK-MIMXRT1064\boards\evkmimxrt1064\driver_examples\flexspi\nor_internal\polling_transfer

  You can operate the internal flash directly, the internal flash is the winbond flash.

  Please try it again.

  If you can't find this project, please download the new SDK:

https://mcuxpresso.nxp.com/

Wish it helps you!

Best Regards,

kerry

[sandeepc]

thaank you kerryzhou it is working fine now both example and as well as below replied code

[sandeepc · Accepted solution]

hi community update to my my quetion i had done modification by referring below links i compiled and its working but i didnt find ANY API TO READ THE DATA FROM FLASH if i get that api i can verify the data which have writeen 

1) iam sharing my code below if any correction required please let me 

2)where can i found the api reference manual for above mentioned functions

https://community.nxp.com/t5/i-MX-RT-Knowledge-Base/How-to-use-the-RT1064-on-chip-flash-as-NVM/ta-p/...

https://community.nxp.com/t5/i-MX-RT/RT1050-QSPI-flash-change-to-Winbond-W25Q32JV-3-3V/m-p/904534

https://community.nxp.com/t5/MCUXpresso-General/I-can-not-erase-QSPI-Flash-W25Q32JV/m-p/884895

after modification my code is below iam attaching my project please go through it and also iam attaching my file 

/*

 * Copyright (c) 2016, Freescale Semiconductor, Inc.

 * Copyright 2016-2018 NXP

 * All rights reserved.

 *

 *

 * SPDX-License-Identifier: BSD-3-Clause

 */

#include "fsl_flexspi.h"

#include "app.h"

#include "fsl_debug_console.h"

#include "fsl_cache.h"

#include "pin_mux.h"

#include "clock_config.h"

#include "board.h"

#include "fsl_common.h"

/*******************************************************************************

 * Definitions

 ******************************************************************************/

/*******************************************************************************

 * Prototypes

 ******************************************************************************/

/*******************************************************************************

 * Variables

 ******************************************************************************/

/* Program data buffer should be 4-bytes alignment, which can avoid busfault due to this memory region is configured as

   Device Memory by MPU. */

SDK_ALIGN(static uint8_t s_nor_program_buffer[256], 4);

static uint8_t s_nor_read_buffer[256];

extern status_t flexspi_nor_flash_erase_sector(FLEXSPI_Type *base, uint32_t address);

extern status_t flexspi_nor_flash_page_program(FLEXSPI_Type *base, uint32_t dstAddr, const uint32_t *src);

extern status_t flexspi_nor_get_vendor_id(FLEXSPI_Type *base, uint8_t *vendorId);

extern status_t flexspi_nor_enable_quad_mode(FLEXSPI_Type *base);

extern status_t flexspi_nor_erase_chip(FLEXSPI_Type *base);

extern void flexspi_nor_flash_init(FLEXSPI_Type *base);

/*******************************************************************************

 * Code

 ******************************************************************************/

flexspi_device_config_t deviceconfig = {

.flexspiRootClk       = 120000000,

.flashSize            = FLASH_SIZE,

.CSIntervalUnit       = kFLEXSPI_CsIntervalUnit1SckCycle,

.CSInterval           = 2,

.CSHoldTime           = 3,

.CSSetupTime          = 3,

.dataValidTime        = 0,

.columnspace          = 0,

.enableWordAddress    = 0,

.AWRSeqIndex          = 0,

.AWRSeqNumber         = 0,

.ARDSeqIndex          = NOR_CMD_LUT_SEQ_IDX_READ_FAST_QUAD,

.ARDSeqNumber         = 1,

.AHBWriteWaitUnit     = kFLEXSPI_AhbWriteWaitUnit2AhbCycle,

.AHBWriteWaitInterval = 0,

};

const uint32_t customLUT[CUSTOM_LUT_LENGTH] = {

/* Normal read mode -SDR */

[4 * NOR_CMD_LUT_SEQ_IDX_READ_NORMAL] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x03, kFLEXSPI_Command_RADDR_SDR, kFLEXSPI_1PAD, 0x18),

[4 * NOR_CMD_LUT_SEQ_IDX_READ_NORMAL + 1] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_READ_SDR, kFLEXSPI_1PAD, 0x04, kFLEXSPI_Command_STOP, kFLEXSPI_1PAD, 0),

/* Fast read mode - SDR */

[4 * NOR_CMD_LUT_SEQ_IDX_READ_FAST] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x0B, kFLEXSPI_Command_RADDR_SDR, kFLEXSPI_1PAD, 0x18),

[4 * NOR_CMD_LUT_SEQ_IDX_READ_FAST + 1] = FLEXSPI_LUT_SEQ(

kFLEXSPI_Command_DUMMY_SDR, kFLEXSPI_1PAD, 0x08, kFLEXSPI_Command_READ_SDR, kFLEXSPI_1PAD, 0x04),

/* Fast read quad mode - SDR */

[4 * NOR_CMD_LUT_SEQ_IDX_READ_FAST_QUAD] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x6B, kFLEXSPI_Command_RADDR_SDR, kFLEXSPI_1PAD, 0x18),

[4 * NOR_CMD_LUT_SEQ_IDX_READ_FAST_QUAD + 1] = FLEXSPI_LUT_SEQ(

kFLEXSPI_Command_DUMMY_SDR, kFLEXSPI_4PAD, 0x08, kFLEXSPI_Command_READ_SDR, kFLEXSPI_4PAD, 0x04),

/* Read extend parameters */

[4 * NOR_CMD_LUT_SEQ_IDX_READSTATUS] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x81, kFLEXSPI_Command_READ_SDR, kFLEXSPI_1PAD, 0x04),

/* Write Enable */

[4 * NOR_CMD_LUT_SEQ_IDX_WRITEENABLE] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x06, kFLEXSPI_Command_STOP, kFLEXSPI_1PAD, 0),

/* Erase Sector  */

[4 * NOR_CMD_LUT_SEQ_IDX_ERASESECTOR] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x20, kFLEXSPI_Command_RADDR_SDR, kFLEXSPI_1PAD, 0x18),

/* Page Program - single mode */

[4 * NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM_SINGLE] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x02, kFLEXSPI_Command_RADDR_SDR, kFLEXSPI_1PAD, 0x18),

[4 * NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM_SINGLE + 1] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_WRITE_SDR, kFLEXSPI_1PAD, 0x04, kFLEXSPI_Command_STOP, kFLEXSPI_1PAD, 0),

/* Page Program - quad mode */

[4 * NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM_QUAD] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x32, kFLEXSPI_Command_RADDR_SDR, kFLEXSPI_1PAD, 0x18),

[4 * NOR_CMD_LUT_SEQ_IDX_PAGEPROGRAM_QUAD + 1] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_WRITE_SDR, kFLEXSPI_4PAD, 0x04, kFLEXSPI_Command_STOP, kFLEXSPI_1PAD, 0),

/* Read ID */

[4 * NOR_CMD_LUT_SEQ_IDX_READID] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x9F, kFLEXSPI_Command_READ_SDR, kFLEXSPI_1PAD, 0x04),

/* Enable Quad mode */

[4 * NOR_CMD_LUT_SEQ_IDX_WRITESTATUSREG] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x01, kFLEXSPI_Command_WRITE_SDR, kFLEXSPI_1PAD, 0x04),

/* Enter QPI mode */

[4 * NOR_CMD_LUT_SEQ_IDX_ENTERQPI] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x35, kFLEXSPI_Command_STOP, kFLEXSPI_1PAD, 0),

/* Exit QPI mode */

[4 * NOR_CMD_LUT_SEQ_IDX_EXITQPI] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_4PAD, 0xF5, kFLEXSPI_Command_STOP, kFLEXSPI_1PAD, 0),

/* Read status register */

[4 * NOR_CMD_LUT_SEQ_IDX_READSTATUSREG] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0x05, kFLEXSPI_Command_READ_SDR, kFLEXSPI_1PAD, 0x04),

/* Erase whole chip */

[4 * NOR_CMD_LUT_SEQ_IDX_ERASECHIP] =

FLEXSPI_LUT_SEQ(kFLEXSPI_Command_SDR, kFLEXSPI_1PAD, 0xC7, kFLEXSPI_Command_STOP, kFLEXSPI_1PAD, 0),

};

int main(void)

{

uint32_t i = 0;

status_t status;

uint8_t vendorID = 0;

BOARD_ConfigMPU();

BOARD_InitBootPins();

BOARD_InitBootClocks();

BOARD_InitDebugConsole();

flexspi_nor_flash_init(EXAMPLE_FLEXSPI);

PRINTF("\r\nFLEXSPI example started!\r\n");

/* Get vendor ID. */

status = flexspi_nor_get_vendor_id(EXAMPLE_FLEXSPI, &vendorID);

if (status != kStatus_Success)

{

return status;

}

PRINTF("Vendor ID: 0x%x\r\n", vendorID);

#if !(defined(XIP_EXTERNAL_FLASH))

/* Erase whole chip . */

PRINTF("Erasing whole chip over FlexSPI...\r\n");

status = flexspi_nor_erase_chip(EXAMPLE_FLEXSPI);

if (status != kStatus_Success)

{

return status;

}

PRINTF("Erase finished !\r\n");

#endif

/* Enter quad mode. */

status = flexspi_nor_enable_quad_mode(EXAMPLE_FLEXSPI);

if (status != kStatus_Success)

{

return status;

}

/* Erase sectors. */

PRINTF("Erasing Serial NOR over FlexSPI...\r\n");

status = flexspi_nor_flash_erase_sector(EXAMPLE_FLEXSPI, EXAMPLE_SECTOR * SECTOR_SIZE);

if (status != kStatus_Success)

{

PRINTF("Erase sector failure !\r\n");

return -1;

}

memset(s_nor_program_buffer, 0xFFU, sizeof(s_nor_program_buffer));

DCACHE_InvalidateByRange(EXAMPLE_FLEXSPI_AMBA_BASE + EXAMPLE_SECTOR * SECTOR_SIZE, FLASH_PAGE_SIZE);

memcpy(s_nor_read_buffer, (void *)(EXAMPLE_FLEXSPI_AMBA_BASE + EXAMPLE_SECTOR * SECTOR_SIZE),

sizeof(s_nor_read_buffer));

if (memcmp(s_nor_program_buffer, s_nor_read_buffer, sizeof(s_nor_program_buffer)))

{

PRINTF("Erase data -  read out data value incorrect !\r\n ");

return -1;

}

else

{

PRINTF("Erase data - successfully. \r\n");

}

for (i = 0; i < 0xFFU; i++)

{

s_nor_program_buffer[i] = i;

}

status =

flexspi_nor_flash_page_program(EXAMPLE_FLEXSPI, EXAMPLE_SECTOR * SECTOR_SIZE, (void *)s_nor_program_buffer);

if (status != kStatus_Success)

{

PRINTF("Page program failure !\r\n");

return -1;

}

DCACHE_InvalidateByRange(EXAMPLE_FLEXSPI_AMBA_BASE + EXAMPLE_SECTOR * SECTOR_SIZE, FLASH_PAGE_SIZE);

memcpy(s_nor_read_buffer, (void *)(EXAMPLE_FLEXSPI_AMBA_BASE + EXAMPLE_SECTOR * SECTOR_SIZE),

sizeof(s_nor_read_buffer));

if (memcmp(s_nor_read_buffer, s_nor_program_buffer, sizeof(s_nor_program_buffer)) != 0)

{

PRINTF("Program data -  read out data value incorrect !\r\n ");

return -1;

}

else

{

PRINTF("Program data - successfully. \r\n");

}

while (1)

{

}

}

status_t flexspi_nor_enable_quad_mode(FLEXSPI_Type *base)
{
flexspi_transfer_t flashXfer;
status_t status;
uint32_t writeValue =0x0200;// FLASH_QUAD_ENABLE;

#if defined(CACHE_MAINTAIN) && CACHE_MAINTAIN
flexspi_cache_status_t cacheStatus;
flexspi_nor_disable_cache(&cacheStatus);
#endif

/* Write enable */
status = flexspi_nor_write_enable(base, 0);

if (status != kStatus_Success)
{
return status;
}

/* Enable quad mode. */
flashXfer.deviceAddress = 0;
flashXfer.port = FLASH_PORT;
flashXfer.cmdType = kFLEXSPI_Write;
flashXfer.SeqNumber = 1;
flashXfer.seqIndex = NOR_CMD_LUT_SEQ_IDX_WRITESTATUSREG;
flashXfer.data = &writeValue;
// flashXfer.dataSize = 1;
flashXfer.dataSize = 2;

status = FLEXSPI_TransferBlocking(base, &flashXfer);
if (status != kStatus_Success)
{
return status;
}

status = flexspi_nor_wait_bus_busy(base);

/* Do software reset. */
FLEXSPI_SoftwareReset(base);

#if defined(CACHE_MAINTAIN) && CACHE_MAINTAIN
flexspi_nor_enable_cache(cacheStatus);
#endif

return status;
}

@kerryzhou @michael_imxrt @IMXRT1050