PROCESSOR-SDK-AM62X: Creating a first 'Hello World' application and run it on the EVM

Hi,

Thanks for reaching out to Texas Instruments E2E support forum.

Can you please confirm have you initialized the SOC before running the program? 

To initialize the SOC using SBL binaries, please refer EVM_FLASH_SOC_INIT for more details.

? ? said:

mcu_plus_sdk_am62x_08_06_00_18-windows-x64-installer.exe

Can you please also tell us the reason behind using an older SDK? As the newer version of SDK is already available on MCU-PLUS-SDK-AM62X 

Regards,

Tushar

Hi，

Is this the reason why SOC initialization fails?

What do I need to do to successfully initialize SOC.

The UART port can print 'C' every 2-3 seconds.

Hi，

We are currently using this SDK.

Hi,

You are using CCS v12.8 but the SDK makefile is configured for CCS v12.7.0.

Can you please update the CCS path to ccs1280 in imports.mak file located at root directory of MCU+SDK.

Regards,

Tushar 

Hi,

? ? said:

We are currently using this SDK.

I can see that you are using SDK v10.0 which is the latest one. Thanks for sharing the screenshot above.

Regards,

Tushar

Hi,

Updating the CCS path in the imports.mak file in the MCU+SDK root directory to ccs1280 still fails.

Hi,

Now the error message got change. Error coming is not related to CCS anymore.

Can you please tell us what command are you running and from which directory it is run?

Regards,

Tushar

Hi,

This is the command executed in the directory where I am located, and the result of executing the command.

Hi,

I have tried to build the SDK using above command gmake -sj4 all and it is working fine for me.

Can you please tell have you modified the SDK code?

I can see you are getting error related to flash_nand_ospi.c file. Can you please share the flash_ospi_nand.c file with us?

Regards,

Tushar

Hi,

I did not modify the SDK code. It is downloaded from the official website and decompressed for use.

mcu_plus_sdk_am62x_10_00_00_14.zip

Hi,

I am sharing the flash_ospi_nand.c file code below, Please compare the code with the file present in MCU+SDK.

/*
 *  Copyright(C) 2023 Texas Instruments Incorporated
 *
 *  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.
 */

#include <board/flash.h>
#include <board/flash/ospi/flash_nand_ospi.h>
#include <drivers/hw_include/cslr.h>
#include <kernel/dpl/CacheP.h>

#define FLASH_OSPI_JEDEC_ID_SIZE_MAX            (8U)
#define FLASH_PAGE_SPARE_ARRAY_SIZE_BYTES       (128U)
#define FLASH_NAND_BLOCK_GOOD                   (0U)
#define FLASH_NAND_BLOCK_BAD                    (1U)

static int32_t Flash_nandOspiOpen(Flash_Config *config, Flash_Params *params);
static int32_t Flash_nandOspiRead(Flash_Config *config, uint32_t offset, uint8_t *buf, uint32_t len);
static int32_t Flash_nandOspiErase(Flash_Config *config, uint32_t blkNum);
static int32_t Flash_nandOspiWrite(Flash_Config *config, uint32_t offset, uint8_t *buf, uint32_t len);
static int32_t Flash_nandOspiReset(Flash_Config *config);
static void Flash_nandOspiClose(Flash_Config *config);
static int32_t Flash_nandOspiCmdWrite(Flash_Config *config, uint8_t cmd, uint32_t cmdAddr,
                                     uint8_t numAddrBytes, uint8_t *txBuf, uint32_t txLen);
static int32_t Flash_nandOspiSetProtocol(Flash_Config *config, void *ospiHandle, Flash_Params *params);
static int32_t Flash_nandOspiDisableWriteProtection(Flash_Config *config);
static int32_t Flash_nandOspiCmdRead(Flash_Config *config, uint8_t cmd, uint32_t cmdAddr,
                            uint8_t numAddrBytes, uint8_t dummyBits, uint8_t *rxBuf, uint32_t rxLen);
static int32_t Flash_nandOspiWaitReady(Flash_Config *config, uint32_t timeOut);
static int32_t Flash_nandOspiSetDummyCycles(Flash_Config *config);
static int32_t Flash_nandOspiEnableDDR(Flash_Config *config);
static int32_t Flash_nandOspiEnableSDR(Flash_Config *config);
static int32_t Flash_nandOspiReadId(Flash_Config *config);
static int32_t Flash_NandOspiWriteDirect(Flash_Config *config, OSPI_Transaction *trans);
static int32_t Flash_nandOspiCheckEraseStatus(Flash_Config *config);
static int32_t Flash_nandOspiCheckProgStatus(Flash_Config *config);
static int32_t Flash_nandOspiPageLoad(Flash_Config *config, uint32_t offset);
static int32_t Flash_nandOspiPageProgram(Flash_Config *config, uint32_t pageNum);
static int32_t Flash_nandGetBBList(Flash_Config *config);
static int32_t Flash_nandCheckBadBlock(Flash_Config *config, uint32_t blkNum);
static int32_t Flash_nandMarkBlockAsBad(Flash_Config *config, uint32_t blkNum);
static void Flash_nandFindGoodBlock(Flash_Config *config, uint32_t *blkNum, uint32_t *pageNum);

uint32_t gNandFlashToSpiProtocolMap[] =
{
    [FLASH_CFG_PROTO_1S_1S_1S] = OSPI_FLASH_PROTOCOL(1,1,1,0),
    [FLASH_CFG_PROTO_1S_8S_8S] = OSPI_FLASH_PROTOCOL(1,8,8,0),
    [FLASH_CFG_PROTO_8D_8D_8D] = OSPI_FLASH_PROTOCOL(8,8,8,1),
};

Flash_Fxns gFlashNandOspiFxns = {

    .openFxn = Flash_nandOspiOpen,
    .closeFxn = Flash_nandOspiClose,
    .readFxn = Flash_nandOspiRead,
    .writeFxn = Flash_nandOspiWrite,
    .eraseFxn = Flash_nandOspiErase,
    .eraseSectorFxn = NULL,
    .resetFxn = Flash_nandOspiReset,
    .enablePhyPipelineFxn = NULL,
    .disablePhyPipelineFxn = NULL,
};

