RTOS/AM5716: QSPI programming issue

/**
 *  \file   main_flash_read_test.c
 *
 *  \brief  Example application main file. This application will write and read
 *          the data to/from nor flash through qspi interface.
 *
 */

/*
 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
 *
 * 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.
 *
 */


/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/cfg/global.h>
#include <xdc/runtime/System.h>
#include <stdio.h>
#include <ti/sysbios/knl/Task.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <xdc/runtime/Error.h>
#include <ti/csl/soc.h>
/* TI-RTOS Header files */
#include <ti/drv/spi/SPI.h>
#include <ti/drv/spi/soc/QSPI_v1.h>
#include "SPI_log.h"

/* Flash header file */
#include <ti/drv/spi/test/qspi_flash/src/Flash_S25FL/S25FL.h>

#include <ti/board/board.h>

/**********************************************************************
 ************************** Macros ************************************
 **********************************************************************/
#define QSPI_PER_CNT            (1U)
#define QSPI_INSTANCE           (1U)

#if defined (SOC_AM335x) || defined (SOC_AM437x)
#define QSPI_OFFSET             (5U)
#endif
#if defined (SOC_AM572x) || defined (SOC_AM571x)
#define QSPI_OFFSET             (4U)
#endif

/**********************************************************************
 ************************** Internal functions ************************
 **********************************************************************/

/* Function to generate known data */
static void GeneratePattern(uint8_t *txBuf, uint8_t *rxBuf, uint32_t length);

/* Data compare function */
bool VerifyData(unsigned char *expData,
                unsigned char *rxData,
                unsigned int length);

#if defined (SOC_AM571x) || defined (SOC_AM572x)
void QSPI_board_crossbarInit(void);
#endif
/**********************************************************************
 ************************** Global Variables **************************
 **********************************************************************/

/* Buffer containing the known data that needs to be written to flash */
unsigned int txBuf[1024];

/* Buffer containing the received data */
unsigned int rxBuf[1024];

unsigned int addrValue = 0x000000U;

int transferlengthGlobal = 128;

/* hardware attributes */
extern QSPI_HwAttrs qspiInitCfg[QSPI_PER_CNT];

/* transfer length */
uint32_t transferLength = 0;


/*
 *  ======== test function ========
 */
