AM2634-Q1: MCAL Flash issues

Bruce(Shanghai) Liu

Part Number: AM2634-Q1

Hi team,

Now we met some MCAL flash issues shown as below:

1. Use Fls_Erase() and Fls_Write() to erase& write flash. When the erased address offset is 0, the address can normally see that the 0 address at the beginning of the flash is erased and written. But the offset offset is 0x800000 or a larger address such as 0xE00000, and the corresponding offset address has not been erased. (The flash of the Am263x CC development board should be 16M bytes)

2.Synchronous waiting is used when calling and executing instructions, which will cause task obstruction, and some instructions are seriously obstructed;

3.The entire chip erase command time is a bit long, and the erase time of 8Mbyte exceeds ten minutes. Is there any way to improve this problem?

over 2 years ago

0 Kowshik Gudimetla over 2 years ago

TI__Genius 15435 points

Hi Bruce,

Can you please expirement with the Fls_Erase( ) API where it uses the offset and the size of the chunk to erase, then you can iterate over the addresses. This makes it not time consuming and avoids the failing of the execution inside the function.

As shown below, you can find this in the fls_app example too.

Thanks

0 Kowshik Gudimetla over 2 years ago in reply to Kowshik Gudimetla

TI__Genius 15435 points

Hi Jane,

As per our discussion, sharing the reference example.

incrementing the offset by 64kb

FlsApp.c

Fullscreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* ======================================================================
 *   Copyright (c) 2022 Texas Instruments Incorporated
 *
 *   All rights reserved. Property of Texas Instruments Incorporated.
 *   Restricted rights to use, duplicate or disclose this code are
 *   granted through contract.
 *
 *   The program may not be used without the written permission
 *   of Texas Instruments Incorporated or against the terms and conditions
 *   stipulated in the agreement under which this program has been
 *   supplied.
 * ==================================================================== */
/**
 *  \file     FlsApp.c
 *
 *  \brief    This file contains the FLS test example
 *
 */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

/* ======================================================================
 *   Copyright (c) 2022 Texas Instruments Incorporated
 *
 *   All rights reserved. Property of Texas Instruments Incorporated.
 *   Restricted rights to use, duplicate or disclose this code are
 *   granted through contract.
 *
 *   The program may not be used without the written permission
 *   of Texas Instruments Incorporated or against the terms and conditions
 *   stipulated in the agreement under which this program has been
 *   supplied.
 * ==================================================================== */

/**
 *  \file     FlsApp.c
 *
 *  \brief    This file contains the FLS test example
 *
 */

/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */

/*LDRA_NOANALYSIS*/
#include "Std_Types.h"
/*LDRA_ANALYSIS*/
#include "Det.h"
#include "Dem.h"
#include "Fls.h"
#include "Fls_Irq.h"
#include "Fls_Brd_Nor.h"
#include "EcuM_Cbk.h"
#include "Mcu.h"
#include "Port_Cfg.h"
#include "Port.h"
/*LDRA_NOANALYSIS*/
#include "string.h"
/*LDRA_ANALYSIS*/
#include "trace.h"

/* Starterware Includes */
#include "sys_vim.h"
#include "app_utils.h"
#include "soc.h"

#include "hw_ctrl_core.h"


/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */

#define ARRAYSIZE(x)                    (sizeof ((x)) / sizeof (x[0]))
#define APP_NAME                        "FLS_APP"
//#define PERF_TEST /* enable flag to log performance data*/

/* ========================================================================== */
/*                         Structures and Enums                               */
/* ========================================================================== */

/* None */

/* ========================================================================== */
/*                 Internal Function Declarations                             */
/* ========================================================================== */

void FlsApp_InterruptConfig(void);
void main_handling_intr();
void main_handling();
void main_handling_noDbgMsg();
void FlsApp_eraseCheck();
void FlsApp_multiSectorWriteCheck();

/* ========================================================================== */
/*                            Global Variables                                */
/* ========================================================================== */
#define FLSEXAMPLE_ARRAYSIZE(x)  (sizeof ((x)) / sizeof (x[0]))
uint32 Fls_TestPassed;//riya
volatile uint32 Fls_JobDoneSuccess;
volatile uint32 Fls_JobDoneError;

#if (STD_ON == FLS_VERSION_INFO_API)
Std_VersionInfoType       VersionInfo;
#endif
#if (STD_OFF == MCU_NO_PLL)
extern CONST(Mcu_ConfigType, MCU_PBCFG) McuModuleConfiguration_0;
#endif

