RF Core

Data Structures
struct	rfTrim_t

Functions
static void	RFCClockEnable (void)
	Enable the RF core clocks. More...
static void	RFCClockDisable (void)
	Disable the RF core clocks. More...
static void	RFCCpeIntClear (uint32_t ui32Mask)
	Clear HW interrupt flags. More...
static void	RFCHwIntClear (uint32_t ui32Mask)
	Clear CPE interrupt flags. More...
static void	RFCCpe0IntSelect (uint32_t ui32Mask)
	Select interrupt sources to CPE0 (assign to INT_RFC_CPE_0 interrupt vector). More...
static void	RFCCpe1IntSelect (uint32_t ui32Mask)
	Select interrupt sources to CPE1 (assign to INT_RFC_CPE_1 interrupt vector). More...
static void	RFCCpeIntEnable (uint32_t ui32Mask)
	Enable CPEx interrupt sources. More...
static void	RFCCpe0IntSelectClearEnable (uint32_t ui32Mask)
	Select, clear, and enable interrupt sources to CPE0. More...
static void	RFCCpe1IntSelectClearEnable (uint32_t ui32Mask)
	Select, clear, and enable interrupt sources to CPE1. More...
static void	RFCHwIntEnable (uint32_t ui32Mask)
	Enable HW interrupt sources. More...
static void	RFCCpeIntDisable (uint32_t ui32Mask)
	Disable CPE interrupt sources. More...
static void	RFCHwIntDisable (uint32_t ui32Mask)
	Disable HW interrupt sources. More...
uint32_t	RFCCpeIntGetAndClear (uint32_t ui32Mask)
	Get and clear CPE interrupt flags. More...
static void	RFCAckIntClear (void)
	Clear ACK interrupt flag. More...
uint32_t	RFCDoorbellSendTo (uint32_t pOp)
	Send a radio operation to the doorbell and wait for an acknowledgment. More...
void	RFCSynthPowerDown (void)
	This function implements a fast way to turn off the synthesizer. More...
void	RFCCpePatchReset (void)
	Reset previously patched CPE RAM to a state where it can be patched again. More...
uint8_t	RFCOverrideSearch (const uint32_t *pOverride, const uint32_t pattern, const uint32_t mask, const uint8_t searchDepth)
uint8_t	RFCOverrideUpdate (rfc_radioOp_t *pOpSetup, uint32_t *pParams)
	Function to update override list. More...
uint32_t	RFCHwIntGetAndClear (uint32_t ui32Mask)
	Get and clear HW interrupt flags. More...
void	RFCRfTrimRead (rfc_radioOp_t *pOpSetup, rfTrim_t *rfTrim)
	Get the type of currently selected PA. More...
void	RFCRfTrimSet (rfTrim_t *rfTrim)
	Write preloaded RF trim values directly into CPE. More...
uint8_t	RFCRTrim (rfc_radioOp_t *pOpSetup)
	Check Override RTrim vs FCFG RTrim. More...
void	RFCAdi3VcoLdoVoltageMode (bool bEnable)
	Function to set VCOLDO reference to voltage mode. More...

Detailed Description

Function Documentation

static void RFCAckIntClear ( void  )

inlinestatic

Clear ACK interrupt flag.

Referenced by RFCDoorbellSendTo().

{
    // Clear any pending interrupts.
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG) = 0x0;
}

void RFCAdi3VcoLdoVoltageMode

(

bool

bEnable

)

Function to set VCOLDO reference to voltage mode.

{
    // Function is left blank for compatibility reasons.
}

static void RFCClockDisable ( void  )

inlinestatic

Disable the RF core clocks.

As soon as the RF core is started it will handle clock control autonomously. No check should be performed to check the clocks. Instead the radio can be ping'ed through the command interface.

When disabling clocks it is the programmers responsibility that the RF core clocks are safely gated. I.e. the RF core should be safely 'parked'.

Returns

None

{
    // Disable all clocks
    HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) = 0x0;
}

static void RFCClockEnable ( void  )

inlinestatic

Enable the RF core clocks.

