GSPI with DMA on TX only problem

Hi Pavlos,

You may refer to the cc3200-sdk\simplelink\cc_pal.c or cc3200-sdk\middleware\driver\spi_drv.c for some working references of the SPI with DMA. These are checked with the internal SPI but since the IP is same should be a good reference for GSPI as well.

Best regards,

Naveen

Hello again,

I checked the suggested source files.

The spi_drv.c does not help much as I am not using an RTOS. The cc_pal.c file as far as I can see does the uDMA/GSPI setup similar to my code.

I attempted to use the same order in function calls but no luck. I have checked the documentation on the uDMA peripheral and the UART - uDMA example and tried everything I can think of but still nothing.

I there a specific order on how to setup uDMA for SPI transfers in terms of function calls ?

What I have noticed in my code , when I enable the SPI_DMA_TX interrupt, is that the interrupt is asserted even before I use the MAP_uDMAChannelRequest() to start the transfer. Once the channel request is sent I set a break-point to the interrupt handler and it seems like even though I clear the interrupt it gets asserted continuously, without request the next transfer.

In my example I have enable WiFi using simplelink and after that I attempt to initialize the OLED driver and display something on the screen.  Could there be a conflict in the uDMA setup when using simplelink ?

Nevertheless, as far as you can see in my code, is there something wrong in the order functions are called ?

P.S.  I have added the below calls to my init function and  use the MAP_SPIWordCountSet(OLED_SPI_BASE,1); function prior to requesting a 1 byte channel transfer.

MAP_SPIFIFOEnable(OLED_SPI_BASE, SPI_TX_FIFO);

MAP_SPIFIFOLevelSet(OLED_SPI_BASE,1,1);

Ok....I found one problem.

I missed the call where I put the transmitted data in the GSPI RX buffer instead of TX...

Once I changed MCSPI_O_RX0 to MCSPI_O_TX0 it works but it only transmits one byte and then nothing.

What am I missing ?

Just edited the above post as I did not find the solution.

Working a bit more with the SPI interrupt handler and uDMA this is what I cannot figure out.

When using SPI with uDMA, what is the interrupt that tells me that my transfer is complete ? 

The SPI_INT_DMATX interrupt when enable gets triggered non-stop and my application does not run even if I clear it.

When I poll the uDMA channel after I request a transfer, the UDMA_MODE_STOP condition is set before the SPI transfer is complete.

When using SPIWordCountSet(GSPI_BASE,size); I never get the SPI_INT_EOW interrupt asserted.

Which approach should I use for my application and which interrupts (if any) should I use ?

Just a follow up.

I tested the code given at this thread : http://e2e.ti.com/support/wireless_connectivity/f/968/t/353790.aspx

Instead of using the uDMA channel on the Slave, I used on Master side TX.

Still getting only one byte transmitted.

And another question, when using DMA and SPI should we transfer the data to the (GSPI_BASE + MCSPI_O_TX0) register or the (GSPI_BASE + MCSPI_O_DAFTX) register ?

Here is the code I use for the Master side uDMA test, teh rest of the code is unchanged with respect to the posted at the above thread.

void MasterMain()
{

unsigned long ulUserData;
unsigned long ulDummy;

//
// Initialize the message
//
memcpy(g_ucTxBuff,MASTER_MSG,sizeof(MASTER_MSG));

//
// Set Tx buffer index
//
ucTxBuffNdx = 0;
ucRxBuffNdx = 0;

//
// Reset SPI
//
MAP_SPIReset(GSPI_BASE);

//
// uDMA Initialization
//
UDMAInit();
Message("Completed DMA Initialization \n\r\n\r");

//
// Configure SPI interface
//
MAP_SPIConfigSetExpClk(GSPI_BASE,MAP_PRCMPeripheralClockGet(PRCM_GSPI),
SPI_IF_BIT_RATE,SPI_MODE_MASTER,SPI_SUB_MODE_0,
(SPI_HW_CTRL_CS |
SPI_4PIN_MODE |
SPI_TURBO_OFF |
SPI_CS_ACTIVELOW |
SPI_WL_8));

MAP_SPIIntRegister(GSPI_BASE,SPIIntHandler);

SetupTransfer(UDMA_CH31_GSPI_TX,UDMA_MODE_BASIC,50,
UDMA_SIZE_8,UDMA_ARB_1,
g_ucTxBuff,UDMA_SRC_INC_8,(void *)(GSPI_BASE + MCSPI_O_TX0),
UDMA_DST_INC_NONE);

SPIDmaEnable(GSPI_BASE, SPI_TX_DMA);

//
// Print mode on uart
//
Message("Enabled SPI Interface in Master Mode\n\r");

//
// User input
//
Report("Press any key to transmit data....");

//
// Read a character from UART terminal
//
ulUserData = MAP_UARTCharGet(UARTA0_BASE);

//
// Enable SPI for communication
//
MAP_SPIIntEnable(GSPI_BASE,SPI_INT_DMATX);

MAP_SPIEnable(GSPI_BASE);

}

void SPIIntHandler()
{
unsigned long ulStatus;

ulStatus = MAP_SPIIntStatus(GSPI_BASE, true);

MAP_SPIIntClear(GSPI_BASE, ulStatus);
}

I would really appreciate your feedback here cause this thing is driving me crazy....

Hi, is there any progress with this?

We are considering using CC3200 for our IoT platform but efficient SPI is absolutely necessary, so if the problems reported above are caused by a hardware bug it will mean we cannot use it.

Let's hope that the problems so far are due to immature datasheet and/or driverlib.

Any new information will be appreciated.

Best,

Giannis