#define DATA_SIZE_TEST 65536U
uint32 offset = 0x0000U;
uint16 test_forloop = 0;
Std_ReturnType retVal = E_OK;
/* Buffer containing the known data that needs to be written to flash */
uint8 txBuf_test[DATA_SIZE_TEST]={0};
/* Buffer containing the received data */
uint8 rxBuf_test[DATA_SIZE_TEST]={0};

/* ========================================================================== */
/*                          Function Definitions                              */
/* ========================================================================== */

int main(void)
{
    uint16 mss_uart_tx_pin, mss_uart_rx_pin;
    uint32 sys_clk_freq_vclk_const;
    AppUtils_defaultInit();
    Mcu_Init(&McuModuleConfiguration);
    Port_Init(PortConfigSet_0_pt);
    /* Default is AM263x*/
    mss_uart_tx_pin = 13;
    mss_uart_rx_pin = 14;
    
    /* Set up the pinmux for UART tx */
    Port_SetPinMode(mss_uart_tx_pin, PORT_PIN_MODE_LIN0);

    /* Set up the pinmux for UART rx */
    Port_SetPinMode(mss_uart_rx_pin, PORT_PIN_MODE_LIN0);
    Port_SetPinDirection(mss_uart_rx_pin, PORT_PIN_IN);
    /* Initialize interrupt */

    #if (STD_OFF == MCU_NO_PLL)
    if(McuModuleConfiguration_0.Mcu_PllSourceId == MCU_CLKSRC_DPLL)
    {
        sys_clk_freq_vclk_const = (McuModuleConfiguration_0.Mcu_PllConfig[MCU_CLKSRC_DPLL].Mcu_PllClk1.MCU_PLL_HSDIV2 / (2e6)) * 30;
    }
    else
    {
        sys_clk_freq_vclk_const = (McuModuleConfiguration_0.Mcu_PllConfig[MCU_CLKSRC_APLL].Mcu_PllClk1.MCU_PLL_HSDIV0 / (2e6)) * 30;
    }
    Enable_Uart();
    #else
    Enable_Uart();
    #endif
    /* Delay for UART to settle up */
    
    AppUtils_printf("FlsApp: Sample Application - STARTS !!!\n\r");
	
	#if (STD_ON == FLS_USE_INTERRUPTS)
		AppUtils_printf(APP_NAME ": Configuring Interrupt.\n\r");
		FlsApp_InterruptConfig();
	#endif
	#if (STD_ON == FLS_PRE_COMPILE_VARIANT)
		AppUtils_printf(APP_NAME ": Variant - Pre Compile being used !!!\n\r");
		Fls_Init((const Fls_ConfigType *) NULL_PTR);
	#else
		AppUtils_printf(APP_NAME ": Variant - Post Build being used !!!\n\r");
		Fls_Init(&FlsConfigSet);
	#endif
	
#if (STD_ON == FLS_VERSION_INFO_API)
    Fls_GetVersionInfo(&VersionInfo);
    AppUtils_printf("FLS MCAL version info:%d.%d.%d\n\r",
                    VersionInfo.sw_major_version,
                    VersionInfo.sw_minor_version,
                    VersionInfo.sw_patch_version);
    AppUtils_printf("FLS MCAL Module/Driver:%d.%d \n\r",
                    VersionInfo.moduleID,
                    VersionInfo.vendorID);
#endif

/* FLS driver should be free now - check */
#if ( STD_ON == FLS_GET_STATUS_API)
   MemIf_StatusType      status;
   status = Fls_GetStatus();
   if (status != MEMIF_IDLE)
   {
       AppUtils_printf(APP_NAME ": FLS driver is not IDLE!!\n\r");
   }
#endif
   AppUtils_printf(APP_NAME ": DATA SIZE TEST is 0x%X \n\r", DATA_SIZE_TEST);
   AppUtils_printf(APP_NAME ": Offset is 0x%X \n\r", offset);
   
   volatile uint32 idx;
   volatile uint8 *txPtr_test = txBuf_test;
   volatile uint8 *rxPtr_test = rxBuf_test;

   #define DATA_VALUE  (test_forloop + 2)
   for(idx = 0U; idx < DATA_SIZE_TEST; idx++)
   {
      *txPtr_test++ = DATA_VALUE;
      *rxPtr_test++ = (uint8)0U;
   }
   /////////////Test//////////////////////
for(test_forloop = 0;test_forloop < 128; test_forloop++)
{
   //#define DATA_VALUE  (test_forloop + 1)
   AppUtils_printf(APP_NAME ": sector no.: %d \n\r",test_forloop+1);

   AppUtils_printf(APP_NAME ": Erasing \n\r");
   while (1U)
   {
       Std_ReturnType job_accepted = Fls_Erase(offset, DATA_SIZE_TEST);
       if (E_OK == job_accepted)
               break;
   }
   main_handling();
#if (STD_OFF == FLS_USE_INTERRUPTS)
	
#if ( STD_ON == FLS_BLANK_CHECK_API)
		AppUtils_printf(APP_NAME ": Blank Checking \n\r");
	while (1U)
	{
       Std_ReturnType job_accepted = Fls_BlankCheck(offset, DATA_SIZE_TEST);
       if (E_OK == job_accepted)
           break;
	}
	main_handling();
#endif /*STD_ON == FLS_BLANK_CHECK_API*/

   AppUtils_printf(APP_NAME ": Writing \n\r");
   while (1U)
   {
       Std_ReturnType job_accepted = Fls_Write(offset, &txBuf_test[0], DATA_SIZE_TEST);
       if (E_OK == job_accepted)
           break;
   }
   main_handling();
   AppUtils_printf(APP_NAME ": Reading \n\r");
   while (1U)
   {
       Std_ReturnType job_accepted = Fls_Read(offset, &rxBuf_test[0], DATA_SIZE_TEST);
       if (E_OK == job_accepted)
           break;
   }
   main_handling();
   
 #if ( STD_ON == FLS_COMPARE_API)
   AppUtils_printf(APP_NAME ": Write Compare \n\r");
   while (1U)
   {
        /*
         Check if the write operation was successful by comparing txBuf_test (hardcoded)
         with the actual data in flash
        */
       Std_ReturnType job_accepted = Fls_Compare(offset, &txBuf_test[0], DATA_SIZE_TEST);
       if (E_OK == job_accepted)
           break;
   }
   main_handling();
   
   AppUtils_printf(APP_NAME ": Read Compare \n\r");
   while (1U)
   {
        /*
         Check if the read operation was successful by comparing rxBuf_test (previously read)
         with the actual data in flash
        */
       Std_ReturnType job_accepted = Fls_Compare(offset, &rxBuf_test[0], DATA_SIZE_TEST);
       if (E_OK == job_accepted)
           break;
   }
   main_handling();
   
#endif /*STD_ON == FLS_COMPARE_API*/
#endif/*STD_OFF == FLS_USE_INTERRUPTS*/
offset = offset + 65536U;
}
//////////////////////////////////////////////////////////////////////////////
#if (STD_ON == FLS_USE_INTERRUPTS)
    AppUtils_printf(APP_NAME ": Testing Interrupt Mode! \n\r");
    AppUtils_printf(APP_NAME ": Writing \n\r");
    while (1U)
    {
        Std_ReturnType job_accepted = Fls_Write(offset, &txBuf_test[0], DATA_SIZE_TEST);
        if (E_OK == job_accepted)
            break;
    }
	main_handling_intr();
    AppUtils_printf(APP_NAME ": Reading \n\r");
    while (1U)
    {
        Std_ReturnType job_accepted = Fls_Read(offset, &rxBuf_test[0], DATA_SIZE_TEST);
        if (E_OK == job_accepted)
            break;
    }
    main_handling_intr();
#endif/*STD_ON == FLS_USE_INTERRUPTS*/
	if(retVal == E_OK)
	{
		AppUtils_printf(APP_NAME ": FLS Test passed \n\r");
	}
	else
	{
		AppUtils_printf(APP_NAME ": FLS Test failed \n\r");
	}

    return (0);
}
void FlsApp_InterruptConfig(void)
{
    Vim_IntCfg intCfg;
    intCfg.map = VIM_INTTYPE_IRQ;
    intCfg.type = VIM_INTTRIGTYPE_LEVEL;

    vimInit();
    intCfg.priority = VIM_PRIORITY_4;
    intCfg.intNum = 54U;
    intCfg.handler = Fls_Hdlr;
    vimRegisterInterrupt(&intCfg);
}
void SchM_Enter_Fls_FLS_EXCLUSIVE_AREA_0(void)
{
    AppUtils_SchM_Enter_EXCLUSIVE_AREA_0();
}

