Add tracing to BLE GAP (#14117)

* Add traces to GapImpl.cpp

* Add helpers and param logs

* Update GapImpl.cpp

* Move helpers to ble_trace_helpers.h

* Add traces to whitelist setter & getter functions

* Prepend parent dir. to ble_trace_helpers.h include line

* Resolve portability issue by using PRI* macro in place of %lu

* Add traces to PalGapImpl.cpp

* Complete PAL GAP traces

* Remove stray include

* Make 'echo' traces in PAL configurable

Some of the tr_info traces at the beginning of PAL functions  are duplicates ('echoes') of those in GAP functions. This commit enables including/excluding of these traces in mbed_app.json by writing 1/0, respectively to the MBED_CONF_CORDIO_TRACE_PAL_ECHOES config macro. The default is to exclude 'echo' traces.

* Add missing spaces in tr_info traces

* Clean-up param log for set_extended_advertising_parameters

* Remove "Failed: " from every tr_error trace

* Apply changes from PalGapImpl.cpp review

* Apply changes from GapImpl.cpp review

* Use binary for channel map trace

B0: ADVERTISING_CHANNEL_37
B1: ADVERTISING_CHANNEL_38
B2: ADVERTISING_CHANNEL_39

We're assuming that the user understands the above. This could be documented somewhere.

* Replace more %lu w/PRIu32

* Add tr_info to terminateSync for user call

* Make trace group for PAL traces BLDM

* Remove [PAL] prefix from every PAL trace

* Add trace to setPeripheralPrivacyConfiguration

* Make set scan params tr_info dependent on selected PHY

* Add trace to GAP events

* Other GAP events required traces

connectivity/FEATURE_BLE/source/common/ble_trace_helpers.h

@@ -21,6 +21,7 @@
 #include "ble/SecurityManager.h"
 #include "mbed-trace/mbed_trace.h"
 #include "pal/GapTypes.h"
+#include "pal/GapEvents.h"
 #include "ble-host/include/dm_api.h"
 #include "common/UUID.h"
 
@@ -226,6 +227,471 @@ static inline const char *to_string(privacy_mode_t mode)
     }
 }
 