I've successfully used SPI w/ DMA. Here are some portions of my code which may help. I know initially I did have the same issue as you that I'd only get one byte to come out. IIRC the fix was correct interrupt mode selection and transfer length setup.

void spi_init( void )
{
    MAP_SPIDisable( GSPI_BASE );
    MAP_SPIReset( GSPI_BASE );

    procClkRate = MAP_PRCMPeripheralClockGet( PRCM_GSPI );

    /* configure the SPI port */
    MAP_SPIConfigSetExpClk( GSPI_BASE,
                            procClkRate,
                            SPI_CLOCK_HZ,
                            SPI_MODE_MASTER,
                            SPI_SUB_MODE_0,
                            (SPI_WL_8 | SPI_CS_ACTIVELOW | SPI_SW_CTRL_CS | SPI_4PIN_MODE | SPI_TURBO_OFF) );

    MAP_uDMAChannelAssign( UDMA_CH6_GSPI_RX );
    MAP_uDMAChannelAssign( UDMA_CH7_GSPI_TX );

    MAP_uDMAChannelAttributeDisable( UDMA_CH6_GSPI_RX, UDMA_ATTR_ALTSELECT );
    MAP_uDMAChannelAttributeDisable( UDMA_CH7_GSPI_TX, UDMA_ATTR_ALTSELECT );

    MAP_SPIFIFOEnable( GSPI_BASE, SPI_RX_FIFO );
    MAP_SPIFIFOEnable( GSPI_BASE, SPI_TX_FIFO );
    MAP_SPIDmaEnable( GSPI_BASE, SPI_RX_DMA );
    MAP_SPIDmaEnable( GSPI_BASE, SPI_TX_DMA );
    MAP_SPIFIFOLevelSet( GSPI_BASE, 1, 1 );

    MAP_IntRegister( INT_GSPI, (void(*)(void))spi_isr );
    MAP_IntPrioritySet( INT_GSPI, SPI_ISR_PRIORITY );
    MAP_IntEnable( INT_GSPI );
    MAP_SPIIntEnable( GSPI_BASE, SPI_INT_EOW );

    MAP_SPIEnable( GSPI_BASE );
}

void spi_transfer ( const uint8_t* pTxBuff, uint8_t* pRxBuff, uint16_t nNumBytes )
{
    uint32_t rxIncrement;

    if( pTxBuff == NULL ) {
        /* the RX buffer can be null... the TX buffer cannot */
        return ;
    }

    if( pRxBuff == NULL ) {
        /* we don't care about the receive data, so dump it to a temp variable */
        pRxBuff = &dumpByte;
        rxIncrement = UDMA_DST_INC_NONE;
    } else {
        rxIncrement = UDMA_DST_INC_8;
    }

    /* configure the TX DMA channel */
    MAP_uDMAChannelControlSet( UDMA_CH7_GSPI_TX, (UDMA_SIZE_8 | UDMA_SRC_INC_8 | UDMA_DST_INC_NONE | UDMA_ARB_1) );
    MAP_uDMAChannelAttributeEnable( UDMA_CH7_GSPI_TX, UDMA_ATTR_USEBURST );
    MAP_uDMAChannelTransferSet( UDMA_CH7_GSPI_TX, UDMA_MODE_BASIC, (void *)pTxBuff, (void *)(GSPI_BASE+MCSPI_O_TX0), nNumBytes );
    MAP_uDMAChannelEnable( UDMA_CH7_GSPI_TX );

    /* configure the RX DMA channel */
    MAP_uDMAChannelControlSet( UDMA_CH6_GSPI_RX, (UDMA_SIZE_8 | UDMA_SRC_INC_NONE | rxIncrement | UDMA_ARB_1) );
    MAP_uDMAChannelAttributeEnable( UDMA_CH6_GSPI_RX, UDMA_ATTR_USEBURST );
    MAP_uDMAChannelTransferSet( UDMA_CH6_GSPI_RX, UDMA_MODE_BASIC, (void *)(GSPI_BASE+MCSPI_O_RX0), pRxBuff, nNumBytes );
    MAP_uDMAChannelEnable( UDMA_CH6_GSPI_RX );

    /*
     * make sure the semaphore is taken
     * before issuing the transfer
     */
    xSemaphoreTake( spiSema, 0 );

    /* prime the FIFO with our transfer size */
    MAP_SPIWordCountSet( GSPI_BASE, nNumBytes );

    /* asserting chip select triggers the transfer process */
    MAP_SPICSEnable( GSPI_BASE );

    /* block for the SPI completion */
    xSemaphoreTake( spiSema, CONVERT_MS_TO_TICKS(SPI_TRANSFER_TIMEOUT_MS) );

    MAP_uDMAChannelDisable( UDMA_CH7_GSPI_TX );
    MAP_uDMAChannelDisable( UDMA_CH6_GSPI_RX );

    return ;
}

void spi_isr ( void )
{
    portBASE_TYPE xYieldRequired = pdFALSE;

    MAP_SPIIntClear( GSPI_BASE, SPI_INT_EOW );
    MAP_SPICSDisable( GSPI_BASE );

    if( spiSema ) {
        /* the DMA transfer is complete */
        xSemaphoreGiveFromISR( spiSema, &xYieldRequired );
    }
    portYIELD_FROM_ISR( xYieldRequired );
}

(This is modified a bit to strip out my application specific stuff). I was using an OS (hence the semaphore), but that should be easy to adopt. I was also using the SW controlled chip select. Note that enabling the CS line started the transfer.

Yes that did it.

Thank you very much, now everything is working fine :)

Hi! Could you send me your code? i would be appreciated!

Balazs