• State Resolved
  • Locked Locked
  • Replies 5 replies
  • Subscribers 82 subscribers
  • Views 455 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

TMS320F28377D: Question about FlashAPI

Green Deng
Expert 4490 points
Part Number: TMS320F28377D
Other Parts Discussed in Thread: C2000WARE

Hi team:

The customer's project is divided into bootloader and app, Bootloader in FLASH A-D and APP in Flash E-K.

Program can work normally when use JTAG to debug, but after loading program into flash and run, it can't run normally.

It seems that customer has copied the code from flash to RAM:

memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
memcpy(&RamfuncsFapiRunStart, &RamfuncsFapiLoadStart, (size_t)&RamfuncsFapiLoadSize);

CMD文件：
.TI.ramfuncFapi : {
--library=../F2837xD_flashapi/lib/F021_API_F2837xD_FPU32.lib
}
LOAD = FLASHG,
RUN = RAMD1,
RUN_START(_RamfuncsFapiRunStart),
LOAD_START(_RamfuncsFapiLoadStart),
LOAD_SIZE(_RamfuncsFapiLoadSize),
PAGE = 0, ALIGN(4)

But the project still has this problem.

Best regards,

Green

  • 0
    TI__Expert 4490 points

    Something additional：

    CCS Version: 11.0.0.00012, SDK Version: C2000Ware_4_00_00_00

    Memcpy code

    #ifdef _FLASH
    //
    // Copy time critical code and flash setup code to RAM. This includes the
    // following functions: InitFlash();
    //
    // The RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart symbols
    // are created by the linker. Refer to the device .cmd file.
    //
    memcpy(&RamfuncsRunStart,       &RamfuncsLoadStart,     (size_t)&RamfuncsLoadSize);
    memcpy(&RamfuncsFapiRunStart,   &RamfuncsFapiLoadStart, (size_t)&RamfuncsFapiLoadSize);
    memcpy(&RamfuncsFpuRunStart,    &RamfuncsFpuLoadStart,  (size_t)&RamfuncsFpuLoadSize);
    memcpy(&RamfuncsUserRunStart,   &RamfuncsUserLoadStart, (size_t)&RamfuncsUserLoadSize);

    //
    // Call Flash Initialization to setup flash waitstates. This function must
    // reside in RAM.
    //
    Flash_initModule(FLASH0CTRL_BASE, FLASH0ECC_BASE, DEVICE_FLASH_WAITSTATES);
#endif

    Flash initialize and call Erase\Write function:

    /*
 * BswEep.c
 *
 *  Created on: 2022��4��5��
 *      Author: Thinkpad-T14
 */
#include "Includes.h"

#pragma CODE_SECTION(BswEep_init, ".User.ramfunc");
uint16_t BswEep_init(void)
{
    uint16_t ReturnValue=0;
    Fapi_StatusType oFapi_Status1,oFapi_Status2;

    Flash_claimPumpSemaphore(FLASHPUMPSEMAPHORE_BASE, FLASH_CPU1_WRAPPER);
    EALLOW;
    oFapi_Status1 = Fapi_initializeAPI(F021_CPU0_BASE_ADDRESS, DEVICE_SYSCLK_FREQ/1000000);
    Flash_disableECC(FLASH0ECC_BASE);
    oFapi_Status2 = Fapi_setActiveFlashBank(Fapi_FlashBank0);
    Flash_enableECC(FLASH0ECC_BASE);
    EDIS;

    if( (oFapi_Status1 != Fapi_Status_Success) || (oFapi_Status2 != Fapi_Status_Success) )
    {
        ReturnValue=0;
    }
    else
    {
        ReturnValue=BswEep_ReadFLSL();
        ReturnValue=ReturnValue & BswEep_ReadFLSM();
        ReturnValue=ReturnValue & BswEep_ReadFLSN();
    }

    GeBswEep_Flag_InitReady=ReturnValue;
    return ReturnValue;
}