void SchM_Exit_Fls_FLS_EXCLUSIVE_AREA_0(void)
{
    AppUtils_SchM_Exit_EXCLUSIVE_AREA_0();
}
void  SchM_Enter_Mcu_MCU_EXCLUSIVE_AREA_0()
{
    AppUtils_SchM_Enter_EXCLUSIVE_AREA_0();
}

void   SchM_Exit_Mcu_MCU_EXCLUSIVE_AREA_0()
{
     AppUtils_SchM_Exit_EXCLUSIVE_AREA_0();
}
void  SchM_Enter_Port_PORT_EXCLUSIVE_AREA_0()
{
    AppUtils_SchM_Enter_EXCLUSIVE_AREA_0();

}

void   SchM_Exit_Port_PORT_EXCLUSIVE_AREA_0()
{

  AppUtils_SchM_Exit_EXCLUSIVE_AREA_0();

}
Std_ReturnType Det_ReportError(uint16 ModuleId,
                               uint8  InstanceId,
                               uint8  ApiId,
                               uint8  ErrorId)
{
    Fls_TestPassed = E_NOT_OK; //riya
    GT_assert(McalAppTrace, FALSE);
    return (E_OK);
}
Std_ReturnType Det_ReportRuntimeError(VAR(uint16, AUTOMATIC) ModuleId,
                                               VAR(uint8, AUTOMATIC) InstanceId,
                                               VAR(uint8, AUTOMATIC) ApiId,
                                               VAR(uint8, AUTOMATIC) ErrorId)
{
    Fls_TestPassed = E_NOT_OK; //riya
    GT_assert(McalAppTrace, FALSE);
    return (E_OK);
}
Std_ReturnType Det_ReportTransientFault(
                                               VAR(uint16, AUTOMATIC) ModuleId,
                                               VAR(uint8, AUTOMATIC) InstanceId,
                                               VAR(uint8, AUTOMATIC) ApiId,
                                               VAR(uint8, AUTOMATIC) FaultId)
{
    Fls_TestPassed = E_NOT_OK; //riya
    GT_assert(McalAppTrace, FALSE);
    return (E_OK);
}
void Fee_JobEndNotification(void)
{
        Fls_JobDoneSuccess = 1U;
}