As soon as the RF core is started it will handle clock control autonomously. No check should be performed to check the clocks. Instead the radio can be ping'ed through the command interface.

Returns

None

{
    // Enable basic clocks to get the CPE run
    HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) = RFC_PWR_PWMCLKEN_CPERAM
                                                    | RFC_PWR_PWMCLKEN_CPE
                                                    | RFC_PWR_PWMCLKEN_RFC;
}

static void RFCCpe0IntSelect ( uint32_t  ui32Mask )

inlinestatic

Select interrupt sources to CPE0 (assign to INT_RFC_CPE_0 interrupt vector).

Referenced by RFCCpe0IntSelectClearEnable().

{
    // Multiplex RF Core interrupts to CPE0 IRQ.
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEISL) &= ~ui32Mask;
}

static void RFCCpe0IntSelectClearEnable ( uint32_t  ui32Mask )

inlinestatic

Select, clear, and enable interrupt sources to CPE0.

{
    // Multiplex RF Core interrupts to CPE0 IRQ.
    RFCCpe0IntSelect(ui32Mask);

    // Clear the masked interrupts.
    RFCCpeIntClear(ui32Mask);

    // Enable the masked interrupts.
    RFCCpeIntEnable(ui32Mask);
}

Here is the call graph for this function:

static void RFCCpe1IntSelect ( uint32_t  ui32Mask )

inlinestatic

Select interrupt sources to CPE1 (assign to INT_RFC_CPE_1 interrupt vector).

Referenced by RFCCpe1IntSelectClearEnable().

{
    // Multiplex RF Core interrupts to CPE1 IRQ.
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEISL) |= ui32Mask;
}

static void RFCCpe1IntSelectClearEnable ( uint32_t  ui32Mask )

inlinestatic

Select, clear, and enable interrupt sources to CPE1.

{
    // Multiplex RF Core interrupts to CPE1 IRQ.
    RFCCpe1IntSelect(ui32Mask);

    // Clear the masked interrupts.
    RFCCpeIntClear(ui32Mask);

    // Enable the masked interrupts.
    RFCCpeIntEnable(ui32Mask);
}

Here is the call graph for this function:

static void RFCCpeIntClear ( uint32_t  ui32Mask )

inlinestatic

Clear HW interrupt flags.

Referenced by RFCCpe0IntSelectClearEnable(), RFCCpe1IntSelectClearEnable(), and RFCCpeIntGetAndClear().

{
    // Clear the masked pending interrupts.
    do
    {
        HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIFG) = ~ui32Mask;
    }while(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIFG) & ui32Mask);
}

static void RFCCpeIntDisable ( uint32_t  ui32Mask )

inlinestatic

Disable CPE interrupt sources.

{
    // Disable the masked interrupts
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIEN) &= ~ui32Mask;
}

static void RFCCpeIntEnable ( uint32_t  ui32Mask )

inlinestatic

Enable CPEx interrupt sources.

Referenced by RFCCpe0IntSelectClearEnable(), and RFCCpe1IntSelectClearEnable().

{
    // Enable CPE interrupts from RF Core.
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIEN) |= ui32Mask;
}

uint32_t RFCCpeIntGetAndClear

(

uint32_t

ui32Mask

)

Get and clear CPE interrupt flags.

{
    // Read the CPE interrupt flags which match the provided bitmask
    uint32_t ui32Ifg = HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIFG) & ui32Mask;

    // Clear the interrupt flags
    RFCCpeIntClear(ui32Ifg);

    // Return with the interrupt flags
    return (ui32Ifg);
}

Here is the call graph for this function:

void RFCCpePatchReset

(

void

)

Reset previously patched CPE RAM to a state where it can be patched again.

{
    uint8_t *pPatchTab  = (uint8_t *) (_CPERAM_START + _PARSER_PATCH_TAB_OFFSET);
    uint32_t *pIrqPatch = (uint32_t *)(_CPERAM_START + _IRQPATCH_OFFSET);

    memset(pPatchTab, 0xFF, _IRQPATCH_OFFSET - _PARSER_PATCH_TAB_OFFSET);

    int i;
    for (i = 0; i < sizeof(rfc_defaultIrqAddr)/sizeof(rfc_defaultIrqAddr[0]); i++)
    {
        pIrqPatch[i * 2 + 1] = rfc_defaultIrqAddr[i];
    }

}