#pragma CODE_SECTION(BswEep_ReadFLSL, ".User.ramfunc");
uint16_t BswEep_ReadFLSL(void)
{
    uint16_t ReturnValue=0;
    Fapi_StatusType oFapi_Status;

    DINT;

    EALLOW;
    oFapi_Status = Fapi_doMarginRead((uint32 *)(0x0BA000),(uint32 *)&CeAswNvm_U_EcuInformation,sizeof(GeAswNvm_Type_EcuInformationUnion)/2,Fapi_NormalRead);
    EDIS;

    EINT;

    if(oFapi_Status == Fapi_Status_Success)
        ReturnValue=1;
    else
        ReturnValue=0;
    return ReturnValue;
}

#pragma CODE_SECTION(BswEep_ReadFLSM, ".User.ramfunc");
uint16_t BswEep_ReadFLSM(void)
{
    uint16_t ReturnValue=0;
    Fapi_StatusType oFapi_Status1,oFapi_Status2;


    DINT;

    EALLOW;
    oFapi_Status1 = Fapi_doMarginRead((uint32 *)(0x0BC000),(uint32 *)&CeAswNvm_U_BoardInformation,sizeof(GeAswNvm_Type_BoardInformationUnion)/2,Fapi_NormalRead);
    oFapi_Status2 = Fapi_doMarginRead((uint32 *)(0x0BC100),(uint32 *)&CeAswNvm_U_CalibInformation,sizeof(GeAswNvm_Type_CalibInformationUnion)/2,Fapi_NormalRead);
    EDIS;

    EINT;


    if( (oFapi_Status1 == Fapi_Status_Success) && (oFapi_Status2 == Fapi_Status_Success)  )
        ReturnValue=1;
    else
        ReturnValue=0;

    if(CeAswNvm_U_BoardInformation.NvmData.BoardID<1)
       CeAswNvm_U_BoardInformation.NvmData.BoardID=1;
    else if(CeAswNvm_U_BoardInformation.NvmData.BoardID>100)
       CeAswNvm_U_BoardInformation.NvmData.BoardID=100;

    if( (CeAswNvm_U_BoardInformation.NvmData.SciBaudRate == 9600) ||
        (CeAswNvm_U_BoardInformation.NvmData.SciBaudRate == 19200) ||
        (CeAswNvm_U_BoardInformation.NvmData.SciBaudRate == 38400) ||
        (CeAswNvm_U_BoardInformation.NvmData.SciBaudRate == 57600) ||
        (CeAswNvm_U_BoardInformation.NvmData.SciBaudRate == 115200)
        )
    {}
    else
    {
        CeAswNvm_U_BoardInformation.NvmData.SciBaudRate=115200;
    }

    if( (CeAswNvm_U_BoardInformation.NvmData.CanBaudRate == 125000) ||
        (CeAswNvm_U_BoardInformation.NvmData.CanBaudRate == 250000) ||
        (CeAswNvm_U_BoardInformation.NvmData.CanBaudRate == 500000) ||
        (CeAswNvm_U_BoardInformation.NvmData.CanBaudRate == 1000000)
        )
    {}
    else
    {
        CeAswNvm_U_BoardInformation.NvmData.CanBaudRate=250000;
    }

    return ReturnValue;
}


