ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

SiLabs: Remove emlib LDMA modifications 

Emlib should now match the standard SiLabs release. Required extensions
have been moved to dma_api and marked with LDMAx_ prefix.
pull/1501/head
Mikko Polojarvi 2016-01-12 13:08:08 +02:00 committed by Steven Cooreman
parent cb2a653bba
commit 2ba71ea761
6 changed files with 108 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
libraries/mbed/targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/dma_api.c
View File

@ -32,6 +32,7 @@
#include "dma_api_HAL.h"
#include "em_device.h"
#include "em_cmu.h"
#include "em_int.h"
#ifdef DMA_PRESENT
#include "em_dma.h"
@ -130,3 +131,81 @@ int dma_channel_free(int channelid)
return 0;
}
#ifdef LDMA_PRESENT
/* LDMA emlib API extensions */
typedef struct {
LDMAx_CBFunc_t callback;
void *userdata;
} LDMA_InternCallback_t;
static LDMA_InternCallback_t ldmaCallback[DMA_CHAN_COUNT];
void LDMAx_StartTransfer( int ch,
LDMA_TransferCfg_t *transfer,
LDMA_Descriptor_t *descriptor,
LDMAx_CBFunc_t cbFunc,
void *userData )
{
ldmaCallback[ch].callback = cbFunc;
ldmaCallback[ch].userdata = userData;
LDMA_StartTransfer(ch, transfer, descriptor);
}
void LDMA_IRQHandler( void )
{
uint32_t pending, chnum, chmask;
/* Get all pending and enabled interrupts */
pending = LDMA->IF;
pending &= LDMA->IEN;
/* Check for LDMA error */
if ( pending & LDMA_IF_ERROR )
{
/* Loop here to enable the debugger to see what has happened */
while (1)
;
}
/* Iterate over all LDMA channels. */
for ( chnum = 0, chmask = 1;
chnum < DMA_CHAN_COUNT;
chnum++, chmask <<= 1 )
{
if ( pending & chmask )
{
/* Clear interrupt flag. */
LDMA->IFC = chmask;
/* Do more stuff here, execute callbacks etc. */
if ( ldmaCallback[chnum].callback )
{
ldmaCallback[chnum].callback(chnum, false, ldmaCallback[chnum].userdata);
}
}
}
}
/***************************************************************************//**
* @brief
* Check if LDMA channel is enabled.
*
* @param[in] ch
* LDMA channel to check.
*
* @return
* true if channel is enabled, false if not.
******************************************************************************/
bool LDMAx_ChannelEnabled( int ch )
{
EFM_ASSERT(ch < DMA_CHAN_COUNT);
uint32_t chMask = 1 << ch;
return (bool)(LDMA->CHEN & chMask);
INT_Disable();
}
#endif /* LDMA_PRESENT */

19
libraries/mbed/targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/dma_api_HAL.h
View File