static int32_t Flash_nandOspiOpen(Flash_Config *config, Flash_Params *params)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = NULL;
    Flash_Attrs *attrs = NULL;
    int32_t attackVectorStatus = SystemP_SUCCESS;
    uint32_t readDataCapDelay, phyTuningOffset;

    if(config == NULL)
    {
        status = SystemP_FAILURE;
    }
    else
    {
        attrs = config->attrs;
        obj = (Flash_NandOspiObject *)(config->object);
        obj->ospiHandle = OSPI_getHandle(attrs->driverInstance);
    }

    if(SystemP_SUCCESS == status)
    {
        /* Set device size and addressing bytes */
        OSPI_setDeviceSize(obj->ospiHandle, attrs->pageSize, attrs->blockSize);

        /* Set command opcode extension type */
        OSPI_setCmdExtType(obj->ospiHandle, config->devConfig->cmdExtType);

        /* Set current protocol as 1s1s1s */
        obj->currentProtocol = FLASH_CFG_PROTO_1S_1S_1S;

        Flash_nandOspiDisableWriteProtection(config);

        status += Flash_nandOspiSetProtocol(config, obj->ospiHandle, params);

        OSPI_setXferOpCodes(obj->ospiHandle, config->devConfig->protocolCfg.cmdRd, config->devConfig->protocolCfg.cmdWr);

        obj->currentProtocol = config->devConfig->protocolCfg.protocol;

        /* Set RD Capture Delay by reading ID */
        readDataCapDelay = 4U;
        OSPI_setRdDataCaptureDelay(obj->ospiHandle, readDataCapDelay, FALSE);
        OSPI_setRdDummyValPhyMode(obj->ospiHandle, obj->rdDummyValPhyMode);

        status = Flash_nandOspiReadId(config);

        while((status != SystemP_SUCCESS) && (readDataCapDelay > 0U))
        {
            readDataCapDelay--;
            OSPI_setRdDataCaptureDelay(obj->ospiHandle, readDataCapDelay, FALSE);
            status = Flash_nandOspiReadId(config);
        }
    }

    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandGetBBList(config);
    }
    else
    {
        DebugP_logError("%s : Unable to read Flash ID...\r\n", __func__);
    }

    if(SystemP_SUCCESS == status)
    {
        if(SystemP_SUCCESS == OSPI_skipTuning(obj->ospiHandle))
        {
            OSPI_enablePhy(obj->ospiHandle);

            /* PHY configuration are already stored and has to be written into register */
            OSPI_phyWriteTunedVal(obj->ospiHandle);

            /* Set RD Capture Delay by reading ID */
            readDataCapDelay = 4U;
            phyTuningOffset = Flash_getPhyTuningOffset(config);

            OSPI_setRdDataCaptureDelay(obj->ospiHandle, readDataCapDelay, TRUE);
            attackVectorStatus = Flash_nandOspiPageLoad(config, phyTuningOffset);
            attackVectorStatus += OSPI_phyReadAttackVector(obj->ospiHandle, 0);

            while((attackVectorStatus != SystemP_SUCCESS) && (readDataCapDelay > 0U))
            {
                readDataCapDelay--;
                OSPI_setRdDataCaptureDelay(obj->ospiHandle, readDataCapDelay, TRUE);
                attackVectorStatus = OSPI_phyReadAttackVector(obj->ospiHandle, 0);
            }

            if(SystemP_SUCCESS == attackVectorStatus)
            {
                obj->phyEnable = TRUE;
            }

            OSPI_disablePhy(obj->ospiHandle);
        }

        if(SystemP_SUCCESS != attackVectorStatus || SystemP_SUCCESS != OSPI_skipTuning(obj->ospiHandle))
        {
            /* Enable PHY if attack vector present and PHY mode is enabled */

            if(OSPI_isPhyEnable(obj->ospiHandle))
            {
                /* For nand flash, data is read page by page. For phy pattern,
                 * once the page load command is sent, the page data becomes available
                 * at the offest zero of OSPI data region. Through out the tuning process,
                 * phy pattern can be read from offset zero of OSPI data region.
                 */
                phyTuningOffset = Flash_getPhyTuningOffset(config);
                attackVectorStatus = Flash_nandOspiPageLoad(config, phyTuningOffset);
                attackVectorStatus += OSPI_phyReadAttackVector(obj->ospiHandle, 0);

                if(attackVectorStatus != SystemP_SUCCESS)
                {
                    /* Flash the attack vector to the last block */
                    uint32_t blk = 0, page = 0;
                    uint32_t phyTuningData = 0,phyTuningDataSize = 0;

                    OSPI_phyGetTuningData(&phyTuningData, &phyTuningDataSize);
                    Flash_offsetToBlkPage(config, phyTuningOffset, &blk, &page);
                    Flash_nandOspiErase(config, blk);
                    Flash_nandOspiWrite(config, phyTuningOffset, (uint8_t *)phyTuningData, phyTuningDataSize);
                    attackVectorStatus = Flash_nandOspiPageLoad(config, phyTuningOffset);
                    attackVectorStatus += OSPI_phyReadAttackVector(obj->ospiHandle, 0);
                }

                if(attackVectorStatus == SystemP_SUCCESS)
                {
                    status += OSPI_phyTuneSDR(obj->ospiHandle, 0);
                    if(status == SystemP_SUCCESS)
                    {
                        obj->phyEnable = TRUE;
                        OSPI_setPhyEnableSuccess(obj->ospiHandle, TRUE);
                    }
                }
                else
                {
                    DebugP_logError("%s : PHY enabling failed!!! Continuing without PHY...\r\n", __func__);
                    obj->phyEnable = FALSE;
                    OSPI_setPhyEnableSuccess(obj->ospiHandle, FALSE);
                }
            }
            else
            {
                obj->phyEnable = FALSE;
            }
        }
    }
    else
    {
        DebugP_logError("%s : Unable to initialize bad block list", __func__);
    }

    return status;
}

static void Flash_nandOspiClose(Flash_Config *config)
{
    Flash_NandOspiObject *obj = (Flash_NandOspiObject *)(config->object);

    /* Reset the flash such that other modules can initialise the
     *  Flash config registers again.
     */
    (void)Flash_nandOspiReset(config);

    /* Disable the PHY */
    OSPI_disablePhy(obj->ospiHandle);

    obj->ospiHandle = NULL;

    /* OSPI Driver will be closed outside flash */

    return;
}