#pragma CODE_SECTION(BswEep_ReadFLSN, ".User.ramfunc");
uint16_t BswEep_ReadFLSN(void)
{
    uint16_t ReturnValue=0;
    Fapi_StatusType          oFapi_Status;
    Fapi_FlashStatusWordType oFapi_FlashStatusWord;

    uint16_t tempIndex=0;
    uint16_t LeBswEep_U16_UnionSize=0;  //used to save size of Unions in 16-bits
    uint32_t LeBswEep_U32_TgtAddr=0;    //Command Target Address;


    DINT;

    LeBswEep_U16_UnionSize=sizeof(GeAswNvm_Type_AppInformationUnion);
    for(tempIndex=0;tempIndex<(0x2000/LeBswEep_U16_UnionSize);tempIndex++)
    {
        LeBswEep_U32_TgtAddr=0x0BE000+tempIndex*LeBswEep_U16_UnionSize;
        EALLOW;
        oFapi_Status = Fapi_doBlankCheck((uint32 *)LeBswEep_U32_TgtAddr,LeBswEep_U16_UnionSize/2,&oFapi_FlashStatusWord);
        EDIS;
        if(oFapi_Status == Fapi_Status_Success)
        {
            break;
        }
    }

    if ( (tempIndex>=0x2000/LeBswEep_U16_UnionSize) || (tempIndex==0) )
    {
        GeAswNvm_U_AppInformationLocationIndex[1]=0x0BE000;
        GeAswNvm_U_AppInformationLocationIndex[0]=GeAswNvm_U_AppInformationLocationIndex[1]+0x2000-LeBswEep_U16_UnionSize-(0x2000%LeBswEep_U16_UnionSize);
        EALLOW;
        oFapi_Status = Fapi_doMarginRead((uint32 *)GeAswNvm_U_AppInformationLocationIndex[0],(uint32 *)&CeAswNvm_U_AppInformation,LeBswEep_U16_UnionSize/2,Fapi_NormalRead);
        EDIS;
    }
    else
    {
        GeAswNvm_U_AppInformationLocationIndex[1]=0x0BE000+tempIndex*LeBswEep_U16_UnionSize;
        GeAswNvm_U_AppInformationLocationIndex[0]=GeAswNvm_U_AppInformationLocationIndex[1]-LeBswEep_U16_UnionSize;
        EALLOW;
        oFapi_Status = Fapi_doMarginRead((uint32 *) GeAswNvm_U_AppInformationLocationIndex[0],(uint32 *)&CeAswNvm_U_AppInformation,LeBswEep_U16_UnionSize/2,Fapi_NormalRead);
        EDIS;
    }

    EINT;


    if(oFapi_Status == Fapi_Status_Success)
        ReturnValue=1;
    else
        ReturnValue=0;


    CeAswNvm_U_AppInformation.NvmData.Reserved1=0;


    return ReturnValue;
}


#pragma CODE_SECTION(BswEep_EraseFLSL, ".User.ramfunc");
uint16_t BswEep_EraseFLSL(void)
{
    uint16_t ReturnValue=0;

    Fapi_StatusType          oFapi_Status,oFapi_Status1,oFapi_Status2;
    Fapi_FlashStatusType     oFapi_FlashStatus;
    Fapi_FlashStatusWordType oFapi_FlashStatusWord;

    DINT;
    SysCtl_disableWatchdog();

    EALLOW;
    oFapi_Status = Fapi_doBlankCheck((uint32 *)(0x0BA000),0x1000,&oFapi_FlashStatusWord);
    EDIS;
    if(oFapi_Status !=Fapi_Status_Success)
    {
        EALLOW;
        oFapi_Status1 = Fapi_issueAsyncCommandWithAddress(Fapi_EraseSector,(uint32 *)(0x0BA000));
        while(Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}
        oFapi_FlashStatus = Fapi_getFsmStatus();
        oFapi_Status2 = Fapi_doBlankCheck((uint32 *)(0x0BA000),0x1000,&oFapi_FlashStatusWord);
        EDIS;


        if( (oFapi_Status1 != Fapi_Status_Success) || (oFapi_Status2 != Fapi_Status_Success) || (oFapi_FlashStatus!=0) )
            ReturnValue=0;
        else
            ReturnValue=1;
    }
    else
    {
        ReturnValue=1;
    }

    SysCtl_enableWatchdog();
    DEVICE_DELAY_US(60000);
    EINT;

    return ReturnValue;
}