void spi_test(UArg arg0, UArg arg1)
{
    SPI_Params spiParams;                /* SPI params structure */
    S25FL_Handle flashHandle;            /* Flash handle */
    unsigned int blockNumber = 0U;       /* Block number */
    S25FL_Transaction flashTransaction;  /* Flash transaction structure */
    SPI_Handle handle;                   /* SPI handle */
    QSPI_HwAttrs *hwAttrs;               /* QSPI hardware attributes */
    bool retVal = false;                 /* return value */
    unsigned int rxLines;
    unsigned int qspiMode;
    unsigned int i = 0;

    /* Init SPI driver */
    SPI_init();

    /* Default SPI configuration parameters */
    SPI_Params_init(&spiParams);

    /* Open QSPI driver */
    flashHandle = SF25FL_open(((QSPI_INSTANCE - 1)+(QSPI_OFFSET)), &spiParams);

    /* Extract hardware attributes */
    handle = flashHandle->spiHandle;
    hwAttrs = (QSPI_HwAttrs *)handle->hwAttrs;

    /* Print flash Id */
    FlashPrintId(flashHandle);

    /* Mode: CFG & Rx Lines: SINGLE */

    /* For CFG Mode: The parameter "flashTransaction.address" should be assigned
       with the address of the variable which contains the flash offset value*/

    qspiMode = QSPI_OPER_MODE_CFG;
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    S25FLFlash_BlockErase(flashHandle, blockNumber);
    S25FLFlash_BlockErase(flashHandle, blockNumber+1);
    S25FLFlash_BlockErase(flashHandle, blockNumber+2);
    S25FLFlash_BlockErase(flashHandle, blockNumber+3);
    S25FLFlash_BlockErase(flashHandle, blockNumber+4);
    S25FLFlash_BlockErase(flashHandle, blockNumber+5);
    S25FLFlash_BlockErase(flashHandle, blockNumber+6);
    S25FLFlash_BlockErase(flashHandle, blockNumber+7);
    S25FLFlash_BlockErase(flashHandle, blockNumber+8);
    S25FLFlash_BlockErase(flashHandle, blockNumber+9);
    S25FLFlash_BlockErase(flashHandle, blockNumber+10);

    /* Set the transfer length in number of 32 bit words */
    transferLength = transferlengthGlobal;

    /* Generate the data */
    GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

    /* Update transaction parameters */
    flashTransaction.data       = (uint8_t *)&txBuf[0];
    flashTransaction.address = (uint32_t)&addrValue;
    flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

    /* Write buffer to flash */
    retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

    if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
    {
        S25FLFlash_QuadModeEnable(flashHandle);
    }

    /* Update transaction parameters */
    flashTransaction.data       = (uint8_t *)&rxBuf[0];
    flashTransaction.address = (uint32_t)&addrValue;
    flashTransaction.dataSize   = transferLength * 4; /* In bytes */

    /* Read data from flash */
    retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

    SPI_log("\n Printing cfg single below. \n");
    log_buffers(txBuf, rxBuf, transferLength);

    /* Verify Data */
    retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
        transferLength);

    /* Mode: CFG & Rx Lines: DUAL */

    /* Reset receive buffer */
    for(i = 0; i < transferlengthGlobal; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_CFG;
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_DUAL;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        S25FLFlash_BlockErase(flashHandle, blockNumber);
        S25FLFlash_BlockErase(flashHandle, blockNumber+1);
        S25FLFlash_BlockErase(flashHandle, blockNumber+2);
        S25FLFlash_BlockErase(flashHandle, blockNumber+3);
        S25FLFlash_BlockErase(flashHandle, blockNumber+4);
        S25FLFlash_BlockErase(flashHandle, blockNumber+5);
        S25FLFlash_BlockErase(flashHandle, blockNumber+6);
        S25FLFlash_BlockErase(flashHandle, blockNumber+7);
        S25FLFlash_BlockErase(flashHandle, blockNumber+8);
        S25FLFlash_BlockErase(flashHandle, blockNumber+9);
        S25FLFlash_BlockErase(flashHandle, blockNumber+10);

        /* Set the transfer length in number of 32 bit words */
        transferLength = transferlengthGlobal;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        SPI_log("\n Printing cfg dual below. \n");
        log_buffers(txBuf, rxBuf, transferLength);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: CFG & Rx Lines: QUAD */

    /* Reset receive buffer */
    for(i = 0; i < transferlengthGlobal; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_CFG;
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_QUAD;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        S25FLFlash_BlockErase(flashHandle, blockNumber);
        S25FLFlash_BlockErase(flashHandle, blockNumber+1);
        S25FLFlash_BlockErase(flashHandle, blockNumber+2);
        S25FLFlash_BlockErase(flashHandle, blockNumber+3);
        S25FLFlash_BlockErase(flashHandle, blockNumber+4);
        S25FLFlash_BlockErase(flashHandle, blockNumber+5);
        S25FLFlash_BlockErase(flashHandle, blockNumber+6);
        S25FLFlash_BlockErase(flashHandle, blockNumber+7);
        S25FLFlash_BlockErase(flashHandle, blockNumber+8);
        S25FLFlash_BlockErase(flashHandle, blockNumber+9);
        S25FLFlash_BlockErase(flashHandle, blockNumber+10);

        /* Set the transfer length in number of 32 bit words */
        transferLength = transferlengthGlobal;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        SPI_log("\n Printing cfg quad below. \n");
        log_buffers(txBuf, rxBuf, transferLength);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: MMAP & Rx Lines: SINGLE */

    /* For MMAP Mode: The parameter "flashTransaction.address" should be
       assigned with directly the flash offset value */

    /* Reset receive buffer */
    for(i = 0; i < transferlengthGlobal; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_MMAP;
    SPI_control(handle, SPI_V1_CMD_SETMEMMORYMAPMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        S25FLFlash_BlockErase(flashHandle, blockNumber);
        S25FLFlash_BlockErase(flashHandle, blockNumber+1);
        S25FLFlash_BlockErase(flashHandle, blockNumber+2);
        S25FLFlash_BlockErase(flashHandle, blockNumber+3);
        S25FLFlash_BlockErase(flashHandle, blockNumber+4);
        S25FLFlash_BlockErase(flashHandle, blockNumber+5);
        S25FLFlash_BlockErase(flashHandle, blockNumber+6);
        S25FLFlash_BlockErase(flashHandle, blockNumber+7);
        S25FLFlash_BlockErase(flashHandle, blockNumber+8);
        S25FLFlash_BlockErase(flashHandle, blockNumber+9);
        S25FLFlash_BlockErase(flashHandle, blockNumber+10);

        /* Set the transfer length in number of 32 bit words */
        transferLength = transferlengthGlobal;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        SPI_log("\n Printing mmap single below. \n");
        log_buffers(txBuf, rxBuf, transferLength);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: MMAP & Rx Lines: DUAL */

    /* Reset receive buffer */
    for(i = 0; i < transferlengthGlobal; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_MMAP;
    SPI_control(handle, SPI_V1_CMD_SETMEMMORYMAPMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_DUAL;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        S25FLFlash_BlockErase(flashHandle, blockNumber);
        S25FLFlash_BlockErase(flashHandle, blockNumber+1);
        S25FLFlash_BlockErase(flashHandle, blockNumber+2);
        S25FLFlash_BlockErase(flashHandle, blockNumber+3);
        S25FLFlash_BlockErase(flashHandle, blockNumber+4);
        S25FLFlash_BlockErase(flashHandle, blockNumber+5);
        S25FLFlash_BlockErase(flashHandle, blockNumber+6);
        S25FLFlash_BlockErase(flashHandle, blockNumber+7);
        S25FLFlash_BlockErase(flashHandle, blockNumber+8);
        S25FLFlash_BlockErase(flashHandle, blockNumber+9);
        S25FLFlash_BlockErase(flashHandle, blockNumber+10);

        /* Set the transfer length in number of 32 bit words */
        transferLength = transferlengthGlobal;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        SPI_log("\n Printing mmap dual below. \n");
        log_buffers(txBuf, rxBuf, transferLength);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: MMAP & Rx Lines: QUAD */

    /* Reset receive buffer */
    for(i = 0; i < transferlengthGlobal; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_MMAP;
    SPI_control(handle, SPI_V1_CMD_SETMEMMORYMAPMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_QUAD;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        /* Erase block, to which data has to be written */
        S25FLFlash_BlockErase(flashHandle, blockNumber);
        S25FLFlash_BlockErase(flashHandle, blockNumber+1);
        S25FLFlash_BlockErase(flashHandle, blockNumber+2);
        S25FLFlash_BlockErase(flashHandle, blockNumber+3);
        S25FLFlash_BlockErase(flashHandle, blockNumber+4);
        S25FLFlash_BlockErase(flashHandle, blockNumber+5);
        S25FLFlash_BlockErase(flashHandle, blockNumber+6);
        S25FLFlash_BlockErase(flashHandle, blockNumber+7);
        S25FLFlash_BlockErase(flashHandle, blockNumber+8);
        S25FLFlash_BlockErase(flashHandle, blockNumber+9);
        S25FLFlash_BlockErase(flashHandle, blockNumber+10);

        /* Set the transfer length in number of 32 bit words */
        transferLength = transferlengthGlobal;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        SPI_log("\n Printing mmap quad below. \n");
        log_buffers(txBuf, rxBuf, transferLength);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    SF25FL_close(flashHandle);

    if(true == retVal)
    {
        SPI_log("\n All tests have passed. \n");
    }
    else
    {
        SPI_log("\n Some tests have failed. \n");
    }

    while(1);
}

/*
 *  ======== main ========
 */
int main(void)
{
    /* Call board init functions */
    Board_initCfg boardCfg;

#if defined (SOC_AM335x) || defined (SOC_AM437x)
    Task_Handle task;
    Error_Block eb;

    Error_init(&eb);
    task = Task_create(spi_test, NULL, &eb);
    if (task == NULL) {
        System_printf("Task_create() failed!\n");
        BIOS_exit(0);
    }
#endif

    boardCfg = BOARD_INIT_PINMUX_CONFIG |
        BOARD_INIT_MODULE_CLOCK |
        BOARD_INIT_UART_STDIO;
    Board_init(boardCfg);

#if defined (SOC_AM571x) || defined (SOC_AM572x)
    QSPI_board_crossbarInit();
#endif

    /* Start BIOS */
    BIOS_start();
    return (0);
}

/*
 *  ======== Board_initQSPI ========
 */
#if defined (SOC_AM571x) || defined (SOC_AM572x)
void QSPI_board_crossbarInit(void) {
    CSL_XbarIrqCpuId                   cpu;
    uint32_t                           cpuEvent;
    uint32_t                           xbarIndex;
#ifdef C66X

    /* Configure xbar connect for MCSPI3: DSP_IRQ_38 mapped to MCSPI3 intr */
    cpu = CSL_XBAR_IRQ_CPU_ID_DSP1;
    cpuEvent = 38;
    xbarIndex = cpuEvent - 31;

    /* Configure xbar */
    CSL_xbarIrqConfigure (cpu, xbarIndex, CSL_XBAR_QSPI_IRQ);

#elif __ARM_ARCH_7A__
    /* Configure xbar connect for QSPI: MPU_IRQ_35 mapped to QSPI intr */
    *(unsigned int*)0x4A002A80 = (unsigned int)(0x0157001D);

#else

    /* Configure xbar connect for MCSPI3: DSP_IRQ_38 mapped to MCSPI3 intr */
    cpu = CSL_XBAR_IRQ_CPU_ID_IPU1;
    cpuEvent = 62;
    xbarIndex = cpuEvent - 22;

    /* Configure xbar */
    CSL_xbarIrqConfigure (cpu, xbarIndex, CSL_XBAR_QSPI_IRQ);
#endif

}
#endif

/*
 *  ======== CompareData ========
 */
bool VerifyData(unsigned char *expData,
                unsigned char *rxData,
                unsigned int length)
{
    unsigned int idx = 0;
    unsigned int match = 1;
    bool retVal = false;
    unsigned int lenInBytes = length * 4;

    for(idx = 0; ((idx < lenInBytes) && (match != 0)); idx++)
    {
        if(*expData != *rxData) match = 0;
        expData++;
        rxData++;
    }

    if(match == 1) retVal = true;

    return retVal;
}

/*
 *  ======== GeneratePattern ========
 */
static void GeneratePattern(uint8_t *txBuf, uint8_t *rxBuf, uint32_t length)
{
    unsigned int idx;
    unsigned int lenInBytes = length * 4;

    for(idx = 0; idx < lenInBytes; idx++)
    {
        txBuf[idx] = (uint8_t)idx;
        rxBuf[idx] = (uint8_t)0U;
    }
}

void log_buffers(unsigned int txBuf[], unsigned int rxBuf[], int transferLength)
{
    int i;
    int countErrors = 0;
    int countSuccess = 0;
    int countPrinted = 0;

    int tempAddress = addrValue;
    FILE *f = fopen ("C:\\temp\\test.txt", "w");
    if(f == NULL)
    {
        SPI_log("Error opening file!\n");
    }



    for(i = 0; i < transferLength; i++)
    {
        if(i%64==0)
        {
            SPI_log("-------  NEW PAGE  ------------------------------------------------------------------------------------------------------\n");
        }
        if(txBuf[i]!=rxBuf[i])
        {
            countErrors++;

            if(1/*rxBuf[i] != 0xFFFFFFFF*/)
            {
                countPrinted++;

                SPI_log("txbuf[%u]:%13u\t0x%08X\t", i, txBuf[i], txBuf[i]);
                SPI_log_bits(sizeof(txBuf[i]), &txBuf[i]);
                //SPI_log("   0x%08X -> 0x%08X -> 0x%08X",tempAddress, tempAddress+memMappedBaseAddr, tempAddress+baseAddr);
                SPI_log("\nrxbuf[%u]:%13u\t0x%08X\t", i, rxBuf[i], rxBuf[i]);
                SPI_log_bits(sizeof(rxBuf[i]), &rxBuf[i]);
                txBuf[i]==rxBuf[i]?SPI_log("   OK."):SPI_log("   Not Equal.");
                SPI_log(" Sector: %d. Page: %d. Pos: %d.\n\n", (i*4/65536), i*4/256, i%64);

            }

        }
        else
        {
            countSuccess++;

            if(i%1==0)
            {
                countPrinted++;
                SPI_log("txbuf[%u]:%13u\t0x%08X\t", i, txBuf[i], txBuf[i]);
                SPI_log_bits(sizeof(txBuf[i]), &txBuf[i]);
                //SPI_log("   0x%08X -> 0x%08X -> 0x%08X",tempAddress, tempAddress+memMappedBaseAddr, tempAddress+baseAddr);
                SPI_log("\nrxbuf[%u]:%13u\t0x%08X\t", i, rxBuf[i], rxBuf[i]);
                SPI_log_bits(sizeof(rxBuf[i]), &rxBuf[i]);
                txBuf[i]==rxBuf[i]?SPI_log("   OK."):SPI_log("   Not Equal.");
                SPI_log(" Sector: %d. Page: %d. Pos: %d.\n\n", (i*4/65536), i*4/256, i%64);
            }


        }
/*
        SPI_log("txbuf[%u]:\t%u\t0x%08X\t", i, txBuf[i], txBuf[i]);
        SPI_log_bits(sizeof(txBuf[i]), &txBuf[i]);
        SPI_log("   0x%08X -> 0x%08X -> 0x%08X",tempAddress, tempAddress+memMappedBaseAddr, tempAddress+baseAddr);
        SPI_log("\nrxbuf[%u]:\t%u\t0x%08X\t", i, rxBuf[i], rxBuf[i]);
        SPI_log_bits(sizeof(rxBuf[i]), &rxBuf[i]);
        txBuf[i]==rxBuf[i]?SPI_log("   OK."):SPI_log("   Not Equal.");
        SPI_log("\n\n");
*/

        tempAddress = tempAddress + 4;
    }
    fprintf(f, "Number of errors: %d.\n",countErrors);
    SPI_log("Number of success:  %d.\n",countSuccess);
    SPI_log("Number of errors:  %d.\n",countErrors);
    SPI_log("Number of printed: %d.\n",countPrinted);
    SPI_log("transferLength: %d * 4 Bytes = %d.\n",transferLength,transferLength*4);
    fclose(f);
}

/*
 * ========== SPI_log_bits ========
 * assumes little endian.
 * prints the bits of a variable
 *
 *
 */
void SPI_log_bits(size_t const size, void const * const ptr)
{
    unsigned char *b = (unsigned char*) ptr;
    unsigned char byte;
    int i, j;

    for (i=size-1;i>=0;i--)
    {
        for (j=7;j>=0;j--)
        {
            byte = (b[i] >> j) & 1;
            SPI_log("%u", byte);
        }
    }
    //puts("");
}

/**
 *  \file   main_flash_read_test.c
 *
 *  \brief  Example application main file. This application will write and read
 *          the data to/from nor flash through qspi interface.
 *
 */

/*
 * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
 *
 * 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.
 *
 */


/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/cfg/global.h>
#include <xdc/runtime/System.h>
#include <stdio.h>
#include <ti/sysbios/knl/Task.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <xdc/runtime/Error.h>
#include <ti/csl/soc.h>
/* TI-RTOS Header files */
#include <ti/drv/spi/SPI.h>
#include <ti/drv/spi/soc/QSPI_v1.h>
#include "SPI_log.h"

/* Flash header file */
#include <ti/drv/spi/test/qspi_flash/src/Flash_S25FL/S25FL.h>

#include <ti/board/board.h>

/**********************************************************************
 ************************** Macros ************************************
 **********************************************************************/
#define QSPI_PER_CNT            (1U)
#define QSPI_INSTANCE           (1U)

#if defined (SOC_AM335x) || defined (SOC_AM437x)
#define QSPI_OFFSET             (5U)
#endif
#if defined(SOC_AM574x) || defined (SOC_AM572x) || defined (SOC_AM571x)
#define QSPI_OFFSET             (4U)
#endif

#define QSPI_TEST_LENGTH        75  /* read/write test data size in 32-bit words */

/**********************************************************************
 ************************** Internal functions ************************
 **********************************************************************/

/* Function to generate known data */
static void GeneratePattern(uint8_t *txBuf, uint8_t *rxBuf, uint32_t length);

/* Data compare function */
bool VerifyData(unsigned char *expData,
                unsigned char *rxData,
                unsigned int length);

#if defined(SOC_AM574x) || defined (SOC_AM571x) || defined (SOC_AM572x)
void QSPI_board_crossbarInit(void);
#endif
/**********************************************************************
 ************************** Global Variables **************************
 **********************************************************************/

/* Buffer containing the known data that needs to be written to flash */
unsigned int txBuf[1024];

/* Buffer containing the received data */
unsigned int rxBuf[1024];

unsigned int addrValue = 0x000000U;

/* hardware attributes */
extern QSPI_HwAttrs qspiInitCfg[QSPI_PER_CNT];

/* transfer length */
uint32_t transferLength = 0;


/*
 *  ======== test function ========
 */
void spi_test(UArg arg0, UArg arg1)
{
    SPI_Params spiParams;                /* SPI params structure */
    S25FL_Handle flashHandle;            /* Flash handle */
    unsigned int blockNumber = 0U;       /* Block number */
    S25FL_Transaction flashTransaction;  /* Flash transaction structure */
    SPI_Handle handle;                   /* SPI handle */
    QSPI_HwAttrs *hwAttrs;               /* QSPI hardware attributes */
    bool retVal = false;                 /* return value */
    unsigned int rxLines;
    unsigned int qspiMode;
    unsigned int i = 0;

    /* Init SPI driver */
    SPI_init();

    /* Default SPI configuration parameters */
    SPI_Params_init(&spiParams);

    /* Open QSPI driver */
    flashHandle = SF25FL_open(((QSPI_INSTANCE - 1)+(QSPI_OFFSET)), &spiParams);

    /* Extract hardware attributes */
    handle = flashHandle->spiHandle;
    hwAttrs = (QSPI_HwAttrs *)handle->hwAttrs;

    /* Print flash Id */
    FlashPrintId(flashHandle);

    /* Mode: CFG & Rx Lines: SINGLE */

    /* For CFG Mode: The parameter "flashTransaction.address" should be assigned
       with the address of the variable which contains the flash offset value*/

    qspiMode = QSPI_OPER_MODE_CFG;
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    /* Erase block, to which data has to be written */
    S25FLFlash_BlockErase(flashHandle, blockNumber);

    /* Set the transfer length in number of 32 bit words */
    transferLength = QSPI_TEST_LENGTH;

    /* Generate the data */
    GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

    /* Update transaction parameters */
    flashTransaction.data       = (uint8_t *)&txBuf[0];
    flashTransaction.address = (uint32_t)&addrValue;
    flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

    /* Write buffer to flash */
    retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

    if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
    {
        S25FLFlash_QuadModeEnable(flashHandle);
    }

    /* Update transaction parameters */
    flashTransaction.data       = (uint8_t *)&rxBuf[0];
    flashTransaction.address = (uint32_t)&addrValue;
    flashTransaction.dataSize   = transferLength * 4; /* In bytes */

    /* Read data from flash */
    retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

    /* Verify Data */
    retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
        transferLength);

    /* Mode: CFG & Rx Lines: DUAL */

    /* Reset receive buffer */
    for(i = 0; i < QSPI_TEST_LENGTH; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_CFG;
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_DUAL;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        /* Erase block, to which data has to be written */
        S25FLFlash_BlockErase(flashHandle, blockNumber);

        /* Set the transfer length in number of 32 bit words */
        transferLength = QSPI_TEST_LENGTH;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: CFG & Rx Lines: QUAD */

    /* Reset receive buffer */
    for(i = 0; i < QSPI_TEST_LENGTH; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_CFG;
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_QUAD;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        /* Erase block, to which data has to be written */
        S25FLFlash_BlockErase(flashHandle, blockNumber);

        /* Set the transfer length in number of 32 bit words */
        transferLength = QSPI_TEST_LENGTH;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = (uint32_t)&addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: MMAP & Rx Lines: SINGLE */

    /* For MMAP Mode: The parameter "flashTransaction.address" should be
       assigned with directly the flash offset value */

    /* Reset receive buffer */
    for(i = 0; i < QSPI_TEST_LENGTH; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_MMAP;
    SPI_control(handle, SPI_V1_CMD_SETMEMMORYMAPMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        /* Erase block, to which data has to be written */
        S25FLFlash_BlockErase(flashHandle, blockNumber);

        /* Set the transfer length in number of 32 bit words */
        transferLength = QSPI_TEST_LENGTH;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: MMAP & Rx Lines: DUAL */

    /* Reset receive buffer */
    for(i = 0; i < QSPI_TEST_LENGTH; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_MMAP;
    SPI_control(handle, SPI_V1_CMD_SETMEMMORYMAPMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_DUAL;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        /* Erase block, to which data has to be written */
        S25FLFlash_BlockErase(flashHandle, blockNumber);

        /* Set the transfer length in number of 32 bit words */
        transferLength = QSPI_TEST_LENGTH;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    /* Mode: MMAP & Rx Lines: QUAD */

    /* Reset receive buffer */
    for(i = 0; i < QSPI_TEST_LENGTH; i++)
    {
        rxBuf[i] = 0x00000000;
    }

    qspiMode = QSPI_OPER_MODE_MMAP;
    SPI_control(handle, SPI_V1_CMD_SETMEMMORYMAPMODE, (void *)&qspiMode);
    rxLines = QSPI_RX_LINES_QUAD;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    if(true == retVal)
    {
        /* Erase block, to which data has to be written */
        S25FLFlash_BlockErase(flashHandle, blockNumber);

        /* Set the transfer length in number of 32 bit words */
        transferLength = QSPI_TEST_LENGTH;

        /* Generate the data */
        GeneratePattern((uint8_t *)&txBuf[0], (uint8_t *)&rxBuf[0], transferLength);

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&txBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4;  /* In bytes */

        /* Write buffer to flash */
        retVal = SF25FL_bufferWrite(flashHandle, &flashTransaction);

        if(QSPI_RX_LINES_QUAD == hwAttrs->rxLines)
        {
            S25FLFlash_QuadModeEnable(flashHandle);
        }

        /* Update transaction parameters */
        flashTransaction.data       = (uint8_t *)&rxBuf[0];
        flashTransaction.address = addrValue;
        flashTransaction.dataSize   = transferLength * 4; /* In bytes */

        /* Read data from flash */
        retVal = SF25FL_bufferRead(flashHandle, &flashTransaction);

        /* Verify Data */
        retVal = VerifyData((unsigned char *)&txBuf[0], (unsigned char *)&rxBuf[0],
            transferLength);
    }

    SF25FL_close(flashHandle);

    if(true == retVal)
    {
        SPI_log("\n All tests have passed. \n");
    }
    else
    {
        SPI_log("\n Some tests have failed. \n");
    }

    while(1);
}

/*
 *  ======== main ========
 */
int main(void)
{
    /* Call board init functions */
    Board_initCfg boardCfg;

#if defined (SOC_AM335x) || defined (SOC_AM437x)
    Task_Handle task;
    Error_Block eb;

    Error_init(&eb);
    task = Task_create(spi_test, NULL, &eb);
    if (task == NULL) {
        System_printf("Task_create() failed!\n");
        BIOS_exit(0);
    }
#endif

    boardCfg = BOARD_INIT_PINMUX_CONFIG |
        BOARD_INIT_MODULE_CLOCK |
        BOARD_INIT_UART_STDIO;
    Board_init(boardCfg);

#if defined (SOC_AM571x) || defined (SOC_AM572x) || defined(SOC_AM574x)
    QSPI_board_crossbarInit();
#endif

    /* Start BIOS */
    BIOS_start();
    return (0);
}

/*
 *  ======== Board_initQSPI ========
 */
#if defined (SOC_AM571x) || defined (SOC_AM572x) || defined(SOC_AM574x)
void QSPI_board_crossbarInit(void) {
    CSL_XbarIrqCpuId                   cpu;
    uint32_t                           cpuEvent;
    uint32_t                           xbarIndex;
#ifdef C66X

    /* Configure xbar connect for MCSPI3: DSP_IRQ_38 mapped to MCSPI3 intr */
    cpu = CSL_XBAR_IRQ_CPU_ID_DSP1;
    cpuEvent = 38;
    xbarIndex = cpuEvent - 31;

    /* Configure xbar */
    CSL_xbarIrqConfigure (cpu, xbarIndex, CSL_XBAR_QSPI_IRQ);

#elif __ARM_ARCH_7A__
    /* Configure xbar connect for QSPI: MPU_IRQ_35 mapped to QSPI intr */
    *(unsigned int*)0x4A002A80 = (unsigned int)(0x0157001D);

#else

    /* Configure xbar connect for MCSPI3: DSP_IRQ_38 mapped to MCSPI3 intr */
    cpu = CSL_XBAR_IRQ_CPU_ID_IPU1;
    cpuEvent = 62;
    xbarIndex = cpuEvent - 22;

    /* Configure xbar */
    CSL_xbarIrqConfigure (cpu, xbarIndex, CSL_XBAR_QSPI_IRQ);
#endif

}
#endif

/*
 *  ======== CompareData ========
 */
bool VerifyData(unsigned char *expData,
                unsigned char *rxData,
                unsigned int length)
{
    unsigned int idx = 0;
    unsigned int match = 1;
    bool retVal = false;
    unsigned int lenInBytes = length * 4;

    for(idx = 0; ((idx < lenInBytes) && (match != 0)); idx++)
    {
        if(*expData != *rxData) match = 0;
        expData++;
        rxData++;
    }

    if(match == 1) retVal = true;

    return retVal;
}

/*
 *  ======== GeneratePattern ========
 */
static void GeneratePattern(uint8_t *txBuf, uint8_t *rxBuf, uint32_t length)
{
    unsigned int idx;
    unsigned int lenInBytes = length * 4;

    for(idx = 0; idx < lenInBytes; idx++)
    {
        txBuf[idx] = (uint8_t)idx;
        rxBuf[idx] = (uint8_t)0U;
    }
}

/**
 *  \file   S25FL.c
 *
 *  \brief  Flash specific driver implementation.
 *
 */

/*
 * Copyright (C) 2014 - 2017 Texas Instruments Incorporated - http://www.ti.com/
 *
 * 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 "S25FL.h"
#include <ti/drv/spi/SPI.h>
#include <ti/drv/spi/soc/QSPI_v1.h>

/*!
 *  @brief Flash object containing flash attributes.
 */
S25FL_Object s25flObject = {NULL,
                            4,
                            S25FL_FLASH_SECTOR_SIZE,
                            S25FL_FLASH_BLOCK_SIZE,
                            S25FL_FLASH_DEVICE_SIZE,
                            S25FL_FLASH_DEVICE_ID};


static bool SF25FL_ConfigMode_Write(uint32_t dstOffstAddr,
                                    unsigned char* srcAddr,
                                    uint32_t length,
                                    S25FL_Handle flashHandle);

/*
 *  ======== SF25FL_close ========
 */
void SF25FL_close(S25FL_Handle handle)
{
    SPI_close(handle->spiHandle);
}

/*
 *  ======== SF25FL_open ========
 */
S25FL_Handle SF25FL_open(unsigned int index, SPI_Params *params)
{
    S25FL_Handle s25flHandle;

    s25flHandle = &s25flObject;

    /* Open SPI driver for SF25FL */
    s25flHandle->spiHandle = SPI_open(index, params);

    return s25flHandle;
}

/*
 *  ======== SF25FL_bufferWrite ========
 */
bool SF25FL_bufferWrite(S25FL_Handle flashHandle,
                        S25FL_Transaction* flashTransaction)
{
    bool retVal = false;                        /* return value */
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    SPI_Transaction transaction;                /* SPI transaction structure */
    unsigned int idx;                           /* index */
    uint32_t dstOffstAddr;                      /* Flash offset address */
    unsigned char *srcAddr;                     /* Address of data buffer */
    uint32_t length;                            /* data length in bytes */
    unsigned int transferType;
    unsigned char transferCmd;
    QSPI_v1_Object  *object;
    uint32_t offsetValue;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* Copy flash transaction parameters to local variables */
    dstOffstAddr = flashTransaction->address;
    srcAddr = flashTransaction->data;
    length = flashTransaction->dataSize;
    offsetValue = *((uint32_t *)dstOffstAddr);

    if(QSPI_OPER_MODE_CFG == object->qspiMode)
    {
        /*
         * Config mode write supports 256 bytes at a time. So if the length is
         * greater than 256, then multiple transactions have to be performed till
         * all the bytes are written.
         */
        while(length > 256)
        {
            SF25FL_ConfigMode_Write(dstOffstAddr, srcAddr, 256, flashHandle);
            *((uint32_t *)dstOffstAddr) += 256;
            srcAddr += 256;
            length -= 256;
        }
        if(length > 0)
        {
            SF25FL_ConfigMode_Write(dstOffstAddr, srcAddr, length, flashHandle);
        }
        *((uint32_t *)dstOffstAddr) = offsetValue;
    }


    if(QSPI_OPER_MODE_MMAP == object->qspiMode)
    {
        for(idx = 0; idx < length; idx++)
        {
            /* Write enable */
            S25FLFlash_WriteEnable(flashHandle);

            /* Perform the transfer */
            transaction.txBuf = (unsigned char *)dstOffstAddr;
            transaction.rxBuf = srcAddr;
            transaction.count = 1;

            transferType = SPI_TRANSACTION_TYPE_WRITE;
            if (dstOffstAddr > 0xFFFFFFU)
            {
                transferCmd  = QSPI_LIB_CMD_PAGE_PRG_4B;
            }
            else
            {
                transferCmd  = QSPI_LIB_CMD_PAGE_PRG;
            }
            SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
            SPI_control(handle, SPI_V1_CMD_MMAP_TRANSFER_CMD, (void *)&transferCmd);
            retVal = SPI_transfer(handle, &transaction);

            /* Check flash status for completion */
            while ((FlashStatus(flashHandle) & 0x1U));

            dstOffstAddr += 1;
            srcAddr += 1;
        }
    }

    return retVal;
}



bool SF25FL_bufferRead(S25FL_Handle flashHandle,
                       S25FL_Transaction* flashTransaction)
{
    bool retVal = false;                        /* return value */
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    unsigned char writeVal[4];               /* data to be written */
    SPI_Transaction transaction;             /* SPI transaction structure */
    uint32_t addrLengthInBytes = 3U;         /* Flash address length in bytes */
    uint32_t readCmd;                        /* Read command */
    uint32_t numDummyBits;                   /* Number of dummy bits */
    uint32_t frameLength;                    /* Frame length */
    uint32_t dstOffstAddr;                   /* Flash offset address */
    unsigned char *srcAddr;                  /* Address of data buffer */
    uint32_t length;                         /* data length in bytes */
/*  unsigned int *tempPtr = (unsigned int *)&writeVal[0]; */ /* temp pointer */
    unsigned int frmLength;
    unsigned int transferType;
    unsigned char transferCmd;
    QSPI_v1_Object  *object;
    uint32_t offsetValue;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* Copy flash transaction parameters to local variables */
    dstOffstAddr = (uint32_t)flashTransaction->data;
    srcAddr = (unsigned char *)flashTransaction->address;
    length = flashTransaction->dataSize;

    if(QSPI_OPER_MODE_CFG == object->qspiMode)
    {
        offsetValue = *((uint32_t *)srcAddr);

        addrLengthInBytes = 3U;

        if(offsetValue > 0xFFFFFF)
        {
            /* Enter 32 bit addressing mode */
            addrLengthInBytes = 4;
        }

        switch(object->rxLines)
        {
            case QSPI_RX_LINES_SINGLE:
            {
                if(offsetValue > 0xFFFFFF)
                {
                    readCmd = QSPI_LIB_CMD_READ_SINGLE_4B;
                }
                else
                {
                    readCmd = QSPI_LIB_CMD_READ_SINGLE;
                }
                numDummyBits = 0U;

                /* total transaction frame length in number of words (bytes)*/
                frameLength = length + 1 + addrLengthInBytes;
                break;
            }

            case QSPI_RX_LINES_DUAL:
            {
                if(offsetValue > 0xFFFFFF)
                {
                    readCmd = QSPI_LIB_CMD_READ_DUAL_4B;
                }
                else
                {
                    readCmd = QSPI_LIB_CMD_READ_DUAL;
                }
                numDummyBits = 8U;

                /* total transaction frame length in number of words (bytes)*/
                frameLength = length + 1 + 1 + addrLengthInBytes;
                break;
            }

            case QSPI_RX_LINES_QUAD:
            {
                if(offsetValue > 0xFFFFFF)
                {
                    readCmd = QSPI_LIB_CMD_READ_QUAD_4B;
                }
                else
                {
                    readCmd = QSPI_LIB_CMD_READ_QUAD;
                }
                numDummyBits = 8U;

                /* total transaction frame length in number of words (bytes)*/
                frameLength = length + 1 + 1 + addrLengthInBytes;
                break;
            }

            default:
            break;
        }

        /* total transaction frame length */
        frmLength = frameLength;
        SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

        /* Write read command */
        writeVal[0] = readCmd;
        transaction.txBuf = (unsigned char *)&writeVal[0];
        transaction.rxBuf = NULL;
        transaction.count = 1;

        transferType = SPI_TRANSACTION_TYPE_WRITE;
        SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
        retVal = SPI_transfer(handle, &transaction);

        /* Write dummy bits for fast read if required */
        if(0 != numDummyBits)
        {
            writeVal[0] = 0U;
            transaction.txBuf = (unsigned char *)&writeVal[0];
            transaction.rxBuf = NULL;
            transaction.count = (numDummyBits >> 3);      /* In bytes */

        transferType = SPI_TRANSACTION_TYPE_WRITE;
        SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
            retVal = SPI_transfer(handle, &transaction);
        }

        /* Write Address Bytes */
/*      *tempPtr = (unsigned int)srcAddr; */
/*      transaction.txBuf = (unsigned char *)tempPtr; */
        transaction.txBuf = (unsigned char *)srcAddr;
        transaction.rxBuf = NULL;
        transaction.count = addrLengthInBytes;

        transferType = SPI_TRANSACTION_TYPE_WRITE;
        SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
        retVal = SPI_transfer(handle, &transaction);

        /* Read the actual flash data */
        transaction.txBuf = NULL;
        transaction.rxBuf = (unsigned char *)dstOffstAddr;
        transaction.count = length;

        transferType = SPI_TRANSACTION_TYPE_READ;
        SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
        retVal = SPI_transfer(handle, &transaction);
    }

    if(QSPI_OPER_MODE_MMAP == object->qspiMode)
    {
        switch(object->rxLines)
        {
            case QSPI_RX_LINES_SINGLE:
            {
                if(flashTransaction->address > 0xFFFFFF)
                {
                    readCmd = QSPI_LIB_CMD_READ_SINGLE_4B;
                }
                else
                {
                    readCmd = QSPI_LIB_CMD_READ_SINGLE;
                }
                break;
            }

            case QSPI_RX_LINES_DUAL:
            {
                if(flashTransaction->address > 0xFFFFFF)
                {
                    readCmd = QSPI_LIB_CMD_READ_DUAL_4B;
                }
                else
                {
                    readCmd = QSPI_LIB_CMD_READ_DUAL;
                }
                break;
            }

            case QSPI_RX_LINES_QUAD:
            {
                if(flashTransaction->address > 0xFFFFFF)
                {
                    readCmd = QSPI_LIB_CMD_READ_QUAD_4B;
                }
                else
                {
                    readCmd = QSPI_LIB_CMD_READ_QUAD;
                }
                break;
            }

            default:
            break;
        }

        /* Perform the transfer */
        transaction.txBuf = srcAddr;
        transaction.rxBuf = (uint8_t *)dstOffstAddr;
        transaction.count = length;

        transferType = SPI_TRANSACTION_TYPE_READ;
        transferCmd  = (unsigned char)readCmd;
        SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
        SPI_control(handle, SPI_V1_CMD_MMAP_TRANSFER_CMD, (void *)&transferCmd);
        retVal = SPI_transfer(handle, &transaction);
    }

    return retVal;
}


bool S25FLFlash_WriteEnable(S25FL_Handle flashHandle)
{
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    bool retVal = false;                /* return value */
    unsigned char writeVal;             /* data to be written */
    SPI_Transaction transaction;        /* SPI transaction structure */
    unsigned int operMode;              /* temp variable to hold mode */
    unsigned int rxLines;               /* temp variable to hold rx lines */
    unsigned int frmLength;
    unsigned int transferType;
    QSPI_v1_Object  *object;
    unsigned int rxLinesArg;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* These operations require the qspi to be configured in the following mode
       only: tx/rx single line and config mode. */

    /* Save the current mode and rxLine configurations */
    operMode = object->qspiMode;
    rxLines  = object->rxLines;

    /* Update the mode and rxLines with the required values */
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);

    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    /* transaction frame length in words (bytes) */
    frmLength = 1;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

    /* Write enable command */
    writeVal = QSPI_LIB_CMD_WRITE_ENABLE;

    /* Update transaction parameters */
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count  = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    /* Restore operating mode and rx Lines */
    object->qspiMode = operMode;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    return retVal;
}


bool S25FLFlash_Enable4ByteAddrMode(S25FL_Handle flashHandle,
                                    bool enable4ByteMode)
{
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    bool retVal = false;             /* return value */
    unsigned char writeVal;          /* data to be written */
    SPI_Transaction transaction;     /* SPI transaction structure */
    unsigned int operMode;           /* temp variable to hold mode */
    unsigned int rxLines;            /* temp variable to hold rx lines */
    unsigned int transferType;
    QSPI_v1_Object  *object;
    unsigned int rxLinesArg;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* These operations require the qspi to be configured in the following mode
       only: tx/rx single line and config mode. */

    /* Save the current mode and rxLine configurations */
    operMode = object->qspiMode;
    rxLines  = object->rxLines;


    /* Update the mode and rxLines with the required values */
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);
    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    /* Command to control the 4 byte mode */
    if (true == enable4ByteMode)
    {
        writeVal = QSPI_LIB_CMD_ENTER_4_BYTE_ADDR;
    }
    else
    {
        writeVal = QSPI_LIB_CMD_EXIT_4_BYTE_ADDR;
    }

    /* Write 4 byte enable/disable command to flash */
    transaction.count = 1U;                    /* Frame length in bytes */
    transaction.txBuf = (unsigned char *)&writeVal;  /* Value to be written */
    transaction.rxBuf = NULL;                  /* Nothing to read */
    transaction.arg   = NULL;                  /* Not applicable */

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);


    retVal = SPI_transfer(handle, &transaction);

    /* Restore operating mode and rx Lines */
    object->qspiMode = operMode;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    return retVal;
}


uint32_t FlashStatus(S25FL_Handle flashHandle)
{
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    bool retVal = false;             /* return value */
    unsigned char writeVal;          /* data to be written */
    SPI_Transaction transaction;     /* SPI transaction structure */
    uint32_t rxData = 0U;            /* received data */
    unsigned int operMode;           /* temp variable to hold mode */
    unsigned int rxLines;            /* temp variable to hold rx lines */
    unsigned int frmLength;
    unsigned int transferType;
    QSPI_v1_Object  *object;
    unsigned int rxLinesArg;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* These operations require the qspi to be configured in the following mode
       only: tx/rx single line and config mode. */

    /* Save the current mode and rxLine configurations */
    operMode = object->qspiMode;
    rxLines  = object->rxLines;

    /* Update the mode and rxLines with the required values */
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);

    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    /* Total transaction frame length in words (bytes) */
    frmLength = 1 + 1;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

    /* Write Address Bytes */
    writeVal = QSPI_LIB_CMD_READ_STATUS_REG;
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 1U;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    if(retVal == false)
    {
        /* Error */
    }

    /* Read the status register */
    transaction.txBuf = NULL;
    transaction.rxBuf = (unsigned char *)&rxData;
    transaction.count = 1U;

    transferType = SPI_TRANSACTION_TYPE_READ;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    if(retVal == false)
    {
        /* Error */
    }

    /* Restore operating mode and rx Lines */
    object->qspiMode = operMode;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    return (rxData & 0xFF);
}

#if defined(SOC_AM574x) || defined (SOC_AM571x) || defined (SOC_AM572x) || defined (SOC_DRA72x) || defined (SOC_DRA75x) || defined (SOC_DRA78x)
bool S25FLFlash_QuadModeEnable(S25FL_Handle flashHandle)
{
    SPI_Transaction transaction;                /* SPI transaction structure */
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    unsigned char writeVal = 0U;    /* data to be written */
    uint32_t norStatus;             /* flash status value */
    uint32_t configReg;             /* configuration register value */
    uint32_t data;                  /* data to be written */
    bool retVal = false;            /* return value */
    unsigned int operMode;          /* temp variable to hold mode */
    unsigned int rxLines;           /* temp variable to hold rx lines */
    unsigned int frmLength;
    unsigned int transferType;
    QSPI_v1_Object  *object;
    unsigned int rxLinesArg;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* These operations require the qspi to be configured in the following mode
       only: tx/rx single line and config mode. */

    /* Save the current mode and rxLine configurations */
    operMode = object->qspiMode;
    rxLines  = object->rxLines;

    /* Update the mode and rxLines with the required values */
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);

    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    /* Set transfer length in bytes: Reading status register */
    frmLength = 1 + 1;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

    /* Read Status register */
    writeVal = QSPI_LIB_CMD_READ_STATUS_REG;
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    transaction.txBuf = NULL;
    transaction.rxBuf = (unsigned char *)&norStatus;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_READ;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    /* Set transfer length in bytes: Reading status register */
    frmLength = 1 + 1;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

    /* Read command register */
    writeVal = QSPI_LIB_CMD_QUAD_RD_CMD_REG;
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    transaction.txBuf = NULL;
    transaction.rxBuf = (unsigned char *)&configReg;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_READ;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    /* Set 2nd bit of configuration register to 1 to enable quad mode */
    configReg |= (QSPI_FLASH_QUAD_ENABLE_VALUE << QSPI_FLASH_QUAD_ENABLE_BIT);
    data = (QSPI_LIB_CMD_WRITE_STATUS_REG << 16) | (norStatus << 8) | configReg;

    /* Set transfer length in bytes */
    frmLength = 1;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);


    transaction.txBuf = (unsigned char *)&data;
    transaction.rxBuf = NULL;
    transaction.count = 3;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    /* Wait till the status register is being written */
    while (1U == (FlashStatus(flashHandle) & 0x1U));

    /* Restore operating mode and rx Lines */
    object->qspiMode = operMode;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    return retVal;
}
#endif
#if defined(SOC_AM437x)
bool S25FLFlash_QuadModeEnable(S25FL_Handle flashHandle)
{
    SPI_Transaction transaction;                /* SPI transaction structure */
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    unsigned char writeVal = 0U;    /* data to be written */
    uint32_t norStatus;             /* flash status value */
    bool retVal = false;            /* return value */
    unsigned int operMode;          /* temp variable to hold mode */
    unsigned int rxLines;           /* temp variable to hold rx lines */
    unsigned int frmLength;
    unsigned int transferType;
    QSPI_v1_Object  *object;
    unsigned int rxLinesArg;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* These operations require the qspi to be configured in the following mode
       only: tx/rx single line and config mode. */

    /* Save the current mode and rxLine configurations */
    operMode = object->qspiMode;
    rxLines  = object->rxLines;

    /* Update the mode and rxLines with the required values */
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);

    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    /* Set transfer length in bytes: Reading status register */
    frmLength = 1 + 1;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

    /* Read Status register */
    writeVal = 0x05U;   //QSPI_LIB_CMD_READ_STATUS_REG;  //Cmd for AM437x
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    transaction.txBuf = NULL;
    transaction.rxBuf = (unsigned char *)&norStatus;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_READ;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    /* Flash write enable */
    S25FLFlash_WriteEnable(flashHandle);

    /* Set transfer length in bytes: Reading status register */
    frmLength = 1 + 1;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

    /* Read command register */
    writeVal = 0x01U;   //QSPI_LIB_CMD_QUAD_RD_CMD_REG;
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);


    /* Set status register 6th bit to 1 for Quad enable
     * Write this value to the status register.
     */
    norStatus &= ~(1U << 0x6U);
    norStatus |= (0x1U << 0x6U);

    transaction.txBuf = (unsigned char *)&norStatus;
    transaction.rxBuf = NULL;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    /* Wait till the status register is being written */
    while (1U == (FlashStatus(flashHandle) & 0x1U));

    /* Restore operating mode and rx Lines */
    object->qspiMode = operMode;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    return retVal;
}
#endif



bool S25FLFlash_BlockErase(S25FL_Handle flashHandle, unsigned int blockNumber)
{
    uint32_t eraseAddr;    /* Flash erase address */
    uint32_t writeVal;     /* data to be written */
    SPI_Handle handle = flashHandle->spiHandle;  /* SPI handle */
    SPI_Transaction transaction;         /* SPI transaction structure */
    unsigned int addrLenInBytes = 3;     /* address length in bytes */
    bool retVal = false;                 /* return value */
    unsigned int operMode;               /* temp variable to hold mode */
    unsigned int rxLines;                /* temp variable to hold rx lines */
    unsigned int frmLength;
    unsigned int transferType;
    QSPI_v1_Object  *object;
    unsigned int rxLinesArg;
    uint32_t tempAddr;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* Compute flash erase address based on the block size */
    eraseAddr = blockNumber * flashHandle->blockSize;

    /* These operations require the qspi to be configured in the following mode
       only: tx/rx single line and config mode. */

    /* Save the current mode and rxLine configurations */
    operMode = object->qspiMode;
    rxLines  = object->rxLines;

    /* Update the mode and rxLines with the required values */
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);

    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    if(eraseAddr > 0xFFFFFF)
    {
        /* Enter 4 byte addressing mode */
        addrLenInBytes = 4;
    }

    tempAddr = ((eraseAddr & 0xFF000000) >> 24) |
               ((eraseAddr & 0x00FF0000) >> 8)  |
               ((eraseAddr & 0x0000FF00) << 8)  |
               ((eraseAddr & 0x000000FF) << 24);

    if(addrLenInBytes == 3)
    {
        tempAddr = (tempAddr >> 8) & 0x00FFFFFF;
    }

    /* Flash write enable */
    S25FLFlash_WriteEnable(flashHandle);


    /*total transaction frame length */
    frmLength = 1 + addrLenInBytes;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, ((void *)&frmLength));

    /* Block erase command */
    if(eraseAddr > 0xFFFFFF)
    {
        writeVal = QSPI_LIB_CMD_BLOCK_ERASE_4B;
    }
    else
    {
        writeVal = QSPI_LIB_CMD_BLOCK_ERASE;
    }
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);


    retVal = SPI_transfer(handle, &transaction);

    /* Send erase address */
    writeVal = tempAddr;
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = addrLenInBytes;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);


    retVal = SPI_transfer(handle, &transaction);

    /* Check flash status for write completion */
    while (1U == (FlashStatus(flashHandle) & 0x1U));

    /* Restore operating mode and rx Lines */
    object->qspiMode = operMode;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    return retVal;
}