uint32_t RFCDoorbellSendTo

(

uint32_t

pOp

)

Send a radio operation to the doorbell and wait for an acknowledgment.

{
    // Wait until the doorbell becomes available
    while(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) != 0);
    RFCAckIntClear();

    // Submit the command to the CM0 through the doorbell
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) = pOp;

    // Wait until the CM0 starts to parse the command
    while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
    RFCAckIntClear();

    // Return with the content of status register
    return(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDSTA));
}

Here is the call graph for this function:

static void RFCHwIntClear ( uint32_t  ui32Mask )

inlinestatic

Clear CPE interrupt flags.

Referenced by RFCHwIntGetAndClear().

{
    // Clear the masked pending interrupts.
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFHWIFG) = ~ui32Mask;
}

static void RFCHwIntDisable ( uint32_t  ui32Mask )

inlinestatic

Disable HW interrupt sources.

{
    // Disable the masked interrupts
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFHWIEN) &= ~ui32Mask;
}

static void RFCHwIntEnable ( uint32_t  ui32Mask )

inlinestatic

Enable HW interrupt sources.

{
    // Enable the masked interrupts
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFHWIEN) |= ui32Mask;
}

uint32_t RFCHwIntGetAndClear

(

uint32_t

ui32Mask

)

Get and clear HW interrupt flags.

{
    // Read the CPE interrupt flags which match the provided bitmask
    uint32_t ui32Ifg = HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFHWIFG) & ui32Mask;

    // Clear the interupt flags
    RFCHwIntClear(ui32Ifg);

    // Return with the interrupt flags
    return (ui32Ifg);
}

Here is the call graph for this function:

uint8_t RFCOverrideSearch	(	const uint32_t *	pOverride,
		const uint32_t	pattern,
		const uint32_t	mask,
		const uint8_t	searchDepth
	)

Referenced by RFCOverrideUpdate().

{
    // Search from start of the override list, to look for first override entry that matches search pattern
    uint8_t override_index;
    for(override_index = 0; (override_index < searchDepth) && (pOverride[override_index] != END_OVERRIDE); override_index++)
    {
        // Compare the value to the given pattern
        if((pOverride[override_index] & mask) == pattern)
        {
            // Return with the index of override in case of match
            return override_index;
        }
    }

    // Return with an invalid index
    return 0xFF;
}

uint8_t RFCOverrideUpdate	(	rfc_radioOp_t *	pOpSetup,
		uint32_t *	pParams
	)

Function to update override list.

{
    uint32_t* overrideLists[3]; //  [0] pRegOverrideCommon;
                                //  [1] pRegOverride1Mbps;
                                //  [2] pRegOverride2Mbps;
    uint32_t fcfg1_value;       //  Value pulled from FCFG1
    uint8_t override_index;     //  Index in Override list to edit
    uint8_t i;          //  Index used in loop

    // Based on the type of setup command, decode the override list
    switch (pOpSetup->commandNo)
    {
      case CMD_BLE5_RADIO_SETUP:
                                    overrideLists[0] = ((rfc_CMD_BLE5_RADIO_SETUP_t *)pOpSetup)->pRegOverrideCommon;
                                    overrideLists[1] = ((rfc_CMD_BLE5_RADIO_SETUP_t *)pOpSetup)->pRegOverride1Mbps;
                                    overrideLists[2] = ((rfc_CMD_BLE5_RADIO_SETUP_t *)pOpSetup)->pRegOverride2Mbps;
                                    break;
      case CMD_RADIO_SETUP:
      case CMD_PROP_RADIO_SETUP:
      case CMD_PROP_RADIO_DIV_SETUP:
      default:
                                    return 1;
    }

    // Read FCFG1 value
    fcfg1_value = (HWREG(FCFG1_BASE + FCFG1_O_CONFIG_RF_FRONTEND)
                   & FCFG1_CONFIG_RF_FRONTEND_LNA_IB_M) >> FCFG1_CONFIG_RF_FRONTEND_LNA_IB_S;

    // Search for a specific entry within three override lists
    for (i = 0; i < 3; i++)
    {
        // If list is missing simply skip it
        if (overrideLists[i] != NULL)
        {
            override_index = RFCOverrideSearch(overrideLists[i], RFC_BLE5_OVERRIDE_PATTERN, 0xFFFFFFFF, RFC_MAX_SEARCH_DEPTH);

            // Skip if the specific override is not present in the list
            if (override_index < RFC_MAX_SEARCH_DEPTH)
            {
                // Update override entry to FCFG1 limit value
                (overrideLists[i])[override_index] = ((overrideLists[i])[override_index] & RFC_BLE5_OVERRIDE_M) | (fcfg1_value << RFC_BLE5_OVERRIDE_S);
            }
        }
    }

    // Success
    return 0;
}

