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	RFCClockSet (uint32_t ui32Mask)
	Enable some of the RF core clocks. More...
static void	RFCClockClear (uint32_t ui32Mask)
	Disable some of the RF core clocks. More...
static void	RFCCpe0IntEnable (uint32_t ui32Mask)
	Enable CPE0 interrupt. More...
static void	RFCCpe1IntEnable (uint32_t ui32Mask)
	Enable CPE1 interrupt. More...
static void	RFCHwIntEnable (uint32_t ui32Mask)
static void	RFCCpeIntDisable (uint32_t ui32Mask)
	Disable CPE interrupt. More...
static void	RFCHwIntDisable (uint32_t ui32Mask)
	Disable HW interrupt. More...
uint32_t	RFCCpeIntGetAndClear (void)
	Get and clear CPE interrupt flags. More...
static void	RFCCpeIntClear (uint32_t ui32Mask)
	Clear interrupt flags. More...
static void	RFCHwIntClear (uint32_t ui32Mask)
	Clear interrupt flags. More...
static void	RFCAckIntClear (void)
	Clear interrupt flags. More...
static uint8_t	RFCOverrideSearch (const uint32_t *pOverride, const uint32_t pattern, const uint32_t mask)
	Function to search top RFC_MAX_SEARCH_DEPTH (5) overrides. More...
uint32_t	RFCDoorbellSendTo (uint32_t pOp)
	Send command to doorbell and wait for ack. More...
void	RFCSynthPowerDown (void)
	Turn off synth, NOTE: Radio will no longer respond to commands! More...
void	RFCRfTrimRead (rfc_radioOp_t *pOpSetup, rfTrim_t *rfTrim)
	Read RF trim from flash using CM3. More...
void	RFCRfTrimSet (rfTrim_t *rfTrim)
	Write preloaded RF trim values to CM0. More...
void	RFCRTrim (rfc_radioOp_t *pOpSetup)
	Check Override RTrim vs FCFG RTrim. More...
void	RFCCPEPatchReset (void)
	Reset previously patched CPE RAM to a state where it can be patched again. More...
void	RFCAdi3VcoLdoVoltageMode (bool bEnable)
	Function to set VCOLDO reference to voltage mode. More...
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...

Detailed Description

Function Documentation

static void RFCAckIntClear ( void  )

inlinestatic

Clear interrupt flags.

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 RFCClockClear ( uint32_t  ui32Mask )

inlinestatic

Disable some of 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 can be safely gated. I.e. the RF core should be safely 'parked'.

Returns

None

{
    //
    // Disable clocks
    //
    HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) &= ~ui32Mask;
}

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 can be 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 all clocks
    HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) =
                                 RFC_PWR_PWMCLKEN_RFCTRC |
                                 RFC_PWR_PWMCLKEN_FSCA |
                                 RFC_PWR_PWMCLKEN_PHA |
                                 RFC_PWR_PWMCLKEN_RAT |
                                 RFC_PWR_PWMCLKEN_RFERAM |
                                 RFC_PWR_PWMCLKEN_RFE |
                                 RFC_PWR_PWMCLKEN_MDMRAM |
                                 RFC_PWR_PWMCLKEN_MDM |
                                 RFC_PWR_PWMCLKEN_CPERAM |
                                 RFC_PWR_PWMCLKEN_CPE |
                                 RFC_PWR_PWMCLKEN_RFC;
}

static void RFCClockSet ( uint32_t  ui32Mask )

inlinestatic

Enable some of 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 clocks
    //
    HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) |= ui32Mask;
}

static void RFCCpe0IntEnable ( uint32_t  ui32Mask )

inlinestatic

Enable CPE0 interrupt.

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

  do
  {
    // Clear any pending interrupts.
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0;
  }while(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIFG) != 0x0);

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

static void RFCCpe1IntEnable ( uint32_t  ui32Mask )

inlinestatic

Enable CPE1 interrupt.

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

  do
  {
    // Clear any pending interrupts.
    HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0;
  }while(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFCPEIFG) != 0x0);

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

static void RFCCpeIntClear ( uint32_t  ui32Mask )

inlinestatic

Clear interrupt flags.

{
  do
  {
    // Clear interrupts that may now be pending
    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.

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

uint32_t RFCCpeIntGetAndClear

(

void

)

Get and clear CPE interrupt flags.

{
    uint32_t ui32Ifg = HWREG(RFC_DBELL_BASE+RFC_DBELL_O_RFCPEIFG);

    do {
        HWREG(RFC_DBELL_BASE+RFC_DBELL_O_RFCPEIFG) = ~ui32Ifg;
    } while (HWREG(RFC_DBELL_BASE+RFC_DBELL_O_RFCPEIFG) & ui32Ifg);

    return (ui32Ifg);
}

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 command to doorbell and wait for ack.

{
    while(HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) != 0);

    RFCAckIntClear();

    HWREG(RFC_DBELL_BASE+RFC_DBELL_O_CMDR) = pOp;

    while(!HWREG(RFC_DBELL_BASE + RFC_DBELL_O_RFACKIFG));
    RFCAckIntClear();

    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 interrupt flags.

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

static void RFCHwIntDisable ( uint32_t  ui32Mask )

inlinestatic

Disable HW interrupt.

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

static void RFCHwIntEnable ( uint32_t  ui32Mask )

inlinestatic

This function is used to map only HW interrupts, and clears/unmasks them. These interrupts are then enabled.

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

  //  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.

{
    uint32_t ui32Ifg = HWREG(RFC_DBELL_BASE+RFC_DBELL_O_RFHWIFG) & ui32Mask;

    do {
        HWREG(RFC_DBELL_BASE+RFC_DBELL_O_RFHWIFG) = ~ui32Ifg;
    } while (HWREG(RFC_DBELL_BASE+RFC_DBELL_O_RFHWIFG) & ui32Ifg);

    return (ui32Ifg);
}

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

inlinestatic

Function to search top RFC_MAX_SEARCH_DEPTH (5) overrides.

Referenced by RFCOverrideUpdate().

{
    uint8_t override_index;

     // Search top overrides for RTRIM
    for(override_index = 0; override_index < RFC_MAX_SEARCH_DEPTH; override_index++)
    {
        if((pOverride[override_index] & mask) == pattern)
        {
            return override_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

    // Check which setup command is used
    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;

    // Walk through override lists and make the change
    for (i = 0; i < 3; i++)
    {
        // If list is missing simply skip
        if (overrideLists[i] != NULL)
        {
            override_index = RFCOverrideSearch(overrideLists[i], RFC_BLE5_OVERRIDE_PATTERN, 0xFFFFFFFF);

            // If specific override is missing in list then skip
            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
	)

Read RF trim from flash using CM3.

{
    // Read trim 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 to CM0.

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

void RFCRTrim

(

rfc_radioOp_t *

pOpSetup

)

Check Override RTrim vs FCFG RTrim.

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

void RFCSynthPowerDown

(

void

)

Turn off synth, NOTE: Radio will no longer respond to commands!

{
    // Disable CPE clock, enable FSCA clock. NOTE: Radio will no longer respond to commands!
  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 RFCOverrideSearch(), and RFCOverrideUpdate().