static int32_t Flash_nandOspiPageLoad(Flash_Config *config, uint32_t offset)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = NULL;
    Flash_DevConfig *devCfg = NULL;
    Flash_Attrs *attrs = NULL;

    uint32_t pageNum;
    uint8_t cmd;
    uint8_t addrLen = 0U;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        devCfg = config->devConfig;
        attrs = config->attrs;

        pageNum = offset / attrs->pageSize;
        cmd = devCfg->cmdPageLoad;

        if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
        {
            addrLen = 2;
        }
        else if(obj->currentProtocol == FLASH_CFG_PROTO_1S_1S_1S ||
                obj->currentProtocol == FLASH_CFG_PROTO_1S_8S_8S)
        {
            addrLen = 3;
        }

        if(status == SystemP_SUCCESS)
        {
            status += Flash_nandOspiCmdWrite(config, cmd, pageNum, addrLen, NULL, 0);

            if(status == SystemP_SUCCESS)
            {
                status += Flash_nandOspiWaitReady(config, 1000u);
            }
        }
    }
    else
    {
        status = SystemP_FAILURE;
    }

    return status;
}

static int32_t Flash_nandOspiPageProgram(Flash_Config *config, uint32_t pageNum)
{
    int32_t status = SystemP_SUCCESS;
    uint8_t cmd;
    Flash_NandOspiObject *obj = NULL;
    Flash_DevConfig *devCfg = NULL;
    Flash_Attrs *attrs = NULL;
    uint32_t blkNum = 0;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        devCfg = config->devConfig;
        attrs = config->attrs;
        blkNum = pageNum / attrs->pageCount;
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        cmd = devCfg->cmdPageProg;
        if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
        {
            status = Flash_nandOspiCmdWrite(config, cmd, pageNum, 2U, NULL, 0U);
        }
        else
        {
            status = Flash_nandOspiCmdWrite(config, cmd, pageNum, 3U, NULL, 0U);
        }
    }

    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiWaitReady(config, 10000U);
    }

    if(status == SystemP_SUCCESS)
    {
        for(int timeOut = 10000U; timeOut > 0U; timeOut--)
        {
            status = Flash_nandOspiCheckProgStatus(config);
            if(status == SystemP_SUCCESS)
            {
                break;
            }
        }
    }

    if(status == SystemP_FAILURE)
    {
        Flash_nandMarkBlockAsBad(config, blkNum);
    }

    return status;
}

static int32_t Flash_nandOspiRead(Flash_Config *config, uint32_t offset, uint8_t *buf, uint32_t len)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = NULL;
    OSPI_Transaction transaction;
    Flash_Attrs *attrs = NULL;

    uint32_t pageSize;
    uint32_t numPages;
    uint32_t offsetFromPage;
    uint32_t pageNum;
    uint32_t readAddr;
    uint32_t blkNum;

    if(config == NULL)
    {
        status = SystemP_FAILURE;
    }
    else
    {
        obj = (Flash_NandOspiObject *)(config->object);
        attrs = config->attrs;
    }

    if(status == SystemP_SUCCESS)
    {
        if(offset + len > attrs->flashSize)
        {
            status = SystemP_FAILURE;
        }
    }

    if(status == SystemP_SUCCESS)
    {
        pageSize = attrs->pageSize;
        blkNum = offset / attrs->blockSize;
        pageNum = offset / pageSize;
        Flash_nandFindGoodBlock(config, &blkNum, &pageNum);

        if(blkNum >= attrs->blockCount)
        {
            status = SystemP_FAILURE;
        }
    }

    if(status == SystemP_SUCCESS)
    {
        offsetFromPage = offset % pageSize;
        numPages = (len + (pageSize - 1) + offsetFromPage) / pageSize;
        readAddr = offset;

        for(uint32_t i = 0; i < numPages; i++)
        {
            status = Flash_nandOspiPageLoad(config, pageNum * pageSize);

            /* Read data if not Bad block */
            if(status == SystemP_SUCCESS)
            {
                if(obj->phyEnable)
                {
                    OSPI_enablePhy(obj->ospiHandle);
                }

                OSPI_Transaction_init(&transaction);
                transaction.buf = (void *)buf + readAddr - offset;
                transaction.dmaCopyLowerLimit = OSPI_NAND_DMA_COPY_LOWER_LIMIT;

                if(numPages == 1)
                {
                    transaction.addrOffset = offsetFromPage;
                    transaction.count = len;
                }
                else
                {
                    if(i == 0)
                    {
                        transaction.addrOffset = offsetFromPage;
                        transaction.count = pageSize - offsetFromPage;
                    }
                    else if(i < (numPages-1))
                    {
                        transaction.addrOffset = 0;
                        transaction.count = pageSize;
                    }
                    else if(i == (numPages-1))
                    {
                        transaction.addrOffset = 0;
                        transaction.count = (offsetFromPage + len ) % pageSize;

                        if(transaction.count == 0)
                        {
                            transaction.count = pageSize;
                        }
                    }
                }

                status = OSPI_readDirect(obj->ospiHandle, &transaction);

                if(obj->phyEnable)
                {
                    OSPI_disablePhy(obj->ospiHandle);
                }
            }

            if(readAddr % pageSize == 0)
            {
                readAddr += pageSize;
            }
            else
            {
                readAddr += (pageSize - (readAddr % pageSize));
            }

            if(status != SystemP_SUCCESS)
            {
                break;
            }

            pageNum++;

            if(pageNum / attrs->pageCount != blkNum)
            {
                blkNum = pageNum / attrs->pageCount;
                Flash_nandFindGoodBlock(config, &blkNum, &pageNum);
                if(blkNum >= attrs->blockCount)
                {
                    status = SystemP_FAILURE;
                    break;
                }
            }
        }
    }

    return status;
}