#pragma CODE_SECTION(BswEep_EraseFLSM, ".User.ramfunc");
uint16_t BswEep_EraseFLSM(void)
{
    uint16_t ReturnValue=0;
    Fapi_StatusType          oFapi_Status,oFapi_Status1,oFapi_Status2;
    Fapi_FlashStatusType     oFapi_FlashStatus;
    Fapi_FlashStatusWordType oFapi_FlashStatusWord;

    DINT;
    SysCtl_disableWatchdog();

    EALLOW;
    oFapi_Status = Fapi_doBlankCheck((uint32 *)(0x0BC000),0x1000,&oFapi_FlashStatusWord);
    EDIS;
    if(oFapi_Status !=Fapi_Status_Success)
    {
        EALLOW;
        oFapi_Status1 = Fapi_issueAsyncCommandWithAddress(Fapi_EraseSector,(uint32 *)(0x0BC000));
        while(Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}
        oFapi_FlashStatus = Fapi_getFsmStatus();
        oFapi_Status2 = Fapi_doBlankCheck((uint32 *)(0x0BC000),0x1000,&oFapi_FlashStatusWord);
        EDIS;


        if( (oFapi_Status1 != Fapi_Status_Success) || (oFapi_Status2 != Fapi_Status_Success) || (oFapi_FlashStatus!=0) )
            ReturnValue=0;
        else
            ReturnValue=1;
    }
    else
    {
        ReturnValue=1;
    }

    SysCtl_enableWatchdog();
    DEVICE_DELAY_US(60000);
    EINT;

    return ReturnValue;
}

#pragma CODE_SECTION(BswEep_EraseFLSN, ".User.ramfunc");
uint16_t BswEep_EraseFLSN(void)
{
    uint16_t ReturnValue=0;
    Fapi_StatusType          oFapi_Status,oFapi_Status1,oFapi_Status2;
    Fapi_FlashStatusType     oFapi_FlashStatus;
    Fapi_FlashStatusWordType oFapi_FlashStatusWord;

    DINT;
    SysCtl_disableWatchdog();

    EALLOW;
    oFapi_Status = Fapi_doBlankCheck((uint32 *)(0x0BE000),0x1000,&oFapi_FlashStatusWord);
    EDIS;
    if(oFapi_Status !=Fapi_Status_Success)
    {
        EALLOW;
        oFapi_Status1 = Fapi_issueAsyncCommandWithAddress(Fapi_EraseSector,(uint32 *)(0x0BE000));
        while(Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}
        oFapi_FlashStatus = Fapi_getFsmStatus();
        oFapi_Status2 = Fapi_doBlankCheck((uint32 *)(0x0BE000),0x1000,&oFapi_FlashStatusWord);
        EDIS;


        if( (oFapi_Status1 != Fapi_Status_Success) || (oFapi_Status2 != Fapi_Status_Success) || (oFapi_FlashStatus!=0) )
            ReturnValue=0;
        else
        {
            ReturnValue=1;
            GeAswNvm_U_AppInformationLocationIndex[1]=0x0BE000;
            GeAswNvm_U_AppInformationLocationIndex[0]=GeAswNvm_U_AppInformationLocationIndex[1]+0x2000-sizeof(GeAswNvm_Type_AppInformationUnion)-(0x2000%sizeof(GeAswNvm_Type_AppInformationUnion));
        }
    }
    else
    {
        ReturnValue=1;
        GeAswNvm_U_AppInformationLocationIndex[1]=0x0BE000;
        GeAswNvm_U_AppInformationLocationIndex[0]=GeAswNvm_U_AppInformationLocationIndex[1]+0x2000-sizeof(GeAswNvm_Type_AppInformationUnion)-(0x2000%sizeof(GeAswNvm_Type_AppInformationUnion));
    }

    SysCtl_enableWatchdog();
    DEVICE_DELAY_US(60000);
    EINT;

    return ReturnValue;
}


