PROCESSOR-SDK-AM437X: Software crash in "QSPI_BasicExample_idkAM437x_armExampleProject"

Hello Dillon,

With those read/write functions I am able to access all 1024 flash blocks. I used those functions inside the FATFS example project to copy an application binary and the QSPI SBL binary from the SD card into the QSPI flash device. After a power cycle the IDK booted properly from the QSPI flash.

Feel free to review and provide feedback as I will not guarantee that there are no further issues. It just looks very promising with those functions.

/************************************************************************************/
/* This function is an alternative approach for the TI functions, which allow us    */
/* to access each of the 1024 (0...1023) 64[kB] memory blocks of the QSPI flash.    */
/* This function works in the same way like the 'S25FLFlash_BlockErase' or the      */
/* 'FlashPrintId', which means in standard SPI mode (MOSI/MISO/CLK/CS) accessing    */
/* the SPI_CORE interface.                                                          */
/*                                                                                  */
/* This function has been written because if calling 'SF25FL_bufferRead' when       */
/* "(QSPI_OPER_MODE_CFG == object->qspiMode)", then there are several bugs inside   */
/* the function (e.g. missing address byte swap) and if calling 'SF25FL_bufferRead' */
/* when "(QSPI_OPER_MODE_MMAP == object->qspiMode)", then the QSPI driver crashes   */
/* when accessing certain flash blocks (addresses), such as flash block 64          */
/* (address 0x400000).                                                              */
/*                                                                                  */
/* See also:                                                                        */
/* ---------                                                                        */
/* e2e.ti.com/.../974055                               */
/* e2e.ti.com/.../969427                             */
/* e2e.ti.com/.../969166                             */
/*                                                                                  */
/*                                                                                  */
/* Arguments: dstOffstAddr - Flash address to be accessed (0x0...0x3FFFFFF)         */
/*            dstAddr - Pointer to the buffer where to store that data, which       */
/*                      has been read from the flash.                               */
/*            length - number of bytes to read from the flash                       */
/*            flashHandle - QSPI flash handle                                       */
/************************************************************************************/
bool SF25FL_ConfigMode_StandardSPI_Read_IWG(uint32_t dstOffstAddr,
                                    unsigned char* dstAddr,
                                    uint32_t length,
                                    S25FL_Handle flashHandle)
{
    bool retVal = true;                        /* return value = success */
    bool retVal2 = true; // Success
    SPI_Handle handle = flashHandle->spiHandle; /* SPI handle */
    unsigned char writeVal[4];               /* data to be written */
    uint32_t addrLengthInBytes = 3U;         /* Flash address length in bytes */
    uint32_t readCmd = 0U;                   /* Read command */
    unsigned int frmLength;
    unsigned int transferType;
    uint32_t offsetValue;
    unsigned int operMode;           /* temp variable to hold mode */
    unsigned int rxLines;            /* temp variable to hold rx lines */
    unsigned int rxLinesArg;
    uint32_t tempAddr;
    QSPI_v1_Object  *object;

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


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

    /**************************************************************************/
    /* Stage 2: Indicate to the QSPI driver to access 'QSPI_cmd_mode_read_v1' */
    /*          upon a read access and 'QSPI_cmd_mode_write_v1' upon a write  */
    /*          access.                                                       */
    /**************************************************************************/
    SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);
    rxLinesArg = QSPI_RX_LINES_SINGLE;
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);

    /***************************************************************************/
    /* Stage 3: Identify the number of bytes for the address information, the  */
    /*           proper command byte and set up the total frame length for the */
    /*           QSPI driver.                                                  */
    /***************************************************************************/

    addrLengthInBytes = 3U;
    offsetValue = dstOffstAddr; // Load the Flash address to read data from
    if(offsetValue > 0xFFFFFF)
    {
        /* Enter 32 bit addressing mode */
        addrLengthInBytes = 4;
    }

    if(offsetValue > 0xFFFFFF)
    {
        readCmd = QSPI_LIB_CMD_READ_SINGLE_4B;
    }
    else
    {
        readCmd = QSPI_LIB_CMD_READ_SINGLE;
    }

    /* total transaction frame length in number of words (bytes)*/
    /* This tells the SPI driver for how long to activate the CS signal. */
    frmLength = 1 + addrLengthInBytes + length; // Command byte plus address bytes plus 'length' data bytes
    SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, ((void *)&frmLength));


    /***********************************************/
    /* Stage 4: Send the command byte to the Flash */
    /***********************************************/
    /* 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); // This command sends finally one byte, which is taken from the pointer 'transaction.txBuf'.
    if(retVal == false)
    {
        retVal2 = retVal;
    }

    /************************************************/
    /* Stage 5: Send the address bytes to the Flash */
    /************************************************/
    // Here we perform a byte swap, so that the highest read address byte is at lowest byte inside 'tempAddr'
    // and the lowest read address byte is at the highest byte inside 'tempAddr'. The flash device expects
    // the highest address byte to be sent first according to the datasheet.
    tempAddr = ((offsetValue & 0xFF000000) >> 24) |
               ((offsetValue & 0x00FF0000) >> 8)  |
               ((offsetValue & 0x0000FF00) << 8)  |
               ((offsetValue & 0x000000FF) << 24);

    // Here we remove the lowest byte of 'tempAddr', which is the highest read address information of a 4-byte address.
    // This highest byte should not be sent for a 3 byte address access (address bits A23...A0).
    if(addrLengthInBytes == 3)
    {
        tempAddr = (tempAddr >> 8) & 0x00FFFFFF;
    }

    transaction.txBuf = (unsigned char *)&tempAddr; // Set pointer to address of the variable
    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); // This command sends finally one byte, which is taken from the pointer 'transaction.txBuf'.
    if(retVal == false)
    {
        retVal2 = retVal;
    }

    /*******************************************************************************/
    /* Stage 6: Read the actual data from the flash device */
    /*******************************************************************************/
    /* Read the actual flash data */
    transaction.txBuf = NULL;
    transaction.rxBuf = (unsigned char *)dstAddr;
    transaction.count = length;

    transferType = SPI_TRANSACTION_TYPE_READ;                               // Tell SPI Driver that we are reading data into the transaction.rxBuf
    SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType); // Tell SPI Driver that we are reading data into the transaction.rxBuf
    retVal = SPI_transfer(handle, &transaction); // This command sends finally the telegram and reads out the data from the flash.
    if(retVal == false)
    {
        retVal2 = retVal;
    }

    /**********************************************************/
    /* Stage 7: Restore operating mode and rx-lines settings. */
    /**********************************************************/
    object->qspiMode = operMode;  // Here we restore the operating mode directly without involving "SPI_control", which is allowed.
    SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

    retVal = retVal2;
    return retVal;
}