static int32_t Flash_nandOspiWrite(Flash_Config *config, uint32_t offset, uint8_t *buf, uint32_t len)
{
    int32_t status = SystemP_SUCCESS;
    Flash_Attrs *attrs = NULL;
    Flash_DevConfig *devCfg = NULL;

    if(config != NULL)
    {
        attrs = config->attrs;
        devCfg = config->devConfig;
    }
    else
    {
        status = SystemP_FAILURE;
    }

    /* Validate address input */
    if((offset + len) > (attrs->blockCount*attrs->pageCount*attrs->pageSize))
    {
        status = SystemP_FAILURE;
    }

    /* Check offset alignment */
    if(0 != (offset % attrs->pageSize))
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        uint32_t pageSize, chunkLen, actual;
        uint32_t byteAddr;
        uint32_t pageAddr;
        uint32_t colmAddr;
        uint32_t blkNum;
        OSPI_Transaction transaction;

        pageSize = attrs->pageSize;
        byteAddr = offset & (pageSize - 1);
        pageAddr = offset / pageSize;
        blkNum = offset / attrs->blockSize;

        Flash_nandFindGoodBlock(config, &blkNum, &pageAddr);

        if(blkNum >= attrs->blockCount)
        {
            status = SystemP_FAILURE;
        }

        if(status == SystemP_SUCCESS)
        {
            for(actual = 0; actual < len; actual += chunkLen)
            {
                status = Flash_nandOspiCmdWrite(config, devCfg->cmdWren, OSPI_CMD_INVALID_ADDR, 0, NULL, 0);

                if(status == SystemP_SUCCESS)
                {
                    status = Flash_nandOspiWaitReady(config, 1000U);
                }

                chunkLen = ((len - actual) < (pageSize - byteAddr) ?
                        (len - actual) : (pageSize - byteAddr));

                /* Split the page and column addresses */
                colmAddr = offset % pageSize;

                if(status == SystemP_SUCCESS)
                {
                    /* Send Page Program command */
                    if((len - actual) < (pageSize))
                    {
                        chunkLen = (len - actual);
                    }
                    else
                    {
                        chunkLen = pageSize;
                    }

                    OSPI_Transaction_init(&transaction);
                    transaction.addrOffset = colmAddr;
                    transaction.buf = (void *)(buf + actual);
                    transaction.count = chunkLen;
                    status = Flash_NandOspiWriteDirect(config, &transaction);
                }

                if(status == SystemP_SUCCESS)
                {
                    status = Flash_nandOspiWaitReady(config, 10000U);
                }

                if(status == SystemP_SUCCESS)
                {
                    status = Flash_nandOspiPageProgram(config, pageAddr);
                }

                if(status == SystemP_SUCCESS)
                {
                    offset += chunkLen;
                    pageAddr++;
                    if(pageAddr / attrs->pageCount != blkNum)
                    {
                        blkNum = pageAddr / attrs->pageCount;
                        Flash_nandFindGoodBlock(config, &blkNum, &pageAddr);
                        if(blkNum >= attrs->blockCount)
                        {
                            status = SystemP_FAILURE;
                            break;
                        }
                    }
                }
                else
                {
                    break;
                }
            }
        }
    }

    return status;
}

static int32_t Flash_nandOspiErase(Flash_Config *config, uint32_t blkNum)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj;
    Flash_Attrs *attrs = NULL;
    Flash_DevConfig *devCfg = NULL;

    uint8_t cmd = OSPI_CMD_INVALID_OPCODE;
    uint32_t cmdAddr = OSPI_CMD_INVALID_ADDR;
    uint8_t cmdWren;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        attrs = config->attrs;
        devCfg = config->devConfig;
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS && obj->badBlockCheck == TRUE)
    {
        while(obj->bbList[blkNum] == FLASH_NAND_BLOCK_BAD)
        {
            blkNum++;
        }

        if(blkNum >= attrs->blockCount)
        {
            status = SystemP_FAILURE;
        }
    }

    if(status == SystemP_SUCCESS)
    {
        while (blkNum < attrs->blockCount)
        {
            cmdWren = devCfg->cmdWren;
            cmdAddr = (blkNum * attrs->blockSize) / attrs->pageSize;
            cmd = devCfg->eraseCfg.cmdBlockErase;

            if(status == SystemP_SUCCESS)
            {
                status = Flash_nandOspiWaitReady(config, 1000U);
            }

            if(status == SystemP_SUCCESS)
            {
                status = Flash_nandOspiCmdWrite(config, cmdWren, OSPI_CMD_INVALID_ADDR, 0, NULL, 0);
            }

            if(status == SystemP_SUCCESS)
            {
                status = Flash_nandOspiWaitReady(config, 1000U);
            }

            if(status == SystemP_SUCCESS)
            {
                if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
                {
                    status = Flash_nandOspiCmdWrite(config, cmd, cmdAddr, 2, NULL, 0);
                }
                else
                {
                    status = Flash_nandOspiCmdWrite(config, cmd, cmdAddr, 3, NULL, 0);
                }
            }

            if(status == SystemP_SUCCESS)
            {
                status = Flash_nandOspiWaitReady(config, 10000U);
            }

            if(status == SystemP_SUCCESS)
            {
                for(int timeOut = 10000; timeOut > 0; timeOut--)
                {
                    status = Flash_nandOspiCheckEraseStatus(config);
                    if(status == SystemP_SUCCESS)
                    {
                        break;
                    }
                }
            }

            if(status != SystemP_SUCCESS && obj->badBlockCheck == TRUE)
            {
                Flash_nandMarkBlockAsBad(config, blkNum);
                blkNum++;

                /* Set status to success to perform erase operation for the next block */
                status = SystemP_SUCCESS;
            }
            else
            {
                break;
            }
        }
    }

    return status;
}

static int32_t Flash_nandOspiReset(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;

    status = Flash_nandOspiCmdWrite(config, 0x66U, OSPI_CMD_INVALID_ADDR, 0, NULL, 0);

    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiCmdWrite(config, 0x99U, OSPI_CMD_INVALID_ADDR, 0, NULL, 0);
    }

    return status;
}

static int32_t Flash_nandOspiSetProtocol(Flash_Config *config, void *ospiHandle, Flash_Params *params)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj;

    if((config == NULL) ||(NULL == ospiHandle))
    {
        status = SystemP_FAILURE;
    }
    else
    {
        Flash_DevConfig *devCfg = config->devConfig;
        obj =(Flash_NandOspiObject *)(config->object);

        /* Configure the flash according to protocol */
        uint32_t protocol = devCfg->protocolCfg.protocol;
        uint32_t dummyCycles = devCfg->protocolCfg.dummyClksRd;

        if(FLASH_CFG_PROTO_CUSTOM == protocol)
        {
            status += params->custProtoFxn(config);
        }
        else
        {
            /* OOB support available for:
                * 1S_1S_1S
                * 1S_8S_8S
                * 8D_8D_8D
                */
            switch(protocol)
            {
                case FLASH_CFG_PROTO_1S_1S_1S:
                    break;

                case FLASH_CFG_PROTO_1S_8S_8S:

                    OSPI_enableSDR(obj->ospiHandle);
                    OSPI_clearDualOpCodeMode(obj->ospiHandle);
                    status += Flash_nandOspiSetDummyCycles(config);
                    status += Flash_nandOspiEnableSDR(config);
                    break;

                case FLASH_CFG_PROTO_8D_8D_8D:

                    status = Flash_nandOspiSetDummyCycles(config);

                    status += Flash_nandOspiEnableDDR(config);

                    break;

                default:
                    status = SystemP_FAILURE;
                    break;
            }
        }

        OSPI_setReadDummyCycles(obj->ospiHandle, dummyCycles);
        OSPI_setNumAddrBytes(obj->ospiHandle, 2);
        OSPI_setProtocol((OSPI_Handle)(obj->ospiHandle), gNandFlashToSpiProtocolMap[protocol]);
    }

    return status;
}