Here is the call graph for this function:

void RFCRfTrimRead	(	rfc_radioOp_t *	pOpSetup,
		rfTrim_t *	rfTrim
	)

Get the type of currently selected PA.

Read RF trim from flash using CM3.

{
    // Definition of position and bitmask of divider value
    const uint32_t CONFIG_MISC_ADC_DIVIDER    = 27;
    const uint32_t CONFIG_MISC_ADC_DIVIDER_BM = 0xF8000000U;

    // Read trim values from FCFG1
    pRfTrim->configIfAdc      =  HWREG(FCFG1_BASE + FCFG1_O_CONFIG_IF_ADC);
    pRfTrim->configRfFrontend =  HWREG(FCFG1_BASE + FCFG1_O_CONFIG_RF_FRONTEND);
    pRfTrim->configSynth      =  HWREG(FCFG1_BASE + FCFG1_O_CONFIG_SYNTH);
    // Make sure configMiscAdc is not 0 by setting an unused bit to 1
    pRfTrim->configMiscAdc    = (HWREG(FCFG1_BASE + FCFG1_O_CONFIG_MISC_ADC)
                              & ~CONFIG_MISC_ADC_DIVIDER_BM) | (2U << CONFIG_MISC_ADC_DIVIDER);
}

void RFCRfTrimSet

(

rfTrim_t *

rfTrim

)

Write preloaded RF trim values directly into CPE.

{
    memcpy((void*)&HWREG(0x21000018), (void*)pRfTrim, sizeof(rfTrim_t));
}

uint8_t RFCRTrim

(

rfc_radioOp_t *

pOpSetup

)

Check Override RTrim vs FCFG RTrim.

{
    // Function is left blank for compatibility reasons.
    return 0;
}

void RFCSynthPowerDown

(

void

)

This function implements a fast way to turn off the synthesizer.

{
    // Definition of reserved words
    const uint32_t RFC_RESERVED0 = 0x40044108;
    const uint32_t RFC_RESERVED1 = 0x40044114;
    const uint32_t RFC_RESERVED2 = 0x4004410C;
    const uint32_t RFC_RESERVED3 = 0x40044100;

    // Disable CPE clock, enable FSCA clock.
    HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) = (HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN)
                                                    & ~RFC_PWR_PWMCLKEN_CPE_M) | RFC_PWR_PWMCLKEN_FSCA_M;

    HWREG(RFC_RESERVED0) = 3;
    HWREG(RFC_RESERVED1) = 0x1030;
    HWREG(RFC_RESERVED2) = 1;
    HWREG(RFC_RESERVED1) = 0x50;
    HWREG(RFC_RESERVED2) = 1;
    HWREG(RFC_RESERVED1) = 0x650;
    HWREG(RFC_RESERVED2) = 1;
    HWREG(RFC_RESERVED3) = 1;

}

Macro Definition Documentation

#define RFC_MAX_SEARCH_DEPTH   5

Referenced by RFCOverrideUpdate().