src: apply clang-format

Signed-off-by: Nick Schonning <nschonni@gmail.com>

Author: nschonni

src/bluetooth-fw/nimble/advert.c

@@ -40,8 +40,7 @@ static int prv_device_name_read_event_cb(uint16_t conn_handle, const struct ble_
 static int prv_device_name_read_op_start(void *ctx) {
   const uint16_t conn_handle = *(uint16_t *)ctx;
 
-  int rc = ble_gattc_read_by_uuid(conn_handle, 1, UINT16_MAX,
-                                  (ble_uuid_t *)&s_device_name_chr_uuid,
+  int rc = ble_gattc_read_by_uuid(conn_handle, 1, UINT16_MAX, (ble_uuid_t *)&s_device_name_chr_uuid,
                                   prv_device_name_read_event_cb, NULL);
   if (rc != 0) {
     PBL_LOG_ERR("Pairing device name read failed to start (rc=0x%04x)", (uint16_t)rc);
@@ -61,7 +60,9 @@ void bt_driver_advert_advertising_disable(void) {
   PBL_ASSERT(rc == 0, "Failed to stop advertising (0x%04x)", (uint16_t)rc);
 }
 
-bool bt_driver_advert_client_get_tx_power(int8_t *tx_power) { return false; }
+bool bt_driver_advert_client_get_tx_power(int8_t *tx_power) {
+  return false;
+}
 
 bool bt_driver_advert_set_advertising_data(const BLEAdData *ad_data) {
   int rc;
@@ -84,7 +85,8 @@ bool bt_driver_advert_set_advertising_data(const BLEAdData *ad_data) {
 
 static void prv_handle_connection_event(struct ble_gap_event *event) {
   // we only want to notify on a successful connection
-  if (event->connect.status != 0) return;
+  if (event->connect.status != 0)
+    return;
 
   struct ble_gap_conn_desc desc;
   if (ble_gap_conn_find(event->connect.conn_handle, &desc) != 0) {
@@ -171,8 +173,7 @@ static void prv_handle_enc_change_event(struct ble_gap_event *event) {
   }
 
   PBL_LOG_INFO("Encryption change: status=0x%04x encrypted=%u bonded=%u",
-               (uint16_t)event->enc_change.status, desc.sec_state.encrypted,
-               desc.sec_state.bonded);
+               (uint16_t)event->enc_change.status, desc.sec_state.encrypted, desc.sec_state.bonded);
 
   struct BleEncryptionChange enc_change_event = {
       .encryption_enabled = desc.sec_state.encrypted,
@@ -185,8 +186,7 @@ static void prv_handle_enc_change_event(struct ble_gap_event *event) {
 
 static void prv_handle_conn_params_updated_event(struct ble_gap_event *event) {
   if (event->conn_update.status != 0) {
-    PBL_LOG_ERR("Connection parameters update failed: 0x%04x",
-              (uint16_t)event->conn_update.status);
+    PBL_LOG_ERR("Connection parameters update failed: 0x%04x", (uint16_t)event->conn_update.status);
     return;
   }
 
@@ -196,10 +196,11 @@ static void prv_handle_conn_params_updated_event(struct ble_gap_event *event) {
     return;
   }
 
-  PBL_LOG_INFO("Connection parameters updated: "
-            "itvl=%u ms, latency=%u, spvn timeout=%u ms",
-            desc.conn_itvl * BLE_HCI_CONN_ITVL / 1000, desc.conn_latency,
-            desc.supervision_timeout * BLE_HCI_CONN_SPVN_TMO_UNITS);
+  PBL_LOG_INFO(
+      "Connection parameters updated: "
+      "itvl=%u ms, latency=%u, spvn timeout=%u ms",
+      desc.conn_itvl * BLE_HCI_CONN_ITVL / 1000, desc.conn_latency,
+      desc.supervision_timeout * BLE_HCI_CONN_SPVN_TMO_UNITS);
 
   struct BleConnectionUpdateCompleteEvent conn_params_update_event = {
       .status = HciStatusCode_Success,
@@ -213,12 +214,13 @@ static void prv_handle_conn_params_updated_event(struct ble_gap_event *event) {
 static void prv_handle_conn_update_req_event(struct ble_gap_event *event) {
   *event->conn_update_req.self_params = *event->conn_update_req.peer_params;
 
-  PBL_LOG_INFO("Connection update request: "
-            "itvl=(%u, %u) ms, latency=%u, spvn timeout=%u ms",
-            event->conn_update_req.self_params->itvl_min * BLE_HCI_CONN_ITVL / 1000,
-            event->conn_update_req.self_params->itvl_max * BLE_HCI_CONN_ITVL / 1000,
-            event->conn_update_req.self_params->latency,
-            event->conn_update_req.self_params->supervision_timeout * BLE_HCI_CONN_SPVN_TMO_UNITS);
+  PBL_LOG_INFO(
+      "Connection update request: "
+      "itvl=(%u, %u) ms, latency=%u, spvn timeout=%u ms",
+      event->conn_update_req.self_params->itvl_min * BLE_HCI_CONN_ITVL / 1000,
+      event->conn_update_req.self_params->itvl_max * BLE_HCI_CONN_ITVL / 1000,
+      event->conn_update_req.self_params->latency,
+      event->conn_update_req.self_params->supervision_timeout * BLE_HCI_CONN_SPVN_TMO_UNITS);
 }
 
 static void prv_handle_passkey_event(struct ble_gap_event *event) {
@@ -283,9 +285,9 @@ extern int pebble_pairing_service_get_connectivity_send_notification(uint16_t co
                                                                      uint16_t attr_handle);
 static void prv_handle_subscription_event(struct ble_gap_event *event) {
   PBL_LOG_DBG("prv_handle_subscription_event: connhandle: %d attr:%d notify:%d/%d indicate:%d/%d",
-            event->subscribe.conn_handle, event->subscribe.attr_handle,
-            event->subscribe.prev_notify, event->subscribe.cur_notify,
-            event->subscribe.prev_indicate, event->subscribe.cur_indicate);
+              event->subscribe.conn_handle, event->subscribe.attr_handle,
+              event->subscribe.prev_notify, event->subscribe.cur_notify,
+              event->subscribe.prev_indicate, event->subscribe.cur_indicate);
 }
 
 static void prv_handle_notification_rx_event(struct ble_gap_event *event) {
@@ -311,9 +313,7 @@ static void prv_handle_notification_rx_event(struct ble_gap_event *event) {
 
 static void prv_handle_notification_tx_event(struct ble_gap_event *event) {
   PBL_LOG_DBG("notification tx event; status=%d attr_handle=%d indication=%d\n",
-            event->notify_tx.status,
-            event->notify_tx.attr_handle,
-            event->notify_tx.indication);
+              event->notify_tx.status, event->notify_tx.attr_handle, event->notify_tx.indication);
 }
 
 static int prv_handle_repeat_pairing_event(struct ble_gap_event *event) {
@@ -342,13 +342,12 @@ static int prv_handle_repeat_pairing_event(struct ble_gap_event *event) {
 
 static void prv_handle_phy_update_event(struct ble_gap_event *event) {
   if (event->phy_updated.status != 0) {
-    PBL_LOG_ERR("PHY update failed: 0x%04x",
-              (uint16_t)event->phy_updated.status);
+    PBL_LOG_ERR("PHY update failed: 0x%04x", (uint16_t)event->phy_updated.status);
     return;
   }
 
   PBL_LOG_DBG("PHY update complete; conn_handle=%d, tx_phy=%d, rx_phy=%d",
-          event->phy_updated.conn_handle, event->phy_updated.tx_phy, event->phy_updated.rx_phy);
+              event->phy_updated.conn_handle, event->phy_updated.tx_phy, event->phy_updated.rx_phy);
 }
 
 static int prv_handle_gap_event(struct ble_gap_event *event, void *arg) {
@@ -358,8 +357,7 @@ static int prv_handle_gap_event(struct ble_gap_event *event, void *arg) {
       prv_handle_connection_event(event);
       break;
     case BLE_GAP_EVENT_DISCONNECT:
-      PBL_LOG_DBG("BLE_GAP_EVENT_DISCONNECT reason=0x%x",
-              event->disconnect.reason);
+      PBL_LOG_DBG("BLE_GAP_EVENT_DISCONNECT reason=0x%x", event->disconnect.reason);
       prv_handle_disconnection_event(event);
       break;
     case BLE_GAP_EVENT_ENC_CHANGE:

src/bluetooth-fw/nimble/bt_classic_stubs.c

@@ -3,4 +3,6 @@
 
 #include <stdint.h>
 
-uint32_t sys_app_comm_get_sniff_interval(void) { return 0; }
+uint32_t sys_app_comm_get_sniff_interval(void) {
+  return 0;
+}

src/bluetooth-fw/nimble/comm.c

@@ -14,4 +14,6 @@ bool bt_driver_comm_schedule_send_next_job(CommSession *session) {
   return true;  // we croak if a task cannot be scheduled on KernelMain
 }
 
-bool bt_driver_comm_is_current_task_send_next_task(void) { return launcher_task_is_current_task(); }
+bool bt_driver_comm_is_current_task_send_next_task(void) {
+  return launcher_task_is_current_task();
+}

src/bluetooth-fw/nimble/gap_le_device_name.c

@@ -26,8 +26,7 @@ static int prv_device_name_read_event_cb(uint16_t conn_handle, const struct ble_
 
   if (error->status != 0) {
     if (error->status != BLE_HS_EDONE) {
-      PBL_LOG_ERR("prv_device_name_read_event_cb error=%d",
-                error->status);
+      PBL_LOG_ERR("prv_device_name_read_event_cb error=%d", error->status);
     }
     // Frees arg (the op context); must be the last use of it
     nimble_gattc_op_queue_complete();
@@ -36,8 +35,7 @@ static int prv_device_name_read_event_cb(uint16_t conn_handle, const struct ble_
 
   const uint16_t name_len = OS_MBUF_PKTLEN(attr->om);
 
-  PBL_LOG_DBG("Device name read cb: conn=%u handle=%u len=%u", conn_handle, attr->handle,
-              name_len);
+  PBL_LOG_DBG("Device name read cb: conn=%u handle=%u len=%u", conn_handle, attr->handle, name_len);
 
   char *device_name = kernel_zalloc_check(name_len + 1);
   if (ble_hs_mbuf_to_flat(attr->om, device_name, name_len, NULL) != 0) {

src/bluetooth-fw/nimble/gap_le_scan.c

@@ -8,4 +8,6 @@ bool bt_driver_start_le_scan(bool active_scan, bool use_white_list_filter, bool
   return true;
 }
 
-bool bt_driver_stop_le_scan(void) { return true; }
+bool bt_driver_stop_le_scan(void) {
+  return true;
+}

src/bluetooth-fw/nimble/gatt.c

@@ -13,7 +13,8 @@
 
 PBL_LOG_MODULE_DECLARE(bt, CONFIG_BT_LOG_LEVEL);
 
-void bt_driver_gatt_respond_read_subscription(uint32_t transaction_id, uint16_t response_code) {}
+void bt_driver_gatt_respond_read_subscription(uint32_t transaction_id, uint16_t response_code) {
+}
 
 void bt_driver_gatt_send_changed_indication(const BTDeviceInternal *device,
                                             const ATTHandleRange *data) {

src/bluetooth-fw/nimble/gatt_client_discovery.c

@@ -156,12 +156,9 @@ static bool prv_find_dsc_by_uuid(ListNode *node, void *data) {
   return ble_uuid_cmp(&dsc_node->descriptor.uuid.u, dsc_uuid) == 0;
 }
 
-static bool prv_find_dsc_uuid(GATTServiceDiscoveryContext *context,
-                              const ble_uuid_t *svc_uuid,
-                              const ble_uuid_t *chr_uuid,
-                              const ble_uuid_t *dsc_uuid,
-                              uint16_t *chr_handle,
-                              uint16_t *dsc_handle) {
+static bool prv_find_dsc_uuid(GATTServiceDiscoveryContext *context, const ble_uuid_t *svc_uuid,
+                              const ble_uuid_t *chr_uuid, const ble_uuid_t *dsc_uuid,
+                              uint16_t *chr_handle, uint16_t *dsc_handle) {
   GATTServiceDiscoveryServiceNode *service_node = (GATTServiceDiscoveryServiceNode *)list_find(
       context->services, prv_find_svc_by_uuid, (void *)svc_uuid);
   if (service_node == NULL) {
@@ -195,12 +192,10 @@ typedef struct {
 static int prv_on_svc_chgd_subscribe(uint16_t conn_handle, const struct ble_gatt_error *error,
                                      struct ble_gatt_attr *attr, void *arg) {
   if (error->status != 0) {
-    PBL_LOG_ERR("Failed to subscribe to service changed: 0x%" PRIx16,
-              error->status);
+    PBL_LOG_ERR("Failed to subscribe to service changed: 0x%" PRIx16, error->status);
   } else {
     GATTServiceDiscoveryDescriptorContext *ctx = arg;
-    bt_driver_cb_gatt_client_discovery_handle_service_changed(ctx->connection,
-                                                              ctx->chr_handle);
+    bt_driver_cb_gatt_client_discovery_handle_service_changed(ctx->connection, ctx->chr_handle);
 
     PBL_LOG_DBG("Subscribed to service changed");
   }
@@ -210,29 +205,30 @@ static int prv_on_svc_chgd_subscribe(uint16_t conn_handle, const struct ble_gatt
   return 0;
 }
 
-static void prv_convert_service_and_notify_os(uint16_t conn_handle, GATTServiceDiscoveryContext *context) {
+static void prv_convert_service_and_notify_os(uint16_t conn_handle,
+                                              GATTServiceDiscoveryContext *context) {
   list_foreach(context->services, prv_convert_service_and_notify_os_cb, context->connection);
   bt_driver_cb_gatt_client_discovery_complete(context->connection, BTErrnoOK);
 
   // Subscribe to service changed indications (BLE Core 6.0, part G 7.7.1)
   uint16_t chr_handle, dsc_handle;
   if (prv_find_dsc_uuid(context, BLE_UUID16_DECLARE(BLE_GATT_SVC_UUID16),
                         BLE_UUID16_DECLARE(BLE_SVC_GATT_CHR_SERVICE_CHANGED_UUID16),
-                        BLE_UUID16_DECLARE(BLE_GATT_DSC_CLT_CFG_UUID16),
-                        &chr_handle, &dsc_handle)) {
+                        BLE_UUID16_DECLARE(BLE_GATT_DSC_CLT_CFG_UUID16), &chr_handle,
+                        &dsc_handle)) {
     uint16_t value;
     int ret;
 
-    GATTServiceDiscoveryDescriptorContext *ctx = kernel_zalloc_check(
-        sizeof(GATTServiceDiscoveryDescriptorContext));
+    GATTServiceDiscoveryDescriptorContext *ctx =
+        kernel_zalloc_check(sizeof(GATTServiceDiscoveryDescriptorContext));
     ctx->connection = context->connection;
     ctx->chr_handle = chr_handle;
 
     value = 0x0002;
-    ret = ble_gattc_write_flat(conn_handle, dsc_handle,
-                               &value, sizeof(value), prv_on_svc_chgd_subscribe, ctx);
+    ret = ble_gattc_write_flat(conn_handle, dsc_handle, &value, sizeof(value),
+                               prv_on_svc_chgd_subscribe, ctx);
     if (ret != 0) {
-        PBL_LOG_ERR("Failed to subscribe to service changed: %d", ret);
+      PBL_LOG_ERR("Failed to subscribe to service changed: %d", ret);
     }
   }
 
@@ -264,8 +260,8 @@ static void prv_discover_next_dscs(uint16_t conn_handle, GATTServiceDiscoveryCon
   uint16_t end_handle = prv_get_last_dsc_handle(context);
   int rc = ble_gattc_disc_all_dscs(conn_handle, start_handle, end_handle, prv_find_dsc_cb, context);
   if (rc != 0) {
-    PBL_LOG_ERR("ble_gattc_disc_all_dscs rc=0x%04x (0x%04x -> 0x%04x)",
-              (uint16_t)rc, start_handle, end_handle);
+    PBL_LOG_ERR("ble_gattc_disc_all_dscs rc=0x%04x (0x%04x -> 0x%04x)", (uint16_t)rc, start_handle,
+                end_handle);
   }
 }
 
@@ -275,8 +271,8 @@ static void prv_discover_next_chrs(uint16_t conn_handle, GATTServiceDiscoveryCon
   int rc = ble_gattc_disc_all_chrs(conn_handle, service_node->service.start_handle,
                                    service_node->service.end_handle, prv_find_chr_cb, context);
   if (rc != 0) {
-    PBL_LOG_ERR("ble_gattc_disc_all_chrs rc=0x%04x (0x%04x -> 0x%04x)",
-              (uint16_t)rc, service_node->service.start_handle, service_node->service.end_handle);
+    PBL_LOG_ERR("ble_gattc_disc_all_chrs rc=0x%04x (0x%04x -> 0x%04x)", (uint16_t)rc,
+                service_node->service.start_handle, service_node->service.end_handle);
   }
 }
 
@@ -339,8 +335,7 @@ static int prv_find_dsc_cb(uint16_t conn_handle, const struct ble_gatt_error *er
     case 0:
       char chr_uuid_str[BLE_UUID_STR_LEN];
       ble_uuid_to_str(&dsc->uuid.u, chr_uuid_str);
-      PBL_LOG_DBG("Found descriptor %s (hdl: 0x%" PRIx16 ")",
-                chr_uuid_str, dsc->handle);
+      PBL_LOG_DBG("Found descriptor %s (hdl: 0x%" PRIx16 ")", chr_uuid_str, dsc->handle);
 
       GATTServiceDiscoveryDescriptorNode *dsc_node = prv_create_descriptor_node(dsc);
       GATTServiceDiscoveryCharacteristicNode *chr_node = prv_get_current_chr(context);
@@ -384,8 +379,7 @@ static int prv_find_dsc_cb(uint16_t conn_handle, const struct ble_gatt_error *er
       break;
 
     default:
-      PBL_LOG_ERR("Descriptor discovery error: %d",
-                error->status);
+      PBL_LOG_ERR("Descriptor discovery error: %d", error->status);
       if (error->status == BLE_HS_ETIMEOUT) {
         errno = BTErrnoServiceDiscoveryTimeout;
       } else if (error->status == BLE_HS_ENOTCONN) {
@@ -420,7 +414,7 @@ static int prv_find_chr_cb(uint16_t conn_handle, const struct ble_gatt_error *er
       char chr_uuid_str[BLE_UUID_STR_LEN];
       ble_uuid_to_str(&chr->uuid.u, chr_uuid_str);
       PBL_LOG_DBG("Found characteristic %s (val hdl: 0x%" PRIx16 ", def hdl: 0x%" PRIx16 ")",
-                chr_uuid_str, chr->val_handle, chr->def_handle);
+                  chr_uuid_str, chr->val_handle, chr->def_handle);
 
       GATTServiceDiscoveryCharacteristicNode *chr_node = prv_create_chr_node(chr);
       GATTServiceDiscoveryServiceNode *service_node = prv_get_current_service(context);
@@ -456,8 +450,7 @@ static int prv_find_chr_cb(uint16_t conn_handle, const struct ble_gatt_error *er
       break;
 
     default:
-      PBL_LOG_ERR("Characteristic discovery error: %d",
-                error->status);
+      PBL_LOG_ERR("Characteristic discovery error: %d", error->status);
       if (error->status == BLE_HS_ETIMEOUT) {
         errno = BTErrnoServiceDiscoveryTimeout;
       } else if (error->status == BLE_HS_ENOTCONN) {
@@ -491,17 +484,16 @@ static int prv_find_inc_svc_cb(uint16_t conn_handle, const struct ble_gatt_error
     case 0:
       if (service->start_handle < context->range.start ||
           service->end_handle > context->range.end) {
-        return 0; // skip this service
+        return 0;  // skip this service
       }
 
       GATTServiceDiscoveryServiceNode *service_node = prv_create_service_node(service);
       prv_list_append_or_set(&context->services, &service_node->node);
 
       char service_uuid_str[BLE_UUID_STR_LEN];
       ble_uuid_to_str(&service->uuid.u, service_uuid_str);
-      PBL_LOG_DBG("Found service %s, 0x%" PRIx16 "-0x%" PRIx16 " (total %lu)",
-                service_uuid_str, service->start_handle, service->end_handle,
-                list_count(context->services));
+      PBL_LOG_DBG("Found service %s, 0x%" PRIx16 "-0x%" PRIx16 " (total %lu)", service_uuid_str,
+                  service->start_handle, service->end_handle, list_count(context->services));
       break;
 
     case BLE_HS_EDONE:
@@ -621,4 +613,5 @@ BTErrno bt_driver_gatt_stop_discovery(GAPLEConnection *connection) {
   return BTErrnoOK;
 }
 
-void bt_driver_gatt_handle_discovery_abandoned(void) {}
+void bt_driver_gatt_handle_discovery_abandoned(void) {
+}

src/bluetooth-fw/nimble/gatt_client_operations.c

@@ -28,25 +28,26 @@ static BLEGATTError prv_gatt_error_code(uint16_t status) {
 static int prv_gatt_write_event_cb(uint16_t conn_handle, const struct ble_gatt_error *error,
                                    struct ble_gatt_attr *attr, void *arg) {
   if (error->status != 0U) {
-    PBL_LOG_ERR("GATT write failed (hdl: 0x%" PRIx16 "): 0x%" PRIx16,
-              error->att_handle, error->status);
+    PBL_LOG_ERR("GATT write failed (hdl: 0x%" PRIx16 "): 0x%" PRIx16, error->att_handle,
+                error->status);
   }
 
   GattClientOpWriteResponse resp = {
       .hdr = {
           .type = GattClientOpResponseWrite,
           .error_code = prv_gatt_error_code(error->status),
           .context = arg,
-      }};
+      }
+  };
   bt_driver_cb_gatt_client_operations_handle_response(&resp.hdr);
   return 0;
 }
 
 static int prv_gatt_read_event_cb(uint16_t conn_handle, const struct ble_gatt_error *error,
                                   struct ble_gatt_attr *attr, void *arg) {
   if (error->status != 0U) {
-    PBL_LOG_ERR("GATT read failed (hdl: 0x%" PRIx16 "): 0x%" PRIx16,
-              error->att_handle, error->status);
+    PBL_LOG_ERR("GATT read failed (hdl: 0x%" PRIx16 "): 0x%" PRIx16, error->att_handle,
+                error->status);
   }
 
   GattClientOpReadResponse resp = {
@@ -65,8 +66,7 @@ static int prv_gatt_read_event_cb(uint16_t conn_handle, const struct ble_gatt_er
 
 BTErrno bt_driver_gatt_write_without_response(GAPLEConnection *connection, const uint8_t *value,
                                               size_t value_length, uint16_t att_handle) {
-  PBL_LOG_VERBOSE("bt_driver_gatt_write_without_response: %d",
-            att_handle);
+  PBL_LOG_VERBOSE("bt_driver_gatt_write_without_response: %d", att_handle);
   uint16_t conn_handle;
   if (!pebble_device_to_nimble_conn_handle(&connection->device, &conn_handle)) {
     return BTErrnoInvalidState;