static int32_t Flash_nandOspiDisableWriteProtection(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;
    Flash_DevConfig *devConfig = NULL;
    uint8_t txBuf = 0;
    uint8_t cmd = 0;
    uint32_t cmdAddr = 0;

    if(NULL != config)
    {
        devConfig =(Flash_DevConfig *)config->devConfig;
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        cmd = devConfig->cmdWrsr;
        cmdAddr = devConfig->srWriteProtectReg;
        txBuf = devConfig->srWriteProtectMask && 0;

        status = Flash_nandOspiCmdWrite(config, cmd, cmdAddr, 1, &txBuf, 1);
    }

    return status;
}

static int32_t Flash_nandOspiCmdWrite(Flash_Config *config, uint8_t cmd, uint32_t cmdAddr,
                                     uint8_t numAddrBytes, uint8_t *txBuf, uint32_t txLen)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = NULL;
    OSPI_WriteCmdParams wrParams;

    if(config !=  NULL)
    {
        obj =(Flash_NandOspiObject *)(config->object);
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        OSPI_WriteCmdParams_init(&wrParams);
        wrParams.cmd          = cmd;
        wrParams.cmdAddr      = cmdAddr;
        wrParams.numAddrBytes = numAddrBytes;
        wrParams.txDataBuf    = txBuf;
        wrParams.txDataLen    = txLen;

        status = OSPI_writeCmd(obj->ospiHandle, &wrParams);
    }

    return status;
}

static int32_t Flash_nandOspiWaitReady(Flash_Config *config, uint32_t timeOut)
{
    int32_t status = SystemP_SUCCESS;
    Flash_DevConfig *devCfg = NULL;
    Flash_NandOspiObject *obj = NULL;

    uint8_t readStatus[2] = { 0 };
    uint8_t cmd = 0, numAddrBytes = 0, readBytes = 0;
    uint32_t cmdAddr = OSPI_CMD_INVALID_ADDR;
    uint8_t dummyBits = 0;
    uint8_t bitMask = 0;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        devCfg = config->devConfig;
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if (status == SystemP_SUCCESS)
    {
        if((devCfg->xspiWipRdCmd != 0x00) && (obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D))
        {
            cmd = devCfg->xspiWipRdCmd;
            cmdAddr = devCfg->xspiWipReg;
            dummyBits = devCfg->xspiRdsrDummy;
            bitMask = devCfg->srWip;
            readBytes = 2;
            numAddrBytes = 2;
        }
        else if(obj->currentProtocol == FLASH_CFG_PROTO_1S_1S_1S ||
                obj->currentProtocol == FLASH_CFG_PROTO_1S_8S_8S)
        {
            cmd = devCfg->cmdRdsr;
            cmdAddr = devCfg->srWipReg;
            dummyBits = 0;
            bitMask = devCfg->srWip;
            readBytes = 1;
            numAddrBytes = 1;
        }

        while((status != SystemP_SUCCESS) || (timeOut > 0))
        {
            status = Flash_nandOspiCmdRead(config, cmd, cmdAddr, numAddrBytes, dummyBits, readStatus, readBytes);

            if((status == SystemP_SUCCESS) && ((readStatus[0] & bitMask) == 0))
            {
                break;
            }
            timeOut --;
        }

        if((readStatus[0] & bitMask)==0)
        {
            status = SystemP_SUCCESS;
        }
        else
        {
            status = SystemP_FAILURE;
        }
    }

    return status;
}


static int32_t Flash_nandOspiCmdRead(Flash_Config *config, uint8_t cmd, uint32_t cmdAddr,
                            uint8_t numAddrBytes, uint8_t dummyBits, uint8_t *rxBuf, uint32_t rxLen)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = NULL;
    OSPI_ReadCmdParams  rdParams;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        OSPI_ReadCmdParams_init(&rdParams);
        rdParams.cmd           = cmd;
        rdParams.cmdAddr       = cmdAddr;
        rdParams.numAddrBytes  = numAddrBytes;
        rdParams.rxDataBuf     = rxBuf;
        rdParams.rxDataLen     = rxLen;
        rdParams.dummyBits     = dummyBits;

        status = OSPI_readCmd(obj->ospiHandle, &rdParams);
    }

    return status;

}

static int32_t Flash_nandOspiSetDummyCycles(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = (Flash_NandOspiObject *)(config->object);
    Flash_DevConfig *devCfg = config->devConfig;
    FlashCfg_RegConfig *dummyCfg = &(devCfg->protocolCfg.dummyCfg);

    /* Send Write Enable Command */
    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiCmdWrite(config, devCfg->cmdWren,
                                OSPI_CMD_INVALID_ADDR, 0, NULL, 0);
    }

    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiWaitReady(config, 1000U);
    }

    if((dummyCfg->cmdRegRd != 0) && (dummyCfg->cmdRegWr != 0))
    {
        uint8_t cfgReg = 0;
        if(dummyCfg->isAddrReg == TRUE)
        {
            if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
            {
                status += Flash_nandOspiCmdRead(config, dummyCfg->cmdRegRd, dummyCfg->cfgReg, 3, 8, &cfgReg, 2);
            }
            else
            {
                status += Flash_nandOspiCmdRead(config, dummyCfg->cmdRegRd, dummyCfg->cfgReg, 3, 8, &cfgReg, 1);
            }
        }
        else
        {
            if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
            {
                status += Flash_nandOspiCmdRead(config, dummyCfg->cmdRegRd, OSPI_CMD_INVALID_ADDR, 0, 8, &cfgReg, 2);
            }
            else
            {
                status += Flash_nandOspiCmdRead(config, dummyCfg->cmdRegRd, OSPI_CMD_INVALID_ADDR, 0, 8, &cfgReg, 1);
            }
        }

        if(SystemP_SUCCESS == status)
        {
            /* Clear the config bits in the register  */
            cfgReg &= ~(uint8_t)(dummyCfg->mask);
            /* Bitwise OR the bit pattern for setting the dummyCycle selected */
            cfgReg |= (dummyCfg->cfgRegBitP << dummyCfg->shift);
            /* There is register config, address might not be needed */

            if(dummyCfg->isAddrReg == TRUE)
            {
                status += Flash_nandOspiCmdWrite(config, dummyCfg->cmdRegWr, dummyCfg->cfgReg, 3, &cfgReg, 1);
            }
            else
            {
                status += Flash_nandOspiCmdWrite(config, dummyCfg->cmdRegWr, OSPI_CMD_INVALID_ADDR, 0, &cfgReg, 1);
            }
        }
    }

    return status;
}