#pragma CODE_SECTION(BswEep_WriteFLSL, ".User.ramfunc");
uint16_t BswEep_WriteFLSL(void)
{
    uint16_t ReturnValue=0;

    Fapi_StatusType          oFapi_Status;
    Fapi_FlashStatusType     oFapi_FlashStatus;
    Fapi_FlashStatusWordType oFapi_FlashStatusWord;

    uint16_t tempIndex=0;
    uint16_t LeBswEep_U16_UnionSize=0;  //used to save size of Unions in 16-bits

    DINT;
    SysCtl_disableWatchdog();

    LeBswEep_U16_UnionSize=sizeof(GeAswNvm_Type_EcuInformationUnion);
    EALLOW;
    oFapi_Status = Fapi_doBlankCheck((uint32 *)(0x0BA000),LeBswEep_U16_UnionSize/2,&oFapi_FlashStatusWord);
    EDIS;
    if(oFapi_Status != Fapi_Status_Success)
    {
        ReturnValue=0;
    }
    else
    {
        oFapi_Status=Fapi_Status_Success;
        oFapi_FlashStatus=0;

        for(tempIndex=0; tempIndex<(LeBswEep_U16_UnionSize/4) && (oFapi_Status==Fapi_Status_Success) && (oFapi_FlashStatus==0) ;tempIndex++)
        {
            EALLOW;
            oFapi_Status = Fapi_issueProgrammingCommand((uint32 *)(0x0BA000+tempIndex*4),
                                                        (uint16 *)(&CeAswNvm_U_EcuInformation.FlsBuffer[0]+tempIndex*4),
                                                        4,
                                                        0,
                                                        0,
                                                        Fapi_AutoEccGeneration);
            while(Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}
            oFapi_FlashStatus = Fapi_getFsmStatus();
            EDIS;
        }

        EALLOW;
        oFapi_Status = Fapi_doVerify((uint32 *)(0x0BA000),LeBswEep_U16_UnionSize/2,(uint32 *)(&CeAswNvm_U_EcuInformation.FlsBuffer[0]),&oFapi_FlashStatusWord);
        EDIS;
        if( (oFapi_Status != Fapi_Status_Success) )
        {
            ReturnValue=0;
        }
        else
            ReturnValue=1;
    }

    SysCtl_enableWatchdog();
    DEVICE_DELAY_US(60000);
    EINT;


    return ReturnValue;
}