/***********************************************************************************/
/* This function is an alternative approach for the TI functions, which allow us   */
/* to access each of the 1024 (0...1023) 64[kB] memory blocks of the QSPI flash.   */
/* This function works in the same way like the 'S25FLFlash_BlockErase' or the     */
/* 'FlashPrintId', which means in standard SPI mode (MOSI/MISO/CLK/CS) accessing   */
/* the SPI_CORE interface.                                                         */
/*                                                                                 */
/* This function has been written because if calling 'SF25FL_bufferWrite' when     */
/* "(QSPI_OPER_MODE_CFG == object->qspiMode)", then there are several bugs inside  */
/* the function 'SF25FL_ConfigMode_Write' and if calling 'SF25FL_bufferWrite' when */
/* "(QSPI_OPER_MODE_MMAP == object->qspiMode)", then the QSPI driver crashes when  */
/* accessing certain flash blocks (addresses), such as flash block 64 (address     */
/* 0x400000).                                                                      */
/*                                                                                 */
/* See also:                                                                       */
/* ---------                                                                       */
/* e2e.ti.com/.../974055                              */
/* e2e.ti.com/.../969427                            */
/* e2e.ti.com/.../969166                            */
/*                                                                                 */
/* Arguments: dstOffstAddr - Flash address to be accessed (0x0...0x3FFFFFF)        */
/*            dstAddr - Pointer to the buffer of the data, which we want to        */
/*                     write to the flash.                                         */
/*            length - number of bytes to read from the flash                      */
/*            flashHandle - QSPI flash handle                                      */
/************************************************************************************/
bool SF25FL_ConfigMode_StandardSPI_Write_IWG(uint32_t dstOffstAddr,
                                    unsigned char* srcAddr,
                                    uint32_t length,
                                    S25FL_Handle flashHandle)
{
    bool retVal = true;                        /* return value = success */
    bool retVal2 = true; // Success
    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 */
    unsigned int transferType;
    uint32_t offsetValue;
    uint32_t tempAddr;
    uint32_t localIndex = 0;
    unsigned int operMode;           /* temp variable to hold mode */
    unsigned int rxLines;            /* temp variable to hold rx lines */
    unsigned int rxLinesArg;
    QSPI_v1_Object  *object;
    uint32_t bytesLeft = length;
    uint32_t dataBytesPerFrame;

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

    // *********************************************************************************
    // At this place we program only as many bytes as possible for one page of 256[byte].
    // We do this in order to protect the user crossing unexpectedly a
    // 256[byte] page boundary.
    //
    // Example
    // -------
    // dstOffstAddr = 12 and length=256,
    //   - If we would write the data in one telegram, we would write bytes 0...243 at
    //     address 12...255 and bytes 244...255 to address 0...11.
    //   - But since we identify the space within a page, we write bytes 0...255 to
    //     address 12...267
    // *********************************************************************************
    while(bytesLeft > 0)
    {
        /***************************************************************************************/
        /* Stage 1: Determine the address to write to and the number of address bytes to sent. */
        /***************************************************************************************/
        addrLengthInBytes = 3U;        /* Flash address length in bytes */
        offsetValue = dstOffstAddr + localIndex;
        /* Extract address word length from the flash's destination offst addr*/
        if(offsetValue > 0xFFFFFF)
        {
            /* Enter 32 bit addressing mode */
            addrLengthInBytes = 4;
        }

        /***********************************************************************************************/
        /* Stage 2: Determine the number of bytes we can write to the page based on the flash address. */
        /***********************************************************************************************/
        dataBytesPerFrame = 256 - (offsetValue%256);
        if(dataBytesPerFrame > bytesLeft)
        {
            dataBytesPerFrame = bytesLeft;
        }

        /***************************************************************************************/
        /* Stage 3: Set the flash device into a state where it accepts a page program request. */
        /***************************************************************************************/
        /* Write Enable */
        S25FLFlash_WriteEnable(flashHandle); // Set Flash to write enable mode, precondition for page write

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

        /**************************************************************************/
        /* Stage 5: Indicate to the QSPI driver to access 'QSPI_cmd_mode_read_v1' */
        /*          upon a read access and 'QSPI_cmd_mode_write_v1' upon a write  */
        /*          access.                                                       */
        /**************************************************************************/
        SPI_control(handle, SPI_V1_CMD_SETCONFIGMODE, NULL);
        rxLinesArg = QSPI_RX_LINES_SINGLE;
        SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLinesArg);


        /***************************************************************/
        /* Stage 6: Set up the total frame length for the QSPI driver. */
        /***************************************************************/
        /* Total transaction frame length in number of bytes.                */
        /* This tells the SPI driver for how long to activate the CS signal. */
        frmLength = 1 + addrLengthInBytes + dataBytesPerFrame; // Command byte plus address bytes plus number of data bytes data byte
        SPI_control(handle, SPI_V1_CMD_SETFRAMELENGTH, ((void *)&frmLength));

        /******************************************/
        /* Stage 7: Send Flash write command byte */
        /******************************************/
        writeVal[0] = QSPI_LIB_CMD_PAGE_PRG;   /* Flash write command */
        // Change Flash command byte to 4 byte page access
        if(addrLengthInBytes == 4)
        {
            writeVal[0] = QSPI_LIB_CMD_PAGE_PRG_4B;
        }

        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); // Set driver to write mode
        retVal = SPI_transfer(handle, &transaction);
        if(retVal == false)
        {
            retVal2 = retVal;
        }

        /****************************************************************/
        /* Stage 8: Send flash address to which data has to be written. */
        /****************************************************************/
        // Here we perform a byte swap, so that the highest write address byte is at lowest byte inside 'tempAddr'
        // and the lowest write address byte is at the highest byte inside 'tempAddr'. The flash device expects
        // the highest address byte to be sent first according to the datasheet.
        tempAddr = ((offsetValue & 0xFF000000) >> 24) |
                   ((offsetValue & 0x00FF0000) >> 8)  |
                   ((offsetValue & 0x0000FF00) << 8)  |
                   ((offsetValue & 0x000000FF) << 24);

        // Here we remove the lowest byte of 'tempAddr', which is the highest write address information of a 4-byte address.
        // This highest byte should not be sent for a 3 byte address access (address bits A23...A0).
        if(addrLengthInBytes == 3)
        {
            tempAddr = (tempAddr >> 8) & 0x00FFFFFF;
        }

        transaction.txBuf = (unsigned char *)&tempAddr; // Set pointer to address of the variable
        transaction.rxBuf = NULL;
        transaction.count = addrLengthInBytes;

        transferType = SPI_TRANSACTION_TYPE_WRITE;
        SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType); // Set driver to write mode
        retVal = SPI_transfer(handle, &transaction);
        if(retVal == false)
        {
            retVal2 = retVal;
        }

        /**************************************/
        /* Stage 9: Write data bytes to flash */
        /**************************************/
        transaction.txBuf = (unsigned char *)&srcAddr[localIndex];
        transaction.rxBuf = NULL;
        transaction.count = dataBytesPerFrame;

        transferType = SPI_TRANSACTION_TYPE_WRITE;
        SPI_control(handle, SPI_V1_CMD_TRANSFERMODE_RW, (void *)&transferType); // Set driver to write mode
        retVal = SPI_transfer(handle, &transaction);
        if(retVal == false)
        {
            retVal2 = retVal;
        }

        /*********************************************************************************/
        /* Stage 10: Restore original operating mode and rx Lines inside the QSPI driver. */
        /*********************************************************************************/
        object->qspiMode = operMode;  // Here we restore the operating mode directly without involving "SPI_control", which is allowed.
        SPI_control(handle, SPI_V1_CMD_SETRXLINES, (void *)&rxLines);

        /**********************************************************************************************/
        /* Stage 11: Wait until the busy bit (bit 0) inside the status register of the flash is true. */
        /**********************************************************************************************/
        /* Check flash status for write completion */
        while ((FlashStatus(flashHandle) & 0x1U));

        /**********************************************************************************************/
        /* Stage 12: Wait until the busy bit (bit 0) inside the status register of the flash is true. */
        /**********************************************************************************************/
        localIndex += dataBytesPerFrame;
        bytesLeft -= dataBytesPerFrame;

    } // while(bytesLeft > 0)

    retVal = retVal2;
    return retVal;
}