static int32_t Flash_nandOspiEnableDDR(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;
    Flash_DevConfig *devCfg = NULL;
    FlashCfg_RegConfig *ddrCfg = NULL;
    Flash_NandOspiObject *obj = NULL;

    if(config != NULL)
    {
        devCfg = config->devConfig;
        ddrCfg = &(devCfg->protocolCfg.protoCfg);
        obj = (Flash_NandOspiObject *)(config->object);
    }
    else
    {
        status = SystemP_FAILURE;
    }

    /* Send Write Enable Command */
    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiCmdWrite(config, devCfg->cmdWren,
                                OSPI_CMD_INVALID_ADDR, 0, NULL, 0);
    }

    /* Check for busy bit of flash */
    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiWaitReady(config, 1000U);
    }

    if(status == SystemP_SUCCESS)
    {
        if((ddrCfg->cmdRegRd != 0) && (ddrCfg->cmdRegWr != 0))
        {
            uint8_t cfgReg = 0;
            if(ddrCfg->isAddrReg == TRUE)
            {
                if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
                {
                    status += Flash_nandOspiCmdRead(config, ddrCfg->cmdRegRd, ddrCfg->cfgReg, 3, 8, &cfgReg, 2);
                }
                else
                {
                    status += Flash_nandOspiCmdRead(config, ddrCfg->cmdRegRd, ddrCfg->cfgReg, 3, 8, &cfgReg, 1);
                }
            }
            else
            {
                if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
                {
                    status += Flash_nandOspiCmdRead(config, ddrCfg->cmdRegRd, OSPI_CMD_INVALID_ADDR, 0, 8, &cfgReg, 2);
                }
                else
                {
                    status += Flash_nandOspiCmdRead(config, ddrCfg->cmdRegRd, OSPI_CMD_INVALID_ADDR, 0, 8, &cfgReg, 1);
                }
            }

            if(SystemP_SUCCESS == status)
            {
                /* Clear the config bits in the register  */
                cfgReg &= ~(uint8_t)(ddrCfg->mask);

                /* Bitwise OR the bit pattern for setting the dummyCycle selected */
                cfgReg |= (ddrCfg->cfgRegBitP << ddrCfg->shift);

                /* There is register config, address might not be needed */
                if(ddrCfg->isAddrReg == TRUE)
                {
                    status += Flash_nandOspiCmdWrite(config, ddrCfg->cmdRegWr, ddrCfg->cfgReg, 3, &cfgReg, 1);
                }
                else
                {
                    status += Flash_nandOspiCmdWrite(config, ddrCfg->cmdRegWr, OSPI_CMD_INVALID_ADDR, 0, &cfgReg, 1);
                }
            }
        }
    }

    return status;
}

static int32_t Flash_nandOspiEnableSDR(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;
    Flash_DevConfig *devCfg = NULL;
    FlashCfg_RegConfig *sdrCfg = NULL;

    if(config != NULL)
    {
        devCfg = config->devConfig;
        sdrCfg = &(devCfg->protocolCfg.protoCfg);
    }
    else
    {
        status = SystemP_FAILURE;
    }

    /* Send Write Enable Command */
    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiCmdWrite(config, devCfg->cmdWren,
                                OSPI_CMD_INVALID_ADDR, 0, NULL, 0);
    }

    /* Check for busy bit of flash */
    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandOspiWaitReady(config, 1000U);
    }

    if(status == SystemP_SUCCESS)
    {
        if((sdrCfg->cmdRegRd != 0) && (sdrCfg->cmdRegWr != 0))
        {
            uint8_t cfgReg = 0;

            if(sdrCfg->isAddrReg == TRUE)
            {
                status += Flash_nandOspiCmdRead(config, sdrCfg->cmdRegRd, sdrCfg->cfgReg, 3, 8, &cfgReg, 1);
            }
            else
            {
                status += Flash_nandOspiCmdRead(config, sdrCfg->cmdRegRd, OSPI_CMD_INVALID_ADDR, 0, 8, &cfgReg, 1);
            }

            if(SystemP_SUCCESS == status)
            {
                /* Clear the config bits in the register  */
                cfgReg &= ~(uint8_t)(sdrCfg->mask & 0xFF);
                /* Bitwise OR the bit pattern for setting the dummyCycle selected */
                cfgReg |= (sdrCfg->cfgRegBitP << sdrCfg->shift);

                /* There is register config, address might not be needed */
                if(sdrCfg->isAddrReg == TRUE)
                {
                    status += Flash_nandOspiCmdWrite(config, sdrCfg->cmdRegWr, sdrCfg->cfgReg, 3, &cfgReg, 1);
                }
                else
                {
                    status += Flash_nandOspiCmdWrite(config, sdrCfg->cmdRegWr, OSPI_CMD_INVALID_ADDR, 0, &cfgReg, 1);
                }
            }
        }
    }

    return status;
}


static int32_t Flash_nandOspiReadId(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = NULL;
    Flash_DevConfig *devCfg = NULL;
    FlashCfg_ReadIDConfig *idCfg = NULL;

    uint8_t  idCode[FLASH_OSPI_JEDEC_ID_SIZE_MAX];
    uint32_t idNumBytes = 3;
    uint32_t numAddrBytes = 0;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        devCfg = config->devConfig;
        idCfg = &(devCfg->idCfg);
    }
    else
    {
        status  = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
        {
            idNumBytes = 4;
        }

        status = Flash_nandOspiCmdRead(config, idCfg->cmd,
                                                OSPI_CMD_INVALID_ADDR, numAddrBytes, 8, idCode, idNumBytes);
    }

    /* Verify ID with filled data */
    if (status == SystemP_SUCCESS)
    {
        uint32_t manfID, devID;

        manfID = (uint32_t)idCode[0];
        devID = ((uint32_t)idCode[1] << 8) | ((uint32_t)idCode[2]);
        if (!((manfID == config->attrs->manufacturerId) && (devID == config->attrs->deviceId)))
        {
            /* Try the other 3 bytes */
            manfID = (uint32_t)idCode[3];
            devID = ((uint32_t)idCode[4] << 8) | ((uint32_t)idCode[5]);
            if (!((manfID == config->attrs->manufacturerId) && (devID == config->attrs->deviceId)))
            {
                status = SystemP_FAILURE;
            }
        }
        else
        {
            /* Success, nothing to do */;
        }
    }

    return status;
}