#pragma CODE_SECTION(BswEep_WriteFLSM, ".User.ramfunc");
uint16_t BswEep_WriteFLSM(void)
{
    uint16_t ReturnValue=0;
    Fapi_StatusType          oFapi_Status,oFapi_Status1,oFapi_Status2;
    Fapi_FlashStatusType     oFapi_FlashStatus;
    Fapi_FlashStatusWordType oFapi_FlashStatusWord;

    uint16_t tempIndex=0;
    uint16_t LeBswEep_U16_UnionSize=0;  //used to save size of Unions in 16-bits

    DINT;
    SysCtl_disableWatchdog();

    LeBswEep_U16_UnionSize=sizeof(GeAswNvm_Type_BoardInformationUnion)+sizeof(GeAswNvm_Type_CalibInformationUnion);
    EALLOW;
    oFapi_Status = Fapi_doBlankCheck((uint32 *)(0x0BC000),LeBswEep_U16_UnionSize/2,&oFapi_FlashStatusWord);
    EDIS;
    if(oFapi_Status != Fapi_Status_Success)
    {
        ReturnValue=0;
    }
    else
    {
        oFapi_Status=Fapi_Status_Success;
        oFapi_FlashStatus=0;
        for(tempIndex=0;tempIndex<(sizeof(GeAswNvm_Type_BoardInformationUnion)/4) && (oFapi_Status==Fapi_Status_Success) && (oFapi_FlashStatus==0) ;tempIndex++)
        {
            EALLOW;
            oFapi_Status = Fapi_issueProgrammingCommand((uint32 *)(0x0BC000+tempIndex*4),
                                                        (uint16 *)(&CeAswNvm_U_BoardInformation.FlsBuffer[0]+tempIndex*4),
                                                         4,
                                                         0,
                                                         0,
                                                         Fapi_AutoEccGeneration);
            while(Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}
            oFapi_FlashStatus = Fapi_getFsmStatus();
            EDIS;
        }

        oFapi_Status=Fapi_Status_Success;
        oFapi_FlashStatus=0;
        for(tempIndex=0;tempIndex<(sizeof(GeAswNvm_Type_CalibInformationUnion)/4) && (oFapi_Status==Fapi_Status_Success) && (oFapi_FlashStatus==0)  ;tempIndex++)
        {
            EALLOW;
            oFapi_Status = Fapi_issueProgrammingCommand((uint32 *)(0x0BC100+tempIndex*4),
                                                        (uint16 *)(&CeAswNvm_U_CalibInformation.FlsBuffer[0]+tempIndex*4),
                                                         4,
                                                         0,
                                                         0,
                                                         Fapi_AutoEccGeneration);
            while(Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}
            oFapi_FlashStatus = Fapi_getFsmStatus();
            EDIS;
        }

        EALLOW;
        oFapi_Status1 = Fapi_doVerify((uint32 *)(0x0BC000),sizeof(GeAswNvm_Type_BoardInformationUnion)/2,(uint32 *)(&CeAswNvm_U_BoardInformation.FlsBuffer[0]),&oFapi_FlashStatusWord);
        oFapi_Status2 = Fapi_doVerify((uint32 *)(0x0BC100),sizeof(GeAswNvm_Type_CalibInformationUnion)/2,(uint32 *)(&CeAswNvm_U_CalibInformation.FlsBuffer[0]),&oFapi_FlashStatusWord);
        EDIS;

        if( (oFapi_Status1 != Fapi_Status_Success)  || (oFapi_Status2 != Fapi_Status_Success) )
            ReturnValue=0;
        else
            ReturnValue=1;
    }


    SysCtl_enableWatchdog();
    DEVICE_DELAY_US(60000);
    EINT;

    return ReturnValue;
}