+static inline const char* to_string(ble::advertising_type_t advType)
+{
+    switch (advType.value()) {
+        case ble::advertising_type_t::CONNECTABLE_UNDIRECTED:
+            return "CONNECTABLE_UNDIRECTED";
+        case ble::advertising_type_t::CONNECTABLE_DIRECTED:
+            return "CONNECTABLE_DIRECTED";
+        case ble::advertising_type_t::SCANNABLE_UNDIRECTED:
+            return "SCANNABLE_UNDIRECTED";
+        case ble::advertising_type_t::NON_CONNECTABLE_UNDIRECTED:
+            return "NON_CONNECTABLE_UNDIRECTED";
+        case ble::advertising_type_t::CONNECTABLE_DIRECTED_LOW_DUTY:
+            return "CONNECTABLE_DIRECTED_LOW_DUTY";
+        case ble::advertising_type_t::CONNECTABLE_NON_SCANNABLE_UNDIRECTED:
+            return "CONNECTABLE_NON_SCANNABLE_UNDIRECTED";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::own_address_type_t addressType)
+{
+    switch (addressType.value()) {
+        case ble::own_address_type_t::PUBLIC:
+            return "PUBLIC";
+        case ble::own_address_type_t::RANDOM:
+            return "RANDOM";
+        case ble::own_address_type_t::RESOLVABLE_PRIVATE_ADDRESS_PUBLIC_FALLBACK:
+            return "RESOLVABLE_PRIVATE_ADDRESS_PUBLIC_FALLBACK";
+        case ble::own_address_type_t::RESOLVABLE_PRIVATE_ADDRESS_RANDOM_FALLBACK:
+            return "RESOLVABLE_PRIVATE_ADDRESS_RANDOM_FALLBACK";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::advertising_filter_policy_t policy)
+{
+    switch (policy.value()) {
+        case ble::advertising_filter_policy_t::NO_FILTER:
+            return "NO_FILTER";
+        case ble::advertising_filter_policy_t::FILTER_SCAN_REQUESTS:
+            return "FILTER_SCAN_REQUESTS";
+        case ble::advertising_filter_policy_t::FILTER_CONNECTION_REQUEST:
+            return "FILTER_CONNECTION_REQUEST";
+        case ble::advertising_filter_policy_t::FILTER_SCAN_AND_CONNECTION_REQUESTS:
+            return "FILTER_SCAN_AND_CONNECTION_REQUESTS";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::phy_t phy)
+{
+    switch (phy.value()) {
+        case ble::phy_t::NONE:
+            return "NONE";
+        case ble::phy_t::LE_1M:
+            return "LE_1M";
+        case ble::phy_t::LE_2M:
+            return "LE_2M";
+        case ble::phy_t::LE_CODED:
+            return "LE_CODED";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::scanning_filter_policy_t policy)
+{
+    switch (policy.value()) {
+        case ble::scanning_filter_policy_t::NO_FILTER:
+            return "NO_FILTER";
+        case ble::scanning_filter_policy_t::FILTER_ADVERTISING:
+            return "FILTER_ADVERTISING";
+        case ble::scanning_filter_policy_t::NO_FILTER_INCLUDE_UNRESOLVABLE_DIRECTED:
+            return "NO_FILTER_INCLUDE_UNRESOLVABLE_DIRECTED";
+        case ble::scanning_filter_policy_t::FILTER_ADVERTISING_INCLUDE_UNRESOLVABLE_DIRECTED:
+            return "FILTER_ADVERTISING_INCLUDE_UNRESOLVABLE_DIRECTED";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::duplicates_filter_t filtering)
+{
+    switch (filtering.value()) {
+        case ble::duplicates_filter_t::ENABLE:
+            return "ENABLE";
+        case ble::duplicates_filter_t::DISABLE:
+            return "DISABLE";
+        case ble::duplicates_filter_t::PERIODIC_RESET:
+            return "PERIODIC_RESET";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::peer_address_type_t addressType)
+{
+    switch (addressType.value()) {
+        case ble::peer_address_type_t::PUBLIC:
+            return "PUBLIC";
+        case ble::peer_address_type_t::RANDOM:
+            return "RANDOM";
+        case ble::peer_address_type_t::PUBLIC_IDENTITY:
+            return "PUBLIC_IDENTITY";
+        case ble::peer_address_type_t::RANDOM_STATIC_IDENTITY:
+            return "RANDOM_STATIC_IDENTITY";
+        case ble::peer_address_type_t::ANONYMOUS:
+            return "ANONYMOUS";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::initiator_filter_policy_t policy)
+{
+    switch(policy.value()) {
+        case ble::initiator_filter_policy_t::NO_FILTER:
+            return "NO_FILTER";
+        case ble::initiator_filter_policy_t::USE_WHITE_LIST:
+            return "USE_WHITE_LIST";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::coded_symbol_per_bit_t sym)
+{
+    switch (sym.value()) {
+        case ble::coded_symbol_per_bit_t::UNDEFINED:
+            return "UNDEFINED";
+        case ble::coded_symbol_per_bit_t::S2:
+            return "S2";
+        case ble::coded_symbol_per_bit_t::S8:
+            return "S8";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::local_disconnection_reason_t reason)
+{
+    switch (reason.value()) {
+        case ble::local_disconnection_reason_t::AUTHENTICATION_FAILURE:
+            return "AUTHENTICATION_FAILURE";
+        case ble::local_disconnection_reason_t::USER_TERMINATION:
+            return "USER_TERMINATION";
+        case ble::local_disconnection_reason_t::LOW_RESOURCES:
+            return "LOW_RESOURCES";
+        case ble::local_disconnection_reason_t::POWER_OFF:
+            return "POWER OFF";
+        case ble::local_disconnection_reason_t::UNSUPPORTED_REMOTE_FEATURE:
+            return "UNSUPPORTED_REMOTE_FEATURE";
+        case ble::local_disconnection_reason_t::PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
+            return "PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED";
+        case ble::local_disconnection_reason_t::UNACCEPTABLE_CONNECTION_PARAMETERS:
+            return "UNACCEPTABLE_CONNECTION_PARAMETERS";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::advertising_channel_map_t map)
+{
+    switch (map.value()) {
+        case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_37:
+            return "[001]";
+        case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_38:
+            return "[010]";
+        case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_37_AND_38:
+            return "[011]";
+        case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_39:
+            return "[100]";
+        case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_37_AND_39:
+            return "[101]";
+        case ble::advertising_channel_map_t::ADVERTISING_CHANNEL_38_AND_39:
+            return "[110]";
+        case ble::advertising_channel_map_t::ALL_ADVERTISING_CHANNELS:
+            return "[111]";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::connection_peer_address_type_t connection_peer_address_type)
+{
+    switch (connection_peer_address_type.value()) {
+        case ble::connection_peer_address_type_t::PUBLIC_ADDRESS:
+            return "PUBLIC_ADDRESS";
+        case ble::connection_peer_address_type_t::RANDOM_ADDRESS:
+            return "RANDOM_ADDRESS";
+        case ble::connection_peer_address_type_t::PUBLIC_IDENTITY_ADDRESS:
+            return "PUBLIC_IDENTITY_ADDRESS";
+        case ble::connection_peer_address_type_t::RANDOM_IDENTITY_ADDRESS:
+            return "RANDOM_IDENTITY_ADDRESS";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::whitelist_address_type_t whitelist_address_type)
+{
+    if (whitelist_address_type.value() == ble::whitelist_address_type_t::PUBLIC_DEVICE_ADDRESS) {
+        return "PUBLIC_DEVICE_ADDRESS";
+    } else {
+        return "RANDOM_DEVICE_ADDRESS";
+    }
+}
+
+static inline const char* to_string(ble::hci_error_code_t error)
+{
+    switch (error.value()) {
+        case ble::hci_error_code_t::SUCCESS:
+            return "SUCCESS";
+        case ble::hci_error_code_t::UNKNOWN_HCI_COMMAND:
+            return "UNKNOWN_HCI_COMMAND";
+        case ble::hci_error_code_t::UNKNOWN_CONNECTION_IDENTIFIER:
+            return "UNKNOWN_CONNECTION_IDENTIFIER";
+        case ble::hci_error_code_t::HARDWARE_FAILLURE:
+            return "HARDWARE_FAILLURE";
+        case ble::hci_error_code_t::PAGE_TIMEOUT:
+            return "PAGE_TIMEOUT";
+        case ble::hci_error_code_t::AUTHENTICATION_FAILLURE:
+            return "AUTHENTICATION_FAILLURE";
+        case ble::hci_error_code_t::PIN_OR_KEY_MISSING:
+            return "PIN_OR_KEY_MISSING";
+        case ble::hci_error_code_t::MEMORY_CAPACITY_EXCEEDED:
+            return "MEMORY_CAPACITY_EXCEEDED";
+        case ble::hci_error_code_t::CONNECTION_TIMEOUT:
+            return "CONNECTION_TIMEOUT";
+        case ble::hci_error_code_t::CONNECTION_LIMIT_EXCEEDED:
+            return "CONNECTION_LIMIT_EXCEEDED";
+        case ble::hci_error_code_t::SYNCHRONOUS_CONNECTION_LIMIT_TO_A_DEVICE_EXCEEDED:
+            return "SYNCHRONOUS_CONNECTION_LIMIT_TO_A_DEVICE_EXCEEDED";
+        case ble::hci_error_code_t::CONNECTION_ALREADY_EXIST:
+            return "CONNECTION_ALREADY_EXIST";
+        case ble::hci_error_code_t::COMMAND_DISALLOWED:
+            return "COMMAND_DISALLOWED";
+        case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES:
+            return "CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES";
+        case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_SECURITY_REASONS:
+            return "CONNECTION_REJECTED_DUE_TO_SECURITY_REASONS";
+        case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_UNACCEPTABLE_BD_ADDR:
+            return "CONNECTION_REJECTED_DUE_TO_UNACCEPTABLE_BD_ADDR";
+        case ble::hci_error_code_t::CONNECTION_ACCEPT_TIMEOUT_EXCEEDED:
+            return "CONNECTION_ACCEPT_TIMEOUT_EXCEEDED";
+        case ble::hci_error_code_t::UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE:
+            return "UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE";
+        case ble::hci_error_code_t::INVALID_HCI_COMMAND_PARAMETERS:
+            return "INVALID_HCI_COMMAND_PARAMETERS";
+        case ble::hci_error_code_t::REMOTE_USER_TERMINATED_CONNECTION:
+            return "REMOTE_USER_TERMINATED_CONNECTION";
+        case ble::hci_error_code_t::REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES:
+            return "REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES";
+        case ble::hci_error_code_t::REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_POWER_OFF:
+            return "REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_POWER_OFF";
+        case ble::hci_error_code_t::CONNECTION_TERMINATED_BY_LOCAL_HOST:
+            return "CONNECTION_TERMINATED_BY_LOCAL_HOST";
+        case ble::hci_error_code_t::REPEATED_ATTEMPTS:
+            return "REPEATED_ATTEMPTS";
+        case ble::hci_error_code_t::PAIRING_NOT_ALLOWED:
+            return "PAIRING_NOT_ALLOWED";
+        case ble::hci_error_code_t::UNKNOWN_LMP_PDU:
+            return "UNKNOWN_LMP_PDU";
+        case ble::hci_error_code_t::UNSUPPORTED_REMOTE_FEATURE | ble::hci_error_code_t::UNSUPPORTED_LMP_FEATURE:
+            return "UNSUPPORTED_REMOTE_FEATURE/UNSUPPORTED_LMP_FEATURE";
+        case ble::hci_error_code_t::SCO_OFFSET_REJECTED:
+            return "SCO_OFFSET_REJECTED";
+        case ble::hci_error_code_t::SCO_INTERVAL_REJECTED:
+            return "SCO_INTERVAL_REJECTED";
+        case ble::hci_error_code_t::SCO_AIR_MODE_REJECTED:
+            return "SCO_AIR_MODE_REJECTED";
+        case ble::hci_error_code_t::INVALID_LMP_PARAMETERS | ble::hci_error_code_t::INVALID_LL_PARAMETERS:
+            return "INVALID_LMP_PARAMETERS/INVALID_LL_PARAMETERS";
+        case ble::hci_error_code_t::UNSPECIFIED_ERROR:
+            return "UNSPECIFIED_ERROR";
+        case ble::hci_error_code_t::UNSUPPORTED_LMP_PARAMETER_VALUE | ble::hci_error_code_t::UNSUPPORTED_LL_PARAMETER_VALUE:
+            return "UNSUPPORTED_LMP_PARAMETER_VALUE/UNSUPPORTED_LL_PARAMETER_VALUE";
+        case ble::hci_error_code_t::ROLE_CHANGE_NOT_ALLOWED:
+            return "ROLE_CHANGE_NOT_ALLOWED";
+        case ble::hci_error_code_t::LMP_RESPONSE_TIMEOUT | ble::hci_error_code_t::LL_RESPONSE_TIMEOUT:
+            return "LMP_RESPONSE_TIMEOUT/LL_RESPONSE_TIMEOUT";
+        case ble::hci_error_code_t::LMP_ERROR_TRANSACTION_COLLISION | ble::hci_error_code_t::LL_PROCEDURE_COLLISION:
+            return "LMP_ERROR_TRANSACTION_COLLISION/LL_PROCEDURE_COLLISION";
+        case ble::hci_error_code_t::LMP_PDU_NOT_ALLOWED:
+            return "LMP_PDU_NOT_ALLOWED";
+        case ble::hci_error_code_t::ENCRYPTION_MODE_NOT_ACCEPTABLE:
+            return "ENCRYPTION_MODE_NOT_ACCEPTABLE";
+        case ble::hci_error_code_t::LINK_KEY_CANNOT_BE_CHANGED:
+            return "LINK_KEY_CANNOT_BE_CHANGED";
+        case ble::hci_error_code_t::REQUESTED_QOS_NOT_SUPPORTED:
+            return "REQUESTED_QOS_NOT_SUPPORTED";
+        case ble::hci_error_code_t::INSTANT_PASSED:
+            return "INSTANT_PASSED";
+        case ble::hci_error_code_t::PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
+            return "PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED";
+        case ble::hci_error_code_t::DIFFERENT_TRANSACTION_COLLISION:
+            return "DIFFERENT_TRANSACTION_COLLISION";
+        case ble::hci_error_code_t::RESERVED_FOR_FUTURE_USE:
+            return "RESERVED_FOR_FUTURE_USE";
+        case ble::hci_error_code_t::QOS_UNACCEPTABLE_PARAMETER:
+            return "QOS_UNACCEPTABLE_PARAMETER";
+        case ble::hci_error_code_t::QOS_REJECTED:
+            return "QOS_REJECTED";
+        case ble::hci_error_code_t::CHANNEL_CLASSIFICATION_NOT_SUPPORTED:
+            return "CHANNEL_CLASSIFICATION_NOT_SUPPORTED";
+        case ble::hci_error_code_t::INSUFFICIENT_SECURITY:
+            return "INSUFFICIENT_SECURITY";
+        case ble::hci_error_code_t::PARAMETER_OUT_OF_MANDATORY_RANGE:
+            return "PARAMETER_OUT_OF_MANDATORY_RANGE";
+        case ble::hci_error_code_t::ROLE_SWITCH_PENDING:
+            return "ROLE_SWITCH_PENDING";
+        case ble::hci_error_code_t::RESERVED_SLOT_VIOLATION:
+            return "RESERVED_SLOT_VIOLATION";
+        case ble::hci_error_code_t::ROLE_SWITCH_FAILED:
+            return "ROLE_SWITCH_FAILED";
+        case ble::hci_error_code_t::EXTENDED_INQUIRY_RESPONSE_TOO_LARGE:
+            return "EXTENDED_INQUIRY_RESPONSE_TOO_LARGE";
+        case ble::hci_error_code_t::SECURE_SIMPLE_PAIRING_NOT_SUPPORTED_BY_HOST:
+            return "SECURE_SIMPLE_PAIRING_NOT_SUPPORTED_BY_HOST";
+        case ble::hci_error_code_t::HOST_BUSY_PAIRING:
+            return "HOST_BUSY_PAIRING";
+        case ble::hci_error_code_t::CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND:
+            return "CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND";
+        case ble::hci_error_code_t::CONTROLLER_BUSY:
+            return "CONTROLLER_BUSY";
+        case ble::hci_error_code_t::UNACCEPTABLE_CONNECTION_PARAMETERS:
+            return "UNACCEPTABLE_CONNECTION_PARAMETERS";
+        case ble::hci_error_code_t::ADVERTISING_TIMEOUT:
+            return "ADVERTISING_TIMEOUT";
+        case ble::hci_error_code_t::CONNECTION_TERMINATED_DUE_TO_MIC_FAILURE:
+            return "CONNECTION_TERMINATED_DUE_TO_MIC_FAILURE";
+        case ble::hci_error_code_t::CONNECTION_FAILED_TO_BE_ESTABLISHED:
+            return "CONNECTION_FAILED_TO_BE_ESTABLISHED";
+        case ble::hci_error_code_t::MAC_CONNECTION_FAILED:
+            return "MAC_CONNECTION_FAILED";
+        case ble::hci_error_code_t::COARSE_CLOCK_ADJUSTMENT_REJECTED_BUT_WILL_TRY_TO_ADJUST_USING_CLOCK_DRAGGING:
+            return "COARSE_CLOCK_ADJUSTMENT_REJECTED_BUT_WILL_TRY_TO_ADJUST_USING_CLOCK_DRAGGING";
+        case ble::hci_error_code_t::TYPE0_SUBMAP_NOT_DEFINED:
+            return "TYPE0_SUBMAP_NOT_DEFINED";
+        case ble::hci_error_code_t::UNKNOWN_ADVERTISING_IDENTIFIER:
+            return "UNKNOWN_ADVERTISING_IDENTIFIER";
+        case ble::hci_error_code_t::LIMIT_REACHED:
+            return "LIMIT_REACHED";
+        case ble::hci_error_code_t::OPERATION_CANCELLED_BY_HOST:
+            return "OPERATION_CANCELLED_BY_HOST";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::advertising_fragment_description_t fragment_description)
+{
+    switch (fragment_description.value()) {
+        case ble::advertising_fragment_description_t::INTERMEDIATE_FRAGMENT:
+            return "INTERMEDIATE_FRAGMENT";
+        case ble::advertising_fragment_description_t::FIRST_FRAGMENT:
+            return "FIRST_FRAGMENT";
+        case ble::advertising_fragment_description_t::LAST_FRAGMENT:
+            return "LAST_FRAGMENT";
+        case ble::advertising_fragment_description_t::COMPLETE_FRAGMENT:
+            return "COMPLETE_FRAGMENT";
+        case ble::advertising_fragment_description_t::UNCHANGED_DATA:
+            return "UNCHANGED_DATA";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::peripheral_privacy_configuration_t::resolution_strategy_t resolution_strategy)
+{
+   switch (resolution_strategy) {
+       case ble::peripheral_privacy_configuration_t::resolution_strategy_t::DO_NOT_RESOLVE:
+           return "DO_NOT_RESOLVE";
+       case ble::peripheral_privacy_configuration_t::resolution_strategy_t::REJECT_NON_RESOLVED_ADDRESS:
+           return "REJECT_NON_RESOLVED_ADDRESS";
+       case ble::peripheral_privacy_configuration_t::resolution_strategy_t::PERFORM_PAIRING_PROCEDURE:
+           return "PERFORM_PAIRING_PROCEDURE";
+       case ble::peripheral_privacy_configuration_t::resolution_strategy_t::PERFORM_AUTHENTICATION_PROCEDURE:
+           return "PERFORM_AUTHENTICATION_PROCEDURE";
+       default:
+           return "unknown";
+   }
+}
+
+static inline const char* to_string(ble::GapEventType event_type)
+{
+    switch (event_type.value()) {
+        case ble::GapEventType::type::UNEXPECTED_ERROR:
+            return "UNEXPECTED_ERROR";
+        case ble::GapEventType::type::CONNECTION_COMPLETE:
+            return "CONNECTION_COMPLETE";
+        case ble::GapEventType::type::ADVERTISING_REPORT:
+            return "ADVERTISING_REPORT";
+        case ble::GapEventType::type::CONNECTION_UPDATE:
+            return "CONNECTION_UPDATE";
+        case ble::GapEventType::type::REMOTE_CONNECTION_PARAMETER_REQUEST:
+            return "REMOTE_CONNECTION_PARAMETER_REQUEST";
+        case ble::GapEventType::type::DISCONNECTION_COMPLETE:
+            return "DISCONNECTION_COMPLETE";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::received_advertising_type_t type)
+{
+    switch (type.value()) {
+        case ble::received_advertising_type_t::ADV_IND:
+            return "ADV_IND";
+        case ble::received_advertising_type_t::ADV_DIRECT_IND:
+            return "ADV_DIRECT_IND";
+        case ble::received_advertising_type_t::ADV_SCAN_IND:
+            return "ADV_SCAN_IND";
+        case ble::received_advertising_type_t::ADV_NONCONN_IND:
+            return "ADV_NONCONN_IND";
+        case ble::received_advertising_type_t::SCAN_RESPONSE:
+            return "SCAN_RESPONSE";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::connection_role_t role)
+{
+    if (role.value() == ble::connection_role_t::CENTRAL) {
+        return "CENTRAL";
+    } else {
+        return "PERIPHERAL";
+    }
+}
+
+static inline const char* to_string(ble::direct_address_type_t direct_address_type)
+{
+    switch (direct_address_type.value()) {
+        case ble::direct_address_type_t::PUBLIC_ADDRESS:
+            return "PUBLIC_ADDRESS";
+        case ble::direct_address_type_t::RANDOM_ADDRESS:
+            return "RANDOM_ADDRESS";
+        case ble::direct_address_type_t::PUBLIC_IDENTITY_ADDRESS:
+            return "PUBLIC_IDENTITY_ADDRESS";
+        case ble::direct_address_type_t::RANDOM_IDENTITY_ADDRESS:
+            return "RANDOM_IDENTITY_ADDRESS";
+        case ble::direct_address_type_t::RANDOM_DEVICE_ADDRESS:
+            return "RANDOM_DEVICE_ADDRESS";
+        default:
+            return "unknown";
+    }
+}
+
+static inline const char* to_string(ble::advertising_data_status_t data_status)
+{
+    switch (data_status.value()) {
+        case ble::advertising_data_status_t::COMPLETE:
+            return "COMPLETE";
+        case ble::advertising_data_status_t::INCOMPLETE_MORE_DATA:
+            return "INCOMPLETE_MORE_DATA";
+        case ble::advertising_data_status_t::INCOMPLETE_DATA_TRUNCATED:
+            return "INCOMPLETE_DATA_TRUNCATED";
+        default:
+            return "unknown";
+    }
+}
 
 } // namespace ble
 

connectivity/FEATURE_BLE/source/cordio/mbed_lib.json

@@ -82,6 +82,10 @@
             "value": null,
             "macro_name": "CORDIO_RPA_SWAP_WORKAROUND"
         },
+        "trace-pal-echoes": {
+            "help": "Include 'echo' traces in PAL, i.e. function signature and argument prints",
+            "value": 0
+        },
         "trace-hci-packets": {
             "help": "If tracing is enabled at level DEBUG traces will include HCI packet traces.",
             "value": false

connectivity/FEATURE_BLE/source/cordio/source/PalGapImpl.cpp

@@ -22,10 +22,16 @@
 #include "dm_main.h"
 #include "dm_conn.h"
 
+#include "mbed-trace/mbed_trace.h"
+#include "common/ble_trace_helpers.h"
+
+#define TRACE_GROUP "BLDM"
+
 namespace ble {
 namespace impl {
 
 namespace {
+
 bool dummy_gap_event_handler(const wsfMsgHdr_t *msg)
 {
     return false;
@@ -102,6 +108,10 @@ address_t PalGap::get_random_address()
 
 ble_error_t PalGap::set_random_address(const address_t &address)
 {
+    tr_info("Set random address - "
+            "address=%s",
+            to_string(address));
+
     device_random_address = address;
     DmDevSetRandAddr(const_cast<uint8_t *>(address.data()));
     return BLE_ERROR_NONE;
@@ -119,6 +129,26 @@ ble_error_t PalGap::set_advertising_parameters(
     advertising_filter_policy_t advertising_filter_policy
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Set advertising parameters - "
+            "advertising_interval_min=%d, "
+            "advertising_interval_max=%d, "
+            "advertising_type=%s, "
+            "own_address_type=%s, "
+            "peer_address_type=%s, "
+            "peer_address=%s, "
+            "advertising_channel_map=%s, "
+            "advertising_filter_policy_t=%s",
+            advertising_interval_min,
+            advertising_interval_max,
+            to_string(advertising_type),
+            to_string(own_address_type),
+            to_string(peer_address_type),
+            to_string(peer_address),
+            to_string(advertising_channel_map),
+            to_string(advertising_filter_policy));
+#endif
+
     DmAdvSetInterval(
         DM_ADV_HANDLE_DEFAULT,
         advertising_interval_min,
@@ -160,6 +190,14 @@ ble_error_t PalGap::set_advertising_data(
     const advertising_data_t &advertising_data
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Set advertising data - "
+            "advertising_data_length=%d, "
+            "advertising_data=%s",
+            advertising_data_length,
+            mbed_trace_array(advertising_data.data(), advertising_data_length));
+#endif
+
     DmAdvSetData(
         DM_ADV_HANDLE_DEFAULT,
         HCI_ADV_DATA_OP_COMP_FRAG,
@@ -170,12 +208,19 @@ ble_error_t PalGap::set_advertising_data(
     return BLE_ERROR_NONE;
 }
 
-
 ble_error_t PalGap::set_scan_response_data(
     uint8_t scan_response_data_length,
     const advertising_data_t &scan_response_data
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Set scan response data - "
+            "scan_response_data_length=%d, "
+            "scan_response_data=%s",
+            scan_response_data_length,
+            mbed_trace_array(scan_response_data.data(), scan_response_data_length));
+#endif
+
     DmAdvSetData(
         DM_ADV_HANDLE_DEFAULT,
         HCI_ADV_DATA_OP_COMP_FRAG,
@@ -189,6 +234,10 @@ ble_error_t PalGap::set_scan_response_data(
 
 ble_error_t PalGap::advertising_enable(bool enable)
 {
+    tr_info("Advertising enable - "
+            "enable=%s",
+            to_string(enable));
+
     if (enable) {
         // The Cordio stack requires to start direct advertising with
         // the function DmConnAccept instead of the function DmAdvStart.
@@ -206,6 +255,7 @@ ble_error_t PalGap::advertising_enable(bool enable)
                 direct_adv_cb->peer_address.data()
             );
             if (direct_adv_cb->connection_handle == DM_CONN_ID_NONE) {
+                tr_error("unknown ID for pending callback");
                 return BLE_ERROR_INTERNAL_STACK_FAILURE;
             } else {
                 direct_adv_cb->state = direct_adv_cb_t::running;
@@ -247,6 +297,20 @@ ble_error_t PalGap::set_scan_parameters(
     scanning_filter_policy_t filter_policy
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Set scan parameters - "
+            "active_scanning=%s, "
+            "scan_interval=%d, "
+            "scan_window=%d, "
+            "own_address_type=%s, "
+            "filter_policy=%s",
+            to_string(active_scanning),
+            scan_interval,
+            scan_window,
+            to_string(own_address_type),
+            to_string(filter_policy));
+#endif
+
     use_active_scanning = active_scanning;
     DmScanSetInterval(HCI_INIT_PHY_LE_1M_BIT, &scan_interval, &scan_window);
     DmScanSetAddrType(own_address_type.value());
@@ -265,6 +329,12 @@ ble_error_t PalGap::scan_enable(
     bool filter_duplicates
 )
 {
+    tr_info("Scan enable - "
+            "enable=%s, "
+            "filter_duplicates=%s",
+            to_string(enable),
+            to_string(filter_duplicates));
+
     if (enable) {
         uint8_t scanType = use_active_scanning ? DM_SCAN_TYPE_ACTIVE : DM_SCAN_TYPE_PASSIVE;
         DmScanStart(
@@ -298,6 +368,34 @@ ble_error_t PalGap::create_connection(
     uint16_t maximum_connection_event_length
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Create Connection - "
+            "scan_interval=%d, "
+            "scan_window=%d, "
+            "initiator_policy=%s, "
+            "peer_address_type=%s, "
+            "peer_address=%s, "
+            "own_address_type=%s, "
+            "connection_interval_min=%d, "
+            "connection_interval_max=%d, "
+            "connection_latency=%d, "
+            "supervision_timout=%d, "
+            "minimum_connection_event_length=%d, "
+            "maximum_connection_event_length=%d",
+            scan_interval,
+            scan_window,
+            to_string(initiator_policy),
+            to_string(peer_address_type),
+            to_string(peer_address),
+            to_string(own_address_type),
+            connection_interval_min,
+            connection_interval_max,
+            connection_latency,
+            supervision_timeout,
+            minimum_connection_event_length,
+            maximum_connection_event_length);
+#endif
+
     DmConnSetScanInterval(scan_interval, scan_window);
 #if BLE_FEATURE_WHITELIST
     DmDevSetFilterPolicy(DM_FILT_POLICY_MODE_INIT, initiator_policy.value());
@@ -322,6 +420,7 @@ ble_error_t PalGap::create_connection(
     );
 
     if (connection_id == DM_CONN_ID_NONE) {
+        tr_error("unknown ID for open connection");
         return BLE_ERROR_INTERNAL_STACK_FAILURE;
     }
 
@@ -368,6 +467,12 @@ ble_error_t PalGap::add_device_to_whitelist(
     address_t address
 )
 {
+    tr_info("Add device to whitelist - "
+            "address_type=%s,"
+            "address=%s",
+            to_string(address_type),
+            to_string(address));
+
     DmDevWhiteListAdd(
         address_type.value(),
         const_cast<uint8_t *>(address.data())
@@ -381,6 +486,12 @@ ble_error_t PalGap::remove_device_from_whitelist(
     address_t address
 )
 {
+    tr_info("Remove device from whitelist - "
+            "address_type=%s, "
+            "address=%s",
+            to_string(address_type),
+            to_string(address));
+
     DmDevWhiteListRemove(
         address_type.value(),
         const_cast<uint8_t *>(address.data())
@@ -400,7 +511,25 @@ ble_error_t PalGap::connection_parameters_update(
     uint16_t maximum_connection_event_length
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Connection %d: connection parameters update - "
+            "connection_interval_min=%d, "
+            "connection_interval_max=%d, "
+            "connection_latency=%d, "
+            "supervision_timeout=%d, "
+            "minimum_connection_event_length=%d, "
+            "maximum_connection_event_length=%d",
+            connection,
+            connection_interval_min,
+            connection_interval_max,
+            connection_latency,
+            supervision_timeout,
+            minimum_connection_event_length,
+            maximum_connection_event_length);
+#endif
+
     if (DmConnCheckIdle(connection) != 0) {
+        tr_error("connection busy");
         return BLE_ERROR_INVALID_STATE;
     }
 
@@ -431,6 +560,21 @@ ble_error_t PalGap::accept_connection_parameter_request(
     uint16_t maximum_connection_event_length
 )
 {
+    tr_info("Connection %d: accept connection parameter request - "
+            "interval_min=%d, "
+            "interval_max=%d, "
+            "latency=%d, "
+            "supervision_timeout=%d, "
+            "minimum_connection_event_length=%d, "
+            "maximum_connection_event_length=%d",
+            connection_handle,
+            interval_min,
+            interval_max,
+            latency,
+            supervision_timeout,
+            minimum_connection_event_length,
+            maximum_connection_event_length);
+
     hciConnSpec_t connection_spec = {
         interval_min,
         interval_max,
@@ -449,6 +593,11 @@ ble_error_t PalGap::reject_connection_parameter_request(
     hci_error_code_t rejection_reason
 )
 {
+    tr_info("Connection %d: reject_connection_parameter_request - "
+            "rejection_reason=%s",
+            connection_handle,
+            to_string(rejection_reason));
+
     DmRemoteConnParamReqNegReply(
         connection_handle,
         rejection_reason.value()
@@ -462,6 +611,13 @@ ble_error_t PalGap::disconnect(
     local_disconnection_reason_t disconnection_reason
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Connection %d: disconnect - "
+            "disconnection_reason=%s",
+            connection,
+            to_string(disconnection_reason));
+#endif
+
     DmConnClose(
         DM_CLIENT_ID_APP,
         connection,
@@ -475,11 +631,13 @@ ble_error_t PalGap::disconnect(
 #if BLE_FEATURE_PHY_MANAGEMENT
 ble_error_t PalGap::read_phy(connection_handle_t connection)
 {
+    tr_info("Connection %d: read phy", connection);
     if (is_feature_supported(controller_supported_features_t::LE_2M_PHY)
         || is_feature_supported(controller_supported_features_t::LE_CODED_PHY)) {
         DmReadPhy(connection);
         return BLE_ERROR_NONE;
     }
+    tr_error("Only 1M PHY supported");
     return BLE_ERROR_NOT_IMPLEMENTED;
 }
 
@@ -488,6 +646,14 @@ ble_error_t PalGap::set_preferred_phys(
     const phy_set_t &rx_phys
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Set preferred phys -"
+            "tx_phys=%s, "
+            "rx_phys=%s",
+            to_string(tx_phys),
+            to_string(rx_phys));
+#endif
+
     DmSetDefaultPhy(
         create_all_phys_value(tx_phys, rx_phys),
         tx_phys.value(),
@@ -505,6 +671,17 @@ ble_error_t PalGap::set_phy(
     coded_symbol_per_bit_t coded_symbol
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Connection %d: set phy - "
+            "tx_phys=%s, "
+            "rx_phys=%s, "
+            "coded_symbol=%s",
+            connection,
+            to_string(tx_phys),
+            to_string(rx_phys),
+            to_string(coded_symbol));
+#endif
+
     /* if phy set is empty set corresponding all_phys bit to 1 */
     uint8_t all_phys = 0;
     if (tx_phys.value() == 0) {
@@ -869,6 +1046,11 @@ ble_error_t PalGap::set_advertising_set_random_address(
     const address_t &address
 )
 {
+    tr_info("Advertising set %d: set random address - "
+            "address=%s",
+            advertising_handle,
+            to_string(address));
+
     DmAdvSetRandAddr(advertising_handle, address.data());
     return BLE_ERROR_NONE;
 }
@@ -891,15 +1073,57 @@ ble_error_t PalGap::set_extended_advertising_parameters(
     bool scan_request_notification
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Advertising set %d: set extended advertising parameters - "
+            "event_properties:[%s%s%s%s%s%s%s ], "
+            "primary_advertising_interval_min=%" PRIu32 ", "
+            "primary_advertising_interval_max=%" PRIu32 ", "
+            "primary_advertising_channel_map=%s, "
+            "own_address_type=%s, "
+            "peer_address_type=%s, "
+            "peer_address=%s, "
+            "advertising_filter_policy=%s, "
+            "advertising_power=%d, "
+            "primary_advertising_phy=%s, "
+            "secondary_advertising_max_skip=%d, "
+            "secondary_phy=%s, "
+            "advertising_sid=%d, "
+            "scan_request_notification=%s",
+            advertising_handle,
+            event_properties.connectable ? " connectable" : "",
+            event_properties.scannable ? " scannable" : "",
+            event_properties.directed ? " directed" : "",
+            event_properties.high_duty_cycle ? " high_duty_cycle" : "",
+            event_properties.use_legacy_pdu ? " use_legacy_pdu" : "",
+            event_properties.omit_advertiser_address ? " omit_advertiser_address," : "",
+            event_properties.include_tx_power ? " nclude_tx_power" : "",
+            primary_advertising_interval_min,
+            primary_advertising_interval_max,
+            to_string(primary_advertising_channel_map),
+            to_string(own_address_type),
+            to_string(peer_address_type),
+            to_string(peer_address),
+            to_string(advertising_filter_policy),
+            advertising_power,
+            to_string(primary_advertising_phy),
+            secondary_advertising_max_skip,
+            to_string(secondary_phy),
+            advertising_sid,
+            to_string(scan_request_notification));
+#endif
+
     uint8_t adv_type;
 
     if (event_properties.use_legacy_pdu) {
         if (event_properties.directed == false) {
+            tr_info("Legacy PDU w/undirected advertising event");
             if (event_properties.high_duty_cycle) {
+                tr_error("cannot use high duty cycle");
                 return BLE_ERROR_INVALID_PARAM;
             }
 
             if (event_properties.connectable && event_properties.scannable == false) {
+                tr_error("must be scannable if connectable");
                 return BLE_ERROR_INVALID_PARAM;
             }
 
@@ -911,11 +1135,14 @@ ble_error_t PalGap::set_extended_advertising_parameters(
                 adv_type = DM_ADV_NONCONN_UNDIRECT;
             }
         } else {
+            tr_info("Legacy PDU w/directed advertising event");
             if (event_properties.scannable) {
+                tr_error("cannot be scannable");
                 return BLE_ERROR_INVALID_PARAM;
             }
 
             if (event_properties.connectable == false) {
+                tr_error("must be connectable");
                 return BLE_ERROR_INVALID_PARAM;
             }
 
@@ -927,7 +1154,9 @@ ble_error_t PalGap::set_extended_advertising_parameters(
         }
     } else {
         if (event_properties.directed == false) {
+            tr_info("Extended PDU w/undirected advertising event");
             if (event_properties.high_duty_cycle) {
+                tr_error("cannot use high duty cycle");
                 return BLE_ERROR_INVALID_PARAM;
             }
 
@@ -946,6 +1175,7 @@ ble_error_t PalGap::set_extended_advertising_parameters(
             // standpoint
 
             if (event_properties.connectable && event_properties.scannable) {
+                tr_error("cannot be scannable if connectable");
                 return BLE_ERROR_INVALID_PARAM;
             } else if (event_properties.connectable) {
                 if (event_properties.high_duty_cycle) {
@@ -1022,6 +1252,17 @@ ble_error_t PalGap::set_periodic_advertising_parameters(
     bool advertise_power
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Advertising set %d: set periodic advertising parameters - "
+            "periodic_advertising_min=%s, "
+            "periodic_advertising_max=%s, "
+            "advertise_power=%s",
+            advertising_handle,
+            to_string(periodic_advertising_min),
+            to_string(periodic_advertising_max),
+            to_string(advertise_power));
+#endif
+
     DmPerAdvIncTxPwr(advertising_handle, advertise_power);
     DmPerAdvSetInterval(
         advertising_handle,
@@ -1043,6 +1284,19 @@ ble_error_t PalGap::set_extended_advertising_data(
     const uint8_t *advertising_data
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Advertising set %d: set extended advertising data - "
+            "operation=%s, "
+            "minimize_fragmentation=%s, "
+            "advertising_data_size=%d, "
+            "advertising_data=%s",
+            advertising_handle,
+            to_string(operation),
+            to_string(minimize_fragmentation),
+            advertising_data_size,
+            mbed_trace_array(advertising_data, advertising_data_size));
+#endif
+
     uint8_t frag_pref = minimize_fragmentation ?
         HCI_ADV_DATA_FRAG_PREF_NO_FRAG :
         HCI_ADV_DATA_FRAG_PREF_FRAG;
@@ -1068,6 +1322,17 @@ ble_error_t PalGap::set_periodic_advertising_data(
     const uint8_t *advertising_data
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Advertising set %d: set periodic advertising data - "
+            "fragment_description=%s, "
+            "advertising_data_size=%d, "
+            "advertising_data=%s",
+            advertising_handle,
+            to_string(fragment_description),
+            advertising_data_size,
+            mbed_trace_array(advertising_data, advertising_data_size));
+#endif
+
     DmPerAdvSetData(
         advertising_handle,
         fragment_description.value(),
@@ -1087,6 +1352,19 @@ ble_error_t PalGap::set_extended_scan_response_data(
     const uint8_t *scan_response_data
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Advertising data %d: set extended scan response data - "
+            "operation=%s, "
+            "minimize_fragmentation=%s, "
+            "scan_response_data_size=%d, "
+            "scan_response_data=%s",
+            advertising_handle,
+            to_string(operation),
+            to_string(minimize_fragmentation),
+            scan_response_data_size,
+            mbed_trace_array(scan_response_data, scan_response_data_size));
+#endif
+
     uint8_t frag_pref = minimize_fragmentation ?
         HCI_ADV_DATA_FRAG_PREF_NO_FRAG :
         HCI_ADV_DATA_FRAG_PREF_FRAG;
@@ -1112,7 +1390,14 @@ ble_error_t PalGap::extended_advertising_enable(
     const uint8_t *in_max_extended_advertising_events
 )
 {
+    tr_info("Extended advertising enable - "
+            "enable=%s, "
+            "number_of_sets=%d",
+            to_string(enable),
+            number_of_sets);
+
     if (number_of_sets > DM_NUM_ADV_SETS) {
+        tr_error("number of sets cannot be greater than %d", DM_NUM_ADV_SETS);
         return BLE_ERROR_INVALID_PARAM;
     }
 
@@ -1143,6 +1428,7 @@ ble_error_t PalGap::extended_advertising_enable(
                     direct_adv_cb->peer_address.data()
                 );
                 if (direct_adv_cb->connection_handle == DM_CONN_ID_NONE) {
+                    tr_error("unknown connection ID %d", direct_adv_cb->connection_handle);
                     return BLE_ERROR_INTERNAL_STACK_FAILURE;
                 } else {
                     direct_adv_cb->state = direct_adv_cb_t::running;
@@ -1201,6 +1487,11 @@ ble_error_t PalGap::periodic_advertising_enable(
     advertising_handle_t advertising_handle
 )
 {
+    tr_info("Advertising set %d: periodic advertsing enable - "
+            "enable=%s",
+            advertising_handle,
+            to_string(enable));
+
     if (enable) {
         DmPerAdvStart(advertising_handle);
     } else {
@@ -1265,6 +1556,16 @@ ble_error_t PalGap::set_extended_scan_parameters(
     const uint16_t *scan_window
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Set extended scan parameters - "
+            "own_address_type=%s, "
+            "filter_policy=%s, "
+            "scanning_phys=%s",
+            to_string(own_address_type),
+            to_string(filter_policy),
+            to_string(scanning_phys));
+#endif
+
     DmScanSetAddrType(own_address_type.value());
 
     for (size_t i = 0, count = scanning_phys.count(); i < count; ++i) {
@@ -1299,6 +1600,16 @@ ble_error_t PalGap::extended_scan_enable(
     uint16_t period
 )
 {
+    tr_info("Extended scan enable - "
+            "enable=%s, "
+            "filter_duplicates=%s, "
+            "duration=%d, "
+            "period=%d",
+            to_string(enable),
+            to_string(filter_duplicates),
+            duration,
+            period);
+
     if (enable) {
         uint32_t duration_ms = duration * 10;
 
@@ -1330,6 +1641,20 @@ ble_error_t PalGap::periodic_advertising_create_sync(
     uint16_t sync_timeout
 )
 {
+    tr_info("Periodic advertising create sync - "
+            "use_periodic_advertiser_list=%s, "
+            "advertising_sid=%d, "
+            "peer_address_type=%s, "
+            "peer_address=%s, "
+            "allowed_skip=%d, "
+            "sync_timeout=%d",
+            to_string(use_periodic_advertiser_list),
+            advertising_sid,
+            to_string(peer_address_type),
+            to_string(peer_address),
+            allowed_skip,
+            sync_timeout);
+
     DmDevSetExtFilterPolicy(
         DM_ADV_HANDLE_DEFAULT,
         DM_FILT_POLICY_MODE_SYNC,
@@ -1345,6 +1670,7 @@ ble_error_t PalGap::periodic_advertising_create_sync(
     );
 
     if (sync_id == DM_SYNC_ID_NONE) {
+        tr_error("unknown sync ID %d", sync_id);
         return BLE_ERROR_INTERNAL_STACK_FAILURE;
     } else {
         /* this is not the real handle, this is CORDIO internal handle but the user doesn't need to know that */
@@ -1375,6 +1701,16 @@ ble_error_t PalGap::add_device_to_periodic_advertiser_list(
     uint8_t advertising_sid
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Add device to periodic advertiser list - "
+            "advertiser_address_type=%s, "
+            "advertiser_address=%s, "
+            "advertiser_sid=%d",
+            to_string(advertiser_address_type),
+            to_string(advertiser_address),
+            advertising_sid);
+#endif
+
     DmAddDeviceToPerAdvList(
         advertiser_address_type.value(),
         const_cast<uint8_t *>(advertiser_address.data()),
@@ -1390,6 +1726,16 @@ ble_error_t PalGap::remove_device_from_periodic_advertiser_list(
     uint8_t advertising_sid
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Remove device from periodic advertiser list - "
+            "advertiser_address_type=%s, "
+            "advertiser_address=%s, "
+            "advertiser_sid=%d",
+            to_string(advertiser_address_type),
+            to_string(advertiser_address),
+            advertising_sid);
+#endif
+
     DmRemoveDeviceFromPerAdvList(
         advertiser_address_type.value(),
         const_cast<uint8_t *>(advertiser_address.data()),
@@ -1430,6 +1776,20 @@ ble_error_t PalGap::extended_create_connection(
     const uint16_t *maximum_connection_event_lengths
 )
 {
+#if MBED_CONF_CORDIO_TRACE_PAL_ECHOES
+    tr_info("Extended create connection - "
+            "initiator_policy=%s, "
+            "own_address_type=%s, "
+            "peer_address_type=%s, "
+            "peer_address=%s, "
+            "initiating_phys=%s",
+            to_string(initiator_policy),
+            to_string(own_address_type),
+            to_string(peer_address_type),
+            to_string(peer_address),
+            to_string(initiating_phys));
+#endif
+
     DmExtConnSetScanInterval(
         initiating_phys.value(),
         const_cast<uint16_t *>(scan_intervals),
@@ -1476,10 +1836,20 @@ ble_error_t PalGap::update_direct_advertising_parameters(
     advertising_peer_address_type_t peer_address_type
 )
 {
+    tr_info("Advertising set %d: update direct advertising parameters - "
+            "advertising_type=%d, "
+            "peer_address=%s, "
+            "peer_address_type=%s",
+            advertising_handle,
+            advertising_type,
+            to_string(peer_address),
+            to_string(peer_address_type));
+
     // The case where a direct advertising is running and parameters are updated
     // is considered to be a programming error. User should stop advertising first.
     direct_adv_cb_t *running = get_running_direct_adv_cb(advertising_handle);
     if (running) {
+        tr_error("trying to update parameters but direct advertising is running");
         return BLE_ERROR_INVALID_STATE;
     }
 
@@ -1506,6 +1876,7 @@ ble_error_t PalGap::update_direct_advertising_parameters(
         advertising_type == DM_ADV_CONN_DIRECT_LO_DUTY) {
         direct_adv_cb_t *adv_cb = get_free_direct_adv_cb();
         if (!adv_cb) {
+            tr_error("failed to acquire a cb");
             return BLE_ERROR_INTERNAL_STACK_FAILURE;
         }
         adv_cb->state = direct_adv_cb_t::pending;