mirror of
https://github.com/fhgwright/SCSI2SD.git
synced 2024-06-10 14:29:28 +00:00
1040 lines
35 KiB
C
Executable File
1040 lines
35 KiB
C
Executable File
/***************************************************************************//**
|
|
* \file CyDmac.c
|
|
* \version 5.50
|
|
*
|
|
* \brief
|
|
* Provides an API for the DMAC component. The API includes functions for the
|
|
* DMA controller, DMA channels and Transfer Descriptors. This API is the library
|
|
* version not the auto generated code that gets generated when the user places a
|
|
* DMA component on the schematic.
|
|
*
|
|
* The auto generated code would use the APi's in this module.
|
|
*
|
|
* \note This code is endian agnostic.
|
|
*
|
|
* \note The Transfer Descriptor memory can be used as regular memory if the
|
|
* TD's are not being used.
|
|
*
|
|
* \note This code uses the first byte of each TD to manage the free list of
|
|
* TD's. The user can overwrite this once the TD is allocated.
|
|
*
|
|
********************************************************************************
|
|
* \copyright
|
|
* Copyright 2008-2016, Cypress Semiconductor Corporation. All rights reserved.
|
|
* You may use this file only in accordance with the license, terms, conditions,
|
|
* disclaimers, and limitations in the end user license agreement accompanying
|
|
* the software package with which this file was provided.
|
|
*******************************************************************************/
|
|
|
|
#include "CyDmac.h"
|
|
|
|
|
|
/*******************************************************************************
|
|
* The following variables are initialized from CyDmacConfigure() function that
|
|
* is executed from initialize_psoc() at the early initialization stage.
|
|
* In case of IAR EW IDE, initialize_psoc() is executed before the data sections
|
|
* are initialized. To avoid zeroing, these variables should be initialized
|
|
* properly during segments initialization as well.
|
|
*******************************************************************************/
|
|
static uint8 CyDmaTdCurrentNumber = CY_DMA_NUMBEROF_TDS; /* Current Number of free elements on list */
|
|
static uint8 CyDmaTdFreeIndex = (uint8)(CY_DMA_NUMBEROF_TDS - 1u); /* Index of first available TD */
|
|
static uint32 CyDmaChannels = DMA_CHANNELS_USED__MASK0; /* Bit map of DMA channel ownership */
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmacConfigure
|
|
****************************************************************************//**
|
|
*
|
|
* Creates a linked list of all the TDs to be allocated. This function is called
|
|
* by the startup code; you do not normally need to call it. You can call this
|
|
* function if all of the DMA channels are inactive.
|
|
*
|
|
*******************************************************************************/
|
|
void CyDmacConfigure(void)
|
|
{
|
|
uint8 dmaIndex;
|
|
|
|
/* Set TD list variables. */
|
|
CyDmaTdFreeIndex = (uint8)(CY_DMA_NUMBEROF_TDS - 1u);
|
|
CyDmaTdCurrentNumber = CY_DMA_NUMBEROF_TDS;
|
|
|
|
/* Make TD free list. */
|
|
for(dmaIndex = (uint8)(CY_DMA_NUMBEROF_TDS - 1u); dmaIndex != 0u; dmaIndex--)
|
|
{
|
|
CY_DMA_TDMEM_STRUCT_PTR[dmaIndex].TD0[0u] = (uint8)(dmaIndex - 1u);
|
|
}
|
|
|
|
/* Make last one point to zero. */
|
|
CY_DMA_TDMEM_STRUCT_PTR[dmaIndex].TD0[0u] = 0u;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmacError
|
|
****************************************************************************//**
|
|
*
|
|
* Returns errors of the last failed DMA transaction.
|
|
*
|
|
* \return Errors of the last failed DMA transaction.
|
|
*
|
|
* DMAC_PERIPH_ERR:
|
|
* Set to 1 when a peripheral responds to a bus transaction with an error
|
|
* response.
|
|
*
|
|
* DMAC_UNPOP_ACC:
|
|
* Set to 1 when an access is attempted to an invalid address.
|
|
*
|
|
* DMAC_BUS_TIMEOUT:
|
|
* Set to 1 when a bus timeout occurs. Cleared by writing a 1. Timeout values
|
|
* are determined by the BUS_TIMEOUT field in the PHUBCFG register.
|
|
*
|
|
* Theory:
|
|
* Once an error occurs the error bits are sticky and are only cleared by
|
|
* writing 1 to the error register.
|
|
*
|
|
*******************************************************************************/
|
|
uint8 CyDmacError(void)
|
|
{
|
|
return((uint8)(((uint32) 0x0Eu) & *CY_DMA_ERR_PTR));
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmacClearError
|
|
****************************************************************************//**
|
|
*
|
|
* Clears the error bits in the error register of the DMAC.
|
|
*
|
|
* \param error:
|
|
* Clears the error bits in the DMAC error register.
|
|
*
|
|
* \param DMAC_PERIPH_ERR:
|
|
* Set to 1 when a peripheral responds to a bus transaction with an error
|
|
* response.
|
|
*
|
|
* \param DMAC_UNPOP_ACC:
|
|
* Set to 1 when an access is attempted to an invalid address.
|
|
*
|
|
* \param DMAC_BUS_TIMEOUT:
|
|
* Set to 1 when a bus timeout occurs. Cleared by writing 1. Timeout values
|
|
* are determined by the BUS_TIMEOUT field in the PHUBCFG register.
|
|
*
|
|
* Theory:
|
|
* Once an error occurs the error bits are sticky and are only cleared by
|
|
* writing 1 to the error register.
|
|
*
|
|
*******************************************************************************/
|
|
void CyDmacClearError(uint8 error)
|
|
{
|
|
*CY_DMA_ERR_PTR = (((uint32)0x0Fu) & ((uint32)error));
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmacErrorAddress
|
|
****************************************************************************//**
|
|
*
|
|
* When DMAC_BUS_TIMEOUT, DMAC_UNPOP_ACC, and DMAC_PERIPH_ERR occur the
|
|
* address of the error is written to the error address register and can be read
|
|
* with this function.
|
|
*
|
|
* If there are multiple errors, only the address of the first is saved.
|
|
*
|
|
* \return The address that caused the error.
|
|
*
|
|
*******************************************************************************/
|
|
uint32 CyDmacErrorAddress(void)
|
|
{
|
|
return(CY_GET_REG32(CY_DMA_ERR_ADR_PTR));
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChAlloc
|
|
****************************************************************************//**
|
|
*
|
|
* Allocates a channel from the DMAC to be used in all functions that require a
|
|
* channel handle.
|
|
*
|
|
* \return The allocated channel number. Zero is a valid channel number.
|
|
* DMA_INVALID_CHANNEL is returned if there are no channels available.
|
|
*
|
|
*******************************************************************************/
|
|
uint8 CyDmaChAlloc(void)
|
|
{
|
|
uint8 interruptState;
|
|
uint8 dmaIndex;
|
|
uint32 channel = 1u;
|
|
|
|
|
|
/* Enter critical section! */
|
|
interruptState = CyEnterCriticalSection();
|
|
|
|
/* Look for free channel. */
|
|
for(dmaIndex = 0u; dmaIndex < CY_DMA_NUMBEROF_CHANNELS; dmaIndex++)
|
|
{
|
|
if(0uL == (CyDmaChannels & channel))
|
|
{
|
|
/* Mark channel as used. */
|
|
CyDmaChannels |= channel;
|
|
break;
|
|
}
|
|
|
|
channel <<= 1u;
|
|
}
|
|
|
|
if(dmaIndex >= CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
dmaIndex = CY_DMA_INVALID_CHANNEL;
|
|
}
|
|
|
|
/* Exit critical section! */
|
|
CyExitCriticalSection(interruptState);
|
|
|
|
return(dmaIndex);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChFree
|
|
****************************************************************************//**
|
|
*
|
|
* Frees a channel allocated by \ref DmaChAlloc().
|
|
*
|
|
* \param chHandle The handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChFree(uint8 chHandle)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
uint8 interruptState;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
/* Enter critical section */
|
|
interruptState = CyEnterCriticalSection();
|
|
|
|
/* Clear bit mask that keeps track of ownership. */
|
|
CyDmaChannels &= ~(((uint32) 1u) << chHandle);
|
|
|
|
/* Exit critical section */
|
|
CyExitCriticalSection(interruptState);
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChEnable
|
|
****************************************************************************//**
|
|
*
|
|
* Enables the DMA channel. A software or hardware request still must happen
|
|
* before the channel is executed.
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \param preserveTds Preserves the original TD state when the TD has completed.
|
|
* This parameter applies to all TDs in the channel.
|
|
*
|
|
* 0 - When TD is completed, the DMAC leaves the TD configuration values in
|
|
* their current state, and does not restore them to their original state.
|
|
*
|
|
* 1 - When TD is completed, the DMAC restores the original configuration
|
|
* values of the TD.
|
|
*
|
|
* When preserveTds is set, the TD slot that equals the channel number becomes
|
|
* RESERVED and that becomes where the working registers exist. So, for example,
|
|
* if you are using CH06 and preserveTds is set, you are not allowed to use TD
|
|
* slot 6. That is reclaimed by the DMA engine for its private use.
|
|
*
|
|
* \note Do not chain back to a completed TD if the preserveTds for the channel
|
|
* is set to 0. When a TD has completed preserveTds for the channel set to 0,
|
|
* the transfer count will be at 0. If a TD with a transfer count of 0 is
|
|
* started, the TD will transfer an indefinite amount of data.
|
|
*
|
|
* Take extra precautions when using the hardware request (DRQ) option when the
|
|
* preserveTds is set to 0, as you might be requesting the wrong data.
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChEnable(uint8 chHandle, uint8 preserveTds)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
if (0u != preserveTds)
|
|
{
|
|
/* Store intermediate TD states separately in CHn_SEP_TD0/1 to
|
|
* preserve original TD chain
|
|
*/
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0u] |= CY_DMA_CH_BASIC_CFG_WORK_SEP;
|
|
}
|
|
else
|
|
{
|
|
/* Store intermediate and final TD states on top of original TD chain */
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0u] &= (uint8)(~CY_DMA_CH_BASIC_CFG_WORK_SEP);
|
|
}
|
|
|
|
/* Enable channel */
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0u] |= CY_DMA_CH_BASIC_CFG_EN;
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChDisable
|
|
****************************************************************************//**
|
|
*
|
|
* Disables the DMA channel. Once this function is called, CyDmaChStatus() may
|
|
* be called to determine when the channel is disabled and which TDs were being
|
|
* executed.
|
|
*
|
|
* If it is currently executing it will allow the current burst to finish
|
|
* naturally.
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChDisable(uint8 chHandle)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
/***********************************************************************
|
|
* Should not change configuration information of a DMA channel when it
|
|
* is active (or vulnerable to becoming active).
|
|
***********************************************************************/
|
|
|
|
/* Disable channel */
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0] &= ((uint8) (~CY_DMA_CH_BASIC_CFG_EN));
|
|
|
|
/* Store intermediate and final TD states on top of original TD chain */
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0] &= ((uint8) (~CY_DMA_CH_BASIC_CFG_WORK_SEP));
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaClearPendingDrq
|
|
****************************************************************************//**
|
|
*
|
|
* Clears pending the DMA data request.
|
|
*
|
|
* \param chHandle Handle to the dma channel.
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaClearPendingDrq(uint8 chHandle)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].action[0] |= CY_DMA_CPU_TERM_CHAIN;
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0] |= 0x01u;
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChPriority
|
|
****************************************************************************//**
|
|
*
|
|
* Sets the priority of a DMA channel. You can use this function when you want
|
|
* to change the priority at run time. If the priority remains the same for a
|
|
* DMA channel, then you can configure the priority in the .cydwr file.
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \param priority Priority to set the channel to, 0 - 7.
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChPriority(uint8 chHandle, uint8 priority)
|
|
{
|
|
uint8 value;
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
value = CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0u] & ((uint8)(~(0x0Eu)));
|
|
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0u] = value | ((uint8) ((priority & 0x7u) << 0x01u));
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChSetExtendedAddress
|
|
****************************************************************************//**
|
|
*
|
|
* Sets the high 16 bits of the source and destination addresses for the DMA
|
|
* channel (valid for all TDs in the chain).
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \param source Upper 16 bit address of the DMA transfer source.
|
|
*
|
|
* \param destination Upper 16 bit address of the DMA transfer destination.
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChSetExtendedAddress(uint8 chHandle, uint16 source, uint16 destination) \
|
|
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
reg16 *convert;
|
|
|
|
#if(CY_PSOC5)
|
|
|
|
/* 0x1FFF8000-0x1FFFFFFF needs to use alias at 0x20008000-0x2000FFFF */
|
|
if(source == 0x1FFFu)
|
|
{
|
|
source = 0x2000u;
|
|
}
|
|
|
|
if(destination == 0x1FFFu)
|
|
{
|
|
destination = 0x2000u;
|
|
}
|
|
|
|
#endif /* (CY_PSOC5) */
|
|
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
/* Set source address */
|
|
convert = (reg16 *) &CY_DMA_CFGMEM_STRUCT_PTR[chHandle].CFG1[0];
|
|
CY_SET_REG16(convert, source);
|
|
|
|
/* Set destination address */
|
|
convert = (reg16 *) &CY_DMA_CFGMEM_STRUCT_PTR[chHandle].CFG1[2u];
|
|
CY_SET_REG16(convert, destination);
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChSetInitialTd
|
|
****************************************************************************//**
|
|
*
|
|
* Sets the initial TD to be executed for the channel when the \ref CyDmaChEnable()
|
|
* function is called.
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or
|
|
* \ref DMA_DmaInitialize().
|
|
*
|
|
* \param startTd Set the TD index as the first TD associated with the
|
|
* channel. Zero is a valid TD index.
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChSetInitialTd(uint8 chHandle, uint8 startTd)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_status[1u] = startTd;
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChSetRequest
|
|
****************************************************************************//**
|
|
*
|
|
* Allows the caller to terminate a chain of TDs, terminate one TD, or create a
|
|
* direct request to start the DMA channel.
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \param request One of the following constants. Each of the constants is a
|
|
* three-bit value.
|
|
* CPU_REQ - Create a direct request to start the DMA channel
|
|
* CPU_TERM_TD - Terminate one TD
|
|
* CPU_TERM_CHAIN - Terminate a chain of TDs
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChSetRequest(uint8 chHandle, uint8 request)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].action[0u] |= (request & (CPU_REQ | CPU_TERM_TD | CPU_TERM_CHAIN));
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChGetRequest
|
|
****************************************************************************//**
|
|
*
|
|
* This function allows the caller of \ref CyDmaChSetRequest() to determine if the
|
|
* request was completed.
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \return Returns a three-bit field, corresponding to the three bits of the
|
|
* request, which describes the state of the previously posted request. If the
|
|
* value is zero, the request was completed. CY_DMA_INVALID_CHANNEL if the handle
|
|
* is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChGetRequest(uint8 chHandle)
|
|
{
|
|
cystatus status = CY_DMA_INVALID_CHANNEL;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
status = (cystatus) ((uint32)CY_DMA_CH_STRUCT_PTR[chHandle].action[0u] &
|
|
(uint32)(CY_DMA_CPU_REQ | CY_DMA_CPU_TERM_TD | CY_DMA_CPU_TERM_CHAIN));
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChStatus
|
|
****************************************************************************//**
|
|
*
|
|
* Determines the status of the DMA channel.
|
|
*
|
|
* \param chHandle A handle previously returned by \ref CyDmaChAlloc() or \ref
|
|
* DMA_DmaInitalize().
|
|
*
|
|
* \param currentTd The address to store the index of the current TD. Can be NULL
|
|
* if the value is not needed.
|
|
*
|
|
* \param state The address to store the state of the channel. Can be NULL if the
|
|
* value is not needed.
|
|
*
|
|
* STATUS_TD_ACTIVE
|
|
* \param 0: Channel is not currently being serviced by DMAC
|
|
* \param 1: Channel is currently being serviced by DMAC
|
|
*
|
|
* STATUS_CHAIN_ACTIVE
|
|
* \param 0: TD chain is inactive; either no DMA requests have triggered a new chain
|
|
* or the previous chain has completed.
|
|
* \param 1: TD chain has been triggered by a DMA request
|
|
*
|
|
* \return CYRET_SUCCESS if successful.
|
|
* \return CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
* Theory:
|
|
* The caller can check on the activity of the Current TD and the Chain.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChStatus(uint8 chHandle, uint8 * currentTd, uint8 * state)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
if(NULL != currentTd)
|
|
{
|
|
*currentTd = CY_DMA_CH_STRUCT_PTR[chHandle].basic_status[1] & 0x7Fu;
|
|
}
|
|
|
|
if(NULL != state)
|
|
{
|
|
*state= CY_DMA_CH_STRUCT_PTR[chHandle].basic_status[0];
|
|
}
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChSetConfiguration
|
|
****************************************************************************//**
|
|
*
|
|
* Sets configuration information of the channel.
|
|
*
|
|
* \param uint8 chHandle:
|
|
* A handle previously returned by CyDmaChAlloc() or DMA_DmaInitialize().
|
|
*
|
|
* \param uint8 burstCount:
|
|
* Specifies the size of bursts (1 to 127) the data transfer should be divided
|
|
* into. If this value is zero then the whole transfer is done in one burst.
|
|
*
|
|
* \param uint8 requestPerBurst:
|
|
* The whole of the data can be split into multiple bursts, if this is
|
|
* \param required to complete the transaction:
|
|
* \param 0: All subsequent bursts after the first burst will be automatically
|
|
* requested and carried out
|
|
* \param 1: All subsequent bursts after the first burst must also be individually
|
|
* requested.
|
|
*
|
|
* \param uint8 tdDone0:
|
|
* Selects one of the TERMOUT0 interrupt lines to signal completion. The line
|
|
* connected to the nrq terminal will determine the TERMOUT0_SEL definition and
|
|
* should be used as supplied by cyfitter.h
|
|
*
|
|
* \param uint8 tdDone1:
|
|
* Selects one of the TERMOUT1 interrupt lines to signal completion. The line
|
|
* connected to the nrq terminal will determine the TERMOUT1_SEL definition and
|
|
* should be used as supplied by cyfitter.h
|
|
*
|
|
* \param uint8 tdStop:
|
|
* Selects one of the TERMIN interrupt lines to signal to the DMAC that the TD
|
|
* should terminate. The signal connected to the trq terminal will determine
|
|
* which TERMIN (termination request) is used.
|
|
*
|
|
* \return
|
|
* CYRET_SUCCESS if successful.
|
|
* CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChSetConfiguration(uint8 chHandle, uint8 burstCount, uint8 requestPerBurst,
|
|
uint8 tdDone0, uint8 tdDone1, uint8 tdStop)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
CY_DMA_CFGMEM_STRUCT_PTR[chHandle].CFG0[0] = (burstCount & 0x7Fu) | ((uint8)((requestPerBurst & 0x1u) << 7u));
|
|
CY_DMA_CFGMEM_STRUCT_PTR[chHandle].CFG0[1] = ((uint8)((tdDone1 & 0xFu) << 4u)) | (tdDone0 & 0xFu);
|
|
CY_DMA_CFGMEM_STRUCT_PTR[chHandle].CFG0[2] = 0x0Fu & tdStop;
|
|
CY_DMA_CFGMEM_STRUCT_PTR[chHandle].CFG0[3] = 0u; /* burstcount_remain. */
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaTdAllocate
|
|
****************************************************************************//**
|
|
*
|
|
* Allocates a TD for use with an allocated DMA channel.
|
|
*
|
|
* \return
|
|
* Zero-based index of the TD to be used by the caller. Since there are 128 TDs
|
|
* minus the reserved TDs (0 to 23), the value returned would range from 24 to
|
|
* 127 not 24 to 128. DMA_INVALID_TD is returned if there are no free TDs
|
|
* available.
|
|
*
|
|
*******************************************************************************/
|
|
uint8 CyDmaTdAllocate(void)
|
|
{
|
|
uint8 interruptState;
|
|
uint8 element = CY_DMA_INVALID_TD;
|
|
|
|
/* Enter critical section! */
|
|
interruptState = CyEnterCriticalSection();
|
|
|
|
if(CyDmaTdCurrentNumber > NUMBEROF_CHANNELS)
|
|
{
|
|
/* Get pointer to Next available. */
|
|
element = CyDmaTdFreeIndex;
|
|
|
|
/* Decrement the count. */
|
|
CyDmaTdCurrentNumber--;
|
|
|
|
/* Update next available pointer. */
|
|
CyDmaTdFreeIndex = CY_DMA_TDMEM_STRUCT_PTR[element].TD0[0];
|
|
}
|
|
|
|
/* Exit critical section! */
|
|
CyExitCriticalSection(interruptState);
|
|
|
|
return(element);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaTdFree
|
|
****************************************************************************//**
|
|
*
|
|
* Returns a TD to the free list.
|
|
*
|
|
* \param uint8 tdHandle:
|
|
* The TD handle returned by the CyDmaTdAllocate().
|
|
*
|
|
*******************************************************************************/
|
|
void CyDmaTdFree(uint8 tdHandle)
|
|
{
|
|
if(tdHandle < CY_DMA_NUMBEROF_TDS)
|
|
{
|
|
/* Enter critical section! */
|
|
uint8 interruptState = CyEnterCriticalSection();
|
|
|
|
/* Get pointer to Next available. */
|
|
CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[0u] = CyDmaTdFreeIndex;
|
|
|
|
/* Set new Next Available. */
|
|
CyDmaTdFreeIndex = tdHandle;
|
|
|
|
/* Keep track of how many left. */
|
|
CyDmaTdCurrentNumber++;
|
|
|
|
/* Exit critical section! */
|
|
CyExitCriticalSection(interruptState);
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaTdFreeCount
|
|
****************************************************************************//**
|
|
*
|
|
* Returns the number of free TDs available to be allocated.
|
|
*
|
|
* \return
|
|
* The number of free TDs.
|
|
*
|
|
*******************************************************************************/
|
|
uint8 CyDmaTdFreeCount(void)
|
|
{
|
|
return(CyDmaTdCurrentNumber - CY_DMA_NUMBEROF_CHANNELS);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaTdSetConfiguration
|
|
****************************************************************************//**
|
|
*
|
|
* Configures the TD.
|
|
*
|
|
* \param uint8 tdHandle:
|
|
* A handle previously returned by CyDmaTdAlloc().
|
|
*
|
|
* \param uint16 transferCount:
|
|
* The size of the data transfer (in bytes) for this TD. A size of zero will
|
|
* cause the transfer to continue indefinitely. This parameter is limited to
|
|
* 4095 bytes; the TD is not initialized at all when a higher value is passed.
|
|
*
|
|
* \param uint8 nextTd:
|
|
* Zero based index of the next Transfer Descriptor in the TD chain. Zero is a
|
|
* valid pointer to the next TD; DMA_END_CHAIN_TD is the end of the chain.
|
|
* DMA_DISABLE_TD indicates an end to the chain and the DMA is disabled. No
|
|
* further TDs are fetched. DMA_DISABLE_TD is only supported on PSoC3 and
|
|
* PSoC 5LP silicons.
|
|
*
|
|
* \param uint8 configuration:
|
|
* Stores the Bit field of configuration bits.
|
|
*
|
|
* CY_DMA_TD_SWAP_EN - Perform endian swap
|
|
*
|
|
* CY_DMA_TD_SWAP_SIZE4 - Swap size = 4 bytes
|
|
*
|
|
* CY_DMA_TD_AUTO_EXEC_NEXT - The next TD in the chain will trigger
|
|
* automatically when the current TD completes.
|
|
*
|
|
* CY_DMA_TD_TERMIN_EN - Terminate this TD if a positive edge on the trq
|
|
* input line occurs. The positive edge must occur
|
|
* during a burst. That is the only time the DMAC
|
|
* will listen for it.
|
|
*
|
|
* DMA__TD_TERMOUT_EN - When this TD completes, the TERMOUT signal will
|
|
* generate a pulse. Note that this option is
|
|
* instance specific with the instance name followed
|
|
* by two underscores. In this example, the instance
|
|
* name is DMA.
|
|
*
|
|
* CY_DMA_TD_INC_DST_ADR - Increment DST_ADR according to the size of each
|
|
* data transaction in the burst.
|
|
*
|
|
* CY_DMA_TD_INC_SRC_ADR - Increment SRC_ADR according to the size of each
|
|
* data transaction in the burst.
|
|
*
|
|
* \return
|
|
* CYRET_SUCCESS if successful.
|
|
* CYRET_BAD_PARAM if tdHandle or transferCount is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaTdSetConfiguration(uint8 tdHandle, uint16 transferCount, uint8 nextTd, uint8 configuration) \
|
|
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if((tdHandle < CY_DMA_NUMBEROF_TDS) && (0u == (0xF000u & transferCount)))
|
|
{
|
|
/* Set 12 bits transfer count. */
|
|
reg16 *convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[0u];
|
|
CY_SET_REG16(convert, transferCount);
|
|
|
|
/* Set Next TD pointer. */
|
|
CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[2u] = nextTd;
|
|
|
|
/* Configure the TD */
|
|
CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[3u] = configuration;
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaTdGetConfiguration
|
|
****************************************************************************//**
|
|
*
|
|
* Retrieves the configuration of the TD. If a NULL pointer is passed as a
|
|
* parameter, that parameter is skipped. You may request only the values you are
|
|
* interested in.
|
|
*
|
|
* \param uint8 tdHandle:
|
|
* A handle previously returned by CyDmaTdAlloc().
|
|
*
|
|
* \param uint16 * transferCount:
|
|
* The address to store the size of the data transfer (in bytes) for this TD.
|
|
* A size of zero could indicate that the TD has completed its transfer, or
|
|
* that the TD is doing an indefinite transfer.
|
|
*
|
|
* \param uint8 * nextTd:
|
|
* The address to store the index of the next TD in the TD chain.
|
|
*
|
|
* \param uint8 * configuration:
|
|
* The address to store the Bit field of configuration bits.
|
|
* See CyDmaTdSetConfiguration() function description.
|
|
*
|
|
* \return
|
|
* CYRET_SUCCESS if successful.
|
|
* CYRET_BAD_PARAM if tdHandle is invalid.
|
|
*
|
|
* \sideeffect
|
|
* If TD has a transfer count of N and is executed, the transfer count becomes
|
|
* 0. If it is reexecuted, the Transfer count of zero will be interpreted as a
|
|
* request for indefinite transfer. Be careful when requesting TD with a
|
|
* transfer count of zero.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaTdGetConfiguration(uint8 tdHandle, uint16 * transferCount, uint8 * nextTd, uint8 * configuration) \
|
|
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(tdHandle < CY_DMA_NUMBEROF_TDS)
|
|
{
|
|
/* If we have pointer */
|
|
if(NULL != transferCount)
|
|
{
|
|
/* Get 12 bits of transfer count */
|
|
reg16 *convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[0];
|
|
*transferCount = 0x0FFFu & CY_GET_REG16(convert);
|
|
}
|
|
|
|
/* If we have pointer */
|
|
if(NULL != nextTd)
|
|
{
|
|
/* Get Next TD pointer */
|
|
*nextTd = CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[2u];
|
|
}
|
|
|
|
/* If we have pointer */
|
|
if(NULL != configuration)
|
|
{
|
|
/* Get configuration TD */
|
|
*configuration = CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD0[3u];
|
|
}
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaTdSetAddress
|
|
****************************************************************************//**
|
|
*
|
|
* Sets the lower 16 bits of the source and destination addresses for this TD
|
|
* only.
|
|
*
|
|
* \param uint8 tdHandle:
|
|
* A handle previously returned by CyDmaTdAlloc().
|
|
*
|
|
* \param uint16 source:
|
|
* The lower 16 address bits of the source of the data transfer.
|
|
*
|
|
* \param uint16 destination:
|
|
* The lower 16 address bits of the destination of the data transfer.
|
|
*
|
|
* \return
|
|
* CYRET_SUCCESS if successful.
|
|
* CYRET_BAD_PARAM if tdHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaTdSetAddress(uint8 tdHandle, uint16 source, uint16 destination)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
reg16 *convert;
|
|
|
|
if(tdHandle < CY_DMA_NUMBEROF_TDS)
|
|
{
|
|
/* Set source address */
|
|
convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD1[0u];
|
|
CY_SET_REG16(convert, source);
|
|
|
|
/* Set destination address */
|
|
convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD1[2u];
|
|
CY_SET_REG16(convert, destination);
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaTdGetAddress
|
|
****************************************************************************//**
|
|
*
|
|
* Retrieves the lower 16 bits of the source and/or destination addresses for
|
|
* this TD only. If NULL is passed for a pointer parameter, that value is
|
|
* skipped. You may request only the values of interest.
|
|
*
|
|
* \param uint8 tdHandle:
|
|
* A handle previously returned by CyDmaTdAlloc().
|
|
*
|
|
* \param uint16 * source:
|
|
* The address to store the lower 16 address bits of the source of the data
|
|
* transfer.
|
|
*
|
|
* \param uint16 * destination:
|
|
* The address to store the lower 16 address bits of the destination of the
|
|
* data transfer.
|
|
*
|
|
* \return
|
|
* CYRET_SUCCESS if successful.
|
|
* CYRET_BAD_PARAM if tdHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaTdGetAddress(uint8 tdHandle, uint16 * source, uint16 * destination)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
reg16 *convert;
|
|
|
|
if(tdHandle < CY_DMA_NUMBEROF_TDS)
|
|
{
|
|
/* If we have a pointer. */
|
|
if(NULL != source)
|
|
{
|
|
/* Get source address */
|
|
convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD1[0u];
|
|
*source = CY_GET_REG16(convert);
|
|
}
|
|
|
|
/* If we have a pointer. */
|
|
if(NULL != destination)
|
|
{
|
|
/* Get Destination address. */
|
|
convert = (reg16 *) &CY_DMA_TDMEM_STRUCT_PTR[tdHandle].TD1[2u];
|
|
*destination = CY_GET_REG16(convert);
|
|
}
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* Function Name: CyDmaChRoundRobin
|
|
****************************************************************************//**
|
|
*
|
|
* Either enables or disables the Round-Robin scheduling enforcement algorithm.
|
|
* Within a priority level a Round-Robin fairness algorithm is enforced.
|
|
*
|
|
* \param uint8 chHandle:
|
|
* A handle previously returned by CyDmaChAlloc() or Dma_DmaInitialize().
|
|
*
|
|
* \param uint8 enableRR:
|
|
* \param 0: Disable Round-Robin fairness algorithm
|
|
* \param 1: Enable Round-Robin fairness algorithm
|
|
*
|
|
* \return
|
|
* CYRET_SUCCESS if successful.
|
|
* CYRET_BAD_PARAM if chHandle is invalid.
|
|
*
|
|
*******************************************************************************/
|
|
cystatus CyDmaChRoundRobin(uint8 chHandle, uint8 enableRR)
|
|
{
|
|
cystatus status = CYRET_BAD_PARAM;
|
|
|
|
if(chHandle < CY_DMA_NUMBEROF_CHANNELS)
|
|
{
|
|
if (0u != enableRR)
|
|
{
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0u] |= (uint8)CY_DMA_ROUND_ROBIN_ENABLE;
|
|
}
|
|
else
|
|
{
|
|
CY_DMA_CH_STRUCT_PTR[chHandle].basic_cfg[0u] &= (uint8)(~CY_DMA_ROUND_ROBIN_ENABLE);
|
|
}
|
|
|
|
status = CYRET_SUCCESS;
|
|
}
|
|
|
|
return(status);
|
|
}
|
|
|
|
|
|
/* [] END OF FILE */
|