#pragma CODE_SECTION(BswEep_WriteFLSN, ".User.ramfunc");
uint16_t BswEep_WriteFLSN(void)
{
    uint16_t ReturnValue=0;
    uint16_t WriteFlag=0;
    Fapi_StatusType          oFapi_Status;
    Fapi_FlashStatusType     oFapi_FlashStatus;
    Fapi_FlashStatusWordType oFapi_FlashStatusWord;

    uint16_t tempIndex=0;
    uint16_t LeBswEep_U16_UnionSize=0;  //used to save size of Unions in 16-bits

    DINT;
    SysCtl_disableWatchdog();


    LeBswEep_U16_UnionSize=sizeof(GeAswNvm_Type_AppInformationUnion);

    EALLOW;
    oFapi_Status=Fapi_doVerify( (uint32 *)GeAswNvm_U_AppInformationLocationIndex[0],
                                LeBswEep_U16_UnionSize/2,(uint32 *)(&CeAswNvm_U_AppInformation.FlsBuffer[0]),&oFapi_FlashStatusWord);
    EDIS;
    if(oFapi_Status == Fapi_Status_Success)
    {
        WriteFlag=0;
    }
    else if( (GeAswNvm_U_AppInformationLocationIndex[1]-0x0BE000+LeBswEep_U16_UnionSize)>0x2000)
    {
        WriteFlag=BswEep_EraseFLSN();
    }
    else
    {
        WriteFlag=1;
    }

    if(WriteFlag)
    {
        oFapi_Status=Fapi_Status_Success;
        oFapi_FlashStatus=0;
        for(tempIndex=0;tempIndex<(LeBswEep_U16_UnionSize/4) && (oFapi_Status==Fapi_Status_Success) && (oFapi_FlashStatus==0) ;tempIndex++)
        {
            EALLOW;
            oFapi_Status = Fapi_issueProgrammingCommand((uint32 *)(GeAswNvm_U_AppInformationLocationIndex[1]+tempIndex*4),
                                                        (uint16 *)(&CeAswNvm_U_AppInformation.FlsBuffer[0]+tempIndex*4),
                                                         4,
                                                         0,
                                                         0,
                                                         Fapi_AutoEccGeneration);
            while(Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}
            oFapi_FlashStatus = Fapi_getFsmStatus();
            EDIS;
        }

        EALLOW;
        oFapi_Status=Fapi_doVerify( (uint32 *)GeAswNvm_U_AppInformationLocationIndex[1],LeBswEep_U16_UnionSize/2,(uint32 *)(&CeAswNvm_U_AppInformation.FlsBuffer[0]),&oFapi_FlashStatusWord);
        EDIS;
        if(oFapi_Status == Fapi_Status_Success)
        {
            ReturnValue=1;
            GeAswNvm_U_AppInformationLocationIndex[0]=GeAswNvm_U_AppInformationLocationIndex[1];
            GeAswNvm_U_AppInformationLocationIndex[1]+=LeBswEep_U16_UnionSize;
        }
        else
        {
            ReturnValue=0;
        }
    }
    else{}

    SysCtl_enableWatchdog();
    DEVICE_DELAY_US(60000);
    EINT;

    return ReturnValue;
}

  • 0 in reply to Green Deng
    TI__Guru* 87155 points

    Hi Green,

    I will review and get back to you in couple of days.

    Thanks and regards,

    Vamsi

  • 0 in reply to Vamsi Gudivada
    TI__Guru* 87155 points

    Hi Green,

    Please provide more details about your statement "but after loading program into flash and run, it can't run normally".

    Is there any specific error/status that you can provide to analyze?

    Thanks and regards,
    Vamsi

  • 0 in reply to Vamsi Gudivada
    TI__Expert 4490 points

    The rest of the programs are running normally, and the Fapi related functions will return error values.

    Such as executing:

    oFapi_Status = Fapi_issueProgrammingCommand(x,x,4,0,0,Fapi_AutoEccGeneration)

    The return value status is:

    Fapi_Error_Fail=500

    typedef enum
{
   Fapi_Status_Success=0,           /* Function completed successfully */
   Fapi_Status_FsmBusy,             /* FSM is Busy */
   Fapi_Status_FsmReady,            /* FSM is Ready */
   Fapi_Status_AsyncBusy,           /* Async function operation is Busy */
   Fapi_Status_AsyncComplete,       /* Async function operation is Complete */
   Fapi_Error_Fail=500,             /* Generic Function Fail code */
   Fapi_Error_StateMachineTimeout,  /* State machine polling never returned ready and timed out */
   Fapi_Error_OtpChecksumMismatch,  /* Returned if OTP checksum does not match expected value */
   Fapi_Error_InvalidDelayValue,    /* Returned if the Calculated RWAIT value exceeds 15  - Legacy Error */
   Fapi_Error_InvalidHclkValue,     /* Returned if FClk is above max FClk value - FClk is a calculated from HClk and RWAIT/EWAIT */
   Fapi_Error_InvalidCpu,           /* Returned if the specified Cpu does not exist */
   Fapi_Error_InvalidBank,          /* Returned if the specified bank does not exist */
   Fapi_Error_InvalidAddress,       /* Returned if the specified Address does not exist in Flash or OTP */
   Fapi_Error_InvalidReadMode,      /* Returned if the specified read mode does not exist */
   Fapi_Error_AsyncIncorrectDataBufferLength,
   Fapi_Error_AsyncIncorrectEccBufferLength,
   Fapi_Error_AsyncDataEccBufferLengthMismatch,
   Fapi_Error_FeatureNotAvailable  /* FMC feature is not available on this device */
}  ATTRIBUTE_PACKED Fapi_StatusType;

  • +1 in reply to Green Deng
    TI__Guru* 87155 points

    Hi Green,

    Were they able to execute the flash programming example in C2000Ware successfully?

    Thanks and regards,
    Vamsi