From 567eedc9dbdb61291e665a976bd284e3876c649b Mon Sep 17 00:00:00 2001 From: Martin Kojtal Date: Tue, 30 Oct 2018 15:10:38 +0000 Subject: [PATCH] nanostack: fix astyle coding style --- CONTRIBUTING.md | 5 - .../mbed-mesh-api/MeshInterfaceNanostack.h | 40 +- .../NanostackEthernetInterface.h | 10 +- .../source/LoWPANNDInterface.cpp | 5 +- .../source/MeshInterfaceNanostack.cpp | 8 +- .../source/NanostackEMACInterface.cpp | 113 ++- .../source/NanostackEthernetInterface.cpp | 6 +- .../source/NanostackMemoryManager.cpp | 3 +- .../mbed-mesh-api/source/ThreadInterface.cpp | 5 +- .../mbed-mesh-api/source/ethernet_tasklet.c | 7 +- .../mbed-mesh-api/source/mesh_system.c | 2 +- .../mbed-mesh-api/source/nd_tasklet.c | 18 +- .../mbed-mesh-api/source/thread_tasklet.c | 53 +- .../arm_hal_fhss_timer.cpp | 3 +- .../arm_hal_interrupt.c | 8 +- .../arm_hal_timer.cpp | 2 +- .../cs_nvm/cs_nvm.c | 39 +- .../unittest/cs_nvm/test_cs_nvm.c | 11 +- .../unittest/stubs/configuration_store_stub.c | 51 +- .../unittest/stubs/ns_trace_stub.c | 2 +- .../unittest/stubs/nsdynmemLIB_stub.c | 20 +- .../unittest/stubs/nsdynmemLIB_stub.h | 2 +- .../unittest/stubs/timeout_stub.c | 3 +- .../ns_event_loop.c | 6 +- .../ns_event_loop_mutex.c | 8 +- .../nvm/nvm_ram.c | 12 +- .../nanostack-interface/Nanostack.cpp | 69 +- .../nanostack-interface/NanostackLockGuard.h | 10 +- .../nanostack-interface/NanostackRfPhy.h | 10 +- .../source/ns_timeout.c | 13 +- .../source/system_timer.c | 4 +- .../NanostackRfPhyNcs36510.cpp | 239 ++--- .../TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp | 840 +++++++++--------- 33 files changed, 846 insertions(+), 781 deletions(-) delete mode 100644 CONTRIBUTING.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md deleted file mode 100644 index 701af04107f..00000000000 --- a/CONTRIBUTING.md +++ /dev/null @@ -1,5 +0,0 @@ -# Contributing to Mbed OS - -Mbed OS is an open-source, device software platform for the Internet of Things. Contributions are an important part of the platform, and our goal is to make it as simple as possible to become a contributor. - -To encourage productive collaboration, as well as robust, consistent and maintainable code, we have a set of guidelines for [contributing to Mbed OS](https://os.mbed.com/docs/latest/reference/contributing.html). diff --git a/features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h b/features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h index a4c7f863924..f6c3c8a53d3 100644 --- a/features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h +++ b/features/nanostack/mbed-mesh-api/mbed-mesh-api/MeshInterfaceNanostack.h @@ -32,7 +32,10 @@ class Nanostack::Interface : public OnboardNetworkStack::Interface, private mbed virtual void attach(mbed::Callback status_cb); virtual nsapi_connection_status_t get_connection_status() const; - void get_mac_address(uint8_t *buf) const { interface_phy.get_mac_address(buf); } + void get_mac_address(uint8_t *buf) const + { + interface_phy.get_mac_address(buf); + } /** * \brief Callback from C-layer @@ -40,15 +43,24 @@ class Nanostack::Interface : public OnboardNetworkStack::Interface, private mbed * */ void network_handler(mesh_connection_status_t status); - int8_t get_interface_id() const { return interface_id; } - int8_t get_driver_id() const { return _device_id; } + int8_t get_interface_id() const + { + return interface_id; + } + int8_t get_driver_id() const + { + return _device_id; + } private: NanostackPhy &interface_phy; protected: Interface(NanostackPhy &phy); virtual nsapi_error_t register_phy(); - NanostackPhy &get_phy() const { return interface_phy; } + NanostackPhy &get_phy() const + { + return interface_phy; + } int8_t interface_id; int8_t _device_id; rtos::Semaphore connect_semaphore; @@ -62,7 +74,10 @@ class Nanostack::Interface : public OnboardNetworkStack::Interface, private mbed class Nanostack::MeshInterface : public Nanostack::Interface { protected: MeshInterface(NanostackRfPhy &phy) : Interface(phy) { } - NanostackRfPhy &get_phy() const { return static_cast(Interface::get_phy()); } + NanostackRfPhy &get_phy() const + { + return static_cast(Interface::get_phy()); + } }; @@ -116,12 +131,18 @@ class InterfaceNanostack : public virtual NetworkInterface { /** Get the interface ID /return Interface identifier */ - int8_t get_interface_id() const { return _interface->get_interface_id(); } + int8_t get_interface_id() const + { + return _interface->get_interface_id(); + } protected: InterfaceNanostack(); virtual Nanostack *get_stack(void); - Nanostack::Interface *get_interface() const { return _interface; } + Nanostack::Interface *get_interface() const + { + return _interface; + } virtual nsapi_error_t do_initialize() = 0; Nanostack::Interface *_interface; @@ -147,7 +168,10 @@ class MeshInterfaceNanostack : public InterfaceNanostack, public MeshInterface, protected: MeshInterfaceNanostack() : _phy(NULL) { } MeshInterfaceNanostack(NanostackRfPhy *phy) : _phy(phy) { } - Nanostack::MeshInterface *get_interface() const { return static_cast(_interface); } + Nanostack::MeshInterface *get_interface() const + { + return static_cast(_interface); + } NanostackRfPhy *_phy; }; diff --git a/features/nanostack/mbed-mesh-api/mbed-mesh-api/NanostackEthernetInterface.h b/features/nanostack/mbed-mesh-api/mbed-mesh-api/NanostackEthernetInterface.h index e5c87853143..4c3a42c0577 100644 --- a/features/nanostack/mbed-mesh-api/mbed-mesh-api/NanostackEthernetInterface.h +++ b/features/nanostack/mbed-mesh-api/mbed-mesh-api/NanostackEthernetInterface.h @@ -35,7 +35,10 @@ class Nanostack::EthernetInterface : public Nanostack::Interface { EthernetInterface(NanostackEthernetPhy &phy) : Interface(phy) {} nsapi_error_t initialize(); protected: - NanostackEthernetPhy &get_phy() const { return static_cast(Interface::get_phy()); } + NanostackEthernetPhy &get_phy() const + { + return static_cast(Interface::get_phy()); + } }; /** Ethernet interface for Nanostack. @@ -50,7 +53,10 @@ class NanostackEthernetInterface : public InterfaceNanostack, public EthInterfac nsapi_error_t initialize(NanostackEthernetPhy *phy); protected: - Nanostack::EthernetInterface *get_interface() const { return static_cast(_interface); } + Nanostack::EthernetInterface *get_interface() const + { + return static_cast(_interface); + } virtual nsapi_error_t do_initialize(); }; diff --git a/features/nanostack/mbed-mesh-api/source/LoWPANNDInterface.cpp b/features/nanostack/mbed-mesh-api/source/LoWPANNDInterface.cpp index 712015af9f1..3ca6315aae5 100644 --- a/features/nanostack/mbed-mesh-api/source/LoWPANNDInterface.cpp +++ b/features/nanostack/mbed-mesh-api/source/LoWPANNDInterface.cpp @@ -8,8 +8,7 @@ #include "ns_trace.h" #define TRACE_GROUP "nslp" -class Nanostack::LoWPANNDInterface : public Nanostack::MeshInterface -{ +class Nanostack::LoWPANNDInterface : public Nanostack::MeshInterface { public: virtual nsapi_error_t bringup(bool dhcp, const char *ip, const char *netmask, const char *gw, @@ -29,7 +28,7 @@ class Nanostack::LoWPANNDInterface : public Nanostack::MeshInterface Nanostack::LoWPANNDInterface *LoWPANNDInterface::get_interface() const { - return static_cast(_interface); + return static_cast(_interface); } nsapi_error_t LoWPANNDInterface::do_initialize() diff --git a/features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp b/features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp index 72702dd2bc9..44df5ce3245 100644 --- a/features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp +++ b/features/nanostack/mbed-mesh-api/source/MeshInterfaceNanostack.cpp @@ -69,7 +69,7 @@ void Nanostack::Interface::attach( } Nanostack::Interface::Interface(NanostackPhy &phy) : interface_phy(phy), interface_id(-1), _device_id(-1), - _connect_status(NSAPI_STATUS_DISCONNECTED), _previous_connection_status(NSAPI_STATUS_DISCONNECTED), _blocking(true) + _connect_status(NSAPI_STATUS_DISCONNECTED), _previous_connection_status(NSAPI_STATUS_DISCONNECTED), _blocking(true) { mesh_system_init(); } @@ -119,7 +119,7 @@ nsapi_error_t MeshInterfaceNanostack::initialize(NanostackRfPhy *phy) void Nanostack::Interface::network_handler(mesh_connection_status_t status) { if ((status == MESH_CONNECTED || status == MESH_CONNECTED_LOCAL || - status == MESH_CONNECTED_GLOBAL) && _blocking) { + status == MESH_CONNECTED_GLOBAL) && _blocking) { connect_semaphore.release(); } @@ -131,10 +131,10 @@ void Nanostack::Interface::network_handler(mesh_connection_status_t status) _connect_status = NSAPI_STATUS_LOCAL_UP; } if (arm_net_address_get(interface_id, ADDR_IPV6_GP, temp_ipv6_global) == 0 - && (memcmp(temp_ipv6_global, temp_ipv6_local, 16) != 0)) { + && (memcmp(temp_ipv6_global, temp_ipv6_local, 16) != 0)) { _connect_status = NSAPI_STATUS_GLOBAL_UP; } - } else if (status == MESH_CONNECTED_LOCAL ) { + } else if (status == MESH_CONNECTED_LOCAL) { _connect_status = NSAPI_STATUS_LOCAL_UP; } else if (status == MESH_CONNECTED_GLOBAL) { _connect_status = NSAPI_STATUS_GLOBAL_UP; diff --git a/features/nanostack/mbed-mesh-api/source/NanostackEMACInterface.cpp b/features/nanostack/mbed-mesh-api/source/NanostackEMACInterface.cpp index 37e047a2300..989b6f8c883 100644 --- a/features/nanostack/mbed-mesh-api/source/NanostackEMACInterface.cpp +++ b/features/nanostack/mbed-mesh-api/source/NanostackEMACInterface.cpp @@ -8,16 +8,15 @@ #include "arm_hal_phy.h" #include "EMAC.h" -class EMACPhy : public NanostackEthernetPhy -{ +class EMACPhy : public NanostackEthernetPhy { public: EMACPhy(NanostackMemoryManager &mem, EMAC &m); virtual int8_t phy_register(); virtual void get_mac_address(uint8_t *mac); virtual void set_mac_address(uint8_t *mac); - int8_t address_write(phy_address_type_e , uint8_t *); - int8_t tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle,data_protocol_e data_flow); + int8_t address_write(phy_address_type_e, uint8_t *); + int8_t tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle, data_protocol_e data_flow); void emac_phy_rx(emac_mem_buf_t *mem); @@ -34,65 +33,65 @@ static EMACPhy *single_phy; extern "C" { -static int8_t emac_phy_address_write(phy_address_type_e address_type, uint8_t *address_ptr) -{ - return single_phy->address_write(address_type, address_ptr); -} + static int8_t emac_phy_address_write(phy_address_type_e address_type, uint8_t *address_ptr) + { + return single_phy->address_write(address_type, address_ptr); + } -static int8_t emac_phy_interface_state_control(phy_interface_state_e, uint8_t) -{ - return -1; -} + static int8_t emac_phy_interface_state_control(phy_interface_state_e, uint8_t) + { + return -1; + } -static int8_t emac_phy_tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle,data_protocol_e data_flow) -{ - return single_phy->tx(data_ptr, data_len, tx_handle, data_flow); -} + static int8_t emac_phy_tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle, data_protocol_e data_flow) + { + return single_phy->tx(data_ptr, data_len, tx_handle, data_flow); + } -EMACPhy::EMACPhy(NanostackMemoryManager &mem, EMAC &m) : memory_manager(mem), emac(m), device_id(-1) -{ - /* Same default address logic as lwIP glue uses */ + EMACPhy::EMACPhy(NanostackMemoryManager &mem, EMAC &m) : memory_manager(mem), emac(m), device_id(-1) + { + /* Same default address logic as lwIP glue uses */ #if (MBED_MAC_ADDRESS_SUM != MBED_MAC_ADDR_INTERFACE) - mac_addr[0] = MBED_MAC_ADDR_0; - mac_addr[1] = MBED_MAC_ADDR_1; - mac_addr[2] = MBED_MAC_ADDR_2; - mac_addr[3] = MBED_MAC_ADDR_3; - mac_addr[4] = MBED_MAC_ADDR_4; - mac_addr[5] = MBED_MAC_ADDR_5; + mac_addr[0] = MBED_MAC_ADDR_0; + mac_addr[1] = MBED_MAC_ADDR_1; + mac_addr[2] = MBED_MAC_ADDR_2; + mac_addr[3] = MBED_MAC_ADDR_3; + mac_addr[4] = MBED_MAC_ADDR_4; + mac_addr[5] = MBED_MAC_ADDR_5; #else - mbed_mac_address((char *) mac_addr); + mbed_mac_address((char *) mac_addr); #endif - /* We have a default MAC address, so do don't force them to supply one */ - /* They may or may not update hwaddr with their address */ - emac.get_hwaddr(mac_addr); -} + /* We have a default MAC address, so do don't force them to supply one */ + /* They may or may not update hwaddr with their address */ + emac.get_hwaddr(mac_addr); + } -void EMACPhy::emac_phy_rx(emac_mem_buf_t *mem) -{ - const uint8_t *ptr = NULL; - uint8_t *tmpbuf = NULL; - uint32_t total_len; - - if (memory_manager.get_next(mem) == NULL) { - // Easy contiguous case - ptr = static_cast(memory_manager.get_ptr(mem)); - total_len = memory_manager.get_len(mem); - } else { - // Nanostack can't accept chunked data - make temporary contiguous copy - total_len = memory_manager.get_total_len(mem); - ptr = tmpbuf = static_cast(ns_dyn_mem_temporary_alloc(total_len)); - if (tmpbuf) { - memory_manager.copy_from_buf(tmpbuf, total_len, mem); + void EMACPhy::emac_phy_rx(emac_mem_buf_t *mem) + { + const uint8_t *ptr = NULL; + uint8_t *tmpbuf = NULL; + uint32_t total_len; + + if (memory_manager.get_next(mem) == NULL) { + // Easy contiguous case + ptr = static_cast(memory_manager.get_ptr(mem)); + total_len = memory_manager.get_len(mem); + } else { + // Nanostack can't accept chunked data - make temporary contiguous copy + total_len = memory_manager.get_total_len(mem); + ptr = tmpbuf = static_cast(ns_dyn_mem_temporary_alloc(total_len)); + if (tmpbuf) { + memory_manager.copy_from_buf(tmpbuf, total_len, mem); + } } - } - if (ptr && phy.phy_rx_cb) { - phy.phy_rx_cb(ptr, total_len, 0xff, 0, device_id); + if (ptr && phy.phy_rx_cb) { + phy.phy_rx_cb(ptr, total_len, 0xff, 0, device_id); + } + ns_dyn_mem_free(tmpbuf); + memory_manager.free(mem); } - ns_dyn_mem_free(tmpbuf); - memory_manager.free(mem); -} } // extern "C" @@ -106,7 +105,7 @@ int8_t EMACPhy::address_write(phy_address_type_e address_type, uint8_t *address_ return 0; } -int8_t EMACPhy::tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle,data_protocol_e data_flow) +int8_t EMACPhy::tx(uint8_t *data_ptr, uint16_t data_len, uint8_t tx_handle, data_protocol_e data_flow) { emac_mem_buf_t *mem = memory_manager.alloc_pool(data_len, 0); if (!mem) { @@ -126,7 +125,7 @@ int8_t EMACPhy::phy_register() phy.PHY_MAC = mac_addr; phy.address_write = emac_phy_address_write; - phy.driver_description = const_cast("ETH"); + phy.driver_description = const_cast("ETH"); phy.link_type = PHY_LINK_ETHERNET_TYPE; phy.phy_MTU = 0; phy.phy_header_length = 0; @@ -153,9 +152,9 @@ int8_t EMACPhy::phy_register() emac.set_all_multicast(true); device_id = arm_net_phy_register(&phy); - // driver_readiness_status_callback = driver_status_cb; + // driver_readiness_status_callback = driver_status_cb; - if (device_id < 0){ + if (device_id < 0) { //tr_error("Ethernet Driver failed to register with Stack. RetCode=%i", eth_driver_enabled); //driver_readiness_status_callback(0, eth_interface_id); emac.power_down(); @@ -188,7 +187,7 @@ nsapi_error_t Nanostack::add_ethernet_interface(EMAC &emac, bool default_if, Nan } if (mac_addr) { - single_phy->set_mac_address(const_cast(mac_addr)); + single_phy->set_mac_address(const_cast(mac_addr)); } Nanostack::EthernetInterface *interface; diff --git a/features/nanostack/mbed-mesh-api/source/NanostackEthernetInterface.cpp b/features/nanostack/mbed-mesh-api/source/NanostackEthernetInterface.cpp index c62297dedbf..a502b868861 100644 --- a/features/nanostack/mbed-mesh-api/source/NanostackEthernetInterface.cpp +++ b/features/nanostack/mbed-mesh-api/source/NanostackEthernetInterface.cpp @@ -44,11 +44,11 @@ nsapi_error_t NanostackEthernetInterface::initialize(NanostackEthernetPhy *phy) } return get_interface()->initialize(); - } +} nsapi_error_t Nanostack::EthernetInterface::bringup(bool dhcp, const char *ip, - const char *netmask, const char *gw, - nsapi_ip_stack_t stack, bool blocking) + const char *netmask, const char *gw, + nsapi_ip_stack_t stack, bool blocking) { if (stack == IPV4_STACK) { return NSAPI_ERROR_UNSUPPORTED; diff --git a/features/nanostack/mbed-mesh-api/source/NanostackMemoryManager.cpp b/features/nanostack/mbed-mesh-api/source/NanostackMemoryManager.cpp index 002a6981113..fc88ee019d4 100644 --- a/features/nanostack/mbed-mesh-api/source/NanostackMemoryManager.cpp +++ b/features/nanostack/mbed-mesh-api/source/NanostackMemoryManager.cpp @@ -19,8 +19,7 @@ #include "mbed_assert.h" #include "NanostackMemoryManager.h" -struct ns_stack_mem_t -{ +struct ns_stack_mem_t { ns_stack_mem_t *next; void *payload; uint32_t len; diff --git a/features/nanostack/mbed-mesh-api/source/ThreadInterface.cpp b/features/nanostack/mbed-mesh-api/source/ThreadInterface.cpp index 8388f627ea6..61fcb4fbad3 100644 --- a/features/nanostack/mbed-mesh-api/source/ThreadInterface.cpp +++ b/features/nanostack/mbed-mesh-api/source/ThreadInterface.cpp @@ -7,8 +7,7 @@ #include "ns_trace.h" #define TRACE_GROUP "nsth" -class Nanostack::ThreadInterface : public Nanostack::MeshInterface -{ +class Nanostack::ThreadInterface : public Nanostack::MeshInterface { public: virtual nsapi_error_t bringup(bool dhcp, const char *ip, const char *netmask, const char *gw, @@ -73,7 +72,7 @@ class Nanostack::ThreadInterface : public Nanostack::MeshInterface Nanostack::ThreadInterface *ThreadInterface::get_interface() const { - return static_cast(_interface); + return static_cast(_interface); } nsapi_error_t ThreadInterface::do_initialize() diff --git a/features/nanostack/mbed-mesh-api/source/ethernet_tasklet.c b/features/nanostack/mbed-mesh-api/source/ethernet_tasklet.c index 88073a698ae..d86b98a36dc 100644 --- a/features/nanostack/mbed-mesh-api/source/ethernet_tasklet.c +++ b/features/nanostack/mbed-mesh-api/source/ethernet_tasklet.c @@ -189,7 +189,7 @@ static void enet_tasklet_poll_network_status(void *param) memcpy(tasklet_data_ptr->ip, temp_ipv6, 16); uint8_t temp_ipv6_local[16]; if (arm_net_address_get(tasklet_data_ptr->network_interface_id, ADDR_IPV6_LL, temp_ipv6_local) == 0 - && (memcmp(temp_ipv6, temp_ipv6_local, 16) != 0)) { + && (memcmp(temp_ipv6, temp_ipv6_local, 16) != 0)) { enet_tasklet_network_state_changed(MESH_CONNECTED_GLOBAL); } else { enet_tasklet_network_state_changed(MESH_CONNECTED_LOCAL);; @@ -197,8 +197,9 @@ static void enet_tasklet_poll_network_status(void *param) } } else { if (tasklet_data_ptr->connection_status != MESH_DISCONNECTED && - tasklet_data_ptr->connection_status != MESH_BOOTSTRAP_STARTED) + tasklet_data_ptr->connection_status != MESH_BOOTSTRAP_STARTED) { enet_tasklet_network_state_changed(MESH_DISCONNECTED); + } } } @@ -242,7 +243,7 @@ int8_t enet_tasklet_connect(mesh_interface_cb callback, int8_t nwk_interface_id) if (re_connecting == false) { tasklet_data_ptr->tasklet = eventOS_event_handler_create(&enet_tasklet_main, - ARM_LIB_TASKLET_INIT_EVENT); + ARM_LIB_TASKLET_INIT_EVENT); if (tasklet_data_ptr->tasklet < 0) { // -1 handler already used by other tasklet // -2 memory allocation failure diff --git a/features/nanostack/mbed-mesh-api/source/mesh_system.c b/features/nanostack/mbed-mesh-api/source/mesh_system.c index 3081d8daa2b..0971f02e4a6 100644 --- a/features/nanostack/mbed-mesh-api/source/mesh_system.c +++ b/features/nanostack/mbed-mesh-api/source/mesh_system.c @@ -54,7 +54,7 @@ void mesh_system_init(void) { if (mesh_initialized == false) { #if MBED_CONF_MBED_MESH_API_USE_MALLOC_FOR_HEAP - app_stack_heap = malloc(MBED_CONF_MBED_MESH_API_HEAP_SIZE+1); + app_stack_heap = malloc(MBED_CONF_MBED_MESH_API_HEAP_SIZE + 1); MBED_ASSERT(app_stack_heap); #endif ns_hal_init(app_stack_heap, MBED_CONF_MBED_MESH_API_HEAP_SIZE, diff --git a/features/nanostack/mbed-mesh-api/source/nd_tasklet.c b/features/nanostack/mbed-mesh-api/source/nd_tasklet.c index 28cc6e72f92..75d124fce60 100644 --- a/features/nanostack/mbed-mesh-api/source/nd_tasklet.c +++ b/features/nanostack/mbed-mesh-api/source/nd_tasklet.c @@ -214,7 +214,7 @@ void nd_tasklet_parse_network_event(arm_event_s *event) } if (tasklet_data_ptr->tasklet_state != TASKLET_STATE_BOOTSTRAP_READY && - tasklet_data_ptr->network_interface_id != INVALID_INTERFACE_ID) { + tasklet_data_ptr->network_interface_id != INVALID_INTERFACE_ID) { // Set 5s timer for new network scan eventOS_event_timer_request(TIMER_EVENT_START_BOOTSTRAP, ARM_LIB_SYSTEM_TIMER_EVENT, @@ -268,15 +268,15 @@ void nd_tasklet_configure_and_connect_to_network(void) tasklet_data_ptr->network_interface_id, NULL); arm_nwk_6lowpan_link_panid_filter_for_nwk_scan( - tasklet_data_ptr->network_interface_id, - MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PANID_FILTER); + tasklet_data_ptr->network_interface_id, + MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PANID_FILTER); // Enable MPL by default - const uint8_t all_mpl_forwarders[16] = {0xff, 0x03, [15]=0xfc}; + const uint8_t all_mpl_forwarders[16] = {0xff, 0x03, [15] = 0xfc}; multicast_mpl_domain_subscribe(tasklet_data_ptr->network_interface_id, - all_mpl_forwarders, - MULTICAST_MPL_SEED_ID_DEFAULT, - NULL); + all_mpl_forwarders, + MULTICAST_MPL_SEED_ID_DEFAULT, + NULL); status = arm_nwk_interface_up(tasklet_data_ptr->network_interface_id); if (status >= 0) { @@ -327,7 +327,7 @@ void nd_tasklet_trace_bootstrap_info() tr_error("MAC Address read fail\n"); } else { uint8_t temp[2]; - common_write_16_bit(app_link_address_info.mac_short,temp); + common_write_16_bit(app_link_address_info.mac_short, temp); tr_debug("MAC 16-bit: %s", trace_array(temp, 2)); common_write_16_bit(app_link_address_info.PANId, temp); tr_debug("PAN ID: %s", trace_array(temp, 2)); @@ -378,7 +378,7 @@ int8_t nd_tasklet_connect(mesh_interface_cb callback, int8_t nwk_interface_id) if (re_connecting == false) { tasklet_data_ptr->tasklet = eventOS_event_handler_create(&nd_tasklet_main, - ARM_LIB_TASKLET_INIT_EVENT); + ARM_LIB_TASKLET_INIT_EVENT); if (tasklet_data_ptr->tasklet < 0) { // -1 handler already used by other tasklet // -2 memory allocation failure diff --git a/features/nanostack/mbed-mesh-api/source/thread_tasklet.c b/features/nanostack/mbed-mesh-api/source/thread_tasklet.c index 9668ad61034..9fe37ab92d9 100644 --- a/features/nanostack/mbed-mesh-api/source/thread_tasklet.c +++ b/features/nanostack/mbed-mesh-api/source/thread_tasklet.c @@ -218,7 +218,7 @@ void thread_tasklet_parse_network_event(arm_event_s *event) } if (thread_tasklet_data_ptr->tasklet_state != TASKLET_STATE_BOOTSTRAP_READY && - thread_tasklet_data_ptr->nwk_if_id != INVALID_INTERFACE_ID) { + thread_tasklet_data_ptr->nwk_if_id != INVALID_INTERFACE_ID) { // Set 5s timer for a new network scan eventOS_event_timer_request(TIMER_EVENT_START_BOOTSTRAP, ARM_LIB_SYSTEM_TIMER_EVENT, @@ -246,23 +246,25 @@ void thread_tasklet_poll_network_status(void *param) } } else { if (thread_tasklet_data_ptr->connection_status != MESH_DISCONNECTED && - thread_tasklet_data_ptr->connection_status != MESH_BOOTSTRAP_STARTED) + thread_tasklet_data_ptr->connection_status != MESH_BOOTSTRAP_STARTED) { thread_tasklet_network_state_changed(MESH_DISCONNECTED); + } } } -void read_link_configuration() { +void read_link_configuration() +{ thread_tasklet_data_ptr->link_config.panId = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_PANID; TRACE_DETAIL("PANID %x", thread_tasklet_data_ptr->link_config.panId); thread_tasklet_data_ptr->link_config.rfChannel = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL; TRACE_DETAIL("channel: %d", thread_tasklet_data_ptr->link_config.rfChannel); - + // Mesh prefix const uint8_t mesh_local_prefix[] = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_ML_PREFIX; MBED_ASSERT(sizeof(mesh_local_prefix) == 8); - + memcpy(thread_tasklet_data_ptr->link_config.mesh_local_ula_prefix, mesh_local_prefix, 8); TRACE_DETAIL("Mesh prefix: %s", trace_array(mesh_local_prefix, 8)); @@ -279,14 +281,14 @@ void read_link_configuration() { thread_tasklet_data_ptr->link_config.key_rotation = 3600; thread_tasklet_data_ptr->link_config.key_sequence = 0; - thread_tasklet_data_ptr->link_config.securityPolicy = MBED_CONF_MBED_MESH_API_THREAD_SECURITY_POLICY; - + thread_tasklet_data_ptr->link_config.securityPolicy = MBED_CONF_MBED_MESH_API_THREAD_SECURITY_POLICY; + // network name MBED_ASSERT(strlen(MBED_CONF_MBED_MESH_API_THREAD_CONFIG_NETWORK_NAME) > 0 && strlen(MBED_CONF_MBED_MESH_API_THREAD_CONFIG_NETWORK_NAME) < 17); memcpy(thread_tasklet_data_ptr->link_config.name, MBED_CONF_MBED_MESH_API_THREAD_CONFIG_NETWORK_NAME, strlen(MBED_CONF_MBED_MESH_API_THREAD_CONFIG_NETWORK_NAME)); - + thread_tasklet_data_ptr->link_config.timestamp = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_COMMISSIONING_DATASET_TIMESTAMP; - + // extended pan-id const uint8_t extented_panid[] = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_EXTENDED_PANID; MBED_ASSERT(sizeof(extented_panid) == 8); @@ -300,13 +302,12 @@ void read_link_configuration() { void thread_tasklet_configure_and_connect_to_network(void) { int8_t status; - link_configuration_s* temp_link_config=NULL; + link_configuration_s *temp_link_config = NULL; if (MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE == MESH_DEVICE_TYPE_THREAD_MINIMAL_END_DEVICE) { - thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_HOST; - } - else if (MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE == MESH_DEVICE_TYPE_THREAD_SLEEPY_END_DEVICE) { + thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_HOST; + } else if (MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE == MESH_DEVICE_TYPE_THREAD_SLEEPY_END_DEVICE) { thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_SLEEPY_HOST; } else { thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_ROUTER; @@ -316,16 +317,16 @@ void thread_tasklet_configure_and_connect_to_network(void) thread_tasklet_data_ptr->nwk_if_id, thread_tasklet_data_ptr->operating_mode, NET_6LOWPAN_THREAD); - + thread_tasklet_data_ptr->channel_list.channel_page = (channel_page_e)MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_PAGE; thread_tasklet_data_ptr->channel_list.channel_mask[0] = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_MASK; - + TRACE_DETAIL("channel page: %d", thread_tasklet_data_ptr->channel_list.channel_page); TRACE_DETAIL("channel mask: 0x%.8lx", thread_tasklet_data_ptr->channel_list.channel_mask[0]); // PSKd const char PSKd[] = MBED_CONF_MBED_MESH_API_THREAD_PSKD; - if(device_configuration.PSKd_len==0) { + if (device_configuration.PSKd_len == 0) { int ret = thread_tasklet_device_pskd_set(PSKd); MBED_ASSERT(!ret); } @@ -334,11 +335,11 @@ void thread_tasklet_configure_and_connect_to_network(void) read_link_configuration(); temp_link_config = &thread_tasklet_data_ptr->link_config; } - + thread_management_node_init(thread_tasklet_data_ptr->nwk_if_id, - &thread_tasklet_data_ptr->channel_list, - &device_configuration, - temp_link_config); + &thread_tasklet_data_ptr->channel_list, + &device_configuration, + temp_link_config); status = arm_nwk_interface_up(thread_tasklet_data_ptr->nwk_if_id); @@ -382,7 +383,7 @@ void thread_tasklet_trace_bootstrap_info() tr_error("MAC Address read fail\n"); } else { uint8_t temp[2]; - common_write_16_bit(app_link_address_info.mac_short,temp); + common_write_16_bit(app_link_address_info.mac_short, temp); tr_debug("MAC 16-bit: %s", trace_array(temp, 2)); common_write_16_bit(app_link_address_info.PANId, temp); tr_debug("PAN ID: %s", trace_array(temp, 2)); @@ -414,12 +415,12 @@ int8_t thread_tasklet_connect(mesh_interface_cb callback, int8_t nwk_interface_i if (re_connecting == false) { thread_tasklet_data_ptr->tasklet = eventOS_event_handler_create(&thread_tasklet_main, - ARM_LIB_TASKLET_INIT_EVENT); + ARM_LIB_TASKLET_INIT_EVENT); if (thread_tasklet_data_ptr->tasklet < 0) { // -1 handler already used by other tasklet // -2 memory allocation failure return thread_tasklet_data_ptr->tasklet; - } + } } else { thread_tasklet_data_ptr->tasklet = tasklet; mesh_system_send_connect_event(thread_tasklet_data_ptr->tasklet); @@ -486,16 +487,16 @@ void thread_tasklet_device_eui64_get(uint8_t *eui64) uint8_t thread_tasklet_device_pskd_set(const char *pskd) { int len = strlen(pskd); - if(len < 6 || len > 32) { + if (len < 6 || len > 32) { return MESH_ERROR_PARAM; } - char *dyn_buf = ns_dyn_mem_alloc(strlen(pskd)+1); + char *dyn_buf = ns_dyn_mem_alloc(strlen(pskd) + 1); if (!dyn_buf) { return MESH_ERROR_MEMORY; } strcpy(dyn_buf, pskd); ns_dyn_mem_free(device_configuration.PSKd_ptr); - device_configuration.PSKd_ptr = (uint8_t*)dyn_buf; + device_configuration.PSKd_ptr = (uint8_t *)dyn_buf; device_configuration.PSKd_len = strlen(pskd); return 0; } diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_fhss_timer.cpp b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_fhss_timer.cpp index 4cb42af986a..56b8a57dec0 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_fhss_timer.cpp +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_fhss_timer.cpp @@ -36,8 +36,7 @@ static const fhss_api_t *fhss_active_handle = NULL; static EventQueue *equeue; #endif -struct fhss_timeout_s -{ +struct fhss_timeout_s { void (*fhss_timer_callback)(const fhss_api_t *fhss_api, uint16_t); uint32_t start_time; uint32_t stop_time; diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_interrupt.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_interrupt.c index 21c352996c4..e09dd3e8bf3 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_interrupt.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_interrupt.c @@ -39,10 +39,10 @@ static uint8_t sys_irq_disable_counter; static mbed_rtos_storage_mutex_t critical_mutex; static const osMutexAttr_t critical_mutex_attr = { - .name = "nanostack_critical_mutex", - .attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust, - .cb_mem = &critical_mutex, - .cb_size = sizeof critical_mutex, + .name = "nanostack_critical_mutex", + .attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust, + .cb_mem = &critical_mutex, + .cb_size = sizeof critical_mutex, }; static osMutexId_t critical_mutex_id; diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_timer.cpp b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_timer.cpp index dbc519196cb..7aeb13f334a 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_timer.cpp +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/arm_hal_timer.cpp @@ -94,7 +94,7 @@ uint16_t platform_timer_get_remaining_slots(void) { uint32_t elapsed = timer->read_us(); if (elapsed < due) { - return (uint16_t) ((due - elapsed) / 50); + return (uint16_t)((due - elapsed) / 50); } else { return 0; } diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/cs_nvm.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/cs_nvm.c index 53f646a9280..bdd77358f6e 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/cs_nvm.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/cs_nvm.c @@ -99,9 +99,9 @@ static void nvm_fsm_timer_cb(void *arg); static void configuration_store_cb(int32_t status, ARM_CFSTORE_OPCODE cmd_code, void *ctx, ARM_CFSTORE_HANDLE handle) { tr_debug("configuration_store_cb status=%d, cmd_code=%d, ctx=%x, hndl=%x", (int)status, (int)cmd_code, (unsigned int)ctx, (unsigned int)handle); - cs_context_t *cf_context = (cs_context_t*)ctx; + cs_context_t *cf_context = (cs_context_t *)ctx; - switch(cmd_code) { + switch (cmd_code) { case CFSTORE_OPCODE_INITIALIZE: tr_debug("CFSTORE_OPCODE_INITIALIZE %d", (int)status); cf_context->state = NVM_STATE_INIT_DONE; @@ -229,8 +229,7 @@ static int nvm_fsm_update(cs_context_t *cs_context) int ret_val = 0; tr_debug("nvm_fsm_update() state=%d", (int)cs_context->state); - switch (cs_context->state) - { + switch (cs_context->state) { case NVM_STATE_UNINIT_DONE: cs_context->client_cb(cs_context->client_status, cs_context->client_context); cs_context->state = NVM_STATE_NONE; @@ -288,7 +287,7 @@ platform_nvm_status platform_nvm_init(nvm_callback *callback, void *context) cs_context_ptr->capabilities = drv->GetCapabilities(); - tr_debug("mode: %s", IS_SYNC_MODE(cs_context_ptr) ? "sync": "async" ); + tr_debug("mode: %s", IS_SYNC_MODE(cs_context_ptr) ? "sync" : "async"); ret = drv->Initialize(configuration_store_cb, cs_context_ptr); if (ret < ARM_DRIVER_OK) { @@ -367,14 +366,14 @@ platform_nvm_status platform_nvm_key_create(nvm_callback *callback, const char * keydesc.drl = ARM_RETENTION_NVM; ret = drv->Create(key_name, value_len, &keydesc, cs_context_ptr->hkey); - if(ret < ARM_DRIVER_OK) { + if (ret < ARM_DRIVER_OK) { if (ret == ARM_CFSTORE_DRIVER_ERROR_PREEXISTING_KEY) { tr_debug("adjust value len to %d", value_len); ret = drv->Create(key_name, value_len, NULL, cs_context_ptr->hkey); } } - if(ret < ARM_DRIVER_OK) { + if (ret < ARM_DRIVER_OK) { tr_error("Key creation failed %d", (int)ret); cs_context_ptr->state = NVM_STATE_CREATE_DONE; cs_context_ptr->client_status = nvm_error_map(ret); @@ -413,7 +412,7 @@ platform_nvm_status platform_nvm_key_delete(nvm_callback *callback, const char * flags.write = 1; ret = drv->Open(key_name, flags, cs_context_ptr->hkey); - if(ret < ARM_DRIVER_OK) { + if (ret < ARM_DRIVER_OK) { tr_error("Key delete, open failed %d", (int)ret); cs_context_ptr->state = NVM_STATE_DELETE_DONE; cs_context_ptr->client_status = nvm_error_map(ret); @@ -455,7 +454,7 @@ platform_nvm_status platform_nvm_read(nvm_callback *callback, const char *key_na flags.read = 1; ret = drv->Open(key_name, flags, cs_context_ptr->hkey); - if(ret < ARM_DRIVER_OK) { + if (ret < ARM_DRIVER_OK) { tr_error("Read failed to open handle %d", (int)ret); cs_context_ptr->state = NVM_STATE_READ_DONE; cs_context_ptr->client_status = nvm_error_map(ret); @@ -485,7 +484,7 @@ platform_nvm_status platform_nvm_write(nvm_callback *callback, const char *key_n } cs_context_ptr->client_cb = callback; cs_context_ptr->client_context = context; - cs_context_ptr->client_buf = (void*)data; + cs_context_ptr->client_buf = (void *)data; cs_context_ptr->client_buf_len = data_len; cs_context_ptr->data_len = *data_len; cs_context_ptr->client_status = PLATFORM_NVM_OK; @@ -496,7 +495,7 @@ platform_nvm_status platform_nvm_write(nvm_callback *callback, const char *key_n flags.write = 1; ret = drv->Open(key_name, flags, cs_context_ptr->hkey); - if(ret < ARM_DRIVER_OK) { + if (ret < ARM_DRIVER_OK) { tr_error("Write failed %d", (int)ret); cs_context_ptr->state = NVM_STATE_WRITE_DONE; cs_context_ptr->client_status = nvm_error_map(ret); @@ -532,7 +531,7 @@ platform_nvm_status platform_nvm_flush(nvm_callback *callback, void *context) ret = drv->Flush(); - if(ret < ARM_DRIVER_OK) { + if (ret < ARM_DRIVER_OK) { cs_context_ptr->state = NVM_STATE_FLUSH_DONE; cs_context_ptr->client_status = nvm_error_map(ret); } @@ -547,9 +546,9 @@ static bool nvm_write_internal(cs_context_t *cf_context) { int32_t ret; cf_context->state = NVM_STATE_WRITING; - ret = drv->Write(cf_context->hkey, (const char*)cf_context->client_buf, &cf_context->data_len); + ret = drv->Write(cf_context->hkey, (const char *)cf_context->client_buf, &cf_context->data_len); - if(ret >= ARM_DRIVER_OK) { + if (ret >= ARM_DRIVER_OK) { return true; } else { tr_error("Write failed %d", (int)ret); @@ -561,9 +560,9 @@ static bool nvm_read_internal(cs_context_t *cf_context) { int32_t ret; cf_context->state = NVM_STATE_READING; - ret = drv->Read(cf_context->hkey, (void*)cf_context->client_buf, &cf_context->data_len); + ret = drv->Read(cf_context->hkey, (void *)cf_context->client_buf, &cf_context->data_len); - if(ret >= ARM_DRIVER_OK) { + if (ret >= ARM_DRIVER_OK) { return true; } else { tr_error("Read failed %d", (int)ret); @@ -577,7 +576,7 @@ static bool nvm_delete_internal(cs_context_t *cf_context) cf_context->state = NVM_STATE_DELETING; ret = drv->Delete(cf_context->hkey); - if(ret >= ARM_DRIVER_OK) { + if (ret >= ARM_DRIVER_OK) { return true; } else { tr_error("Delete failed %d", (int)ret); @@ -591,7 +590,7 @@ static bool nvm_close_internal(cs_context_t *cf_context) cf_context->state = NVM_STATE_CLOSING; ret = drv->Close(cf_context->hkey); - if(ret >= ARM_DRIVER_OK) { + if (ret >= ARM_DRIVER_OK) { return true; } else { tr_error("Close failed %d", (int)ret); @@ -626,7 +625,7 @@ static platform_nvm_status nvm_error_map(int32_t cs_error) return PLATFORM_NVM_OK; } - switch(cs_error) { + switch (cs_error) { case ARM_CFSTORE_DRIVER_ERROR_KEY_NOT_FOUND: client_error = PLATFORM_NVM_KEY_NOT_FOUND; break; @@ -641,7 +640,7 @@ static platform_nvm_status nvm_error_map(int32_t cs_error) static void nvm_fsm_timer_cb(void *args) { (void) args; - switch(nvm_fsm_update(cs_context_ptr)) { + switch (nvm_fsm_update(cs_context_ptr)) { case 0: // Nothing processed, restart timer tr_debug("nvm_fsm_timer_cb not handled event in () %d", (int)cs_context_ptr->state); diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/cs_nvm/test_cs_nvm.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/cs_nvm/test_cs_nvm.c index bfe069fbdd3..ced1cec5e87 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/cs_nvm/test_cs_nvm.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/cs_nvm/test_cs_nvm.c @@ -22,8 +22,7 @@ uint8_t buf[100]; uint16_t buf_len; uint16_t data_len; -typedef struct -{ +typedef struct { platform_nvm_status status; void *ctx; } test_platform_nvm_api_callback_t; @@ -187,7 +186,7 @@ bool test_cs_nvm_init_finalize() } // finalize NVM - OK - if (!test_nvm_finalize()){ + if (!test_nvm_finalize()) { return false; } @@ -300,7 +299,7 @@ bool test_cs_nvm_key_create() } // finalize NVM - OK - if (!test_nvm_finalize()){ + if (!test_nvm_finalize()) { return false; } @@ -341,7 +340,7 @@ bool test_cs_nvm_key_delete() ret = platform_nvm_key_delete(test_nvm_callback, NULL, TEST_NS_NVM_HELPER_CONTEXT1); if (ret != PLATFORM_NVM_ERROR) { return false; - } + } // Configuration-store returns error in OPEN directly cfstore_stub.ret_val = ARM_DRIVER_ERROR; @@ -389,7 +388,7 @@ bool test_cs_nvm_key_delete() ret = platform_nvm_key_delete(test_nvm_callback, key_name, TEST_NS_NVM_HELPER_CONTEXT1); if (ret != PLATFORM_NVM_OK) { return false; - } + } // simulate open cfstore_stub.cmd_code = CFSTORE_OPCODE_OPEN; diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/configuration_store_stub.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/configuration_store_stub.c index 565836cb1f1..e00ead2cad3 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/configuration_store_stub.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/configuration_store_stub.c @@ -16,7 +16,7 @@ static int32_t test_cfstore_close(ARM_CFSTORE_HANDLE hkey) return cfstore_stub.close_ret_val; } -static int32_t test_cfstore_create(const char* key_name, ARM_CFSTORE_SIZE value_len, const ARM_CFSTORE_KEYDESC* kdesc, ARM_CFSTORE_HANDLE hkey) +static int32_t test_cfstore_create(const char *key_name, ARM_CFSTORE_SIZE value_len, const ARM_CFSTORE_KEYDESC *kdesc, ARM_CFSTORE_HANDLE hkey) { return cfstore_stub.ret_val; } @@ -26,7 +26,7 @@ static int32_t test_cfstore_delete(ARM_CFSTORE_HANDLE hkey) return cfstore_stub.delete_ret_val; } -static int32_t test_cfstore_find(const char* key_name_query, const ARM_CFSTORE_HANDLE previous, ARM_CFSTORE_HANDLE next) +static int32_t test_cfstore_find(const char *key_name_query, const ARM_CFSTORE_HANDLE previous, ARM_CFSTORE_HANDLE next) { return ARM_DRIVER_OK; } @@ -42,7 +42,7 @@ ARM_CFSTORE_CAPABILITIES test_cfstore_get_capabilities(void) return cfstore_caps_g; } -static int32_t test_cfstore_get_key_name(ARM_CFSTORE_HANDLE hkey, char* key_name, uint8_t *key_name_len) +static int32_t test_cfstore_get_key_name(ARM_CFSTORE_HANDLE hkey, char *key_name, uint8_t *key_name_len) { return ARM_DRIVER_OK; } @@ -64,14 +64,14 @@ ARM_DRIVER_VERSION test_cfstore_get_version(void) return cfstore_driver_version_g; } -static int32_t test_cfstore_initialise(ARM_CFSTORE_CALLBACK callback, void* client_context) +static int32_t test_cfstore_initialise(ARM_CFSTORE_CALLBACK callback, void *client_context) { cfstore_stub.callback = callback; cfstore_stub.client_context = client_context; return cfstore_stub.ret_val; } -static int32_t test_cfstore_open(const char* key_name, ARM_CFSTORE_FMODE flags, ARM_CFSTORE_HANDLE hkey) +static int32_t test_cfstore_open(const char *key_name, ARM_CFSTORE_FMODE flags, ARM_CFSTORE_HANDLE hkey) { return cfstore_stub.ret_val; } @@ -81,7 +81,7 @@ static int32_t test_cfstore_power_control(ARM_POWER_STATE state) return ARM_DRIVER_OK; } -static int32_t test_cfstore_read(ARM_CFSTORE_HANDLE hkey, void* data, ARM_CFSTORE_SIZE* len) +static int32_t test_cfstore_read(ARM_CFSTORE_HANDLE hkey, void *data, ARM_CFSTORE_SIZE *len) { return cfstore_stub.read_ret_val; } @@ -96,30 +96,29 @@ static int32_t test_cfstore_uninitialise(void) return cfstore_stub.ret_val; } -static int32_t test_cfstore_write(ARM_CFSTORE_HANDLE hkey, const char* data, ARM_CFSTORE_SIZE* len) +static int32_t test_cfstore_write(ARM_CFSTORE_HANDLE hkey, const char *data, ARM_CFSTORE_SIZE *len) { return cfstore_stub.write_ret_val; } -ARM_CFSTORE_DRIVER cfstore_driver = -{ - .Close = test_cfstore_close, - .Create = test_cfstore_create, - .Delete= test_cfstore_delete, - .Find = test_cfstore_find, - .Flush = test_cfstore_flush, - .GetCapabilities = test_cfstore_get_capabilities, - .GetKeyName = test_cfstore_get_key_name, - .GetStatus = test_cfstore_get_status, - .GetValueLen = test_cfstore_get_value_len, - .GetVersion = test_cfstore_get_version, - .Initialize = test_cfstore_initialise, - .Open = test_cfstore_open, - .PowerControl = test_cfstore_power_control, - .Read = test_cfstore_read, - .Rseek = test_cfstore_rseek, - .Uninitialize = test_cfstore_uninitialise, - .Write = test_cfstore_write, +ARM_CFSTORE_DRIVER cfstore_driver = { + .Close = test_cfstore_close, + .Create = test_cfstore_create, + .Delete = test_cfstore_delete, + .Find = test_cfstore_find, + .Flush = test_cfstore_flush, + .GetCapabilities = test_cfstore_get_capabilities, + .GetKeyName = test_cfstore_get_key_name, + .GetStatus = test_cfstore_get_status, + .GetValueLen = test_cfstore_get_value_len, + .GetVersion = test_cfstore_get_version, + .Initialize = test_cfstore_initialise, + .Open = test_cfstore_open, + .PowerControl = test_cfstore_power_control, + .Read = test_cfstore_read, + .Rseek = test_cfstore_rseek, + .Uninitialize = test_cfstore_uninitialise, + .Write = test_cfstore_write, }; diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/ns_trace_stub.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/ns_trace_stub.c index d9cedf5a6bd..b4b4f442b67 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/ns_trace_stub.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/ns_trace_stub.c @@ -190,7 +190,7 @@ void debug_int(int i) { } -void printf_array(const void *buf , uint16_t len) +void printf_array(const void *buf, uint16_t len) { } diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.c index 10e39b5170e..0b10772efcc 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.c @@ -17,32 +17,26 @@ void ns_dyn_mem_init(uint8_t *heap, uint16_t h_size, void (*passed_fptr)(heap_fa void *ns_dyn_mem_alloc(int16_t alloc_size) { - if (nsdynmemlib_stub.returnCounter > 0) - { + if (nsdynmemlib_stub.returnCounter > 0) { nsdynmemlib_stub.returnCounter--; return malloc(alloc_size); - } - else - { - return(nsdynmemlib_stub.expectedPointer); + } else { + return (nsdynmemlib_stub.expectedPointer); } } void *ns_dyn_mem_temporary_alloc(int16_t alloc_size) { - if (nsdynmemlib_stub.returnCounter > 0) - { + if (nsdynmemlib_stub.returnCounter > 0) { nsdynmemlib_stub.returnCounter--; return malloc(alloc_size); - } - else - { - return(nsdynmemlib_stub.expectedPointer); + } else { + return (nsdynmemlib_stub.expectedPointer); } } void ns_dyn_mem_free(void *block) { - free(block); + free(block); } diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.h b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.h index a67197576d2..3a155198767 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.h +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/nsdynmemLIB_stub.h @@ -12,7 +12,7 @@ extern "C" { typedef struct { uint8_t returnCounter; - void* expectedPointer; + void *expectedPointer; } nsdynmemlib_stub_data_t; extern nsdynmemlib_stub_data_t nsdynmemlib_stub; diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/timeout_stub.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/timeout_stub.c index d11b1ae721e..be22af487ae 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/timeout_stub.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/cs_nvm/test/test_cs_nvm_unit/unittest/stubs/timeout_stub.c @@ -19,7 +19,8 @@ void eventOS_timeout_cancel(timeout_t *t) } -void test_eventOS_timeout_trigger() { +void test_eventOS_timeout_trigger() +{ test_callback(test_args); } diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop.c index 35e0c3e25dd..ec970bdd077 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop.c @@ -43,11 +43,11 @@ static osEventFlagsId_t event_flag_id; #ifndef MBED_TZ_DEFAULT_ACCESS #define MBED_TZ_DEFAULT_ACCESS 0 -#endif - +#endif + static void event_loop_thread(void *arg); -static uint64_t event_thread_stk[MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_THREAD_STACK_SIZE/8]; +static uint64_t event_thread_stk[MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_THREAD_STACK_SIZE / 8]; static mbed_rtos_storage_thread_t event_thread_tcb; static const osThreadAttr_t event_thread_attr = { .name = "nanostack_event_thread", diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop_mutex.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop_mutex.c index f4d91236fa2..b65c98617af 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop_mutex.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/ns_event_loop_mutex.c @@ -28,10 +28,10 @@ static mbed_rtos_storage_mutex_t event_mutex; static const osMutexAttr_t event_mutex_attr = { - .name = "nanostack_event_mutex", - .attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust, - .cb_mem = &event_mutex, - .cb_size = sizeof event_mutex, + .name = "nanostack_event_mutex", + .attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust, + .cb_mem = &event_mutex, + .cb_size = sizeof event_mutex, }; static osMutexId_t event_mutex_id; static osThreadId_t event_mutex_owner_id = NULL; diff --git a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/nvm/nvm_ram.c b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/nvm/nvm_ram.c index 5ac8e70a5e8..51ad41160c2 100644 --- a/features/nanostack/nanostack-hal-mbed-cmsis-rtos/nvm/nvm_ram.c +++ b/features/nanostack/nanostack-hal-mbed-cmsis-rtos/nvm/nvm_ram.c @@ -11,7 +11,7 @@ #endif /* - * Define flag IGNORE_SIMULATED_NVM_STORAGE to ignore usage of simulated NVM and use + * Define flag IGNORE_SIMULATED_NVM_STORAGE to ignore usage of simulated NVM and use * platform specific NVM instead. */ #ifndef IGNORE_SIMULATED_NVM_STORAGE @@ -143,7 +143,7 @@ platform_nvm_status platform_nvm_key_create(nvm_callback *callback, const char * tr_debug("platform_nvm_key_create() %s len=%d", key_name, (int)value_len); ns_list_foreach(nvm_data_entry_t, current_entry, &nvm_entry_list) { - if (strcmp(current_entry->key, key_name)==0) { + if (strcmp(current_entry->key, key_name) == 0) { // resizing existing key ns_list_remove(&nvm_entry_list, current_entry); nvm_ram_free_entry(current_entry); @@ -182,7 +182,7 @@ platform_nvm_status platform_nvm_key_delete(nvm_callback *callback, const char * tr_debug("platform_nvm_key_delete() %s", key_name); ns_list_foreach(nvm_data_entry_t, current_entry, &nvm_entry_list) { - if (strcmp(current_entry->key, key_name)==0) { + if (strcmp(current_entry->key, key_name) == 0) { client_status = PLATFORM_NVM_OK; ns_list_remove(&nvm_entry_list, current_entry); nvm_ram_free_entry(current_entry); @@ -199,7 +199,7 @@ platform_nvm_status platform_nvm_write(nvm_callback *callback, const char *key_n tr_debug("platform_nvm_write() %s len=%d", key_name, (int)*data_len); ns_list_foreach(nvm_data_entry_t, current_entry, &nvm_entry_list) { - if (strcmp(current_entry->key, key_name)==0) { + if (strcmp(current_entry->key, key_name) == 0) { if (current_entry->data_len >= *data_len) { memcpy(current_entry->data, data, *data_len); } else { @@ -211,7 +211,7 @@ platform_nvm_status platform_nvm_write(nvm_callback *callback, const char *key_n } } - return create_client_request(callback, context, (void*)data, data_len, client_status); + return create_client_request(callback, context, (void *)data, data_len, client_status); } platform_nvm_status platform_nvm_read(nvm_callback *callback, const char *key_name, void *buf, uint16_t *buf_len, void *context) @@ -220,7 +220,7 @@ platform_nvm_status platform_nvm_read(nvm_callback *callback, const char *key_na tr_debug("platform_nvm_read() %s len=%d", key_name, (int)*buf_len); ns_list_foreach(nvm_data_entry_t, current_entry, &nvm_entry_list) { - if (strcmp(current_entry->key, key_name)==0) { + if (strcmp(current_entry->key, key_name) == 0) { if (*buf_len >= current_entry->data_len) { memcpy(buf, current_entry->data, current_entry->data_len); *buf_len = current_entry->data_len; diff --git a/features/nanostack/nanostack-interface/Nanostack.cpp b/features/nanostack/nanostack-interface/Nanostack.cpp index cddb054d349..8c070b660cd 100644 --- a/features/nanostack/nanostack-interface/Nanostack.cpp +++ b/features/nanostack/nanostack-interface/Nanostack.cpp @@ -61,15 +61,18 @@ enum socket_mode_t { class NanostackSocket { public: static void socket_callback(void *cb); - static void* operator new(std::size_t sz); - static void operator delete(void* ptr); + static void *operator new (std::size_t sz); + static void operator delete (void *ptr); NanostackSocket(int8_t protocol); ~NanostackSocket(void); bool open(void); int accept(NanostackSocket *accepted_socket, ns_address_t *addr); void close(void); - bool closed(void) {return SOCKET_MODE_CLOSED == mode;} + bool closed(void) + { + return SOCKET_MODE_CLOSED == mode; + } bool is_connecting(void); void set_connecting(ns_address_t *addr); bool is_connected(void); @@ -101,21 +104,26 @@ class NanostackSocket { socket_mode_t mode; }; -static NanostackSocket * socket_tbl[NS_INTERFACE_SOCKETS_MAX]; +static NanostackSocket *socket_tbl[NS_INTERFACE_SOCKETS_MAX]; nsapi_error_t map_mesh_error(mesh_error_t err) { switch (err) { - case MESH_ERROR_NONE: return 0; - case MESH_ERROR_MEMORY: return NSAPI_ERROR_NO_MEMORY; - case MESH_ERROR_PARAM: return NSAPI_ERROR_UNSUPPORTED; - case MESH_ERROR_STATE: return NSAPI_ERROR_DEVICE_ERROR; - default: return NSAPI_ERROR_DEVICE_ERROR; + case MESH_ERROR_NONE: + return 0; + case MESH_ERROR_MEMORY: + return NSAPI_ERROR_NO_MEMORY; + case MESH_ERROR_PARAM: + return NSAPI_ERROR_UNSUPPORTED; + case MESH_ERROR_STATE: + return NSAPI_ERROR_DEVICE_ERROR; + default: + return NSAPI_ERROR_DEVICE_ERROR; } } static void convert_mbed_addr_to_ns(ns_address_t *ns_addr, - const SocketAddress *s_addr) + const SocketAddress *s_addr) { ns_addr->type = ADDRESS_IPV6; ns_addr->identifier = s_addr->get_port(); @@ -142,10 +150,12 @@ static int8_t find_interface_by_address(const uint8_t target_addr[16]) return -1; } -void* NanostackSocket::operator new(std::size_t sz) { +void *NanostackSocket::operator new (std::size_t sz) +{ return MALLOC(sz); } -void NanostackSocket::operator delete(void* ptr) { +void NanostackSocket::operator delete (void *ptr) +{ FREE(ptr); } @@ -296,7 +306,8 @@ void NanostackSocket::signal_event() } } -void NanostackSocket::socket_callback(void *cb) { +void NanostackSocket::socket_callback(void *cb) +{ nanostack_assert_locked(); socket_callback_t *sock_cb = (socket_callback_t *) cb; @@ -304,7 +315,7 @@ void NanostackSocket::socket_callback(void *cb) { MBED_ASSERT(socket != NULL); tr_debug("socket_callback() sock=%d, event=%d, interface=%d, data len=%d", - sock_cb->socket_id, sock_cb->event_type, sock_cb->interface_id, sock_cb->d_len); + sock_cb->socket_id, sock_cb->event_type, sock_cb->interface_id, sock_cb->d_len); switch (sock_cb->event_type) { case SOCKET_DATA: @@ -506,7 +517,7 @@ Nanostack::call_in_callback_cb_t Nanostack::get_call_in_callback() return cb; } -const char * Nanostack::get_ip_address() +const char *Nanostack::get_ip_address() { NanostackLockGuard lock; @@ -539,11 +550,11 @@ nsapi_error_t Nanostack::socket_open(void **handle, nsapi_protocol_t protocol) MBED_ASSERT(false); return NSAPI_ERROR_UNSUPPORTED; } - *handle = (void*)NULL; + *handle = (void *)NULL; NanostackLockGuard lock; - NanostackSocket * socket = new NanostackSocket(ns_proto); + NanostackSocket *socket = new NanostackSocket(ns_proto); if (socket == NULL) { tr_debug("socket_open() ret=%i", NSAPI_ERROR_NO_MEMORY); return NSAPI_ERROR_NO_MEMORY; @@ -553,7 +564,7 @@ nsapi_error_t Nanostack::socket_open(void **handle, nsapi_protocol_t protocol) tr_debug("socket_open() ret=%i", NSAPI_ERROR_NO_MEMORY); return NSAPI_ERROR_NO_MEMORY; } - *handle = (void*)socket; + *handle = (void *)socket; tr_debug("socket_open() socket=%p, sock_id=%d, ret=0", socket, socket->socket_id); @@ -564,7 +575,7 @@ nsapi_error_t Nanostack::socket_close(void *handle) { NanostackLockGuard lock; // Validate parameters - NanostackSocket * socket = static_cast(handle); + NanostackSocket *socket = static_cast(handle); if (NULL == handle) { MBED_ASSERT(false); return NSAPI_ERROR_NO_SOCKET; @@ -580,7 +591,7 @@ nsapi_error_t Nanostack::socket_close(void *handle) nsapi_size_or_error_t Nanostack::do_sendto(void *handle, const ns_address_t *address, const void *data, nsapi_size_t size) { // Validate parameters - NanostackSocket * socket = static_cast(handle); + NanostackSocket *socket = static_cast(handle); if (handle == NULL) { MBED_ASSERT(false); return NSAPI_ERROR_NO_SOCKET; @@ -604,7 +615,7 @@ nsapi_size_or_error_t Nanostack::do_sendto(void *handle, const ns_address_t *add int retcode; #if 0 retcode = ::socket_sendto(socket->socket_id, address, - data, size); + data, size); #else // Use sendmsg purely to get the new return style // of returning data written rather than 0 on success, @@ -616,7 +627,7 @@ nsapi_size_or_error_t Nanostack::do_sendto(void *handle, const ns_address_t *add iov.iov_base = const_cast(data); iov.iov_len = size; msg.msg_name = const_cast(address); - msg.msg_namelen = address ? sizeof *address : 0; + msg.msg_namelen = address ? sizeof * address : 0; msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_control = NULL; @@ -771,7 +782,7 @@ nsapi_error_t Nanostack::setsockopt(void *handle, int level, int optname, const /* Check address types are IPv6, or unspecified for interface */ if (imr->imr_multiaddr.version != NSAPI_IPv6 || - (imr->imr_interface.version != NSAPI_UNSPEC && imr->imr_interface.version != NSAPI_IPv6)) { + (imr->imr_interface.version != NSAPI_UNSPEC && imr->imr_interface.version != NSAPI_IPv6)) { return NSAPI_ERROR_PARAMETER; } @@ -841,7 +852,7 @@ nsapi_error_t Nanostack::socket_listen(void *handle, int backlog) NanostackLockGuard lock; - if(::socket_listen(socket->socket_id, backlog) < 0) { + if (::socket_listen(socket->socket_id, backlog) < 0) { ret = NSAPI_ERROR_PARAMETER; } else { socket->set_listening(); @@ -904,7 +915,7 @@ nsapi_error_t Nanostack::socket_connect(void *handle, const SocketAddress &addr) nsapi_error_t Nanostack::socket_accept(void *server, void **handle, SocketAddress *address) { - NanostackSocket * socket = static_cast(server); + NanostackSocket *socket = static_cast(server); NanostackSocket *accepted_sock = NULL; nsapi_error_t ret; @@ -965,7 +976,7 @@ nsapi_size_or_error_t Nanostack::socket_recv(void *handle, void *data, nsapi_siz void Nanostack::socket_attach(void *handle, void (*callback)(void *), void *id) { // Validate parameters - NanostackSocket * socket = static_cast(handle); + NanostackSocket *socket = static_cast(handle); if (handle == NULL) { MBED_ASSERT(false); return; @@ -979,7 +990,8 @@ void Nanostack::socket_attach(void *handle, void (*callback)(void *), void *id) tr_debug("socket_attach(socket=%p) sock_id=%d", socket, socket->socket_id); } -Nanostack &Nanostack::get_instance() { +Nanostack &Nanostack::get_instance() +{ static Nanostack nanostack; return nanostack; } @@ -989,7 +1001,8 @@ Nanostack &Nanostack::get_instance() { #define NANOSTACK 0x99119911 #if MBED_CONF_NSAPI_DEFAULT_STACK == NANOSTACK #undef NANOSTACK -OnboardNetworkStack &OnboardNetworkStack::get_default_instance() { +OnboardNetworkStack &OnboardNetworkStack::get_default_instance() +{ return Nanostack::get_instance(); } #endif diff --git a/features/nanostack/nanostack-interface/NanostackLockGuard.h b/features/nanostack/nanostack-interface/NanostackLockGuard.h index ec1a249a14d..9a064f82d77 100644 --- a/features/nanostack/nanostack-interface/NanostackLockGuard.h +++ b/features/nanostack/nanostack-interface/NanostackLockGuard.h @@ -27,17 +27,19 @@ class NanostackLockGuard { public: - NanostackLockGuard() { + NanostackLockGuard() + { eventOS_scheduler_mutex_wait(); } - ~NanostackLockGuard() { + ~NanostackLockGuard() + { eventOS_scheduler_mutex_release(); } private: - NanostackLockGuard(const NanostackLockGuard&); - NanostackLockGuard& operator=(const NanostackLockGuard&); + NanostackLockGuard(const NanostackLockGuard &); + NanostackLockGuard &operator=(const NanostackLockGuard &); }; #endif /* NANOSTACK_LOCK_GUARD_H_ */ diff --git a/features/nanostack/nanostack-interface/NanostackRfPhy.h b/features/nanostack/nanostack-interface/NanostackRfPhy.h index c085dbe0e82..6ade690df5b 100644 --- a/features/nanostack/nanostack-interface/NanostackRfPhy.h +++ b/features/nanostack/nanostack-interface/NanostackRfPhy.h @@ -48,12 +48,18 @@ class NanostackRfPhy : public NanostackPhy { * @return Device driver ID or a negative error * code on failure */ - virtual int8_t phy_register() { return rf_register();} + virtual int8_t phy_register() + { + return rf_register(); + } /** Unregister this physical interface * */ - virtual void unregister() { rf_unregister(); } + virtual void unregister() + { + rf_unregister(); + } }; #endif /* NANOSTACK_RF_PHY_H_ */ diff --git a/features/nanostack/sal-stack-nanostack-eventloop/source/ns_timeout.c b/features/nanostack/sal-stack-nanostack-eventloop/source/ns_timeout.c index 62f131bd9db..4b3082f5015 100644 --- a/features/nanostack/sal-stack-nanostack-eventloop/source/ns_timeout.c +++ b/features/nanostack/sal-stack-nanostack-eventloop/source/ns_timeout.c @@ -78,14 +78,16 @@ static timeout_t *eventOS_timeout_at_(void (*callback)(void *), void *arg, uint3 .data_ptr = timeout }; - if (period) + if (period) { storage = eventOS_event_timer_request_every(&event, period); - else + } else { storage = eventOS_event_timer_request_at(&event, at); + } timeout->event = storage; - if (storage) + if (storage) { return timeout; + } FAIL: ns_dyn_mem_free(timeout); return NULL; @@ -93,7 +95,7 @@ static timeout_t *eventOS_timeout_at_(void (*callback)(void *), void *arg, uint3 timeout_t *eventOS_timeout_ms(void (*callback)(void *), uint32_t ms, void *arg) { - return eventOS_timeout_at_(callback, arg, eventOS_event_timer_ms_to_ticks(ms)+eventOS_event_timer_ticks(), 0); + return eventOS_timeout_at_(callback, arg, eventOS_event_timer_ms_to_ticks(ms) + eventOS_event_timer_ticks(), 0); } timeout_t *eventOS_timeout_every_ms(void (*callback)(void *), uint32_t every, void *arg) @@ -103,8 +105,9 @@ timeout_t *eventOS_timeout_every_ms(void (*callback)(void *), uint32_t every, vo void eventOS_timeout_cancel(timeout_t *t) { - if (!t) + if (!t) { return; + } eventOS_cancel(t->event); diff --git a/features/nanostack/sal-stack-nanostack-eventloop/source/system_timer.c b/features/nanostack/sal-stack-nanostack-eventloop/source/system_timer.c index 7535a4c5979..70d684b5908 100644 --- a/features/nanostack/sal-stack-nanostack-eventloop/source/system_timer.c +++ b/features/nanostack/sal-stack-nanostack-eventloop/source/system_timer.c @@ -53,7 +53,7 @@ static int8_t platform_tick_timer_start(uint32_t period_ms); /* Implement platform tick timer using eventOS timer */ // platform tick timer callback function static void (*tick_timer_callback)(void); -static int8_t tick_timer_id = -1; // eventOS timer id for tick timer +static int8_t tick_timer_id = -1; // eventOS timer id for tick timer // EventOS timer callback function static void tick_timer_eventOS_callback(int8_t timer_id, uint16_t slots) @@ -299,7 +299,7 @@ int8_t eventOS_event_timer_request(uint8_t event_id, uint8_t event_type, int8_t platform_enter_critical(); arm_event_storage_t *ret = eventOS_event_timer_request_at_(&event, timer_sys_ticks + time, 0); platform_exit_critical(); - return ret?0:-1; + return ret ? 0 : -1; } int8_t eventOS_event_timer_cancel(uint8_t event_id, int8_t tasklet_id) diff --git a/features/nanostack/targets/TARGET_NCS36510/NanostackRfPhyNcs36510.cpp b/features/nanostack/targets/TARGET_NCS36510/NanostackRfPhyNcs36510.cpp index f88b2ca2dbc..548055d6673 100644 --- a/features/nanostack/targets/TARGET_NCS36510/NanostackRfPhyNcs36510.cpp +++ b/features/nanostack/targets/TARGET_NCS36510/NanostackRfPhyNcs36510.cpp @@ -43,39 +43,39 @@ Thread rf_thread(osPriorityRealtime, RF_THREAD_STACK_SIZE); /** * MAC status code bit definition */ -#define MAC_STATUS_SUCCESS (0x0) /**< Success */ -#define MAC_STATUS_TIMEOUT (0x1) /**< Time out */ -#define MAC_STATUS_BUSY (0x2) /**< Channel Busy */ -#define MAC_STATUS_CRCFAIL (0x3) /**< CRC Failed */ -#define MAC_STATUS_NOACK (0x5) /**< No ACK */ -#define MAC_STATUS_UNLOCK (0x6) /**< PLL unlocked */ -#define MAC_STATUS_BADSTART (0x7) /**< Bad Start */ -#define MAC_STATUS_RXACK_PENDING (0x8) /**< ACK frame was received with the Pending bit set */ -#define MAC_STATUS_TXACK_PENDING (0x9) /**< ACK frame was transmitted with the Pending bit set */ -#define MAC_STATUS_FAIL_FILTER (0xA) /**< One or more frame filtering tests has failed */ -#define MAC_STATUS_PANID_CONFLICT (0xB) /**< A PANID conflict has been detected */ -#define MAC_STATUS_NOTCOMPLETE (0xF) /**< Not complete */ +#define MAC_STATUS_SUCCESS (0x0) /**< Success */ +#define MAC_STATUS_TIMEOUT (0x1) /**< Time out */ +#define MAC_STATUS_BUSY (0x2) /**< Channel Busy */ +#define MAC_STATUS_CRCFAIL (0x3) /**< CRC Failed */ +#define MAC_STATUS_NOACK (0x5) /**< No ACK */ +#define MAC_STATUS_UNLOCK (0x6) /**< PLL unlocked */ +#define MAC_STATUS_BADSTART (0x7) /**< Bad Start */ +#define MAC_STATUS_RXACK_PENDING (0x8) /**< ACK frame was received with the Pending bit set */ +#define MAC_STATUS_TXACK_PENDING (0x9) /**< ACK frame was transmitted with the Pending bit set */ +#define MAC_STATUS_FAIL_FILTER (0xA) /**< One or more frame filtering tests has failed */ +#define MAC_STATUS_PANID_CONFLICT (0xB) /**< A PANID conflict has been detected */ +#define MAC_STATUS_NOTCOMPLETE (0xF) /**< Not complete */ /** * MAC sequence modes */ -#define MAC_SEQUENCE_NOP (0x0) /**< NOP */ -#define MAC_SEQUENCE_RX (0x3) /**< RX */ -#define MAC_SEQUENCE_TX (0x4) /**< TX */ -#define MAC_SEQUENCE_ED (0x5) /**< ED */ -#define MAC_SEQUENCE_CCA (0x6) /**< CCA */ +#define MAC_SEQUENCE_NOP (0x0) /**< NOP */ +#define MAC_SEQUENCE_RX (0x3) /**< RX */ +#define MAC_SEQUENCE_TX (0x4) /**< TX */ +#define MAC_SEQUENCE_ED (0x5) /**< ED */ +#define MAC_SEQUENCE_CCA (0x6) /**< CCA */ /** * MAC Interrupt enable / disable */ -#define MAC_IRQ_NONE (0x0) /**< No IRQ */ -#define MAC_IRQ_COMPLETE (0x1) /**< Event-complete IRQ */ -#define MAC_IRQ_EVENT_STARTED (0x2) /**< Event-started IRQ */ -#define MAC_IRQ_DATA (0x4) /**< Data-arrived IRQ */ -#define MAC_IRQ_FRAME_STARTED (0x8) /**< Frame-started IRQ */ -#define MAC_IRQ_PACKET_FAIL (0x10) /**< Failed-packet IRQ */ -#define MAC_IRQ_FRAME_MATCH (0x20) /**< Frame-match IRQ (indicating matching process is done) */ -#define MAC_IRQ_ALL (0x3F) /**< All IRQs */ +#define MAC_IRQ_NONE (0x0) /**< No IRQ */ +#define MAC_IRQ_COMPLETE (0x1) /**< Event-complete IRQ */ +#define MAC_IRQ_EVENT_STARTED (0x2) /**< Event-started IRQ */ +#define MAC_IRQ_DATA (0x4) /**< Data-arrived IRQ */ +#define MAC_IRQ_FRAME_STARTED (0x8) /**< Frame-started IRQ */ +#define MAC_IRQ_PACKET_FAIL (0x10) /**< Failed-packet IRQ */ +#define MAC_IRQ_FRAME_MATCH (0x20) /**< Frame-match IRQ (indicating matching process is done) */ +#define MAC_IRQ_ALL (0x3F) /**< All IRQs */ #define MAC_RSSI_TO_ED 0 #define MAC_RSSI_TO_LQI 1 @@ -104,11 +104,11 @@ static void rf_mac_write(uint8_t *data_ptr, uint8_t length); 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 void rf_mac_get_mac64(uint8_t* valueAddress); +static void rf_mac_get_mac64(uint8_t *valueAddress); static int8_t set_channel(uint8_t channel); static void handle_IRQ_events(void); @@ -131,8 +131,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 = { @@ -140,7 +140,7 @@ static phy_device_driver_s device_driver = { PHY_LAYER_PAYLOAD_DATA_FLOW, MAC64_addr, PHY_MTU_SIZE, - (char*)"ON Semi ncs36510", + (char *)"ON Semi ncs36510", CRC_LENGTH, PHY_HEADER_LENGTH, &rf_interface_state_control, @@ -171,7 +171,7 @@ static void rf_thread_loop() static int8_t rf_device_register(void) { - if( rf_radio_driver_id < 0 ) { + if (rf_radio_driver_id < 0) { rf_mac_hw_init(); /** @@ -210,7 +210,8 @@ void rf_set_mac_address(const uint8_t *ptr) platform_exit_critical(); } -static void rf_mac_set_pending(uint8_t status) { +static void rf_mac_set_pending(uint8_t status) +{ if (status) { MACHWREG->OPTIONS.BITS.TFPO = 0; @@ -226,33 +227,33 @@ static void rf_mac_set_pending(uint8_t status) { static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_t rf_channel) { platform_enter_critical(); - switch(new_state){ + switch (new_state) { case PHY_INTERFACE_RESET: { /**< Reset PHY driver and set to idle. */ rf_mac_set_rx_on_state(false); break; - } + } case PHY_INTERFACE_DOWN: { /**< Disable PHY interface driver (RF radio disable). */ rf_mac_set_rx_on_state(false); break; - } + } case PHY_INTERFACE_UP: { /**< Enable PHY interface driver (RF radio receiver ON). */ set_channel(rf_channel); rf_mac_set_rx_on_state(true); break; - } + } case PHY_INTERFACE_RX_ENERGY_STATE: { /**< Enable wirless interface ED scan mode. */ rf_ed_value = 0; set_channel(rf_channel); rf_mac_set_rx_on_state(false); rf_mac_ed_state_enable(); break; - } + } case PHY_INTERFACE_SNIFFER_STATE: { set_channel(rf_channel); rf_mac_set_rx_on_state(true); break; - } + } } platform_exit_critical(); return 0; @@ -273,17 +274,17 @@ static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address int ret_value = 0; platform_enter_critical(); switch (address_type) { - case PHY_MAC_64BIT: /**< RF/PLC link layer address. */ - rf_mac_set_mac64(address_ptr); - break; - case PHY_MAC_16BIT: /**< RF interface short address. */ - rf_mac_set_shortAddress(address_ptr); - break; - case PHY_MAC_PANID: /**< RF interface 16-Bit PAN-ID. */ - rf_mac_set_panId(address_ptr); - break; - default: - ret_value = -1; + case PHY_MAC_64BIT: /**< RF/PLC link layer address. */ + rf_mac_set_mac64(address_ptr); + break; + case PHY_MAC_16BIT: /**< RF interface short address. */ + rf_mac_set_shortAddress(address_ptr); + break; + case PHY_MAC_PANID: /**< RF interface 16-Bit PAN-ID. */ + rf_mac_set_panId(address_ptr); + break; + default: + ret_value = -1; } platform_exit_critical(); @@ -310,7 +311,7 @@ static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_pt case PHY_EXTENSION_READ_LINK_STATUS: /**< Net library could read link status. */ case PHY_EXTENSION_CONVERT_SIGNAL_INFO: /**< Convert signal info. */ - default: + default: ret_value = -1; } platform_exit_critical(); @@ -320,7 +321,7 @@ static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_pt static int8_t set_channel(uint8_t channel) { - if( channel > 10 && channel < 27 ){ + if (channel > 10 && channel < 27) { fRfAnaIoctl(SET_RF_CHANNEL, &channel); return 0; } @@ -331,32 +332,37 @@ static int8_t set_channel(uint8_t channel) /** * SET MAC 16 address to Register */ -static void rf_mac_set_shortAddress(uint8_t* valueAddress) { +static void rf_mac_set_shortAddress(uint8_t *valueAddress) +{ MACHWREG->SHORT_ADDRESS = common_read_16_bit(valueAddress); } /** * SET PAN-ID to Register */ -static void rf_mac_set_panId(uint8_t* valueAddress) { +static void rf_mac_set_panId(uint8_t *valueAddress) +{ MACHWREG->PANID = common_read_16_bit(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) +{ MACHWREG->LONG_ADDRESS_HIGH = common_read_32_bit(valueAddress); valueAddress += 4; MACHWREG->LONG_ADDRESS_LOW = common_read_32_bit(valueAddress); } -static void rf_mac_get_mac64(uint8_t* valueAddress) { +static void rf_mac_get_mac64(uint8_t *valueAddress) +{ valueAddress = common_write_32_bit(MACHWREG->LONG_ADDRESS_HIGH, valueAddress); common_write_32_bit(MACHWREG->LONG_ADDRESS_LOW, valueAddress); } -static void rf_mac_timers_disable_trig_event(void) { +static void rf_mac_timers_disable_trig_event(void) +{ MACHWREG->TIMER_DISABLE.BITS.START = true; MACHWREG->TIMER_DISABLE.BITS.STOP = true; MACHWREG->SEQ_OPTIONS.BITS.NOW = true; @@ -365,7 +371,8 @@ static void rf_mac_timers_disable_trig_event(void) { /** * Call this only One time */ -static void rf_mac_hw_init(void) { +static void rf_mac_hw_init(void) +{ uint32_t periphClockfrequency; uint8_t lutIndex; volatile uint8_t *pMatchReg = MACMATCHREG; @@ -448,8 +455,8 @@ static void rf_mac_hw_init(void) { rf_mac_reset(); /** Initialise LUT RAM */ - for (lutIndex=0;lutIndex<96;lutIndex++) { - *(pMatchReg + lutIndex) = 0xFF; + for (lutIndex = 0; lutIndex < 96; lutIndex++) { + *(pMatchReg + lutIndex) = 0xFF; } osStatus status = rf_thread.start(mbed::callback(rf_thread_loop)); MBED_ASSERT(status == osOK); @@ -459,7 +466,8 @@ static void rf_mac_hw_init(void) { NVIC_EnableIRQ(MacHw_IRQn); } -static void rf_mac_set_rx_on_state(bool enable) { +static void rf_mac_set_rx_on_state(bool enable) +{ /** Abort ongoing sequence */ rf_mac_reset(); /** Start rx if requested */ @@ -473,7 +481,8 @@ static void rf_mac_set_rx_on_state(bool enable) { } } -static void rf_mac_write(uint8_t *data_ptr, uint8_t length) { +static void rf_mac_write(uint8_t *data_ptr, uint8_t length) +{ uint8_t i; volatile uint8_t *txRam = MACTXREG; @@ -511,7 +520,9 @@ static void rf_mac_write(uint8_t *data_ptr, uint8_t length) { /* Start CCA immediately */ rf_mac_timers_disable_trig_event(); - while (MACHWREG->TIMER != 0x0) MACHWREG->TIMER = 0x0; // HW ISSUE: field is not set immediately + while (MACHWREG->TIMER != 0x0) { + MACHWREG->TIMER = 0x0; // HW ISSUE: field is not set immediately + } /* Enable tx irq, reset protocol timer and start tx sequence */ MACHWREG->MASK_IRQ.WORD = MAC_IRQ_COMPLETE; @@ -520,7 +531,8 @@ static void rf_mac_write(uint8_t *data_ptr, uint8_t length) { } -static void rf_mac_ed_state_enable(void) { +static void rf_mac_ed_state_enable(void) +{ rf_mac_state = MAC_RF_ED_SCAN; /** Enable Energy scan state and event complete interrupt */ MACHWREG->CLEAR_IRQ.WORD = MAC_IRQ_COMPLETE; @@ -529,18 +541,22 @@ static void rf_mac_ed_state_enable(void) { } -static void rf_mac_rx_enable(void) { +static void rf_mac_rx_enable(void) +{ rf_mac_state = MAC_RF_RX_ON; /** Enable rx irqs, reset protocol timer and start rx sequence */ MACHWREG->MASK_IRQ.WORD = MAC_IRQ_COMPLETE | MAC_IRQ_FRAME_MATCH | MAC_IRQ_DATA; - while (MACHWREG->TIMER != 0x0) MACHWREG->TIMER = 0x0; // HW ISSUE: field is not set immediately + while (MACHWREG->TIMER != 0x0) { + MACHWREG->TIMER = 0x0; // HW ISSUE: field is not set immediately + } MACHWREG->SEQUENCER = MAC_SEQUENCE_RX; return; } -static void rf_mac_reset(void) { +static void rf_mac_reset(void) +{ uint32_t macHwDivider; /** Recommended abort sequence (with synchronous reset) */ @@ -583,7 +599,8 @@ static void rf_mac_reset(void) { rf_mac_state = MAC_RF_TRX_OFF; } -static uint8_t rf_mac_convert_rssi(uint8_t scale) { +static uint8_t rf_mac_convert_rssi(uint8_t scale) +{ /* RSSI Value: The value is captured at the end of packet reception or at the end of ED/CCA * measurements and is interpreted in dBm as follows: * 1xxxxxxx: not used @@ -605,7 +622,7 @@ static uint8_t rf_mac_convert_rssi(uint8_t scale) { /* convert rssi in sign char: translate 01111111 into 0 and following alike, make negative */ signed char rssi_value = -1 * (DMDREG->DMD_STATUS.BITS.RSSI_VALUE ^ 0x7F); - if (scale == MAC_RSSI_TO_ED ) { + if (scale == MAC_RSSI_TO_ED) { /** * For ED (IEEE 6.9.7) "The ED result shall be reported to the MLME as an 8 bit integer * ranging from 0x00 to 0xff. The minimum ED value (zero) shall indicate received power less than 10 dB @@ -617,8 +634,12 @@ static uint8_t rf_mac_convert_rssi(uint8_t scale) { */ /* Clip maximal and minimal rssi value reported by ED */ - if (rssi_value < -75) rssi_value = -75; - if (rssi_value > -24) rssi_value = -24; + if (rssi_value < -75) { + rssi_value = -75; + } + if (rssi_value > -24) { + rssi_value = -24; + } /* scale the span -75dBm --> -24dBm to 0x00 --> 0xFF * Attention: This scaling implies that granularity of the result is changing from 1dBm per unit to 1/5 dBm per unit @@ -646,8 +667,12 @@ static uint8_t rf_mac_convert_rssi(uint8_t scale) { */ /* Clip maximal and minimal rssi value reported by LQI */ - if (rssi_value < -85) rssi_value = -85; - if (rssi_value > -21) rssi_value = -21; + if (rssi_value < -85) { + rssi_value = -85; + } + if (rssi_value > -21) { + rssi_value = -21; + } /* scale the span -85dBm --> -21,25dBm to 0x00 --> 0xFF * Attention: This scaling implies that granularity of the result is changing from 1dBm per unit to 1/4 dBm per unit @@ -667,19 +692,22 @@ static uint8_t rf_mac_convert_rssi(uint8_t scale) { * 0x01: (impossible code) * 0x00: - 85dBm */ - if (rssi_value == -21) + if (rssi_value == -21) { return ((rssi_value + 85) * 4) - 1; - else + } else { return (rssi_value + 85) * 4; + } } } -static int8_t rf_mac_get_rssi(void) { +static int8_t rf_mac_get_rssi(void) +{ int8_t rssi_value = -1 * (DMDREG->DMD_STATUS.BITS.RSSI_VALUE ^ 0x7F); return rssi_value; } -static void rf_rx_ed_scan_interrupt() { +static void rf_rx_ed_scan_interrupt() +{ MACHWREG->CLEAR_IRQ.WORD = MAC_IRQ_COMPLETE; if (MACHWREG->STATUS.BITS.CODE == MAC_STATUS_SUCCESS) { uint8_t ed = rf_mac_convert_rssi(MAC_RSSI_TO_ED); @@ -694,7 +722,8 @@ static void rf_rx_ed_scan_interrupt() { MACHWREG->SEQUENCER = MAC_SEQUENCE_ED; } -static void rf_rx_interrupt() { +static void rf_rx_interrupt() +{ // Frame match is used for association and data frames uint8_t seqSts = MACHWREG->STATUS.BITS.CODE; @@ -736,14 +765,14 @@ static void rf_rx_interrupt() { } length = *rxRam++; - if (length < 5){ + if (length < 5) { rf_mac_rx_enable(); return; } length -= 2; //Cut CRC OUT /* Initialize frame status */ - for (uint8_t i=0; i < length; i++) { + for (uint8_t i = 0; i < length; i++) { PHYPAYLOAD[i] = *rxRam++; } @@ -751,7 +780,7 @@ static void rf_rx_interrupt() { rssi = rf_mac_get_rssi(); rf_mac_rx_enable(); //Call ARM API - if( device_driver.phy_rx_cb ){ + if (device_driver.phy_rx_cb) { device_driver.phy_rx_cb(PHYPAYLOAD, length, lqi, rssi, rf_radio_driver_id); } } @@ -768,31 +797,31 @@ static void rf_mac_tx_interrupt(void) rf_mac_set_rx_on_state(true); switch (sharedSeqSts) { - case MAC_STATUS_SUCCESS: /* Positive */ - //SET Success - if (rf_mac_ack_requsted) { - status = PHY_LINK_TX_DONE; - } else { - status = PHY_LINK_TX_SUCCESS; - } - break; + case MAC_STATUS_SUCCESS: /* Positive */ + //SET Success + if (rf_mac_ack_requsted) { + status = PHY_LINK_TX_DONE; + } else { + status = PHY_LINK_TX_SUCCESS; + } + break; - case MAC_STATUS_RXACK_PENDING: /* Positive for broadcast */ - status = PHY_LINK_TX_DONE_PENDING; - break; + case MAC_STATUS_RXACK_PENDING: /* Positive for broadcast */ + status = PHY_LINK_TX_DONE_PENDING; + break; - case MAC_STATUS_BUSY: - status = PHY_LINK_CCA_FAIL; - break; + case MAC_STATUS_BUSY: + status = PHY_LINK_CCA_FAIL; + break; - default: - status = PHY_LINK_TX_FAIL; - break; + default: + status = PHY_LINK_TX_FAIL; + break; } rf_mac_ack_requsted = false; - //Call RX TX complete - if( device_driver.phy_tx_done_cb ) { + //Call RX TX complete + if (device_driver.phy_tx_done_cb) { device_driver.phy_tx_done_cb(rf_radio_driver_id, rf_mac_handle, status, 1, 1); } } @@ -820,9 +849,9 @@ static void handle_IRQ_events(void) if (rf_mac_state == MAC_RF_RX_ON) { rf_rx_interrupt(); - } else if(rf_mac_state == MAC_RF_TX_ON) { + } else if (rf_mac_state == MAC_RF_TX_ON) { rf_mac_tx_interrupt(); - } else if (rf_mac_state == MAC_RF_ED_SCAN){ + } else if (rf_mac_state == MAC_RF_ED_SCAN) { rf_rx_ed_scan_interrupt(); } else { /** Clear the event complete IRQ */ @@ -880,7 +909,7 @@ void NanostackRfPhyNcs36510::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(); } @@ -894,7 +923,7 @@ void NanostackRfPhyNcs36510::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_Silicon_Labs/TARGET_SL_RAIL/NanostackRfPhyEfr32.cpp b/features/nanostack/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/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()