void Fee_JobErrorNotification(void)
{
        Fls_JobDoneError = 1U;
}
void main_handling()
{
	AppUtils_printf(APP_NAME ": Job Processing in Progress.\n\r");
    while (1U)
    {
        Fls_MainFunction();
        if ( Fls_JobDoneSuccess == 1U)
        {
            AppUtils_printf(APP_NAME ": Job Ends: SUCCESS\n\r");
			retVal = E_OK;
            break;
        }
        if ( Fls_JobDoneError == 1U)
        {
            AppUtils_printf(APP_NAME ": Job Ends: Error\n\r");
			retVal = E_NOT_OK;
            break;
        }
    }

    Fls_JobDoneSuccess = 0U;
    Fls_JobDoneError = 0U;
    return;
}
void main_handling_intr()
{
	AppUtils_printf(APP_NAME ": Job Processing in Progress.\n\r");
    while(1U)
    {
        if ( Fls_JobDoneSuccess == 1U)
        {
			AppUtils_printf(APP_NAME ": Job Ends: SUCCESS\n\r");
			retVal = E_OK;
            break;
        }
        if ( Fls_JobDoneError == 1U)
        {
			AppUtils_printf(APP_NAME ": Job Ends: Error\n\r");
			retVal = E_NOT_OK;
            break;
        }

    }

    Fls_JobDoneSuccess = 0U;
    Fls_JobDoneError = 0U;
    return;
}

0 Jane over 2 years ago in reply to Kowshik Gudimetla

TI__Intellectual 2260 points

All,

Update the latest status, looks like the Fls_norErase() function limit the erase command to block erase and not support chip erase and sector erase. Need BU revise the MCAL code. Thanks!

Jane

0 Kowshik Gudimetla over 2 years ago in reply to Jane

TI__Genius 15435 points

Hi Jane,

I have already raised a JIRA for this it's currently in development. We are adding following features.

1. Erase support in sector/block and chip wise erase.

2. QE bit configurability for custom flash integrations.

[SITARA_MCU_MCAL-4406] Fls QE bit configurability in flash Fls_NOR_s25fl128sa.h file - Texas Instruments JIRA (ti.com)

[SITARA_MCU_MCAL-4440] Fls Erase function always performs a BLOCK erase - Texas Instruments JIRA

Arm-based microcontrollers

Arm-based microcontrollers forum

AM2634-Q1: MCAL Flash issues