void FlashPrintId(S25FL_Handle flashHandle)
{
    uint32_t writeVal;               /* data to be written */
    SPI_Handle handle = flashHandle->spiHandle;  /* SPI handle */
    SPI_Transaction transaction;     /* SPI transaction structure */
    bool retVal = false;             /* return value */
    unsigned char mfgId = 0;         /* manufacture ID value */
    unsigned char deviceId = 0;      /* device ID value */
    unsigned int operMode;           /* temp variable to hold mode */
    unsigned int rxLines;            /* temp variable to hold rx lines */
    unsigned int frmLength;
    unsigned int transferType;
    QSPI_v1_Object  *object;
    unsigned int rxLinesArg;

    /* Get the pointer to the object and hwAttrs */
    object = handle->object;

    /* These operations require the qspi to be configured in the following mode
       only: tx/rx single line and config mode. */

    /* Save the current mode and rxLine configurations */
    operMode = object->qspiMode;
    rxLines  = object->rxLines;

    /* Update the mode and rxLines with the required values */
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);

    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    /* Total transaction frame length in bytes */
    frmLength = 1 + 3 + 2;   /* cmd + address + read data */
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, (void *)&frmLength);

    /* Write Command */
    writeVal = QSPI_LIB_CMD_READ_MFG_ID;
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    if(retVal == false)
    {
        /* Error */
    }

    /* Write Address Bytes */
    writeVal = 0x0U;
    transaction.txBuf = (unsigned char *)&writeVal;
    transaction.rxBuf = NULL;
    transaction.count = 3;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);


    retVal = SPI_transfer(handle, &transaction);


    /* Read Manufacturer ID
     * The manufacturer ID is of 1 byte(8 bits)
     */
    transaction.txBuf = NULL;
    transaction.rxBuf = &mfgId;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_READ;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);

    retVal = SPI_transfer(handle, &transaction);

    /* Read Device ID */
    transaction.txBuf = NULL;
    transaction.rxBuf = &deviceId;
    transaction.count = 1;

    transferType = SPI_TRANSACTION_TYPE_READ;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);


    retVal = SPI_transfer(handle, &transaction);

    /* Note - This ID is the device ID of the flash device.
     * This ID is read from the flash
     */

    /* Restore operating mode and rx Lines */
    object->qspiMode = operMode;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);
}

