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

Apply astyle suggestions from the CI

pull/13119/head
Lingkai Dong 2020-06-16 15:29:48 +01:00
parent 7149877c5d
commit 8a31b6a7ca
2 changed files with 501 additions and 502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
features/nanostack/nanostack-interface/targets/TARGET_NXP/TARGET_KW41Z/NanostackRfPhyKw41z.cpp
View File

@ -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_hw_init(void);
static void rf_mac_ed_state_enable(void); static void rf_mac_ed_state_enable(void);
static void rf_mac_set_pending(uint8_t status); static void rf_mac_set_pending(uint8_t status);
static void rf_mac_set_shortAddress(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_panId(uint8_t *valueAddress);
static void rf_mac_set_mac64(const uint8_t* valueAddress); static void rf_mac_set_mac64(const uint8_t *valueAddress);
static uint8_t rf_convert_energy_level(uint8_t energyLevel); static uint8_t rf_convert_energy_level(uint8_t energyLevel);
static void rf_abort(void); static void rf_abort(void);
static void rf_ack_wait_timer_start(uint16_t time); static void rf_ack_wait_timer_start(uint16_t time);
@ -109,7 +109,7 @@ static phy_device_driver_s device_driver = {
PHY_LAYER_PAYLOAD_DATA_FLOW, PHY_LAYER_PAYLOAD_DATA_FLOW,
MAC64_addr, MAC64_addr,
PHY_MTU_SIZE, PHY_MTU_SIZE,
(char*)"NXP kw41z", (char *)"NXP kw41z",
CRC_LENGTH, CRC_LENGTH,
PHY_HEADER_LENGTH, PHY_HEADER_LENGTH,
&rf_interface_state_control, &rf_interface_state_control,
@ -211,8 +211,7 @@ static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_
{ {
platform_enter_critical(); platform_enter_critical();
switch (new_state) switch (new_state) {
{
/*Reset PHY driver and set to idle*/ /*Reset PHY driver and set to idle*/
case PHY_INTERFACE_RESET: case PHY_INTERFACE_RESET:
rf_abort(); rf_abort();
@ -294,7 +293,7 @@ static void rf_abort(void)
if (ZLL->PHY_CTRL & ZLL_PHY_CTRL_TMRTRIGEN_MASK) { if (ZLL->PHY_CTRL & ZLL_PHY_CTRL_TMRTRIGEN_MASK) {
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 */ /* 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 */ /* 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; need_ack = (*data_ptr & 0x20) == 0x20;
/* Load data into Packet Buffer */ /* Load data into Packet Buffer */
pPB = (uint8_t*)ZLL->PKT_BUFFER_TX; pPB = (uint8_t *)ZLL->PKT_BUFFER_TX;
tx_len = data_length + 2; tx_len = data_length + 2;
*pPB++ = tx_len; /* including 2 bytes of FCS */ *pPB++ = tx_len; /* including 2 bytes of FCS */
@ -495,7 +494,8 @@ static uint8_t rf_convert_energy_level(uint8_t energyLevel)
/** /**
* SET MAC 16 address to Register * 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_MASK;
ZLL->MACSHORTADDRS0 |= ZLL_MACSHORTADDRS0_MACSHORTADDRS0(common_read_16_bit(valueAddress)); 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 * 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_MASK;
ZLL->MACSHORTADDRS0 |= ZLL_MACSHORTADDRS0_MACPANID0(common_read_16_bit(valueAddress)); 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 * 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); ZLL->MACLONGADDRS0_MSB = common_read_32_bit(valueAddress);
valueAddress += 4; valueAddress += 4;
ZLL->MACLONGADDRS0_LSB = common_read_32_bit(valueAddress); 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) static uint8_t PhyPlmeSetCurrentChannelRequest(uint8_t channel, uint8_t pan)
{ {
if((channel < 11) || (channel > 26)) { if ((channel < 11) || (channel > 26)) {
return 1; return 1;
} }
@ -617,8 +619,8 @@ static void PhyIsrTimeoutCleanup(void)
/* Mask TMR3 interrupt */ /* Mask TMR3 interrupt */
irqStatus |= ZLL_IRQSTS_TMR3MSK_MASK; irqStatus |= ZLL_IRQSTS_TMR3MSK_MASK;
/* Clear transceiver interrupts except TMR1IRQ and TMR4IRQ. */ /* Clear transceiver interrupts except TMR1IRQ and TMR4IRQ. */
irqStatus &= ~( ZLL_IRQSTS_TMR1IRQ_MASK | irqStatus &= ~(ZLL_IRQSTS_TMR1IRQ_MASK |
ZLL_IRQSTS_TMR4IRQ_MASK ); ZLL_IRQSTS_TMR4IRQ_MASK);
ZLL->IRQSTS = irqStatus; ZLL->IRQSTS = irqStatus;
/* The packet was transmitted successfully, but no ACK was received */ /* The packet was transmitted successfully, but no ACK was received */
@ -944,7 +946,7 @@ static void rf_handle_rx_end(void)
rf_rssi = rf_convert_LQI_to_RSSI(rf_lqi); rf_rssi = rf_convert_LQI_to_RSSI(rf_lqi);
/* Load data from Packet Buffer */ /* 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++) { for (i = 0; i < len; i++) {
PHYPAYLOAD[i] = *pPB++; PHYPAYLOAD[i] = *pPB++;
@ -978,7 +980,7 @@ static void handle_IRQ_events(void)
} else { } else {
/* Rx Watermark IRQ */ /* Rx Watermark IRQ */
if((!(ZLL->PHY_CTRL & ZLL_PHY_CTRL_RX_WMRK_MSK_MASK)) && if ((!(ZLL->PHY_CTRL & ZLL_PHY_CTRL_RX_WMRK_MSK_MASK)) &&
(irqStatus & ZLL_IRQSTS_RXWTRMRKIRQ_MASK)) { (irqStatus & ZLL_IRQSTS_RXWTRMRKIRQ_MASK)) {
uint32_t rx_len = (irqStatus & ZLL_IRQSTS_RX_FRAME_LENGTH_MASK) >> ZLL_IRQSTS_RX_FRAME_LENGTH_SHIFT; uint32_t rx_len = (irqStatus & ZLL_IRQSTS_RX_FRAME_LENGTH_MASK) >> ZLL_IRQSTS_RX_FRAME_LENGTH_SHIFT;
@ -1009,8 +1011,7 @@ static void handle_IRQ_events(void)
rf_receive(); rf_receive();
} else { } else {
PhyIsrSeqCleanup(); PhyIsrSeqCleanup();
switch(xcvseqCopy) switch (xcvseqCopy) {
{
case gTX_c: case gTX_c:
if ((ZLL->PHY_CTRL & ZLL_PHY_CTRL_CCABFRTX_MASK) && if ((ZLL->PHY_CTRL & ZLL_PHY_CTRL_CCABFRTX_MASK) &&
(irqStatus & ZLL_IRQSTS_CCA_MASK)) { (irqStatus & ZLL_IRQSTS_CCA_MASK)) {
@ -1097,7 +1098,7 @@ void NanostackRfPhyKw41z::get_mac_address(uint8_t *mac)
{ {
platform_enter_critical(); platform_enter_critical();
memcpy((void*)mac, (void*)MAC64_addr, sizeof(MAC64_addr)); memcpy((void *)mac, (void *)MAC64_addr, sizeof(MAC64_addr));
platform_exit_critical(); platform_exit_critical();
} }
@ -1111,7 +1112,7 @@ void NanostackRfPhyKw41z::set_mac_address(uint8_t *mac)
platform_exit_critical(); platform_exit_critical();
return; return;
} }
memcpy((void*)MAC64_addr, (void*)mac, sizeof(MAC64_addr)); memcpy((void *)MAC64_addr, (void *)mac, sizeof(MAC64_addr));
platform_exit_critical(); platform_exit_critical();
} }

142
features/nanostack/nanostack-interface/targets/TARGET_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp
View File

@ -84,10 +84,10 @@ static volatile size_t rx_queue_tail = 0;
/* Silicon Labs headers */ /* Silicon Labs headers */
extern "C" { extern "C" {
#include "rail/rail.h" #include "rail/rail.h"
#include "rail/pa.h" #include "rail/pa.h"
#include "rail/pti.h" #include "rail/pti.h"
#include "rail/ieee802154/rail_ieee802154.h" #include "rail/ieee802154/rail_ieee802154.h"
} }
/* RF driver data */ /* RF driver data */
@ -186,21 +186,21 @@ static const RAIL_ChannelConfig_t channels = {
#endif #endif
#if defined (MBED_CONF_SL_RAIL_HAS_2P4) #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 = { static const RAIL_TxPowerConfig_t paInit2p4 = {
.mode = RAIL_TX_POWER_MODE_2P4_HP, .mode = RAIL_TX_POWER_MODE_2P4_HP,
.voltage = 1800, .voltage = 1800,
.rampTime = 10, .rampTime = 10,
}; };
#endif #endif
#if MBED_CONF_SL_RAIL_HAS_SUBGIG #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 = { static const RAIL_TxPowerConfig_t paInitSubGhz = {
.mode = RAIL_TX_POWER_MODE_SUBGIG, .mode = RAIL_TX_POWER_MODE_SUBGIG,
.voltage = 1800, .voltage = 1800,
.rampTime = 10, .rampTime = 10,
}; };
#endif #endif
static const RAIL_StateTiming_t timings = { 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_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_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_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 */ /* Local function prototypes */
static bool rail_checkAndSwitchChannel(uint8_t channel); static bool rail_checkAndSwitchChannel(uint8_t channel);
@ -275,8 +275,8 @@ static void rf_thread_loop(const void *arg)
platform_enter_critical(); platform_enter_critical();
if (event.value.signals & SL_RX_DONE) { if (event.value.signals & SL_RX_DONE) {
while(rx_queue_tail != rx_queue_head) { while (rx_queue_tail != rx_queue_head) {
uint8_t* packet = (uint8_t*) rx_queue[rx_queue_tail]; uint8_t *packet = (uint8_t *) rx_queue[rx_queue_tail];
SL_DEBUG_PRINT("rPKT %d\n", packet[MAC_PACKET_INFO_LENGTH] - 2); SL_DEBUG_PRINT("rPKT %d\n", packet[MAC_PACKET_INFO_LENGTH] - 2);
device_driver.phy_rx_cb( device_driver.phy_rx_cb(
&packet[MAC_PACKET_INFO_LENGTH + 1], /* Data payload for Nanostack starts at FCS */ &packet[MAC_PACKET_INFO_LENGTH + 1], /* Data payload for Nanostack starts at FCS */
@ -294,7 +294,7 @@ static void rf_thread_loop(const void *arg)
1, 1,
1); 1);
} else if (event.value.signals & SL_ACK_RECV) { } else if (event.value.signals & SL_ACK_RECV) {
device_driver.phy_tx_done_cb( rf_radio_driver_id, device_driver.phy_tx_done_cb(rf_radio_driver_id,
current_tx_handle, current_tx_handle,
(event.value.signals & SL_ACK_PEND) ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE, (event.value.signals & SL_ACK_PEND) ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE,
1, 1,
@ -306,25 +306,25 @@ static void rf_thread_loop(const void *arg)
PHY_LINK_TX_FAIL, PHY_LINK_TX_FAIL,
1, 1,
1); 1);
} else if(event.value.signals & SL_TX_ERR) { } else if (event.value.signals & SL_TX_ERR) {
device_driver.phy_tx_done_cb( rf_radio_driver_id, device_driver.phy_tx_done_cb(rf_radio_driver_id,
current_tx_handle, current_tx_handle,
PHY_LINK_CCA_FAIL, PHY_LINK_CCA_FAIL,
8, 8,
1); 1);
} else if(event.value.signals & SL_TX_TIMEOUT) { } else if (event.value.signals & SL_TX_TIMEOUT) {
device_driver.phy_tx_done_cb( rf_radio_driver_id, device_driver.phy_tx_done_cb(rf_radio_driver_id,
current_tx_handle, current_tx_handle,
PHY_LINK_CCA_FAIL, PHY_LINK_CCA_FAIL,
8, 8,
1); 1);
} else if(event.value.signals & SL_CAL_REQ) { } else if (event.value.signals & SL_CAL_REQ) {
SL_DEBUG_PRINT("rf_thread_loop: SL_CAL_REQ signal received (unhandled)\n"); 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"); 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"); 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"); SL_DEBUG_PRINT("rf_thread_loop: SL_QUEUE_FULL signal received (packet dropped)\n");
} else { } else {
SL_DEBUG_PRINT("rf_thread_loop unhandled event status: %d value: %d\n", event.status, (int)event.value.signals); 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) static int8_t rf_device_register(void)
{ {
// If we already exist, bail. // If we already exist, bail.
if(radio_state != RADIO_UNINIT) { if (radio_state != RADIO_UNINIT) {
return -1; return -1;
} }
@ -422,12 +422,12 @@ static int8_t rf_device_register(void)
/* Get real MAC address */ /* Get real MAC address */
/* MAC is stored MSB first */ /* MAC is stored MSB first */
memcpy(MAC_address, (const void*)&DEVINFO->UNIQUEH, 4); memcpy(MAC_address, (const void *)&DEVINFO->UNIQUEH, 4);
memcpy(&MAC_address[4], (const void*)&DEVINFO->UNIQUEL, 4); memcpy(&MAC_address[4], (const void *)&DEVINFO->UNIQUEL, 4);
/*Set pointer to MAC address*/ /*Set pointer to MAC address*/
device_driver.PHY_MAC = 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*/ /*Type of RF PHY*/
#if MBED_CONF_SL_RAIL_BAND == 2400 #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); 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 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; radio_state = RADIO_INITING;
} }
@ -485,7 +485,7 @@ static int8_t rf_device_register(void)
static void rf_device_unregister(void) static void rf_device_unregister(void)
{ {
arm_net_phy_unregister(rf_radio_driver_id); arm_net_phy_unregister(rf_radio_driver_id);
if(sleep_blocked) { if (sleep_blocked) {
sleep_manager_unlock_deep_sleep(); sleep_manager_unlock_deep_sleep();
sleep_blocked = false; sleep_blocked = false;
} }
@ -500,9 +500,9 @@ static void rf_device_unregister(void)
* \return 0 Success * \return 0 Success
* \return -1 Busy * \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) { switch (radio_state) {
case RADIO_UNINIT: case RADIO_UNINIT:
SL_DEBUG_PRINT("rf_start_cca: Radio uninit\n"); SL_DEBUG_PRINT("rf_start_cca: Radio uninit\n");
return -1; return -1;
@ -518,8 +518,8 @@ static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_h
case RADIO_IDLE: case RADIO_IDLE:
case RADIO_RX: case RADIO_RX:
// If we're still waiting for an ACK, don't mess up the internal state // 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 (waiting_for_ack || RAIL_GetRadioState(gRailHandle) == RAIL_RF_STATE_TX) {
if((RAIL_GetTime() - last_tx) < 30000) { if ((RAIL_GetTime() - last_tx) < 30000) {
SL_DEBUG_PRINT("rf_start_cca: Still waiting on previous ACK\n"); SL_DEBUG_PRINT("rf_start_cca: Still waiting on previous ACK\n");
return -1; return -1;
} else { } else {
@ -539,7 +539,7 @@ static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_h
RAIL_TxOptions_t txOpt = RAIL_TX_OPTIONS_DEFAULT; RAIL_TxOptions_t txOpt = RAIL_TX_OPTIONS_DEFAULT;
//Check to see whether we'll be waiting for an ACK //Check to see whether we'll be waiting for an ACK
if(data_ptr[1] & (1 << 5)) { if (data_ptr[1] & (1 << 5)) {
txOpt |= RAIL_TX_OPTION_WAIT_FOR_ACK; txOpt |= RAIL_TX_OPTION_WAIT_FOR_ACK;
waiting_for_ack = true; waiting_for_ack = true;
} else { } else {
@ -548,7 +548,7 @@ static int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_h
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) { if (RAIL_StartCcaCsmaTx(gRailHandle, channel, txOpt, &csma_config, NULL) == 0) {
//Save packet number and sequence //Save packet number and sequence
current_tx_handle = tx_handle; current_tx_handle = tx_handle;
current_tx_sequence = data_ptr[3]; current_tx_sequence = data_ptr[3];
@ -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) static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_t rf_channel)
{ {
int8_t ret_val = 0; int8_t ret_val = 0;
switch (new_state) switch (new_state) {
{
/* Reset PHY driver and set to idle */ /* Reset PHY driver and set to idle */
case PHY_INTERFACE_RESET: case PHY_INTERFACE_RESET:
RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true); RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true);
radio_state = RADIO_IDLE; radio_state = RADIO_IDLE;
if(sleep_blocked) { if (sleep_blocked) {
sleep_manager_unlock_deep_sleep(); sleep_manager_unlock_deep_sleep();
sleep_blocked = false; 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: case PHY_INTERFACE_DOWN:
RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true); RAIL_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true);
radio_state = RADIO_IDLE; radio_state = RADIO_IDLE;
if(sleep_blocked) { if (sleep_blocked) {
sleep_manager_unlock_deep_sleep(); sleep_manager_unlock_deep_sleep();
sleep_blocked = false; sleep_blocked = false;
} }
break; break;
/* Enable RX */ /* Enable RX */
case PHY_INTERFACE_UP: 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_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true);
RAIL_IEEE802154_SetPromiscuousMode(gRailHandle, false); RAIL_IEEE802154_SetPromiscuousMode(gRailHandle, false);
RAIL_StartRx(gRailHandle, channel, NULL); RAIL_StartRx(gRailHandle, channel, NULL);
radio_state = RADIO_RX; radio_state = RADIO_RX;
if(!sleep_blocked) { if (!sleep_blocked) {
/* RX can only happen in EM0/1*/ /* RX can only happen in EM0/1*/
sleep_manager_lock_deep_sleep(); sleep_manager_lock_deep_sleep();
sleep_blocked = true; sleep_blocked = true;
@ -620,12 +619,12 @@ static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_
break; break;
/* Enable RX in promiscuous mode (aka no address filtering) */ /* Enable RX in promiscuous mode (aka no address filtering) */
case PHY_INTERFACE_SNIFFER_STATE: 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_Idle(gRailHandle, RAIL_IDLE_FORCE_SHUTDOWN_CLEAR_FLAGS, true);
RAIL_IEEE802154_SetPromiscuousMode(gRailHandle, true); RAIL_IEEE802154_SetPromiscuousMode(gRailHandle, true);
RAIL_StartRx(gRailHandle, channel, NULL); RAIL_StartRx(gRailHandle, channel, NULL);
radio_state = RADIO_RX; radio_state = RADIO_RX;
if(!sleep_blocked) { if (!sleep_blocked) {
/* RX can only happen in EM0/1*/ /* RX can only happen in EM0/1*/
sleep_manager_lock_deep_sleep(); sleep_manager_lock_deep_sleep();
sleep_blocked = true; 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) 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 */ /* Control MAC pending bit for Indirect data transmission */
case PHY_EXTENSION_CTRL_PENDING_BIT: case PHY_EXTENSION_CTRL_PENDING_BIT:
if(*data_ptr) { if (*data_ptr) {
data_pending = true; data_pending = true;
} else { } else {
data_pending = false; data_pending = false;
@ -660,7 +658,7 @@ static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_pt
break; break;
/* Return frame pending bit from last received ACK */ /* Return frame pending bit from last received ACK */
case PHY_EXTENSION_READ_LAST_ACK_PENDING_STATUS: case PHY_EXTENSION_READ_LAST_ACK_PENDING_STATUS:
if(last_ack_pending_bit) { if (last_ack_pending_bit) {
*data_ptr = 0xFF; *data_ptr = 0xFF;
} else { } else {
*data_ptr = 0; *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) static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address_ptr)
{ {
int8_t ret_val = 0; int8_t ret_val = 0;
switch (address_type) switch (address_type) {
{
/*Set 48-bit address*/ /*Set 48-bit address*/
case PHY_MAC_48BIT: case PHY_MAC_48BIT:
// 15.4 does not support 48-bit addressing // 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 */ /* Store MAC in MSB order */
memcpy(MAC_address, address_ptr, 8); memcpy(MAC_address, address_ptr, 8);
SL_DEBUG_PRINT("rf_address_write: MACw "); 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("%02x:", MAC_address[i]);
} }
SL_DEBUG_PRINT("\n"); SL_DEBUG_PRINT("\n");
/* Pass MAC to the RF driver in LSB order */ /* Pass MAC to the RF driver in LSB order */
uint8_t MAC_reversed[8]; 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]; MAC_reversed[i] = MAC_address[sizeof(MAC_address) - 1 - i];
} }
RAIL_IEEE802154_SetLongAddress(gRailHandle, MAC_reversed, 0); 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 * Callback that lets the app know when the radio has finished init
* and is ready. * and is ready.
*/ */
static void RAILCb_RfReady(RAIL_Handle_t handle) { static void RAILCb_RfReady(RAIL_Handle_t handle)
{
(void) handle; (void) handle;
radio_state = RADIO_IDLE; 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 * @return bool True if able to switch to the requested channel
* *
*/ */
static bool rail_checkAndSwitchChannel(uint8_t newChannel) { static bool rail_checkAndSwitchChannel(uint8_t newChannel)
if(channel == newChannel) { {
if (channel == newChannel) {
return true; return true;
} }
if(newChannel > 0 && newChannel < 11) { if (newChannel > 0 && newChannel < 11) {
if(MBED_CONF_SL_RAIL_BAND == 915) { if (MBED_CONF_SL_RAIL_BAND == 915) {
channel = newChannel; channel = newChannel;
return true; return true;
} else { } else {
return false; return false;
} }
} else if(newChannel >= 11 && newChannel <= 26) { } else if (newChannel >= 11 && newChannel <= 26) {
if(MBED_CONF_SL_RAIL_BAND == 2400) { if (MBED_CONF_SL_RAIL_BAND == 2400) {
channel = newChannel; channel = newChannel;
return true; return true;
} else { } 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 /* 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 * signal bits. This means we have to convert from a RAIL event mask to
* our own custom event mask. */ * our own custom event mask. */
if (railHandle != gRailHandle) if (railHandle != gRailHandle) {
return; return;
}
#ifdef MBED_CONF_RTOS_PRESENT #ifdef MBED_CONF_RTOS_PRESENT
if(rf_thread_id == 0) { if (rf_thread_id == 0) {
return; return;
} }
#endif #endif
@ -900,7 +900,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
size_t index = 0; size_t index = 0;
do { do {
if (events & 1ull) { if (events & 1ull) {
switch(index) { switch (index) {
/* /*
* Occurs when the AGC averaged RSSI is done. * Occurs when the AGC averaged RSSI is done.
* It occurs in response to RAIL_StartAverageRssi() to indicate that the * It occurs in response to RAIL_StartAverageRssi() to indicate that the
@ -920,12 +920,12 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
* ACK is exceeded. * ACK is exceeded.
*/ */
case RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT: case RAIL_EVENT_RX_ACK_TIMEOUT_SHIFT:
if(waiting_for_ack) { if (waiting_for_ack) {
waiting_for_ack = false; waiting_for_ack = false;
#ifdef MBED_CONF_RTOS_PRESENT #ifdef MBED_CONF_RTOS_PRESENT
osSignalSet(rf_thread_id, SL_ACK_TIMEOUT); osSignalSet(rf_thread_id, SL_ACK_TIMEOUT);
#else #else
device_driver.phy_tx_done_cb( rf_radio_driver_id, device_driver.phy_tx_done_cb(rf_radio_driver_id,
current_tx_handle, current_tx_handle,
PHY_LINK_TX_FAIL, PHY_LINK_TX_FAIL,
1, 1,
@ -955,8 +955,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
* If \ref RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, this event also occurs * If \ref RAIL_RX_OPTION_IGNORE_CRC_ERRORS is set, this event also occurs
* for packets with CRC errors. * for packets with CRC errors.
*/ */
case RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT: case RAIL_EVENT_RX_PACKET_RECEIVED_SHIFT: {
{
/* Get RX packet that got signaled */ /* Get RX packet that got signaled */
RAIL_RxPacketInfo_t rxPacketInfo; RAIL_RxPacketInfo_t rxPacketInfo;
RAIL_RxPacketHandle_t rxHandle = RAIL_GetRxPacketInfo(gRailHandle, RAIL_RxPacketHandle_t rxHandle = RAIL_GetRxPacketInfo(gRailHandle,
@ -965,12 +964,12 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
); );
/* Only process the packet if it had a correct CRC */ /* 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]; uint8_t header[4];
RAIL_PeekRxPacket(gRailHandle, rxHandle, header, 4, 0); RAIL_PeekRxPacket(gRailHandle, rxHandle, header, 4, 0);
/* If this is an ACK, deal with it early */ /* If this is an ACK, deal with it early */
if( (header[0] == 5) && if ((header[0] == 5) &&
(header[3] == current_tx_sequence) && (header[3] == current_tx_sequence) &&
waiting_for_ack) { waiting_for_ack) {
/* Tell the radio to not ACK an ACK */ /* Tell the radio to not ACK an ACK */
@ -985,7 +984,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
osSignalSet(rf_thread_id, SL_ACK_RECV | (last_ack_pending_bit ? SL_ACK_PEND : 0)); osSignalSet(rf_thread_id, SL_ACK_RECV | (last_ack_pending_bit ? SL_ACK_PEND : 0));
#else #else
SL_DEBUG_PRINT("rACK\n"); SL_DEBUG_PRINT("rACK\n");
device_driver.phy_tx_done_cb( rf_radio_driver_id, device_driver.phy_tx_done_cb(rf_radio_driver_id,
current_tx_handle, current_tx_handle,
last_ack_pending_bit ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE, last_ack_pending_bit ? PHY_LINK_TX_DONE_PENDING : PHY_LINK_TX_DONE,
1, 1,
@ -1007,7 +1006,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
} }
/* Copy into queue */ /* Copy into queue */
uint8_t* packetBuffer = (uint8_t*)rx_queue[rx_queue_head]; uint8_t *packetBuffer = (uint8_t *)rx_queue[rx_queue_head];
#else #else
/* Packet going temporarily onto stack for bare-metal apps */ /* Packet going temporarily onto stack for bare-metal apps */
uint8_t packetBuffer[MAC_PACKET_MAX_LENGTH + MAC_PACKET_INFO_LENGTH]; 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 * [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 * [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 */ /* Cancel the ACK if the sender did not request one */
RAIL_CancelAutoAck(gRailHandle); RAIL_CancelAutoAck(gRailHandle);
} }
@ -1109,7 +1108,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
* packet. * packet.
*/ */
case RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT: case RAIL_EVENT_IEEE802154_DATA_REQUEST_COMMAND_SHIFT:
if(data_pending) { if (data_pending) {
RAIL_IEEE802154_SetFramePending(gRailHandle); RAIL_IEEE802154_SetFramePending(gRailHandle);
} }
break; break;
@ -1142,8 +1141,8 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
#ifdef MBED_CONF_RTOS_PRESENT #ifdef MBED_CONF_RTOS_PRESENT
osSignalSet(rf_thread_id, SL_TX_DONE); osSignalSet(rf_thread_id, SL_TX_DONE);
#else #else
if(device_driver.phy_tx_done_cb != NULL) { if (device_driver.phy_tx_done_cb != NULL) {
device_driver.phy_tx_done_cb( rf_radio_driver_id, device_driver.phy_tx_done_cb(rf_radio_driver_id,
current_tx_handle, current_tx_handle,
// Normally we'd switch on ACK requested here, but Nanostack does that for us. // Normally we'd switch on ACK requested here, but Nanostack does that for us.
PHY_LINK_TX_SUCCESS, PHY_LINK_TX_SUCCESS,
@ -1272,8 +1271,7 @@ static void radioEventHandler(RAIL_Handle_t railHandle,
} }
events = events >> 1; events = events >> 1;
index += 1; index += 1;
} } while (events != 0);
while (events != 0);
} }
NanostackRfPhy &NanostackRfPhy::get_default_instance() NanostackRfPhy &NanostackRfPhy::get_default_instance()