@ -68,13 +68,30 @@ extern "C" {
#error "Unsupported DMA channel count (dma_api.c)."
#endif
#ifdef LDMA_PRESENT
typedef void (*LDMAx_CBFunc_t)(unsigned int channel, bool primary, void *user);
typedef struct
{
LDMAx_CBFunc_t cbFunc;
void *userPtr;
} LDMAx_Callback_t;
void LDMAx_StartTransfer( int ch,
LDMA_TransferCfg_t *transfer,
LDMA_Descriptor_t *descriptor,
LDMAx_CBFunc_t cbFunc,
void *userData );
bool LDMAx_ChannelEnabled( int ch );
#endif
typedef struct {
DMAUsage dmaUsageState;
int dmaChannel;
#ifndef LDMA_PRESENT
DMA_CB_TypeDef dmaCallback;
#else
LDMA_Callback_t dmaCallback;
LDMAx_Callback_t dmaCallback;
#endif
} DMA_OPTIONS_t;

13
libraries/mbed/targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/emlib/inc/em_ldma.h
View File

@ -434,13 +434,6 @@ typedef struct
uint8_t ldmaLoopCnt; /**< Counter for looped transfers. */
} LDMA_TransferCfg_t;
typedef void (*LDMA_CBFunc_t)(unsigned int channel, bool primary, void *user);
typedef struct
{
LDMA_CBFunc_t cbFunc;
void *userPtr;
} LDMA_Callback_t;
/*******************************************************************************
************************** STRUCT INITIALIZERS ****************************
@ -1220,13 +1213,11 @@ void LDMA_DeInit( void );
void LDMA_Init( LDMA_Init_t *init );
void LDMA_StartTransfer( int ch,
LDMA_TransferCfg_t *transfer,
LDMA_Descriptor_t *descriptor,
LDMA_CBFunc_t callback,
void *userData );
LDMA_Descriptor_t *descriptor );
void LDMA_StopTransfer( int ch );
bool LDMA_TransferDone( int ch );
uint32_t LDMA_TransferRemainingCount( int ch );
bool LDMA_ChannelEnabled( int ch );
/***************************************************************************//**
* @brief

38
libraries/mbed/targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/emlib/src/em_ldma.c
View File

@ -202,13 +202,7 @@
@endverbatim
* @{ *************************************************************************/
typedef struct {
LDMA_CBFunc_t callback;
void *userdata;
} LDMA_InternCallback_t;
static LDMA_InternCallback_t ldmaCallback[DMA_CHAN_COUNT];
#if defined( LDMA_IRQ_HANDLER_TEMPLATE )
/***************************************************************************//**
* @brief
* Template for an LDMA IRQ handler.
@ -240,13 +234,10 @@ void LDMA_IRQHandler( void )
LDMA->IFC = chmask;
/* Do more stuff here, execute callbacks etc. */
if ( ldmaCallback[chnum].callback )
{
ldmaCallback[chnum].callback(chnum, false, ldmaCallback[chnum].userdata);
}
}
}
}
#endif
/***************************************************************************//**
* @brief
@ -317,9 +308,7 @@ void LDMA_Init( LDMA_Init_t *init )
******************************************************************************/
void LDMA_StartTransfer( int ch,
LDMA_TransferCfg_t *transfer,
LDMA_Descriptor_t *descriptor,
LDMA_CBFunc_t cbFunc,
void *userData )
LDMA_Descriptor_t *descriptor )
{
uint32_t tmp;
uint32_t chMask = 1 << ch;
@ -346,9 +335,6 @@ void LDMA_StartTransfer( int ch,
EFM_ASSERT( !( ( transfer->ldmaLoopCnt << _LDMA_CH_LOOP_LOOPCNT_SHIFT )
& ~_LDMA_CH_LOOP_LOOPCNT_MASK ) );
ldmaCallback[ch].callback = cbFunc;
ldmaCallback[ch].userdata = userData;
LDMA->CH[ ch ].REQSEL = transfer->ldmaReqSel;
LDMA->CH[ ch ].LOOP =
@ -508,24 +494,6 @@ uint32_t LDMA_TransferRemainingCount( int ch )
return remaining + 1;
}
/***************************************************************************//**
* @brief
* Check if LDMA channel is enabled.
*
* @param[in] ch
* LDMA channel to check.
*
* @return
* true if channel is enabled, false if not.
******************************************************************************/
bool LDMA_ChannelEnabled( int ch )
{
EFM_ASSERT(ch < DMA_CHAN_COUNT);
uint32_t chMask = 1 << ch;
return (bool)(LDMA->CHEN & chMask);
INT_Disable();
}
/** @} (end addtogroup LDMA) */
/** @} (end addtogroup EM_Library) */
#endif /* defined( LDMA_PRESENT ) && ( LDMA_COUNT == 1 ) */

4
libraries/mbed/targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/serial_api.c
View File

@ -1388,7 +1388,7 @@ static void serial_dmaActivate(serial_t *obj, void* cb, void* buffer, int length
// Start DMA transfer
LDMA_TransferCfg_t xferConf = LDMA_TRANSFER_CFG_PERIPHERAL(dma_periph);
LDMA_Descriptor_t desc = LDMA_DESCRIPTOR_SINGLE_M2P_BYTE(buffer, target_addr, length);
LDMA_StartTransfer(obj->serial.dmaOptionsTX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete, NULL);
LDMAx_StartTransfer(obj->serial.dmaOptionsTX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete, NULL);
} else {
volatile const void *source_addr;
@ -1425,7 +1425,7 @@ static void serial_dmaActivate(serial_t *obj, void* cb, void* buffer, int length
LDMA_TransferCfg_t xferConf = LDMA_TRANSFER_CFG_PERIPHERAL(dma_periph);
LDMA_Descriptor_t desc = LDMA_DESCRIPTOR_SINGLE_P2M_BYTE(source_addr, buffer, length);
LDMA_StartTransfer(obj->serial.dmaOptionsRX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete, cb);
LDMAx_StartTransfer(obj->serial.dmaOptionsRX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete, cb);
}
}

8
libraries/mbed/targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/spi_api.c
View File

@ -444,7 +444,7 @@ uint8_t spi_active(spi_t *obj)
case DMA_USAGE_ALLOCATED:
/* Check whether the allocated DMA channel is active */
#ifdef LDMA_PRESENT
return(LDMA_ChannelEnabled(obj->spi.dmaOptionsTX.dmaChannel) || LDMA_ChannelEnabled(obj->spi.dmaOptionsRX.dmaChannel));
return(LDMAx_ChannelEnabled(obj->spi.dmaOptionsTX.dmaChannel) || LDMAx_ChannelEnabled(obj->spi.dmaOptionsRX.dmaChannel));
#else
return(DMA_ChannelEnabled(obj->spi.dmaOptionsTX.dmaChannel) || DMA_ChannelEnabled(obj->spi.dmaOptionsRX.dmaChannel));
#endif
@ -869,7 +869,7 @@ static void spi_activate_dma(spi_t *obj, void* rxdata, const void* txdata, int t
if(obj->spi.bits >= 9){
desc.xfer.size = ldmaCtrlSizeHalf;
}
LDMA_StartTransfer(obj->spi.dmaOptionsTX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete,obj->spi.dmaOptionsRX.dmaCallback.userPtr);
LDMAx_StartTransfer(obj->spi.dmaOptionsTX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete,obj->spi.dmaOptionsRX.dmaCallback.userPtr);
}
if(rxdata) {
@ -908,7 +908,7 @@ static void spi_activate_dma(spi_t *obj, void* rxdata, const void* txdata, int t
if(obj->spi.bits >= 9){
desc.xfer.size = ldmaCtrlSizeHalf;
}
LDMA_StartTransfer(obj->spi.dmaOptionsRX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete,obj->spi.dmaOptionsRX.dmaCallback.userPtr);
LDMAx_StartTransfer(obj->spi.dmaOptionsRX.dmaChannel, &xferConf, &desc, serial_dmaTransferComplete,obj->spi.dmaOptionsRX.dmaCallback.userPtr);
}
}
@ -1139,7 +1139,7 @@ uint32_t spi_irq_handler_asynch(spi_t* obj)
return 0;
}
/* If there is an RX transfer ongoing, wait for it to finish */
if (LDMA_ChannelEnabled(obj->spi.dmaOptionsRX.dmaChannel)) {
if (LDMAx_ChannelEnabled(obj->spi.dmaOptionsRX.dmaChannel)) {
/* Check if we need to kick off TX transfer again to force more incoming data. */
if (LDMA_TransferDone(obj->spi.dmaOptionsTX.dmaChannel) && (obj->tx_buff.pos < obj->rx_buff.length)) {
void* tx_pointer = (char*)obj->tx_buff.buffer + obj->tx_buff.pos;