/*
* ======== CameraCC3200DMA_configDMA ========
*/
static void CameraCC3200DMA_configDMA(Camera_Handle handle)
{
CameraCC3200DMA_Object *object = handle->object;
CameraCC3200DMA_HWAttrs const *hwAttrs = handle->hwAttrs;
unsigned long **bufferPtr = (unsigned long**)&object->captureBuf;
/* Setup ping-pong transfer */
MAP_uDMAChannelControlSet(hwAttrs->channelIndex,
UDMA_SIZE_32 | UDMA_SRC_INC_32 | UDMA_DST_INC_32 | UDMA_ARB_8);
MAP_uDMAChannelAttributeEnable(hwAttrs->channelIndex,UDMA_ATTR_USEBURST);
MAP_uDMAChannelTransferSet(hwAttrs->channelIndex, UDMA_MODE_PINGPONG,
(void *)CAM_BUFFER_ADDR, (void *)*bufferPtr,
CameraCC3200DMA_DMA_TRANSFER_SIZE);
MAP_uDMAChannelEnable(hwAttrs->channelIndex);
/* Pong Buffer */
*bufferPtr += CameraCC3200DMA_DMA_TRANSFER_SIZE;
MAP_uDMAChannelControlSet(hwAttrs->channelIndex | UDMA_ALT_SELECT,
UDMA_SIZE_32 | UDMA_SRC_INC_32 | UDMA_DST_INC_32 | UDMA_ARB_8);
MAP_uDMAChannelAttributeEnable(hwAttrs->channelIndex | UDMA_ALT_SELECT,
UDMA_ATTR_USEBURST);
MAP_uDMAChannelTransferSet(hwAttrs->channelIndex | UDMA_ALT_SELECT,
UDMA_MODE_PINGPONG,
(void *)CAM_BUFFER_ADDR,
(void *)*bufferPtr,
CameraCC3200DMA_DMA_TRANSFER_SIZE);
MAP_uDMAChannelEnable(hwAttrs->channelIndex | UDMA_ALT_SELECT);
/* Ping Buffer */
*bufferPtr += CameraCC3200DMA_DMA_TRANSFER_SIZE;
DebugP_log1("Camera:(%p) DMA transfer enabled", hwAttrs->baseAddr);
/* Set mode to Ping buffer initially */
object->cameraDMA_PingPongMode = 0;
/* Clear any pending interrupt */
MAP_CameraIntClear(hwAttrs->baseAddr, CAM_INT_DMA);
/* DMA Interrupt unmask from apps config */
MAP_CameraIntEnable(hwAttrs->baseAddr, CAM_INT_DMA);
DebugP_log3("Camera:(%p) DMA receive, "
"CaptureBuf: %p; Count: %d",
hwAttrs->baseAddr,
(uintptr_t)*bufferPtr,
(uintptr_t)object->bufferlength);
}
void ssi_udma_channel_config(unsigned int channel) {
/* Set the USEBURST attribute for the uDMA SSI TX channel. This will force the controller to always use a burst
* when transferring data from the TX buffer to the SSI. This is somewhat more effecient bus usage than the default
* which allows single or burst transfers. */
MAP_uDMAChannelAttributeEnable(channel, UDMA_ATTR_USEBURST);
/* Configure the SSI Tx µDMA Channel to transfer from RAM to TX FIFO. The arbitration size is set to 4, which
* matches the SSI TX FIFO µDMA trigger threshold. */
MAP_uDMAChannelControlSet(channel | UDMA_PRI_SELECT, UDMA_SIZE_16 | UDMA_SRC_INC_16 | UDMA_DST_INC_NONE | UDMA_ARB_1);
}
void DMASetupTransfer(unsigned long ulChannel, unsigned long ulMode,
unsigned long ulItemCount, unsigned long ulItemSize,
unsigned long ulArbSize, void *pvSrcBuf,
unsigned long ulSrcInc, void *pvDstBuf, unsigned long ulDstInc)
{
MAP_uDMAChannelControlSet(ulChannel, ulItemSize | ulSrcInc | ulDstInc | ulArbSize);
MAP_uDMAChannelAttributeEnable(ulChannel,UDMA_ATTR_USEBURST);
MAP_uDMAChannelTransferSet(ulChannel, ulMode, pvSrcBuf, pvDstBuf, ulItemCount);
MAP_uDMAChannelEnable(ulChannel);
}
/*
* ======== CameraCC3200DMA_hwiIntFxn ========
* Hwi function that processes Camera interrupts.
*
* The Frame end,DMA interrupts is enabled for the camera.
* The DMA interrupt is triggered for every 64 elements.
* The ISR will check for Frame end interrupt to trigger the callback
* in the non-blocking mode/post a semaphore in the blocking mode to
* indicate capture complete.
*
* @param(arg) The Camera_Handle for this Hwi.
*/
static void CameraCC3200DMA_hwiIntFxn(uintptr_t arg)
{
uint32_t status;
CameraCC3200DMA_Object *object = ((Camera_Handle)arg)->object;
CameraCC3200DMA_HWAttrs const *hwAttrs = ((Camera_Handle)arg)->hwAttrs;
unsigned long **bufferPtr = (unsigned long**)&object->captureBuf;
status = MAP_CameraIntStatus(hwAttrs->baseAddr);
if ((object->cameraDMAxIntrRcvd > 1) && (status & (CAM_INT_FE))) {
DebugP_log2("Camera:(%p) Interrupt with mask 0x%x",
hwAttrs->baseAddr,status);
MAP_CameraIntClear(hwAttrs->baseAddr, CAM_INT_FE);
object->captureCallback((Camera_Handle)arg, *bufferPtr,
object->frameLength);
DebugP_log2("Camera:(%p) capture finished, %d bytes written",
hwAttrs->baseAddr, object->frameLength);
object->inUse = 0;
MAP_CameraCaptureStop(hwAttrs->baseAddr, true);
Power_releaseConstraint(PowerCC3200_DISALLOW_DEEPSLEEP);
}
if (status & CAM_INT_DMA) {
// Camera DMA Done clear
MAP_CameraIntClear(hwAttrs->baseAddr, CAM_INT_DMA);
object->cameraDMAxIntrRcvd++;
object->frameLength +=
(CameraCC3200DMA_DMA_TRANSFER_SIZE*sizeof(unsigned long));
if (object->frameLength < object->bufferlength) {
if (object->cameraDMA_PingPongMode == 0) {
MAP_uDMAChannelControlSet(hwAttrs->channelIndex,
UDMA_SIZE_32 | UDMA_SRC_INC_32 | UDMA_DST_INC_32 | UDMA_ARB_8);
MAP_uDMAChannelAttributeEnable(hwAttrs->channelIndex,
UDMA_ATTR_USEBURST);
MAP_uDMAChannelTransferSet(hwAttrs->channelIndex,
UDMA_MODE_PINGPONG,
(void *)CAM_BUFFER_ADDR,
(void *)*bufferPtr,
CameraCC3200DMA_DMA_TRANSFER_SIZE);
MAP_uDMAChannelEnable(hwAttrs->channelIndex);
*bufferPtr += CameraCC3200DMA_DMA_TRANSFER_SIZE;
object->cameraDMA_PingPongMode = 1;
}
else {
MAP_uDMAChannelControlSet(hwAttrs->channelIndex | UDMA_ALT_SELECT,
UDMA_SIZE_32 | UDMA_SRC_INC_32 | UDMA_DST_INC_32 | UDMA_ARB_8);
MAP_uDMAChannelAttributeEnable(
hwAttrs->channelIndex | UDMA_ALT_SELECT,
UDMA_ATTR_USEBURST);
MAP_uDMAChannelTransferSet(
hwAttrs->channelIndex | UDMA_ALT_SELECT,
UDMA_MODE_PINGPONG,
(void *)CAM_BUFFER_ADDR, (void *)*bufferPtr,
CameraCC3200DMA_DMA_TRANSFER_SIZE);
MAP_uDMAChannelEnable(hwAttrs->channelIndex | UDMA_ALT_SELECT);
*bufferPtr += CameraCC3200DMA_DMA_TRANSFER_SIZE;
object->cameraDMA_PingPongMode = 0;
}
}
else {
// Disable DMA
MAP_UtilsDelay(20000);
MAP_uDMAChannelDisable(hwAttrs->channelIndex);
MAP_CameraIntDisable(hwAttrs->baseAddr, CAM_INT_DMA);
object->cameraDMA_PingPongMode = 0;
object->captureCallback((Camera_Handle)arg, *bufferPtr,
object->frameLength);
DebugP_log2("Camera:(%p) capture finished, %d bytes written",
hwAttrs->baseAddr, object->frameLength);
MAP_CameraCaptureStop(hwAttrs->baseAddr, true);
Power_releaseConstraint(PowerCC3200_DISALLOW_DEEPSLEEP);
}
}
}