static int32_t Flash_NandOspiWriteDirect(Flash_Config *config, OSPI_Transaction *trans)
{
    int32_t status = SystemP_SUCCESS;

    Flash_NandOspiObject *obj;
    Flash_Attrs *attrs = config->attrs;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        OSPI_writeDirect(obj->ospiHandle, trans);

        OSPI_Transaction spareByteTrans;
        OSPI_Transaction_init(&spareByteTrans);

        spareByteTrans.count = FLASH_PAGE_SPARE_ARRAY_SIZE_BYTES;
        spareByteTrans.addrOffset = attrs->pageSize;
        spareByteTrans.buf = obj->spareAreaData;

        OSPI_writeDirect(obj->ospiHandle, &spareByteTrans);

    }

    return status;
}

static int32_t Flash_nandOspiCheckProgStatus(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;
    uint8_t readStatus[2];
    Flash_NandOspiObject *obj = NULL;
    Flash_DevConfig *devCfg = NULL;
    uint8_t cmd = 0, numAddrBytes = 0, readBytes = 0;
    uint32_t cmdAddr = 0;
    uint8_t dummyBits = 0;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        devCfg = config->devConfig;
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
        {
            cmd = devCfg->cmdRdsr;
            dummyBits = devCfg->xspiRdsrDummy;
            cmdAddr = devCfg->xspiProgStatusReg;
            numAddrBytes = 2;
            readBytes = 2;
        }
        else if(obj->currentProtocol == FLASH_CFG_PROTO_1S_1S_1S ||
                obj->currentProtocol == FLASH_CFG_PROTO_1S_8S_8S)
        {
            cmd = devCfg->cmdRdsr;
            dummyBits = 0;
            cmdAddr = devCfg->progStatusReg;
            numAddrBytes = 1;
            readBytes = 1;
        }

        status = Flash_nandOspiCmdRead(config, cmd, cmdAddr, numAddrBytes, dummyBits, readStatus, readBytes);

        if(status == SystemP_SUCCESS)
        {
            if((readStatus[0] & devCfg->srProgStatus) != 0)
            {
                status = SystemP_FAILURE;
            }
        }
    }

    return status;
}

static int32_t Flash_nandOspiCheckEraseStatus(Flash_Config *config)
{
    int32_t status = SystemP_SUCCESS;
    uint8_t readStatus[2];
    Flash_NandOspiObject *obj = NULL;
    Flash_DevConfig *devCfg = NULL;
    uint8_t cmd = 0, numAddrBytes = 0, readBytes = 0;
    uint32_t cmdAddr = 0;
    uint8_t dummyBits = 0;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        devCfg = config->devConfig;
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
        {
            cmd = devCfg->cmdRdsr;
            dummyBits = devCfg->xspiRdsrDummy;
            cmdAddr = devCfg->xspiEraseStatusReg;
            numAddrBytes = 2;
            readBytes = 2;
        }
        else if(obj->currentProtocol == FLASH_CFG_PROTO_1S_1S_1S ||
                obj->currentProtocol == FLASH_CFG_PROTO_1S_8S_8S)
        {
            cmd = devCfg->cmdRdsr;
            dummyBits = 0;
            cmdAddr = devCfg->eraseStatusReg;
            numAddrBytes = 1;
            readBytes = 1;
        }

        status = Flash_nandOspiCmdRead(config, cmd, cmdAddr, numAddrBytes, dummyBits, readStatus, readBytes);

        if(status == SystemP_SUCCESS)
        {
            if((readStatus[0] && devCfg->srEraseStatus) != 0)
            {
                status = SystemP_FAILURE;
            }
        }
    }

    return status;
}

/* Flash_nandGetBBlist iterates through all the blocks and
 * checks for bad block
 */
static int32_t Flash_nandGetBBList(Flash_Config *config)
{
    uint32_t count;
    int32_t status = SystemP_SUCCESS;
    Flash_Attrs *attrs = NULL;
    Flash_NandOspiObject *obj =  NULL;

    if(config != NULL)
    {
        attrs = config->attrs;
        obj = (Flash_NandOspiObject *)(config->object);

        /* If bad block check option not enabled skip execution and return success */
        if(obj->badBlockCheck == FALSE)
        {
            return SystemP_SUCCESS;
        }
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        for(count = 0; count < attrs->blockCount; count++)
        {
            status = Flash_nandCheckBadBlock(config, count);

            if(status == SystemP_FAILURE)
            {
                break;
            }
        }
    }

    return status;
}

/* Flash_nandMarkBlockAsBad api writes the spare area of the
 * block with flashBadSpareAreaData.
 */
static int32_t Flash_nandMarkBlockAsBad(Flash_Config *config, uint32_t blkNum)
{
    int32_t status = SystemP_SUCCESS;;
    Flash_NandOspiObject *obj = NULL;
    Flash_Attrs *attrs = NULL;
    Flash_DevConfig *devCfg = NULL;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        attrs = config->attrs;
        devCfg = config->devConfig;

        /* If bad block check option not enabled skip execution and return success */
        if(obj->badBlockCheck == FALSE)
        {
            return SystemP_SUCCESS;
        }

        if(blkNum >= attrs->blockCount)
        {
            return SystemP_FAILURE;
        }
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        status = Flash_nandCheckBadBlock(config, blkNum);

        if(status == SystemP_SUCCESS && obj->bbList[blkNum] == FLASH_NAND_BLOCK_BAD)
        {
            return SystemP_SUCCESS;
        }

        if(status == SystemP_SUCCESS)
        {
            uint32_t pageSize;
            uint32_t pageAddr;
            OSPI_Transaction transaction;

            pageSize = attrs->pageSize;
            pageAddr = blkNum * attrs->pageCount;

            status = Flash_nandOspiCmdWrite(config, devCfg->cmdWren, OSPI_CMD_INVALID_ADDR, 0, NULL, 0);

            if(status == SystemP_SUCCESS)
            {
                status = Flash_nandOspiWaitReady(config, 1000U);
            }

            if(status == SystemP_SUCCESS)
            {
                OSPI_Transaction_init(&transaction);
                transaction.addrOffset = pageSize;
                transaction.buf = obj->badSpareAreaData;
                transaction.count = FLASH_PAGE_SPARE_ARRAY_SIZE_BYTES;
                OSPI_writeDirect(obj->ospiHandle, &transaction);
            }

            if(status == SystemP_SUCCESS)
            {
                status = Flash_nandOspiWaitReady(config, 10000U);
            }

            if(status == SystemP_SUCCESS)
            {
                status = Flash_nandOspiPageProgram(config, pageAddr);
            }

            if(status == SystemP_SUCCESS)
            {
                obj->bbList[blkNum] = FLASH_NAND_BLOCK_BAD;
            }
        }
    }

    return status;
}

