int32_t DRV_SPI_ISRMasterEBM8BitTasks ( struct DRV_SPI_DRIVER_OBJECT * pDrvInstance )
{
bool continueLoop;
/* Disable the interrupts */
SYS_INT_SourceDisable(pDrvInstance->rxInterruptSource);
SYS_INT_SourceDisable(pDrvInstance->txInterruptSource);
SYS_INT_SourceDisable(pDrvInstance->errInterruptSource);
do {
DRV_SPI_JOB_OBJECT * currentJob = pDrvInstance->currentJob;
SPI_MODULE_ID spiId = pDrvInstance->spiId;
/* Check for a new task */
if (pDrvInstance->currentJob == NULL)
{
if (DRV_SPI_SYS_QUEUE_Dequeue(pDrvInstance->queue, (void *)&(pDrvInstance->currentJob)) != DRV_SPI_SYS_QUEUE_SUCCESS)
{
SYS_ASSERT(false, "\r\nSPI Driver: Error in dequeing.");
return 0;
}
if (pDrvInstance->currentJob == NULL)
{
pDrvInstance->txEnabled = false;
return 0;
}
currentJob = pDrvInstance->currentJob;
pDrvInstance->symbolsInProgress = 0;
/* Call the operation starting function pointer. This can be used to modify the slave select lines */
DRV_SPI_CLIENT_OBJECT * pClient = (DRV_SPI_CLIENT_OBJECT*)currentJob->pClient;
if (pClient->operationStarting != NULL)
{
(*pClient->operationStarting)(DRV_SPI_BUFFER_EVENT_PROCESSING, (DRV_SPI_BUFFER_HANDLE)currentJob, currentJob->context);
}
/* Check the baud rate. If its different set the new baud rate*/
if (pClient->baudRate != pDrvInstance->currentBaudRate)
{
PLIB_SPI_BaudRateSet( spiId , SYS_CLK_PeripheralFrequencyGet(pDrvInstance->spiClk), pClient->baudRate );
pDrvInstance->currentBaudRate = pClient->baudRate;
}
/* List the new job as processing*/
currentJob->status = DRV_SPI_BUFFER_EVENT_PROCESSING;
if (currentJob->dataLeftToTx +currentJob->dummyLeftToTx > PLIB_SPI_RX_8BIT_FIFO_SIZE(spiId))
{
PLIB_SPI_FIFOInterruptModeSelect(spiId, SPI_FIFO_INTERRUPT_WHEN_TRANSMIT_BUFFER_IS_1HALF_EMPTY_OR_MORE);
PLIB_SPI_FIFOInterruptModeSelect(spiId, SPI_FIFO_INTERRUPT_WHEN_RECEIVE_BUFFER_IS_1HALF_FULL_OR_MORE);
}
/* Flush out the Receive buffer */
PLIB_SPI_BufferClear(spiId);
}
/* Set up DMA Receive job. This is done here to ensure that the RX job is ready to receive when TXing starts*/
if ((pDrvInstance->rxDmaThreshold != 0) && (currentJob->dataLeftToRx > pDrvInstance->rxDmaThreshold))
{
PLIB_SPI_FIFOInterruptModeSelect(spiId, SPI_FIFO_INTERRUPT_WHEN_RECEIVE_BUFFER_IS_NOT_EMPTY);
uint8_t * ptr = &(currentJob->rxBuffer[currentJob->dataRxed]);
uint32_t len = MIN(MIN(PLIB_DMA_MAX_TRF_SIZE, DRV_SPI_DMA_TXFER_SIZE), currentJob->dataLeftToRx);
void * spiPtr = PLIB_SPI_BufferAddressGet(spiId);
currentJob->rxDMAProgressStage = DRV_SPI_DMA_DATA_INPROGRESS;
currentJob->dataLeftToRx -= len;
currentJob->dataRxed += len;
pDrvInstance->rxEnabled = false;
SYS_DMA_ChannelTransferAdd(pDrvInstance->rxDmaChannelHandle, spiPtr, 1, ptr, len, 1);
}
else if ((currentJob->rxDMAProgressStage == DRV_SPI_DMA_NONE) && (currentJob->dataLeftToRx == 0) && (pDrvInstance->rxDmaThreshold != 0) && (currentJob->dummyLeftToRx > pDrvInstance->rxDmaThreshold))
{
PLIB_SPI_FIFOInterruptModeSelect(spiId, SPI_FIFO_INTERRUPT_WHEN_RECEIVE_BUFFER_IS_NOT_EMPTY);
uint8_t * ptr = sDrvSpiRxDummy;
uint32_t len = MIN(MIN(MIN(PLIB_DMA_MAX_TRF_SIZE, DRV_SPI_DMA_DUMMY_BUFFER_SIZE), DRV_SPI_DMA_TXFER_SIZE), currentJob->dummyLeftToRx);
void * spiPtr = PLIB_SPI_BufferAddressGet(spiId);
currentJob->rxDMAProgressStage = DRV_SPI_DMA_DUMMY_INPROGRESS;
currentJob->dummyLeftToRx -= len;
pDrvInstance->rxEnabled = false;
SYS_DMA_ChannelTransferAdd(pDrvInstance->rxDmaChannelHandle, spiPtr, 1, ptr, len, 1);
}
/* Set up the DMA Transmit job here. This is done after the RX job to help prevent buffer overruns.*/
if ((pDrvInstance->txDmaThreshold != 0) && (currentJob->dataLeftToTx > pDrvInstance->txDmaThreshold))
{
PLIB_SPI_FIFOInterruptModeSelect(spiId, SPI_FIFO_INTERRUPT_WHEN_TRANSMIT_BUFFER_IS_1HALF_EMPTY_OR_MORE);
uint8_t * ptr = &(currentJob->txBuffer[currentJob->dataTxed]);
uint32_t len = MIN(MIN(PLIB_DMA_MAX_TRF_SIZE, DRV_SPI_DMA_TXFER_SIZE), currentJob->dataLeftToTx);
void * spiPtr = PLIB_SPI_BufferAddressGet(pDrvInstance->spiId);
currentJob->txDMAProgressStage = DRV_SPI_DMA_DATA_INPROGRESS;
currentJob->dataLeftToTx -= len;
currentJob->dataTxed += len;
pDrvInstance->txEnabled = false;
SYS_DMA_ChannelTransferAdd(pDrvInstance->txDmaChannelHandle, ptr, len, spiPtr, 1, 1);
}
else if ((currentJob->txDMAProgressStage == DRV_SPI_DMA_NONE) && (currentJob->dataLeftToTx == 0) && (pDrvInstance->txDmaThreshold != 0) && (currentJob->dummyLeftToTx > pDrvInstance->txDmaThreshold))
{
PLIB_SPI_FIFOInterruptModeSelect(spiId, SPI_FIFO_INTERRUPT_WHEN_TRANSMIT_BUFFER_IS_1HALF_EMPTY_OR_MORE);
uint8_t * ptr = sDrvSpiTxDummy;
uint32_t len = MIN(MIN(MIN(PLIB_DMA_MAX_TRF_SIZE, DRV_SPI_DMA_DUMMY_BUFFER_SIZE), DRV_SPI_DMA_TXFER_SIZE), currentJob->dummyLeftToTx);
void * spiPtr = PLIB_SPI_BufferAddressGet(pDrvInstance->spiId);
currentJob->txDMAProgressStage = DRV_SPI_DMA_DUMMY_INPROGRESS;
currentJob->dummyLeftToTx -= len;
pDrvInstance->txEnabled = false;
SYS_DMA_ChannelTransferAdd(pDrvInstance->txDmaChannelHandle, ptr, len, spiPtr, 1, 1);
}
bool rxDMAInProgress = (currentJob->rxDMAProgressStage == DRV_SPI_DMA_DATA_INPROGRESS) || (currentJob->rxDMAProgressStage == DRV_SPI_DMA_DUMMY_INPROGRESS);
bool txDMAInProgress = (currentJob->txDMAProgressStage == DRV_SPI_DMA_DATA_INPROGRESS) || (currentJob->txDMAProgressStage == DRV_SPI_DMA_DUMMY_INPROGRESS);
continueLoop = false;
/* Execute the sub tasks */
DRV_SPI_ISRErrorTasks(pDrvInstance);
/* Figure out how many bytes are left to be received */
size_t bytesLeft = currentJob->dataLeftToRx + currentJob->dummyLeftToRx;
// Check to see if we have any data left to receive and update the bytes left.
if ((bytesLeft != 0) && !rxDMAInProgress)
{
DRV_SPI_MasterEBMReceive8BitISR(pDrvInstance);
bytesLeft = currentJob->dataLeftToRx + currentJob->dummyLeftToRx;
}
if
(!txDMAInProgress &&
(currentJob->dataLeftToTx +currentJob->dummyLeftToTx != 0)
)
{
DRV_SPI_MasterEBMSend8BitISR(pDrvInstance);
}
if ((bytesLeft == 0) && !rxDMAInProgress && !txDMAInProgress)
{
// Disable the interrupt, or more correctly don't re-enable it later*/
pDrvInstance->rxEnabled = false;
/* Job is complete*/
currentJob->status = DRV_SPI_BUFFER_EVENT_COMPLETE;
/* Call the job complete call back*/
if (currentJob->completeCB != NULL)
{
(*currentJob->completeCB)(DRV_SPI_BUFFER_EVENT_COMPLETE, (DRV_SPI_BUFFER_HANDLE)currentJob, currentJob->context);
}
/* Call the operation complete call back. This is different than the
job complete callback. This can be used to modify the Slave Select line.
The job complete callback can be used to free a client that is blocked
waiting for complete*/
DRV_SPI_CLIENT_OBJECT * pClient = (DRV_SPI_CLIENT_OBJECT*)currentJob->pClient;
if (pClient->operationEnded != NULL)
{
(*pClient->operationEnded)(DRV_SPI_BUFFER_EVENT_COMPLETE, (DRV_SPI_BUFFER_HANDLE)currentJob, currentJob->context);
}
/* Return the job back to the free queue*/
if (DRV_SPI_SYS_QUEUE_FreeElement(pDrvInstance->queue, currentJob) != DRV_SPI_SYS_QUEUE_SUCCESS)
{
SYS_ASSERT(false, "\r\nSPI Driver: Queue free element error.");
return 0;
}
/* Clean up */
pDrvInstance->currentJob = NULL;
if (!DRV_SPI_SYS_QUEUE_IsEmpty(pDrvInstance->queue))
{
continueLoop = true;
continue;
}
else
{
break;
}
}
else if (rxDMAInProgress)
{
// DMA is in progress
// Wipe out the symbols in Progress
pDrvInstance->rxEnabled = false;
pDrvInstance->symbolsInProgress = 0;
}
/* Check to see if the interrupts would fire again if so just go back into
the loop instead of suffering the interrupt latency of exiting and re-entering*/
if (pDrvInstance->currentJob != NULL)
{
/* Clear the Interrupts */
SYS_INT_SourceStatusClear(pDrvInstance->rxInterruptSource);
SYS_INT_SourceStatusClear(pDrvInstance->txInterruptSource);
SYS_INT_SourceStatusClear(pDrvInstance->errInterruptSource);
/* Interrupts should immediately become active again if they're in a fired condition */
if (((pDrvInstance->rxEnabled) && SYS_INT_SourceStatusGet(pDrvInstance->rxInterruptSource)) ||
((pDrvInstance->txEnabled) && SYS_INT_SourceStatusGet(pDrvInstance->txInterruptSource)) ||
(SYS_INT_SourceStatusGet(pDrvInstance->errInterruptSource)))
{
/* Interrupt would fire again anyway so we should just go back to the start*/
continueLoop = true;
continue;
}
/* If we're here then we know that the interrupt should not be firing again so we can exit cleanly*/
/* Clear the interrupts now that we're done*/
/* Re-enable the interrupts*/
if (pDrvInstance->rxEnabled)
{
SYS_INT_SourceEnable(pDrvInstance->rxInterruptSource);
}
if (pDrvInstance->txEnabled)
{
SYS_INT_SourceEnable(pDrvInstance->txInterruptSource);
}
return 0;
}
} while(continueLoop);
/* if we're here it means that we have no more jobs in the queue, tx and rx interrupts will be re-enabled by the BufferAdd* functions*/
SYS_INT_SourceStatusClear(pDrvInstance->rxInterruptSource);
SYS_INT_SourceStatusClear(pDrvInstance->txInterruptSource);
return 0;
}
void DRV_USART_BufferAddRead
(
DRV_HANDLE hClient,
DRV_USART_BUFFER_HANDLE * bufferHandle,
void * destination,
size_t nBytes
)
{
DRV_USART_CLIENT_OBJ * clientObj;
DRV_USART_OBJ * hDriver;
bool interruptWasEnabled=false;
DRV_USART_BUFFER_OBJ * bufferObj, * iterator;
DRV_USART_BUFFER_OBJECT_INDEX usartBufIndex;
/* This function adds a buffer to the read queue */
/* We first check the arguments and initialize the
buffer handle */
if(bufferHandle == NULL)
{
return;
}
*bufferHandle = DRV_USART_BUFFER_HANDLE_INVALID;
clientObj = _DRV_USART_DriverHandleValidate(hClient);
if(clientObj == NULL)
{
SYS_ASSERT(false, "Invalid driver handle");
return;
}
if((nBytes == 0) || (NULL == destination))
{
/* We either got an invalid client handle,
invalid destination pointer or 0 bytes to
transfer */
SYS_DEBUG(0, "Invalid parameters");
return;
}
hDriver = clientObj->hDriver;
if(hDriver->queueSizeCurrentRead >= hDriver->queueSizeRead)
{
/* This means the queue is full. We cannot add
* this request */
SYS_DEBUG(0, "Receive Queue is full");
return;
}
/* We will allow buffers to be added in the interrupt
* context of this USART driver. But we must make
* sure that if we are in interrupt, then we should
* not modify mutexes. */
if(hDriver->interruptNestingCount == 0)
{
/* Grab a mutex. This is okay because we are not in an
* interrupt context */
if(OSAL_MUTEX_Lock(&(hDriver->mutexDriverInstance), OSAL_WAIT_FOREVER) == OSAL_RESULT_TRUE)
{
/* We will disable interrupts so that the queue
* status does not get updated asynchronously.
* This code will always execute. */
if(SYS_DMA_CHANNEL_HANDLE_INVALID != hDriver->dmaChannelHandleRead)
{
interruptWasEnabled = _DRV_USART_InterruptSourceDisable(hDriver->dmaInterruptReceive);
}
else
{
interruptWasEnabled = _DRV_USART_InterruptSourceDisable(hDriver->rxInterruptSource);
}
}
else
{
/* The mutex acquisition timed out. Return with an
* invalid handle. This code will not execute
* if there is no RTOS. */
return;
}
}
usartBufIndex = _DRV_USART_QueueObjectIndexGet();
if (usartBufIndex != DRV_USART_BUFFER_OBJECT_INDEX_INVALID)
{
bufferObj = &gDrvUSARTBufferObj[usartBufIndex];
bufferObj->bufferHandle = _DRV_USART_DMA_MAKE_HANDLE(gDrvUSARTDMATokenCount, usartBufIndex);
*bufferHandle = bufferObj->bufferHandle;
_DRV_USART_DMA_UPDATE_BUFFER_TOKEN(gDrvUSARTDMATokenCount);
bufferObj->size = nBytes;
bufferObj->inUse = true;
bufferObj->buffer = (uint8_t*)destination;
bufferObj->hClient = clientObj;
bufferObj->next = NULL;
bufferObj->previous = NULL;
bufferObj->nCurrentBytes = 0;
bufferObj->flags = (0 | DRV_USART_BUFFER_OBJ_FLAG_BUFFER_ADD);
}
else
{
/* This means we could not find a buffer. This
will happen if the the DRV_USART_QUEUE_DEPTH_COMBINED
parameter is configured to be less */
SYS_ASSERT(false, "Insufficient Combined Queue Depth");
/* Enable the interrupt if it was enabled */
if(interruptWasEnabled)
{
if(SYS_DMA_CHANNEL_HANDLE_INVALID != hDriver->dmaChannelHandleRead)
{
_DRV_USART_InterruptSourceEnable(hDriver->dmaInterruptReceive);
}
else
{
_DRV_USART_InterruptSourceEnable(hDriver->rxInterruptSource);
}
}
/* Release mutex */
OSAL_MUTEX_Unlock(&(hDriver->mutexDriverInstance));
return;
}
/* Increment the current queue size*/
hDriver->queueSizeCurrentRead ++;
/* Check if the queue is empty */
if(hDriver->queueRead == NULL)
{
/* This is the first buffer in the queue */
hDriver->queueRead = bufferObj;
/* This is the first item in the queue. Enable RX interrupt. */
if(SYS_DMA_CHANNEL_HANDLE_INVALID != hDriver->dmaChannelHandleRead)
{
/* Since this is the first buffer in the queue Add it immediately
to DMA for processing */
size_t srcSize, cellSize;
srcSize = 1;
cellSize = 1;
SYS_DMA_ChannelTransferAdd(hDriver->dmaChannelHandleRead,
PLIB_USART_ReceiverAddressGet(hDriver->moduleId),
srcSize,bufferObj->buffer, bufferObj->size,
cellSize);
_SYS_DMA_ChannelForceStart(hDriver->dmaChannelHandleRead);
_DRV_USART_InterruptSourceEnable(hDriver->dmaInterruptReceive);
}
else
{
_DRV_USART_InterruptSourceEnable(hDriver->rxInterruptSource);
}
}
else
{
/* This means the read queue is not empty. We must add
the buffer object to the end of the queue */
iterator = hDriver->queueRead;
while(iterator->next != NULL)
{
/* Get the next buffer object */
iterator = iterator->next;
}
/* At this point, iterator will point to the
last object in the queue. We add the buffer
object to the linked list. Note that we
need to set up the previous pointer as well
because buffer should be deleted when the
client closes the driver */
iterator->next = bufferObj;
bufferObj->previous = iterator;
/* We are done. Restore the interrupt enable status
and return. */
if(interruptWasEnabled)
{
if(SYS_DMA_CHANNEL_HANDLE_INVALID != hDriver->dmaChannelHandleRead)
{
/* There is already a buffer under processing in the queue.
This buffer will be added to DMA for processing immediately
after the processing of the buffer prior to this buffer completes.
(This functionality is implemented in _DRV_USART_BufferQueueRxTasks)*/
_SYS_DMA_ChannelForceStart(hDriver->dmaChannelHandleRead);
_DRV_USART_InterruptSourceEnable(hDriver->dmaInterruptReceive);
}
else
{
_DRV_USART_InterruptSourceEnable(hDriver->rxInterruptSource);
}
}
}
/* Release mutex */
OSAL_MUTEX_Unlock(&(hDriver->mutexDriverInstance));
return;
}
