CC3120MOD: interfacing with STM32 Using SPI by Callback mode (Interrupt mode for data transaction) ?

Thank you for your reply Kristen,

But my point is that how spi will call back to CC3120 (sl_IfWrite or any other function )APIs?

If I implement call back mode, then what will be the callback function for the host drive API of cc3120?

How we link call back fuction of spi (transaction complete call back) to Host driver API of cc3120.

Could you just provide example of cc3120 for call back mode in spi. Because I have only found blocking mode in sdk example of cc3120.

Hello Kristen,

I think you did not get my point. I want to know that how spi will call the Host driver of CC3120 in callback mode.

If you see below code of CC3120 from cc_pal.c (porting folder of SDK CC3120 ). It is having a while loop for Read and write both.It will stuck in this loop until transaction complete. But I want to implement interface  porting driver of CC3120 for host  in callback mode So I have to remove while loop and provide the callback.Then where I will add callback functionality in this porting driver (below code). 

If I provide callback functionality in spi interface then how SPI interface driver call back to CC3120 hsot api (upper layer). Because there is nowhere mention in programming guide of CC3120 about callback method for spi write and read.

In porting driver comment it is mention that int spi_Write() could be implemented as zero copy and return only upon successful completion of writing the whole buffer? Please check this comment below I have mentioned the comment below from porting driver.

/*!
    \brief attempts to write up to len bytes to the SPI channel

    \param             fd            -    file descriptor of an opened SPI channel

    \param            pBuff        -     points to first location to start getting the data from

    \param            len            -    number of bytes to write to the SPI channel

    \return            upon successful completion, the function shall return 0.
                    Otherwise, -1 shall be returned

    \sa             spi_Open , spi_Read
    \note            This function could be implemented as zero copy and return only upon successful completion
                    of writing the whole buffer, but in cases that memory allocation is not too tight, the
                    function could copy the data to internal buffer, return back and complete the write in
                    parallel to other activities as long as the other SPI activities would be blocked untill
                    the entire buffer write would be completed
    \warning
 */
extern int spi_Write(Fd_t fd,
                     unsigned char *pBuff,
                     int len);

/***********************************************/

int spi_Read(Fd_t fd,
             unsigned char *pBuff,
             int len)
{
    SPI_Transaction transact_details;
    int read_size = 0;

    ASSERT_CS();

    /* check if the link SPI has been initialized successfully */
    if(fd < 0)
    {
        DEASSERT_CS();
        return (-1);
    }

    transact_details.txBuf = NULL;
    transact_details.arg = NULL;
    transact_details.rxBuf = (void*) (pBuff);

    while(len > 0)
    {
        if(len > curDeviceConfiguration->maxDMASize)
        {
            transact_details.count = curDeviceConfiguration->maxDMASize;
        }
        else
        {
            transact_details.count = len;
        }

        if(SPI_transfer((SPI_Handle) fd, &transact_details))
        {
            read_size += transact_details.count;
            len = len - transact_details.count;
            transact_details.rxBuf = ((unsigned char *) (transact_details.rxBuf)
                                      + read_size);
        }
        else
        {
            DEASSERT_CS();
            return (-1);
        }
    }

    DEASSERT_CS();

    return (read_size);
}

int spi_Write(Fd_t fd,
              unsigned char *pBuff,
              int len)
{
    SPI_Transaction transact_details;
    int write_size = 0;

    ASSERT_CS();

    /* check if the link SPI has been initialized successfully */
    if(fd < 0)
    {
        DEASSERT_CS();
        return (-1);
    }

    transact_details.rxBuf = NULL;
    transact_details.arg = NULL;
    transact_details.txBuf = (void*) (pBuff);

    while(len > 0)
    {
        if(len > curDeviceConfiguration->maxDMASize)
        {
            transact_details.count = curDeviceConfiguration->maxDMASize;
        }
        else
        {
            transact_details.count = len;
        }

        if(SPI_transfer((SPI_Handle) fd, &transact_details))
        {
            write_size += transact_details.count;
            len = len - transact_details.count;
            transact_details.txBuf = ((unsigned char *) (transact_details.txBuf)
                                      + transact_details.count);
        }
        else
        {
            DEASSERT_CS();
            return (-1);
        }
    }

    DEASSERT_CS();

    return (write_size);
}