diff --git a/features/nanostack/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.cpp b/features/nanostack/nanostack-interface/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.cpp similarity index 87% rename from features/nanostack/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.cpp rename to features/nanostack/nanostack-interface/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.cpp index 8be325b0dcf..9ddc9cdbada 100644 --- a/features/nanostack/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.cpp +++ b/features/nanostack/nanostack-interface/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.cpp @@ -68,9 +68,9 @@ static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_pt static void rf_mac_hw_init(void); static void rf_mac_ed_state_enable(void); static void rf_mac_set_pending(uint8_t status); -static void rf_mac_set_shortAddress(uint8_t* valueAddress); -static void rf_mac_set_panId(uint8_t* valueAddress); -static void rf_mac_set_mac64(const uint8_t* valueAddress); +static void rf_mac_set_shortAddress(uint8_t *valueAddress); +static void rf_mac_set_panId(uint8_t *valueAddress); +static void rf_mac_set_mac64(const uint8_t *valueAddress); static uint8_t rf_convert_energy_level(uint8_t energyLevel); static void rf_abort(void); static void rf_ack_wait_timer_start(uint16_t time); @@ -100,8 +100,8 @@ static uint8_t PHYPAYLOAD[MAC_PACKET_SIZE]; const phy_rf_channel_configuration_s phy_2_4ghz = {2405000000U, 5000000U, 250000U, 16U, M_OQPSK}; const phy_device_channel_page_s phy_channel_pages[] = { - {CHANNEL_PAGE_0, &phy_2_4ghz}, - {CHANNEL_PAGE_0, NULL} + {CHANNEL_PAGE_0, &phy_2_4ghz}, + {CHANNEL_PAGE_0, NULL} }; static phy_device_driver_s device_driver = { @@ -109,7 +109,7 @@ static phy_device_driver_s device_driver = { PHY_LAYER_PAYLOAD_DATA_FLOW, MAC64_addr, PHY_MTU_SIZE, - (char*)"NXP kw41z", + (char *)"NXP kw41z", CRC_LENGTH, PHY_HEADER_LENGTH, &rf_interface_state_control, @@ -184,9 +184,9 @@ static void rf_promiscuous(uint8_t state) /* FRM_VER[11:8] = b0011. Accept FrameVersion 0 and 1 packets, reject all others */ /* Beacon, Data and MAC command frame types accepted */ ZLL->RX_FRAME_FILTER &= ~(ZLL_RX_FRAME_FILTER_FRM_VER_FILTER_MASK | - ZLL_RX_FRAME_FILTER_ACK_FT_MASK | - ZLL_RX_FRAME_FILTER_NS_FT_MASK | - ZLL_RX_FRAME_FILTER_ACTIVE_PROMISCUOUS_MASK); + ZLL_RX_FRAME_FILTER_ACK_FT_MASK | + ZLL_RX_FRAME_FILTER_NS_FT_MASK | + ZLL_RX_FRAME_FILTER_ACTIVE_PROMISCUOUS_MASK); ZLL->RX_FRAME_FILTER |= ZLL_RX_FRAME_FILTER_FRM_VER_FILTER(3); } } @@ -211,8 +211,7 @@ static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_ { platform_enter_critical(); - switch (new_state) - { + switch (new_state) { /*Reset PHY driver and set to idle*/ case PHY_INTERFACE_RESET: rf_abort(); @@ -294,7 +293,7 @@ static void rf_abort(void) if (ZLL->PHY_CTRL & ZLL_PHY_CTRL_TMRTRIGEN_MASK) { ZLL->PHY_CTRL &= ~ZLL_PHY_CTRL_TMRTRIGEN_MASK; /* give the FSM enough time to start if it was triggered */ - while( (XCVR_MISC->XCVR_CTRL & XCVR_CTRL_XCVR_STATUS_TSM_COUNT_MASK) == 0) {} + while ((XCVR_MISC->XCVR_CTRL & XCVR_CTRL_XCVR_STATUS_TSM_COUNT_MASK) == 0) {} } /* If XCVR is not idle, abort current SEQ */ @@ -347,7 +346,7 @@ static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_h need_ack = (*data_ptr & 0x20) == 0x20; /* Load data into Packet Buffer */ - pPB = (uint8_t*)ZLL->PKT_BUFFER_TX; + pPB = (uint8_t *)ZLL->PKT_BUFFER_TX; tx_len = data_length + 2; *pPB++ = tx_len; /* including 2 bytes of FCS */ @@ -382,7 +381,7 @@ static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_h ZLL->IRQSTS = irqSts; tx_warmup_time = (XCVR_TSM->END_OF_SEQ & XCVR_TSM_END_OF_SEQ_END_OF_TX_WU_MASK) >> - XCVR_TSM_END_OF_SEQ_END_OF_TX_WU_SHIFT; + XCVR_TSM_END_OF_SEQ_END_OF_TX_WU_SHIFT; /* Compute warmup times (scaled to 16us) */ if (tx_warmup_time & 0x0F) { @@ -418,19 +417,19 @@ static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address platform_enter_critical(); switch (address_type) { - case PHY_MAC_64BIT: - rf_mac_set_mac64(address_ptr); - break; - /*Set 16-bit address*/ - case PHY_MAC_16BIT: - rf_mac_set_shortAddress(address_ptr); - break; - /*Set PAN Id*/ - case PHY_MAC_PANID: - rf_mac_set_panId(address_ptr); - break; - default: - ret_val = -1; + case PHY_MAC_64BIT: + rf_mac_set_mac64(address_ptr); + break; + /*Set 16-bit address*/ + case PHY_MAC_16BIT: + rf_mac_set_shortAddress(address_ptr); + break; + /*Set PAN Id*/ + case PHY_MAC_PANID: + rf_mac_set_panId(address_ptr); + break; + default: + ret_val = -1; } platform_exit_critical(); @@ -495,7 +494,8 @@ static uint8_t rf_convert_energy_level(uint8_t energyLevel) /** * SET MAC 16 address to Register */ -static void rf_mac_set_shortAddress(uint8_t* valueAddress) { +static void rf_mac_set_shortAddress(uint8_t *valueAddress) +{ ZLL->MACSHORTADDRS0 &= ~ZLL_MACSHORTADDRS0_MACSHORTADDRS0_MASK; ZLL->MACSHORTADDRS0 |= ZLL_MACSHORTADDRS0_MACSHORTADDRS0(common_read_16_bit(valueAddress)); } @@ -503,7 +503,8 @@ static void rf_mac_set_shortAddress(uint8_t* valueAddress) { /** * SET PAN-ID to Register */ -static void rf_mac_set_panId(uint8_t* valueAddress) { +static void rf_mac_set_panId(uint8_t *valueAddress) +{ ZLL->MACSHORTADDRS0 &= ~ZLL_MACSHORTADDRS0_MACPANID0_MASK; ZLL->MACSHORTADDRS0 |= ZLL_MACSHORTADDRS0_MACPANID0(common_read_16_bit(valueAddress)); } @@ -511,7 +512,8 @@ static void rf_mac_set_panId(uint8_t* valueAddress) { /** * SET MAC64 address to register */ -static void rf_mac_set_mac64(const uint8_t* valueAddress) { +static void rf_mac_set_mac64(const uint8_t *valueAddress) +{ ZLL->MACLONGADDRS0_MSB = common_read_32_bit(valueAddress); valueAddress += 4; ZLL->MACLONGADDRS0_LSB = common_read_32_bit(valueAddress); @@ -544,7 +546,7 @@ static uint8_t PhyPlmeGetPwrLevelRequest(void) static uint8_t PhyPlmeSetCurrentChannelRequest(uint8_t channel, uint8_t pan) { - if((channel < 11) || (channel > 26)) { + if ((channel < 11) || (channel > 26)) { return 1; } @@ -591,9 +593,9 @@ static void PhyIsrSeqCleanup(void) irqStatus |= ZLL_IRQSTS_TMR3MSK_MASK; /* Clear transceiver interrupts except TMRxIRQ */ irqStatus &= ~(ZLL_IRQSTS_TMR1IRQ_MASK | - ZLL_IRQSTS_TMR2IRQ_MASK | - ZLL_IRQSTS_TMR3IRQ_MASK | - ZLL_IRQSTS_TMR4IRQ_MASK); + ZLL_IRQSTS_TMR2IRQ_MASK | + ZLL_IRQSTS_TMR3IRQ_MASK | + ZLL_IRQSTS_TMR4IRQ_MASK); ZLL->IRQSTS = irqStatus; } @@ -617,8 +619,8 @@ static void PhyIsrTimeoutCleanup(void) /* Mask TMR3 interrupt */ irqStatus |= ZLL_IRQSTS_TMR3MSK_MASK; /* Clear transceiver interrupts except TMR1IRQ and TMR4IRQ. */ - irqStatus &= ~( ZLL_IRQSTS_TMR1IRQ_MASK | - ZLL_IRQSTS_TMR4IRQ_MASK ); + irqStatus &= ~(ZLL_IRQSTS_TMR1IRQ_MASK | + ZLL_IRQSTS_TMR4IRQ_MASK); ZLL->IRQSTS = irqStatus; /* The packet was transmitted successfully, but no ACK was received */ @@ -686,19 +688,19 @@ static void rf_mac_hw_init(void) /* Enable 16 bit mode for TC2 - TC2 prime EN, disable all timers, enable AUTOACK, mask all interrupts */ ZLL->PHY_CTRL = (gCcaCCA_MODE1_c << ZLL_PHY_CTRL_CCATYPE_SHIFT) | - ZLL_PHY_CTRL_TC2PRIME_EN_MASK | - ZLL_PHY_CTRL_TSM_MSK_MASK | - ZLL_PHY_CTRL_WAKE_MSK_MASK | - ZLL_PHY_CTRL_CRC_MSK_MASK | - ZLL_PHY_CTRL_PLL_UNLOCK_MSK_MASK | - ZLL_PHY_CTRL_FILTERFAIL_MSK_MASK | - ZLL_PHY_CTRL_RX_WMRK_MSK_MASK | - ZLL_PHY_CTRL_CCAMSK_MASK | - ZLL_PHY_CTRL_RXMSK_MASK | - ZLL_PHY_CTRL_TXMSK_MASK | - ZLL_PHY_CTRL_SEQMSK_MASK | - ZLL_PHY_CTRL_AUTOACK_MASK | - ZLL_PHY_CTRL_TRCV_MSK_MASK; + ZLL_PHY_CTRL_TC2PRIME_EN_MASK | + ZLL_PHY_CTRL_TSM_MSK_MASK | + ZLL_PHY_CTRL_WAKE_MSK_MASK | + ZLL_PHY_CTRL_CRC_MSK_MASK | + ZLL_PHY_CTRL_PLL_UNLOCK_MSK_MASK | + ZLL_PHY_CTRL_FILTERFAIL_MSK_MASK | + ZLL_PHY_CTRL_RX_WMRK_MSK_MASK | + ZLL_PHY_CTRL_CCAMSK_MASK | + ZLL_PHY_CTRL_RXMSK_MASK | + ZLL_PHY_CTRL_TXMSK_MASK | + ZLL_PHY_CTRL_SEQMSK_MASK | + ZLL_PHY_CTRL_AUTOACK_MASK | + ZLL_PHY_CTRL_TRCV_MSK_MASK; /* Clear all PP IRQ bits to avoid unexpected interrupts immediately after init disable all timer interrupts */ @@ -927,7 +929,7 @@ static uint8_t rf_convert_LQI(uint8_t hwLqi) static void rf_handle_rx_end(void) { uint8_t rf_lqi = (ZLL->LQI_AND_RSSI & ZLL_LQI_AND_RSSI_LQI_VALUE_MASK) >> - ZLL_LQI_AND_RSSI_LQI_VALUE_SHIFT; + ZLL_LQI_AND_RSSI_LQI_VALUE_SHIFT; int8_t rf_rssi = 0; uint8_t len; uint8_t i; @@ -944,7 +946,7 @@ static void rf_handle_rx_end(void) rf_rssi = rf_convert_LQI_to_RSSI(rf_lqi); /* Load data from Packet Buffer */ - pPB = (uint8_t*)ZLL->PKT_BUFFER_RX; + pPB = (uint8_t *)ZLL->PKT_BUFFER_RX; for (i = 0; i < len; i++) { PHYPAYLOAD[i] = *pPB++; @@ -978,8 +980,8 @@ static void handle_IRQ_events(void) } else { /* Rx Watermark IRQ */ - if((!(ZLL->PHY_CTRL & ZLL_PHY_CTRL_RX_WMRK_MSK_MASK)) && - (irqStatus & ZLL_IRQSTS_RXWTRMRKIRQ_MASK)) { + if ((!(ZLL->PHY_CTRL & ZLL_PHY_CTRL_RX_WMRK_MSK_MASK)) && + (irqStatus & ZLL_IRQSTS_RXWTRMRKIRQ_MASK)) { uint32_t rx_len = (irqStatus & ZLL_IRQSTS_RX_FRAME_LENGTH_MASK) >> ZLL_IRQSTS_RX_FRAME_LENGTH_SHIFT; /* Convert to symbols and add IFS and ACK duration */ @@ -1002,47 +1004,46 @@ static void handle_IRQ_events(void) } /* TMR3 timeout, the autosequence has been aborted due to TMR3 timeout */ else if ((irqStatus & ZLL_IRQSTS_TMR3IRQ_MASK) && - (!(irqStatus & ZLL_IRQSTS_RXIRQ_MASK)) && - (xcvseqCopy != gTX_c)) { + (!(irqStatus & ZLL_IRQSTS_RXIRQ_MASK)) && + (xcvseqCopy != gTX_c)) { PhyIsrTimeoutCleanup(); /* Start receiver */ rf_receive(); } else { PhyIsrSeqCleanup(); - switch(xcvseqCopy) - { - case gTX_c: - if ((ZLL->PHY_CTRL & ZLL_PHY_CTRL_CCABFRTX_MASK) && - (irqStatus & ZLL_IRQSTS_CCA_MASK)) { - device_driver.phy_tx_done_cb(rf_radio_driver_id, rf_mac_handle, - PHY_LINK_CCA_FAIL, 1, 1); - } else { - rf_handle_tx_end(false); - } - break; - - case gTR_c: - if ((ZLL->PHY_CTRL & ZLL_PHY_CTRL_CCABFRTX_MASK) && - (irqStatus & ZLL_IRQSTS_CCA_MASK)) { - device_driver.phy_tx_done_cb(rf_radio_driver_id, rf_mac_handle, - PHY_LINK_CCA_FAIL, 1, 1); - } else { - rf_handle_tx_end((irqStatus & ZLL_IRQSTS_RX_FRM_PEND_MASK) > 0); - } - break; - - case gRX_c: - rf_handle_rx_end(); - break; - - case gCCA_c: - rf_ed_value = rf_convert_energy_level((ZLL->LQI_AND_RSSI & - ZLL_LQI_AND_RSSI_CCA1_ED_FNL_MASK) >> - ZLL_LQI_AND_RSSI_CCA1_ED_FNL_SHIFT); - break; - - default: - break; + switch (xcvseqCopy) { + case gTX_c: + if ((ZLL->PHY_CTRL & ZLL_PHY_CTRL_CCABFRTX_MASK) && + (irqStatus & ZLL_IRQSTS_CCA_MASK)) { + device_driver.phy_tx_done_cb(rf_radio_driver_id, rf_mac_handle, + PHY_LINK_CCA_FAIL, 1, 1); + } else { + rf_handle_tx_end(false); + } + break; + + case gTR_c: + if ((ZLL->PHY_CTRL & ZLL_PHY_CTRL_CCABFRTX_MASK) && + (irqStatus & ZLL_IRQSTS_CCA_MASK)) { + device_driver.phy_tx_done_cb(rf_radio_driver_id, rf_mac_handle, + PHY_LINK_CCA_FAIL, 1, 1); + } else { + rf_handle_tx_end((irqStatus & ZLL_IRQSTS_RX_FRM_PEND_MASK) > 0); + } + break; + + case gRX_c: + rf_handle_rx_end(); + break; + + case gCCA_c: + rf_ed_value = rf_convert_energy_level((ZLL->LQI_AND_RSSI & + ZLL_LQI_AND_RSSI_CCA1_ED_FNL_MASK) >> + ZLL_LQI_AND_RSSI_CCA1_ED_FNL_SHIFT); + break; + + default: + break; } } } @@ -1097,7 +1098,7 @@ void NanostackRfPhyKw41z::get_mac_address(uint8_t *mac) { platform_enter_critical(); - memcpy((void*)mac, (void*)MAC64_addr, sizeof(MAC64_addr)); + memcpy((void *)mac, (void *)MAC64_addr, sizeof(MAC64_addr)); platform_exit_critical(); } @@ -1111,7 +1112,7 @@ void NanostackRfPhyKw41z::set_mac_address(uint8_t *mac) platform_exit_critical(); return; } - memcpy((void*)MAC64_addr, (void*)mac, sizeof(MAC64_addr)); + memcpy((void *)MAC64_addr, (void *)mac, sizeof(MAC64_addr)); platform_exit_critical(); } diff --git a/features/nanostack/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.h b/features/nanostack/nanostack-interface/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.h similarity index 100% rename from features/nanostack/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.h rename to features/nanostack/nanostack-interface/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.h diff --git a/features/nanostack/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp b/features/nanostack/nanostack-interface/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp similarity index 57% rename from features/nanostack/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp rename to features/nanostack/nanostack-interface/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp index 329ccca021b..1369287cb75 100644 --- a/features/nanostack/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp +++ b/features/nanostack/nanostack-interface/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp @@ -84,10 +84,10 @@ static volatile size_t rx_queue_tail = 0; /* Silicon Labs headers */ extern "C" { - #include "rail/rail.h" - #include "rail/pa.h" - #include "rail/pti.h" - #include "rail/ieee802154/rail_ieee802154.h" +#include "rail/rail.h" +#include "rail/pa.h" +#include "rail/pti.h" +#include "rail/ieee802154/rail_ieee802154.h" } /* RF driver data */ @@ -105,9 +105,9 @@ static const phy_rf_channel_configuration_s phy_24ghz = {2405000000U, 5000000U, static const phy_rf_channel_configuration_s phy_subghz = {868300000U, 2000000U, 250000U, 11U, M_OQPSK}; static const phy_device_channel_page_s phy_channel_pages[] = { - { CHANNEL_PAGE_0, &phy_24ghz}, - { CHANNEL_PAGE_2, &phy_subghz}, - { CHANNEL_PAGE_0, NULL} + { CHANNEL_PAGE_0, &phy_24ghz}, + { CHANNEL_PAGE_2, &phy_subghz}, + { CHANNEL_PAGE_0, NULL} }; /* Driver structures */ @@ -135,25 +135,25 @@ static RAIL_ChannelConfigEntryAttr_t entry_868; static RAIL_ChannelConfigEntryAttr_t entry_915; static const RAIL_ChannelConfigEntry_t entry[] = { { - .phyConfigDeltaAdd = NULL, // Add this to default config for this entry - .baseFrequency = 868300000U, - .channelSpacing = 600000U, - .physicalChannelOffset = 0, - .channelNumberStart = 0, - .channelNumberEnd = 0, - .maxPower = RAIL_TX_POWER_MAX, - .attr = &entry_868 - }, - { - .phyConfigDeltaAdd = NULL, // Add this to default config for this entry - .baseFrequency = 906000000U, - .channelSpacing = 2000000U, - .physicalChannelOffset = 1, - .channelNumberStart = 1, - .channelNumberEnd = 10, - .maxPower = RAIL_TX_POWER_MAX, - .attr = &entry_915 - } + .phyConfigDeltaAdd = NULL, // Add this to default config for this entry + .baseFrequency = 868300000U, + .channelSpacing = 600000U, + .physicalChannelOffset = 0, + .channelNumberStart = 0, + .channelNumberEnd = 0, + .maxPower = RAIL_TX_POWER_MAX, + .attr = &entry_868 + }, + { + .phyConfigDeltaAdd = NULL, // Add this to default config for this entry + .baseFrequency = 906000000U, + .channelSpacing = 2000000U, + .physicalChannelOffset = 1, + .channelNumberStart = 1, + .channelNumberEnd = 10, + .maxPower = RAIL_TX_POWER_MAX, + .attr = &entry_915 + } }; #endif @@ -162,20 +162,20 @@ static const RAIL_ChannelConfigEntry_t entry[] = { #error "Sub-Gigahertz band is not supported on this target." #endif static const RAIL_ChannelConfig_t channels = { - ieee802154_config_863, - ieee802154_config_863_min, - &entry[0], - 1 + ieee802154_config_863, + ieee802154_config_863_min, + &entry[0], + 1 }; #elif MBED_CONF_SL_RAIL_BAND == 915 #if !MBED_CONF_SL_RAIL_HAS_SUBGIG #error "Sub-Gigahertz band is not supported on this target." #endif static const RAIL_ChannelConfig_t channels = { - ieee802154_config_915, - ieee802154_config_915_min, - &entry[1], - 1 + ieee802154_config_915, + ieee802154_config_915_min, + &entry[1], + 1 }; #elif MBED_CONF_SL_RAIL_BAND == 2400 #ifndef MBED_CONF_SL_RAIL_HAS_2P4 @@ -186,21 +186,21 @@ static const RAIL_ChannelConfig_t channels = { #endif #if defined (MBED_CONF_SL_RAIL_HAS_2P4) - // Set up the PA for 2.4 GHz operation +// Set up the PA for 2.4 GHz operation static const RAIL_TxPowerConfig_t paInit2p4 = { .mode = RAIL_TX_POWER_MODE_2P4_HP, .voltage = 1800, .rampTime = 10, - }; +}; #endif #if MBED_CONF_SL_RAIL_HAS_SUBGIG - // Set up the PA for sub-GHz operation +// Set up the PA for sub-GHz operation static const RAIL_TxPowerConfig_t paInitSubGhz = { .mode = RAIL_TX_POWER_MODE_SUBGIG, .voltage = 1800, .rampTime = 10, - }; +}; #endif static const RAIL_StateTiming_t timings = { @@ -249,7 +249,7 @@ static uint8_t txFifo[256]; static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_ptr); static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_t rf_channel); static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address_ptr); -static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_handle, data_protocol_e data_protocol ); +static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_handle, data_protocol_e data_protocol); /* Local function prototypes */ static bool rail_checkAndSwitchChannel(uint8_t channel); @@ -257,9 +257,9 @@ static void RAILCb_RfReady(RAIL_Handle_t railHandle); static void radioEventHandler(RAIL_Handle_t railHandle, RAIL_Events_t events); static RAIL_Config_t railCfg = { // Must never be const - .eventsCallback = &radioEventHandler, - .protocol = NULL, // For BLE, pointer to a RAIL_BLE_State_t. For IEEE802.15.4 this must be NULL. - .scheduler = NULL, // For MultiProtocol, pointer to a RAIL_SchedConfig_t + .eventsCallback = &radioEventHandler, + .protocol = NULL, // For BLE, pointer to a RAIL_BLE_State_t. For IEEE802.15.4 this must be NULL. + .scheduler = NULL, // For MultiProtocol, pointer to a RAIL_SchedConfig_t }; static void rf_thread_loop(const void *arg) @@ -275,56 +275,56 @@ static void rf_thread_loop(const void *arg) platform_enter_critical(); if (event.value.signals & SL_RX_DONE) { - while(rx_queue_tail != rx_queue_head) { - uint8_t* packet = (uint8_t*) rx_queue[rx_queue_tail]; + while (rx_queue_tail != rx_queue_head) { + uint8_t *packet = (uint8_t *) rx_queue[rx_queue_tail]; SL_DEBUG_PRINT("rPKT %d\n", packet[MAC_PACKET_INFO_LENGTH] - 2); device_driver.phy_rx_cb( - &packet[MAC_PACKET_INFO_LENGTH + 1], /* Data payload for Nanostack starts at FCS */ - packet[MAC_PACKET_INFO_LENGTH] - 2, /* Payload length is part of frame, but need to subtract CRC bytes */ - packet[MAC_PACKET_OFFSET_LQI], /* LQI in second byte */ - packet[MAC_PACKET_OFFSET_RSSI], /* RSSI in first byte */ - rf_radio_driver_id); + &packet[MAC_PACKET_INFO_LENGTH + 1], /* Data payload for Nanostack starts at FCS */ + packet[MAC_PACKET_INFO_LENGTH] - 2, /* Payload length is part of frame, but need to subtract CRC bytes */ + packet[MAC_PACKET_OFFSET_LQI], /* LQI in second byte */ + packet[MAC_PACKET_OFFSET_RSSI], /* RSSI in first byte */ + rf_radio_driver_id); rx_queue_tail = (rx_queue_tail + 1) % RF_QUEUE_SIZE; } } else if (event.value.signals & SL_TX_DONE) { device_driver.phy_tx_done_cb(rf_radio_driver_id, - current_tx_handle, - PHY_LINK_TX_SUCCESS, - 1, - 1); + current_tx_handle, + PHY_LINK_TX_SUCCESS, + 1, + 1); } else if (event.value.signals & SL_ACK_RECV) { - device_driver.phy_tx_done_cb( rf_radio_driver_id, - current_tx_handle, - (event.value.signals & SL_ACK_PEND) ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE, - 1, - 1); + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + (event.value.signals & SL_ACK_PEND) ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE, + 1, + 1); } else if (event.value.signals & SL_ACK_TIMEOUT) { waiting_for_ack = false; device_driver.phy_tx_done_cb(rf_radio_driver_id, - current_tx_handle, - PHY_LINK_TX_FAIL, - 1, - 1); - } else if(event.value.signals & SL_TX_ERR) { - device_driver.phy_tx_done_cb( rf_radio_driver_id, - current_tx_handle, - PHY_LINK_CCA_FAIL, - 8, - 1); - } else if(event.value.signals & SL_TX_TIMEOUT) { - device_driver.phy_tx_done_cb( rf_radio_driver_id, - current_tx_handle, - PHY_LINK_CCA_FAIL, - 8, - 1); - } else if(event.value.signals & SL_CAL_REQ) { + current_tx_handle, + PHY_LINK_TX_FAIL, + 1, + 1); + } else if (event.value.signals & SL_TX_ERR) { + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + PHY_LINK_CCA_FAIL, + 8, + 1); + } else if (event.value.signals & SL_TX_TIMEOUT) { + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + PHY_LINK_CCA_FAIL, + 8, + 1); + } else if (event.value.signals & SL_CAL_REQ) { SL_DEBUG_PRINT("rf_thread_loop: SL_CAL_REQ signal received (unhandled)\n"); - } else if(event.value.signals & SL_RXFIFO_ERR) { + } else if (event.value.signals & SL_RXFIFO_ERR) { SL_DEBUG_PRINT("rf_thread_loop: SL_RXFIFO_ERR signal received (unhandled)\n"); - } else if(event.value.signals & SL_TXFIFO_ERR) { + } else if (event.value.signals & SL_TXFIFO_ERR) { SL_DEBUG_PRINT("rf_thread_loop: SL_TXFIFO_ERR signal received (unhandled)\n"); - } else if(event.value.signals & SL_QUEUE_FULL) { + } else if (event.value.signals & SL_QUEUE_FULL) { SL_DEBUG_PRINT("rf_thread_loop: SL_QUEUE_FULL signal received (packet dropped)\n"); } else { SL_DEBUG_PRINT("rf_thread_loop unhandled event status: %d value: %d\n", event.status, (int)event.value.signals); @@ -346,7 +346,7 @@ static void rf_thread_loop(const void *arg) static int8_t rf_device_register(void) { // If we already exist, bail. - if(radio_state != RADIO_UNINIT) { + if (radio_state != RADIO_UNINIT) { return -1; } @@ -422,12 +422,12 @@ static int8_t rf_device_register(void) /* Get real MAC address */ /* MAC is stored MSB first */ - memcpy(MAC_address, (const void*)&DEVINFO->UNIQUEH, 4); - memcpy(&MAC_address[4], (const void*)&DEVINFO->UNIQUEL, 4); + memcpy(MAC_address, (const void *)&DEVINFO->UNIQUEH, 4); + memcpy(&MAC_address[4], (const void *)&DEVINFO->UNIQUEL, 4); /*Set pointer to MAC address*/ device_driver.PHY_MAC = MAC_address; - device_driver.driver_description = (char*)"EFR32_154"; + device_driver.driver_description = (char *)"EFR32_154"; /*Type of RF PHY*/ #if MBED_CONF_SL_RAIL_BAND == 2400 @@ -462,7 +462,7 @@ static int8_t rf_device_register(void) rf_radio_driver_id = arm_net_phy_register(&device_driver); // If the radio hasn't called the ready callback by now, place it in the initing state - if(radio_state == RADIO_UNINIT) { + if (radio_state == RADIO_UNINIT) { radio_state = RADIO_INITING; } @@ -485,7 +485,7 @@ static int8_t rf_device_register(void) static void rf_device_unregister(void) { arm_net_phy_unregister(rf_radio_driver_id); - if(sleep_blocked) { + if (sleep_blocked) { sleep_manager_unlock_deep_sleep(); sleep_blocked = false; } @@ -500,67 +500,67 @@ static void rf_device_unregister(void) * \return 0 Success * \return -1 Busy */ -static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_handle, data_protocol_e data_protocol ) +static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_handle, data_protocol_e data_protocol) { - switch(radio_state) { - case RADIO_UNINIT: - SL_DEBUG_PRINT("rf_start_cca: Radio uninit\n"); - return -1; - case RADIO_INITING: - SL_DEBUG_PRINT("rf_start_cca: Radio initing\n"); - return -1; - case RADIO_CALIBRATION: - SL_DEBUG_PRINT("rf_start_cca: Radio calibrating\n"); - return -1; - case RADIO_TX: - SL_DEBUG_PRINT("rf_start_cca: Radio in TX mode\n"); - return -1; - case RADIO_IDLE: - case RADIO_RX: - // If we're still waiting for an ACK, don't mess up the internal state - if(waiting_for_ack || RAIL_GetRadioState(gRailHandle) == RAIL_RF_STATE_TX) { - if((RAIL_GetTime() - last_tx) < 30000) { - SL_DEBUG_PRINT("rf_start_cca: Still waiting on previous ACK\n"); - return -1; - } else { - SL_DEBUG_PRINT("rf_start_cca: TXerr\n"); + switch (radio_state) { + case RADIO_UNINIT: + SL_DEBUG_PRINT("rf_start_cca: Radio uninit\n"); + return -1; + case RADIO_INITING: + SL_DEBUG_PRINT("rf_start_cca: Radio initing\n"); + return -1; + case RADIO_CALIBRATION: + SL_DEBUG_PRINT("rf_start_cca: Radio calibrating\n"); + return -1; + case RADIO_TX: + SL_DEBUG_PRINT("rf_start_cca: Radio in TX mode\n"); + return -1; + case RADIO_IDLE: + case RADIO_RX: + // If we're still waiting for an ACK, don't mess up the internal state + if (waiting_for_ack || RAIL_GetRadioState(gRailHandle) == RAIL_RF_STATE_TX) { + if ((RAIL_GetTime() - last_tx) < 30000) { + SL_DEBUG_PRINT("rf_start_cca: Still waiting on previous ACK\n"); + return -1; + } else { + SL_DEBUG_PRINT("rf_start_cca: TXerr\n"); + } } - } - platform_enter_critical(); + platform_enter_critical(); - /* Since we set up Nanostack to give us a 1-byte PHY header, we get the one extra byte at the start of data_ptr - * and need to populate it with the MAC-frame length byte (including the 2-byte hardware-inserted CRC) */ - data_ptr[0] = data_length + 2; + /* Since we set up Nanostack to give us a 1-byte PHY header, we get the one extra byte at the start of data_ptr + * and need to populate it with the MAC-frame length byte (including the 2-byte hardware-inserted CRC) */ + data_ptr[0] = data_length + 2; - RAIL_Idle(gRailHandle, RAIL_IDLE_ABORT, true); - RAIL_WriteTxFifo(gRailHandle, data_ptr, data_length + 1, true); - radio_state = RADIO_TX; + RAIL_Idle(gRailHandle, RAIL_IDLE_ABORT, true); + RAIL_WriteTxFifo(gRailHandle, data_ptr, data_length + 1, true); + radio_state = RADIO_TX; - RAIL_TxOptions_t txOpt = RAIL_TX_OPTIONS_DEFAULT; - //Check to see whether we'll be waiting for an ACK - if(data_ptr[1] & (1 << 5)) { - txOpt |= RAIL_TX_OPTION_WAIT_FOR_ACK; - waiting_for_ack = true; - } else { - waiting_for_ack = false; - } + RAIL_TxOptions_t txOpt = RAIL_TX_OPTIONS_DEFAULT; + //Check to see whether we'll be waiting for an ACK + if (data_ptr[1] & (1 << 5)) { + txOpt |= RAIL_TX_OPTION_WAIT_FOR_ACK; + waiting_for_ack = true; + } else { + waiting_for_ack = false; + } - SL_DEBUG_PRINT("rf_start_cca: Called TX, len %d, chan %d, ack %d\n", data_length, channel, waiting_for_ack ? 1 : 0); + SL_DEBUG_PRINT("rf_start_cca: Called TX, len %d, chan %d, ack %d\n", data_length, channel, waiting_for_ack ? 1 : 0); - if(RAIL_StartCcaCsmaTx(gRailHandle, channel, txOpt, &csma_config, NULL) == 0) { - //Save packet number and sequence - current_tx_handle = tx_handle; - current_tx_sequence = data_ptr[3]; - platform_exit_critical(); - return 0; - } else { - RAIL_Idle(gRailHandle, RAIL_IDLE_ABORT, true); - RAIL_StartRx(gRailHandle, channel, NULL); - radio_state = RADIO_RX; - platform_exit_critical(); - return -1; - } + if (RAIL_StartCcaCsmaTx(gRailHandle, channel, txOpt, &csma_config, NULL) == 0) { + //Save packet number and sequence + current_tx_handle = tx_handle; + current_tx_sequence = data_ptr[3]; + platform_exit_critical(); + return 0; + } else { + RAIL_Idle(gRailHandle, RAIL_IDLE_ABORT, true); + RAIL_StartRx(gRailHandle, channel, NULL); + radio_state = RADIO_RX; + platform_exit_critical(); + return -1; + } } //Should never get here... return -1; @@ -577,13 +577,12 @@ static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_h static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_t rf_channel) { int8_t ret_val = 0; - switch (new_state) - { + switch (new_state) { /* Reset PHY driver and set to idle */ case PHY_INTERFACE_RESET: RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true); radio_state = RADIO_IDLE; - if(sleep_blocked) { + if (sleep_blocked) { sleep_manager_unlock_deep_sleep(); sleep_blocked = false; } @@ -592,19 +591,19 @@ static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_ case PHY_INTERFACE_DOWN: RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true); radio_state = RADIO_IDLE; - if(sleep_blocked) { + if (sleep_blocked) { sleep_manager_unlock_deep_sleep(); sleep_blocked = false; } break; /* Enable RX */ case PHY_INTERFACE_UP: - if(rail_checkAndSwitchChannel(rf_channel)) { + if (rail_checkAndSwitchChannel(rf_channel)) { RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true); RAIL_IEEE802154_SetPromiscuousMode(gRailHandle, false); RAIL_StartRx(gRailHandle, channel, NULL); radio_state = RADIO_RX; - if(!sleep_blocked) { + if (!sleep_blocked) { /* RX can only happen in EM0/1*/ sleep_manager_lock_deep_sleep(); sleep_blocked = true; @@ -620,12 +619,12 @@ static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_ break; /* Enable RX in promiscuous mode (aka no address filtering) */ case PHY_INTERFACE_SNIFFER_STATE: - if(rail_checkAndSwitchChannel(rf_channel)) { + if (rail_checkAndSwitchChannel(rf_channel)) { RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true); RAIL_IEEE802154_SetPromiscuousMode(gRailHandle, true); RAIL_StartRx(gRailHandle, channel, NULL); radio_state = RADIO_RX; - if(!sleep_blocked) { + if (!sleep_blocked) { /* RX can only happen in EM0/1*/ sleep_manager_lock_deep_sleep(); sleep_blocked = true; @@ -648,11 +647,10 @@ static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_ */ static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_ptr) { - switch (extension_type) - { + switch (extension_type) { /* Control MAC pending bit for Indirect data transmission */ case PHY_EXTENSION_CTRL_PENDING_BIT: - if(*data_ptr) { + if (*data_ptr) { data_pending = true; } else { data_pending = false; @@ -660,7 +658,7 @@ static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_pt break; /* Return frame pending bit from last received ACK */ case PHY_EXTENSION_READ_LAST_ACK_PENDING_STATUS: - if(last_ack_pending_bit) { + if (last_ack_pending_bit) { *data_ptr = 0xFF; } else { *data_ptr = 0; @@ -703,8 +701,7 @@ static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_pt static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address_ptr) { int8_t ret_val = 0; - switch (address_type) - { + switch (address_type) { /*Set 48-bit address*/ case PHY_MAC_48BIT: // 15.4 does not support 48-bit addressing @@ -715,13 +712,13 @@ static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address /* Store MAC in MSB order */ memcpy(MAC_address, address_ptr, 8); SL_DEBUG_PRINT("rf_address_write: MACw "); - for(unsigned int i = 0; i < sizeof(MAC_address); i ++) { + for (unsigned int i = 0; i < sizeof(MAC_address); i ++) { SL_DEBUG_PRINT("%02x:", MAC_address[i]); } SL_DEBUG_PRINT("\n"); /* Pass MAC to the RF driver in LSB order */ uint8_t MAC_reversed[8]; - for(unsigned int i = 0; i < sizeof(MAC_address); i ++) { + for (unsigned int i = 0; i < sizeof(MAC_address); i ++) { MAC_reversed[i] = MAC_address[sizeof(MAC_address) - 1 - i]; } RAIL_IEEE802154_SetLongAddress(gRailHandle, MAC_reversed, 0); @@ -841,7 +838,8 @@ uint32_t NanostackRfPhyEfr32::get_driver_version() * Callback that lets the app know when the radio has finished init * and is ready. */ -static void RAILCb_RfReady(RAIL_Handle_t handle) { +static void RAILCb_RfReady(RAIL_Handle_t handle) +{ (void) handle; radio_state = RADIO_IDLE; } @@ -854,20 +852,21 @@ static void RAILCb_RfReady(RAIL_Handle_t handle) { * @return bool True if able to switch to the requested channel * */ -static bool rail_checkAndSwitchChannel(uint8_t newChannel) { - if(channel == newChannel) { +static bool rail_checkAndSwitchChannel(uint8_t newChannel) +{ + if (channel == newChannel) { return true; } - if(newChannel > 0 && newChannel < 11) { - if(MBED_CONF_SL_RAIL_BAND == 915) { + if (newChannel > 0 && newChannel < 11) { + if (MBED_CONF_SL_RAIL_BAND == 915) { channel = newChannel; return true; } else { return false; } - } else if(newChannel >= 11 && newChannel <= 26) { - if(MBED_CONF_SL_RAIL_BAND == 2400) { + } else if (newChannel >= 11 && newChannel <= 26) { + if (MBED_CONF_SL_RAIL_BAND == 2400) { channel = newChannel; return true; } else { @@ -888,11 +887,12 @@ static void radioEventHandler(RAIL_Handle_t railHandle, /* RAIL_Events_t is a 64-bit event mask, but a thread only supports 32 * signal bits. This means we have to convert from a RAIL event mask to * our own custom event mask. */ - if (railHandle != gRailHandle) + if (railHandle != gRailHandle) { return; + } #ifdef MBED_CONF_RTOS_PRESENT - if(rf_thread_id == 0) { + if (rf_thread_id == 0) { return; } #endif @@ -900,79 +900,78 @@ static void radioEventHandler(RAIL_Handle_t railHandle, size_t index = 0; do { if (events & 1ull) { - switch(index) { - /* - * Occurs when the AGC averaged RSSI is done. - * It occurs in response to RAIL_StartAverageRssi() to indicate that the - * hardware has completed averaging. Call \ref RAIL_GetAverageRssi to get the - * result. - */ - case RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT: + switch (index) { + /* + * Occurs when the AGC averaged RSSI is done. + * It occurs in response to RAIL_StartAverageRssi() to indicate that the + * hardware has completed averaging. Call \ref RAIL_GetAverageRssi to get the + * result. + */ + case RAIL_EVENT_RSSI_AVERAGE_DONE_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_RSSI_DONE); + osSignalSet(rf_thread_id, SL_RSSI_DONE); #else - SL_DEBUG_PRINT("RSSI done (%d)\n", RAIL_GetAverageRssi(gRailHandle)); + SL_DEBUG_PRINT("RSSI done (%d)\n", RAIL_GetAverageRssi(gRailHandle)); #endif - break; - /* - * Notifies the application when searching for an ACK has timed - * out. This event occurs whenever the timeout for searching for an - * ACK is exceeded. - */ - case RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT: - if(waiting_for_ack) { - waiting_for_ack = false; + break; + /* + * Notifies the application when searching for an ACK has timed + * out. This event occurs whenever the timeout for searching for an + * ACK is exceeded. + */ + case RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT: + if (waiting_for_ack) { + waiting_for_ack = false; #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_ACK_TIMEOUT); + osSignalSet(rf_thread_id, SL_ACK_TIMEOUT); #else - device_driver.phy_tx_done_cb( rf_radio_driver_id, - current_tx_handle, - PHY_LINK_TX_FAIL, - 1, - 1); + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + PHY_LINK_TX_FAIL, + 1, + 1); #endif - } - break; - /* - * Occurs when the receive FIFO exceeds the configured threshold - * value. Call \ref RAIL_GetRxFifoBytesAvailable to get the number of bytes - * available. - */ - case RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT: + } + break; + /* + * Occurs when the receive FIFO exceeds the configured threshold + * value. Call \ref RAIL_GetRxFifoBytesAvailable to get the number of bytes + * available. + */ + case RAIL_EVENT_RX_FIFO_ALMOST_FULL_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_RXFIFO_ERR); + osSignalSet(rf_thread_id, SL_RXFIFO_ERR); #else - SL_DEBUG_PRINT("RX near full (%d)\n", RAIL_GetRxFifoBytesAvailable(gRailHandle)); + SL_DEBUG_PRINT("RX near full (%d)\n", RAIL_GetRxFifoBytesAvailable(gRailHandle)); #endif - break; - /* - * Occurs whenever a packet is received. - * Call RAIL_GetRxPacketInfo() to get basic packet information along - * with a handle to this packet for subsequent use with - * RAIL_PeekRxPacket(), RAIL_GetRxPacketDetails(), - * RAIL_HoldRxPacket(), and RAIL_ReleaseRxPacket() as needed. - * - * If \ref RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, this event also occurs - * for packets with CRC errors. - */ - case RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT: - { + break; + /* + * Occurs whenever a packet is received. + * Call RAIL_GetRxPacketInfo() to get basic packet information along + * with a handle to this packet for subsequent use with + * RAIL_PeekRxPacket(), RAIL_GetRxPacketDetails(), + * RAIL_HoldRxPacket(), and RAIL_ReleaseRxPacket() as needed. + * + * If \ref RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, this event also occurs + * for packets with CRC errors. + */ + case RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT: { /* Get RX packet that got signaled */ RAIL_RxPacketInfo_t rxPacketInfo; RAIL_RxPacketHandle_t rxHandle = RAIL_GetRxPacketInfo(gRailHandle, RAIL_RX_PACKET_HANDLE_NEWEST, &rxPacketInfo - ); + ); /* Only process the packet if it had a correct CRC */ - if(rxPacketInfo.packetStatus == RAIL_RX_PACKET_READY_SUCCESS) { + if (rxPacketInfo.packetStatus == RAIL_RX_PACKET_READY_SUCCESS) { uint8_t header[4]; RAIL_PeekRxPacket(gRailHandle, rxHandle, header, 4, 0); /* If this is an ACK, deal with it early */ - if( (header[0] == 5) && - (header[3] == current_tx_sequence) && - waiting_for_ack) { + if ((header[0] == 5) && + (header[3] == current_tx_sequence) && + waiting_for_ack) { /* Tell the radio to not ACK an ACK */ RAIL_CancelAutoAck(gRailHandle); waiting_for_ack = false; @@ -985,11 +984,11 @@ static void radioEventHandler(RAIL_Handle_t railHandle, osSignalSet(rf_thread_id, SL_ACK_RECV | (last_ack_pending_bit ? SL_ACK_PEND : 0)); #else SL_DEBUG_PRINT("rACK\n"); - device_driver.phy_tx_done_cb( rf_radio_driver_id, - current_tx_handle, - last_ack_pending_bit ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE, - 1, - 1); + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + last_ack_pending_bit ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE, + 1, + 1); #endif } else { /* Get RSSI and LQI information about this packet */ @@ -1007,7 +1006,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle, } /* Copy into queue */ - uint8_t* packetBuffer = (uint8_t*)rx_queue[rx_queue_head]; + uint8_t *packetBuffer = (uint8_t *)rx_queue[rx_queue_head]; #else /* Packet going temporarily onto stack for bare-metal apps */ uint8_t packetBuffer[MAC_PACKET_MAX_LENGTH + MAC_PACKET_INFO_LENGTH]; @@ -1031,7 +1030,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle, * [1] => b[0:2] frame type, b[3] = security enabled, b[4] = frame pending, b[5] = ACKreq, b[6] = intrapan * [2] => b[2:3] destmode, b[4:5] version, b[6:7] srcmode */ - if( (packetBuffer[MAC_PACKET_INFO_LENGTH + 1] & (1 << 5)) == 0 ) { + if ((packetBuffer[MAC_PACKET_INFO_LENGTH + 1] & (1 << 5)) == 0) { /* Cancel the ACK if the sender did not request one */ RAIL_CancelAutoAck(gRailHandle); } @@ -1050,230 +1049,229 @@ static void radioEventHandler(RAIL_Handle_t railHandle, } } break; - /* Event for preamble detection */ - case RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT: - break; - /* Event for detection of the first sync word */ - case RAIL_EVENT_RX_SYNC1_DETECT_SHIFT: - break; - /** Event for detection of the second sync word */ - case RAIL_EVENT_RX_SYNC2_DETECT_SHIFT: - break; - /* Event for detection of frame errors - * - * For efr32xg1x parts, frame errors include violations of variable length - * minimum/maximum limits, frame coding errors, and CRC errors. If \ref - * RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, \ref RAIL_EVENT_RX_FRAME_ERROR - * will not occur for CRC errors. - */ - case RAIL_EVENT_RX_FRAME_ERROR_SHIFT: - break; - /* Occurs when RX buffer is full */ - case RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT: - break; - /* Occurs when a packet is address filtered */ - case RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT: - break; - /* Occurs when an RX event times out */ - case RAIL_EVENT_RX_TIMEOUT_SHIFT: - break; - /* Occurs when the scheduled RX window ends */ - case RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT: - break; - /* An event for an aborted packet. It is triggered when a more specific - * reason isn't known for why the packet was aborted (e.g. - * \ref RAIL_EVENT_RX_ADDRESS_FILTERED). */ - case RAIL_EVENT_RX_PACKET_ABORTED_SHIFT: - break; - /* - * Occurs when the packet has passed any configured address and frame - * filtering options. - */ - case RAIL_EVENT_RX_FILTER_PASSED_SHIFT: - break; - /* Occurs when modem timing is lost */ - case RAIL_EVENT_RX_TIMING_LOST_SHIFT: - break; - /* Occurs when modem timing is detected */ - case RAIL_EVENT_RX_TIMING_DETECT_SHIFT: - break; - /* - * Indicates a Data Request is being received when using IEEE 802.15.4 - * functionality. This occurs when the command byte of an incoming frame is - * for a data request, which requests an ACK. This callback is called before - * the packet is fully received to allow the node to have more time to decide - * whether to set the frame pending in the outgoing ACK. This event only ever - * occurs if the RAIL IEEE 802.15.4 functionality is enabled. - * - * Call \ref RAIL_IEEE802154_GetAddress to get the source address of the - * packet. - */ - case RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT: - if(data_pending) { - RAIL_IEEE802154_SetFramePending(gRailHandle); - } - break; - - // TX Event Bitmasks - - /* - * Occurs when the transmit FIFO falls under the configured - * threshold value. It only occurs if a rising edge occurs across this - * threshold. This event does not occur on initailization or after resetting - * the transmit FIFO with RAIL_ResetFifo(). - * Call \ref RAIL_GetTxFifoSpaceAvailable to get the number of bytes - * available in the transmit FIFO at the time of the callback dispatch. - */ - case RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT: + /* Event for preamble detection */ + case RAIL_EVENT_RX_PREAMBLE_DETECT_SHIFT: + break; + /* Event for detection of the first sync word */ + case RAIL_EVENT_RX_SYNC1_DETECT_SHIFT: + break; + /** Event for detection of the second sync word */ + case RAIL_EVENT_RX_SYNC2_DETECT_SHIFT: + break; + /* Event for detection of frame errors + * + * For efr32xg1x parts, frame errors include violations of variable length + * minimum/maximum limits, frame coding errors, and CRC errors. If \ref + * RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, \ref RAIL_EVENT_RX_FRAME_ERROR + * will not occur for CRC errors. + */ + case RAIL_EVENT_RX_FRAME_ERROR_SHIFT: + break; + /* Occurs when RX buffer is full */ + case RAIL_EVENT_RX_FIFO_OVERFLOW_SHIFT: + break; + /* Occurs when a packet is address filtered */ + case RAIL_EVENT_RX_ADDRESS_FILTERED_SHIFT: + break; + /* Occurs when an RX event times out */ + case RAIL_EVENT_RX_TIMEOUT_SHIFT: + break; + /* Occurs when the scheduled RX window ends */ + case RAIL_EVENT_RX_SCHEDULED_RX_END_SHIFT: + break; + /* An event for an aborted packet. It is triggered when a more specific + * reason isn't known for why the packet was aborted (e.g. + * \ref RAIL_EVENT_RX_ADDRESS_FILTERED). */ + case RAIL_EVENT_RX_PACKET_ABORTED_SHIFT: + break; + /* + * Occurs when the packet has passed any configured address and frame + * filtering options. + */ + case RAIL_EVENT_RX_FILTER_PASSED_SHIFT: + break; + /* Occurs when modem timing is lost */ + case RAIL_EVENT_RX_TIMING_LOST_SHIFT: + break; + /* Occurs when modem timing is detected */ + case RAIL_EVENT_RX_TIMING_DETECT_SHIFT: + break; + /* + * Indicates a Data Request is being received when using IEEE 802.15.4 + * functionality. This occurs when the command byte of an incoming frame is + * for a data request, which requests an ACK. This callback is called before + * the packet is fully received to allow the node to have more time to decide + * whether to set the frame pending in the outgoing ACK. This event only ever + * occurs if the RAIL IEEE 802.15.4 functionality is enabled. + * + * Call \ref RAIL_IEEE802154_GetAddress to get the source address of the + * packet. + */ + case RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT: + if (data_pending) { + RAIL_IEEE802154_SetFramePending(gRailHandle); + } + break; + + // TX Event Bitmasks + + /* + * Occurs when the transmit FIFO falls under the configured + * threshold value. It only occurs if a rising edge occurs across this + * threshold. This event does not occur on initailization or after resetting + * the transmit FIFO with RAIL_ResetFifo(). + * Call \ref RAIL_GetTxFifoSpaceAvailable to get the number of bytes + * available in the transmit FIFO at the time of the callback dispatch. + */ + case RAIL_EVENT_TX_FIFO_ALMOST_EMPTY_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_TXFIFO_ERR); + osSignalSet(rf_thread_id, SL_TXFIFO_ERR); #else - SL_DEBUG_PRINT("TX near empty (%d)\n", spaceAvailable); + SL_DEBUG_PRINT("TX near empty (%d)\n", spaceAvailable); #endif - break; - /* - * Interrupt level event to signify when the packet was sent. - * Call RAIL_GetTxPacketDetails() to get information about the packet - * that was transmitted. - * @note that this structure is only valid during the timeframe of the - * \ref RAIL_Config_t::eventsCallback. - */ - case RAIL_EVENT_TX_PACKET_SENT_SHIFT: + break; + /* + * Interrupt level event to signify when the packet was sent. + * Call RAIL_GetTxPacketDetails() to get information about the packet + * that was transmitted. + * @note that this structure is only valid during the timeframe of the + * \ref RAIL_Config_t::eventsCallback. + */ + case RAIL_EVENT_TX_PACKET_SENT_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_TX_DONE); + osSignalSet(rf_thread_id, SL_TX_DONE); #else - if(device_driver.phy_tx_done_cb != NULL) { - device_driver.phy_tx_done_cb( rf_radio_driver_id, - current_tx_handle, - // Normally we'd switch on ACK requested here, but Nanostack does that for us. - PHY_LINK_TX_SUCCESS, - // Succeeded, so how many times we tried is really not relevant. - 1, - 1); - } + if (device_driver.phy_tx_done_cb != NULL) { + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + // Normally we'd switch on ACK requested here, but Nanostack does that for us. + PHY_LINK_TX_SUCCESS, + // Succeeded, so how many times we tried is really not relevant. + 1, + 1); + } #endif - last_tx = RAIL_GetTime(); - radio_state = RADIO_RX; - break; - /* - * An interrupt level event to signify when the packet was sent. - * Call RAIL_GetTxPacketDetails() to get information about the packet - * that was transmitted. - * @note This structure is only valid during the timeframe of the - * \ref RAIL_Config_t::eventsCallback. - */ - case RAIL_EVENT_TXACK_PACKET_SENT_SHIFT: - break; - /* Occurs when a TX is aborted by the user */ - case RAIL_EVENT_TX_ABORTED_SHIFT: + last_tx = RAIL_GetTime(); + radio_state = RADIO_RX; + break; + /* + * An interrupt level event to signify when the packet was sent. + * Call RAIL_GetTxPacketDetails() to get information about the packet + * that was transmitted. + * @note This structure is only valid during the timeframe of the + * \ref RAIL_Config_t::eventsCallback. + */ + case RAIL_EVENT_TXACK_PACKET_SENT_SHIFT: + break; + /* Occurs when a TX is aborted by the user */ + case RAIL_EVENT_TX_ABORTED_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_TX_TIMEOUT); + osSignalSet(rf_thread_id, SL_TX_TIMEOUT); #else - device_driver.phy_tx_done_cb(rf_radio_driver_id, - current_tx_handle, - PHY_LINK_CCA_FAIL, - 8, - 1); + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + PHY_LINK_CCA_FAIL, + 8, + 1); #endif - waiting_for_ack = false; - radio_state = RADIO_RX; - break; - /* Occurs when a TX ACK is aborted by the user */ - case RAIL_EVENT_TXACK_ABORTED_SHIFT: - break; - /* Occurs when a TX is blocked by something like PTA or RHO */ - case RAIL_EVENT_TX_BLOCKED_SHIFT: + waiting_for_ack = false; + radio_state = RADIO_RX; + break; + /* Occurs when a TX ACK is aborted by the user */ + case RAIL_EVENT_TXACK_ABORTED_SHIFT: + break; + /* Occurs when a TX is blocked by something like PTA or RHO */ + case RAIL_EVENT_TX_BLOCKED_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_TX_TIMEOUT); + osSignalSet(rf_thread_id, SL_TX_TIMEOUT); #else - device_driver.phy_tx_done_cb(rf_radio_driver_id, - current_tx_handle, - PHY_LINK_CCA_FAIL, - 8, - 1); + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + PHY_LINK_CCA_FAIL, + 8, + 1); #endif - waiting_for_ack = false; - radio_state = RADIO_RX; - break; - /* Occurs when a TX ACK is blocked by something like PTA or RHO */ - case RAIL_EVENT_TXACK_BLOCKED_SHIFT: - break; - /* Occurs when the TX buffer underflows */ - case RAIL_EVENT_TX_UNDERFLOW_SHIFT: + waiting_for_ack = false; + radio_state = RADIO_RX; + break; + /* Occurs when a TX ACK is blocked by something like PTA or RHO */ + case RAIL_EVENT_TXACK_BLOCKED_SHIFT: + break; + /* Occurs when the TX buffer underflows */ + case RAIL_EVENT_TX_UNDERFLOW_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_TX_TIMEOUT); + osSignalSet(rf_thread_id, SL_TX_TIMEOUT); #else - device_driver.phy_tx_done_cb(rf_radio_driver_id, - current_tx_handle, - PHY_LINK_CCA_FAIL, - 8, - 1); + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + PHY_LINK_CCA_FAIL, + 8, + 1); #endif - waiting_for_ack = false; - radio_state = RADIO_RX; - break; - /* Occurs when the buffer used for TX acking underflows */ - case RAIL_EVENT_TXACK_UNDERFLOW_SHIFT: - break; - /* Occurs when CCA/CSMA/LBT succeeds */ - case RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT: - break; - /* Occurs when CCA/CSMA/LBT fails */ - case RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT: + waiting_for_ack = false; + radio_state = RADIO_RX; + break; + /* Occurs when the buffer used for TX acking underflows */ + case RAIL_EVENT_TXACK_UNDERFLOW_SHIFT: + break; + /* Occurs when CCA/CSMA/LBT succeeds */ + case RAIL_EVENT_TX_CHANNEL_CLEAR_SHIFT: + break; + /* Occurs when CCA/CSMA/LBT fails */ + case RAIL_EVENT_TX_CHANNEL_BUSY_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_TX_TIMEOUT); + osSignalSet(rf_thread_id, SL_TX_TIMEOUT); #else - device_driver.phy_tx_done_cb(rf_radio_driver_id, - current_tx_handle, - PHY_LINK_CCA_FAIL, - 8, - 1); + device_driver.phy_tx_done_cb(rf_radio_driver_id, + current_tx_handle, + PHY_LINK_CCA_FAIL, + 8, + 1); #endif - waiting_for_ack = false; - radio_state = RADIO_RX; - break; - /* Occurs when a CCA check is being retried */ - case RAIL_EVENT_TX_CCA_RETRY_SHIFT: - break; - /** Occurs when a clear channel assessment (CCA) is begun */ - case RAIL_EVENT_TX_START_CCA_SHIFT: - break; - - // Scheduler Event Bitmasks: Not used - - /* Event for when the scheduler switches away from this configuration */ - case RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT: - break; - /* Event for when the scheduler switches to this configuration */ - case RAIL_EVENT_CONFIG_SCHEDULED_SHIFT: - break; - /* Event for when the status of the scheduler changes */ - case RAIL_EVENT_SCHEDULER_STATUS_SHIFT: - break; - - // Other Event Bitmasks - - /* - * Notifies the application that a calibration is needed. - * It occurs whenever the RAIL library detects that a - * calibration is needed. An application determines a valid - * window to call \ref RAIL_Calibrate(). - */ - case RAIL_EVENT_CAL_NEEDED_SHIFT: + waiting_for_ack = false; + radio_state = RADIO_RX; + break; + /* Occurs when a CCA check is being retried */ + case RAIL_EVENT_TX_CCA_RETRY_SHIFT: + break; + /** Occurs when a clear channel assessment (CCA) is begun */ + case RAIL_EVENT_TX_START_CCA_SHIFT: + break; + + // Scheduler Event Bitmasks: Not used + + /* Event for when the scheduler switches away from this configuration */ + case RAIL_EVENT_CONFIG_UNSCHEDULED_SHIFT: + break; + /* Event for when the scheduler switches to this configuration */ + case RAIL_EVENT_CONFIG_SCHEDULED_SHIFT: + break; + /* Event for when the status of the scheduler changes */ + case RAIL_EVENT_SCHEDULER_STATUS_SHIFT: + break; + + // Other Event Bitmasks + + /* + * Notifies the application that a calibration is needed. + * It occurs whenever the RAIL library detects that a + * calibration is needed. An application determines a valid + * window to call \ref RAIL_Calibrate(). + */ + case RAIL_EVENT_CAL_NEEDED_SHIFT: #ifdef MBED_CONF_RTOS_PRESENT - osSignalSet(rf_thread_id, SL_CAL_REQ); + osSignalSet(rf_thread_id, SL_CAL_REQ); #else - SL_DEBUG_PRINT("!!!! Calling for calibration\n"); + SL_DEBUG_PRINT("!!!! Calling for calibration\n"); #endif - break; - default: - break; + break; + default: + break; } } events = events >> 1; index += 1; - } - while (events != 0); + } while (events != 0); } NanostackRfPhy &NanostackRfPhy::get_default_instance() diff --git a/features/nanostack/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.h b/features/nanostack/nanostack-interface/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.h similarity index 100% rename from features/nanostack/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.h rename to features/nanostack/nanostack-interface/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.h