static bool SF25FL_ConfigMode_Write(uint32_t dstOffstAddr,
                                    unsigned char* srcAddr,
                                    uint32_t length,
                                    S25FL_Handle flashHandle)
{
    bool retVal = false;                        /* return value */
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    uint32_t addrLengthInBytes = 3U;            /* Flash addr length in bytes */
    unsigned int frmLength;
    unsigned char writeVal[4];                  /* data to be written to QSPI */
    SPI_Transaction transaction;                /* SPI transaction structure */
    unsigned int transferType;
    uint32_t offsetValue;


    addrLengthInBytes = 3U;        /* Flash address length in bytes */
    offsetValue = *((uint32_t *)dstOffstAddr);

   /* Extract address word length from the flash's destination offst addr*/
    if(offsetValue > 0xFFFFFF)
    {
        /* Enter 32 bit addressing mode */
        addrLengthInBytes = 4;
    }

    /* Write Enable */
    S25FLFlash_WriteEnable(flashHandle);

    /* total transaction frame length in number of words (bytes)*/
    frmLength = 1 + addrLengthInBytes + length;
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, ((void *)&frmLength));

    /* Send Flash write command */
    writeVal[0] = QSPI_LIB_CMD_PAGE_PRG;   /* Flash write command */
    transaction.txBuf = (unsigned char *)&writeVal[0];
    transaction.rxBuf = NULL;
    transaction.count = 1U;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
    retVal = SPI_transfer(handle, &transaction);

    /* Send flash address offset to which data has to be written */
    transaction.txBuf = (unsigned char *)dstOffstAddr;
    transaction.rxBuf = NULL;
    transaction.count = addrLengthInBytes;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
    retVal = SPI_transfer(handle, &transaction);

    /* Write buffer data to flash */
    transaction.txBuf = (unsigned char *)srcAddr;
    transaction.rxBuf = NULL;
    transaction.count = length;

    transferType = SPI_TRANSACTION_TYPE_WRITE;
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType);
    retVal = SPI_transfer(handle, &transaction);

    /* Check flash status for write completion */
    while ((FlashStatus(flashHandle) & 0x1U));

    return retVal;
}