/* Flash_nandCheckBadBlock reads the spare area of given
 * block number and checks for bad block marker.
 */
static int32_t Flash_nandCheckBadBlock(Flash_Config *config, uint32_t blkNum)
{
    int32_t status = SystemP_SUCCESS;
    Flash_NandOspiObject *obj = NULL;
    OSPI_Transaction transaction;
    Flash_DevConfig *devCfg = NULL;
    Flash_Attrs *attrs = NULL;

    uint32_t pageNum;
    uint8_t cmd;
    uint8_t addrLen = 0U;

    if(config != NULL)
    {
        obj = (Flash_NandOspiObject *)(config->object);
        devCfg = config->devConfig;
        attrs = config->attrs;

        /* If bad block check option not enabled skip execution and return success */
        if(obj->badBlockCheck == FALSE)
        {
            return SystemP_SUCCESS;
        }

        if(blkNum >= attrs->blockCount)
        {
            return SystemP_FAILURE;
        }
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        if(obj->bbList[blkNum] == FLASH_NAND_BLOCK_BAD)
        {
            return SystemP_SUCCESS;
        }

        pageNum = blkNum*attrs->pageCount;

        cmd = devCfg->cmdPageLoad;

        if(obj->currentProtocol == FLASH_CFG_PROTO_8D_8D_8D)
        {
            addrLen = 2;
        }
        else if(obj->currentProtocol == FLASH_CFG_PROTO_1S_1S_1S ||
                obj->currentProtocol == FLASH_CFG_PROTO_1S_8S_8S)
        {
            addrLen = 3;
        }

        if(status == SystemP_SUCCESS)
        {
            status = Flash_nandOspiWaitReady(config, 1000u);
        }

        if(status == SystemP_SUCCESS)
        {
            status = Flash_nandOspiCmdWrite(config, cmd, pageNum, addrLen, NULL, 0);
        }

        if(status == SystemP_SUCCESS)
        {
            status = Flash_nandOspiWaitReady(config, 1000u);
        }

        /* Check for bad block */
        if(status == SystemP_SUCCESS)
        {
            uint8_t readBBMarkerBuf[2];
            OSPI_Transaction_init(&transaction);

            transaction.addrOffset = attrs->pageSize;
            transaction.count = 2;
            transaction.buf = readBBMarkerBuf;
            transaction.dmaCopyLowerLimit = OSPI_NAND_DMA_COPY_LOWER_LIMIT;

            status = OSPI_readDirect(obj->ospiHandle, &transaction);

            if(readBBMarkerBuf[0] != 0xFF || readBBMarkerBuf[1] != 0xFF)
            {
                obj->bbList[blkNum] = FLASH_NAND_BLOCK_BAD;
            }
            else
            {
                obj->bbList[blkNum] = FLASH_NAND_BLOCK_GOOD;
            }
        }
    }

    return status;
}

/* Flash_nandFindGoodBlock checks for bad block if block is bad,
 * update the block number with next good block and update the
 * page number with the page number in good block.
 */
static void Flash_nandFindGoodBlock(Flash_Config *config, uint32_t *blkNum, uint32_t *pageNum)
{
    Flash_Attrs *attrs = NULL;
    Flash_NandOspiObject *obj = NULL;
    int32_t status = SystemP_SUCCESS;

    if(config != NULL)
    {
        attrs = config->attrs;
        obj = (Flash_NandOspiObject*)(config->object);

        if(obj->badBlockCheck == FALSE || *blkNum >= attrs->blockCount)
        {
            return;
        }
    }
    else
    {
        status = SystemP_FAILURE;
    }

    if(status == SystemP_SUCCESS)
    {
        while(*blkNum < attrs->blockCount)
        {
            if(obj->bbList[*blkNum] == FLASH_NAND_BLOCK_GOOD)
            {
                break;
            }

        /*
         * If block is bad increment the block number and increase the
         * pageNum by pageCount, to move the page into the next block.
         */
            *blkNum += 1;
            *pageNum += attrs->pageCount;
        }
    }

    return;
}

Can you also try building the SDK once, after including the stdint.h header file in flash_ospi_nand.c file? Add the below line of code to the top of flash_ospi_nand.c file and try to build the SDK again.

#include <stdint.h>

Regards,

Tushar

Hi,

I compared and found that the two files are exactly the same, with added header files, but it still doesn't work. Can you try using the SDK package I gave you?

Hi,

I have checked building with above zip package also and it is working fine for me.

Regards,

Tushar

Hi,

I deleted everything under "C: \ ti" and reinstalled it. CCS installed ccs1270, and now "gmake - sj4 all" has succeeded, but the subsequent operations have failed.

Hi,

The above command you are trying to run is incorrect. Please run below command.

python uart_uniflash.py -p COM5 --cfg=sbl_prebuilt/am62x-sk/default_sbl_null.cfg

Regards,

Tushar

Hi,

My problem has been resolved。

There are two errors:
1、

I copied 'gcc-arm-9.2-2019.12-mengw-w64-i686-arch64-none elf' to 'C: \ ti', which is incorrect. I can only decompress it directly and cannot copy it.

Otherwise, there will be a bunch of "gmake" errors.

There is a question here, why can't it be done through copying?

2、

Command error, not com<5>, it is com5.

Hi,

After decompression, I copied it directly, but the extracted file was not moved. I don't know what the reason is.

Hi,

Maybe you didn't see it clearly. I was referring to the GCC package, and copying it would cause problems. Simply unzip it to use it properly.