Merge remote-tracking branch 'origin/main' into bitmap-read-2

27 files changed, 1690 insertions, 1485 deletions

diff --git a/devices/ble_hci/common-hal/_bleio/Adapter.c b/devices/ble_hci/common-hal/_bleio/Adapter.c
index 753a88648..7f0b088c4 100644
--- a/devices/ble_hci/common-hal/_bleio/Adapter.c
+++ b/devices/ble_hci/common-hal/_bleio/Adapter.c
@@ -51,7 +51,7 @@
 
 #define MSEC_TO_UNITS(TIME, RESOLUTION) (((TIME) * 1000) / (RESOLUTION))
 #define SEC_TO_UNITS(TIME, RESOLUTION) (((TIME) * 1000000) / (RESOLUTION))
-#define UNITS_TO_SEC(TIME, RESOLUTION) (((TIME) * (RESOLUTION)) / 1000000)
+#define UNITS_TO_SEC(TIME, RESOLUTION) (((TIME)*(RESOLUTION)) / 1000000)
 // 0.625 msecs (625 usecs)
 #define ADV_INTERVAL_UNIT_FLOAT_SECS (0.000625)
 // Microseconds is the base unit. The macros above know that.
@@ -63,7 +63,7 @@
 
 // TODO make this settable from Python.
 #define DEFAULT_TX_POWER 0  // 0 dBm
-#define MAX_ANONYMOUS_ADV_TIMEOUT_SECS (60*15)
+#define MAX_ANONYMOUS_ADV_TIMEOUT_SECS (60 * 15)
 #define MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS (180)
 
 #define BLE_MIN_CONN_INTERVAL        MSEC_TO_UNITS(15, UNIT_0_625_MS)
@@ -289,7 +289,7 @@ STATIC void bleio_adapter_hci_init(bleio_adapter_obj_t *self) {
 
     // Get version information.
     if (hci_read_local_version(&self->hci_version, &self->hci_revision, &self->lmp_version,
-                               &self->manufacturer, &self->lmp_subversion) != HCI_OK) {
+        &self->manufacturer, &self->lmp_subversion) != HCI_OK) {
         mp_raise_bleio_BluetoothError(translate("Could not read HCI version"));
     }
     // Get supported features.
@@ -414,11 +414,11 @@ bool common_hal_bleio_adapter_set_address(bleio_adapter_obj_t *self, bleio_addre
     return hci_le_set_random_address(bufinfo.buf) == HCI_OK;
 }
 
-mp_obj_str_t* common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
+mp_obj_str_t *common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
     return self->name;
 }
 
-void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char* name) {
+void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char *name) {
     self->name = mp_obj_new_str(name, strlen(name));
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(self->name, &bufinfo, MP_BUFFER_READ);
@@ -459,7 +459,7 @@ void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char* na
 //     return true;
 // }
 
-mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t* prefixes, size_t prefix_length, bool extended, mp_int_t buffer_size, mp_float_t timeout, mp_float_t interval, mp_float_t window, mp_int_t minimum_rssi, bool active) {
+mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t *prefixes, size_t prefix_length, bool extended, mp_int_t buffer_size, mp_float_t timeout, mp_float_t interval, mp_float_t window, mp_int_t minimum_rssi, bool active) {
     // TODO
     mp_raise_NotImplementedError(NULL);
     check_enabled(self);
@@ -704,7 +704,7 @@ uint32_t _common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
 
         uint8_t handle[1] = { 0 };
         uint16_t duration_10msec[1] = { timeout * 100 };
-        uint8_t max_ext_adv_evts[1] =  { 0 };
+        uint8_t max_ext_adv_evts[1] = { 0 };
         hci_check_error(
             hci_le_set_extended_advertising_enable(
                 BT_HCI_LE_ADV_ENABLE,
@@ -789,11 +789,11 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self, bool
     } else {
         if (timeout > MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS) {
             mp_raise_bleio_BluetoothError(translate("Timeout is too long: Maximum timeout length is %d seconds"),
-                                          MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS);
+                MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS);
         }
     }
 
-    const uint32_t result =_common_hal_bleio_adapter_start_advertising(
+    const uint32_t result = _common_hal_bleio_adapter_start_advertising(
         self, connectable, anonymous, timeout, interval,
         advertising_data_bufinfo->buf,
         advertising_data_bufinfo->len,
@@ -820,11 +820,11 @@ void common_hal_bleio_adapter_stop_advertising(bleio_adapter_obj_t *self) {
         hci_check_error(result);
     }
 
-    //TODO startup CircuitPython advertising again.
+    // TODO startup CircuitPython advertising again.
 }
 
 // Note that something stopped advertising, such as a connection happening.
-//Don't ask the adapter to stop.
+// Don't ask the adapter to stop.
 void bleio_adapter_advertising_was_stopped(bleio_adapter_obj_t *self) {
     self->now_advertising = false;
     self->extended_advertising = false;
@@ -876,14 +876,14 @@ void common_hal_bleio_adapter_erase_bonding(bleio_adapter_obj_t *self) {
     mp_raise_NotImplementedError(NULL);
     check_enabled(self);
 
-    //FIX bonding_erase_storage();
+    // FIX bonding_erase_storage();
 }
 
 uint16_t bleio_adapter_add_attribute(bleio_adapter_obj_t *adapter, mp_obj_t *attribute) {
     check_enabled(adapter);
 
     // The handle is the index of this attribute in the attributes list.
-    uint16_t handle = (uint16_t) adapter->attributes->len;
+    uint16_t handle = (uint16_t)adapter->attributes->len;
     mp_obj_list_append(adapter->attributes, attribute);
 
     if (MP_OBJ_IS_TYPE(attribute, &bleio_service_type)) {
@@ -896,7 +896,7 @@ uint16_t bleio_adapter_add_attribute(bleio_adapter_obj_t *adapter, mp_obj_t *att
     return handle;
 }
 
-mp_obj_t* bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle) {
+mp_obj_t *bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle) {
     check_enabled(adapter);
 
     if (handle == 0 || handle >= adapter->attributes->len) {
@@ -912,12 +912,12 @@ uint16_t bleio_adapter_max_attribute_handle(bleio_adapter_obj_t *adapter) {
 }
 
 
-void bleio_adapter_gc_collect(bleio_adapter_obj_t* adapter) {
-    gc_collect_root((void**)adapter, sizeof(bleio_adapter_obj_t) / sizeof(size_t));
-    gc_collect_root((void**)bleio_connections, sizeof(bleio_connections) / sizeof(size_t));
+void bleio_adapter_gc_collect(bleio_adapter_obj_t *adapter) {
+    gc_collect_root((void **)adapter, sizeof(bleio_adapter_obj_t) / sizeof(size_t));
+    gc_collect_root((void **)bleio_connections, sizeof(bleio_connections) / sizeof(size_t));
 }
 
-void bleio_adapter_reset(bleio_adapter_obj_t* adapter) {
+void bleio_adapter_reset(bleio_adapter_obj_t *adapter) {
 
     if (!common_hal_bleio_adapter_get_enabled(adapter)) {
         return;
@@ -939,7 +939,7 @@ void bleio_adapter_reset(bleio_adapter_obj_t* adapter) {
 
 }
 
-void bleio_adapter_background(bleio_adapter_obj_t* adapter) {
+void bleio_adapter_background(bleio_adapter_obj_t *adapter) {
     if (!common_hal_bleio_adapter_get_enabled(adapter)) {
         return;
     }
diff --git a/devices/ble_hci/common-hal/_bleio/Adapter.h b/devices/ble_hci/common-hal/_bleio/Adapter.h
index bec1329f2..48d4f2e6a 100644
--- a/devices/ble_hci/common-hal/_bleio/Adapter.h
+++ b/devices/ble_hci/common-hal/_bleio/Adapter.h
@@ -49,7 +49,7 @@ typedef struct _bleio_adapter_obj_t {
     bleio_scanresults_obj_t *scan_results;
     mp_obj_t name;
     mp_obj_tuple_t *connection_objs;
-    busio_uart_obj_t* hci_uart;
+    busio_uart_obj_t *hci_uart;
     digitalio_digitalinout_obj_t *rts_digitalinout;
     digitalio_digitalinout_obj_t *cts_digitalinout;
     bool allocated;  // True when in use.
@@ -72,7 +72,7 @@ typedef struct _bleio_adapter_obj_t {
     // Generic services characteristics.
     bleio_characteristic_obj_t *device_name_characteristic;
     bleio_characteristic_obj_t *appearance_characteristic;
-    bleio_characteristic_obj_t * service_changed_characteristic;
+    bleio_characteristic_obj_t *service_changed_characteristic;
 
     uint16_t max_acl_buffer_len;
     uint16_t max_acl_num_buffers;
@@ -90,10 +90,10 @@ typedef struct _bleio_adapter_obj_t {
 
 uint16_t bleio_adapter_add_attribute(bleio_adapter_obj_t *adapter, mp_obj_t *attribute);
 void bleio_adapter_advertising_was_stopped(bleio_adapter_obj_t *self);
-mp_obj_t* bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle);
+mp_obj_t *bleio_adapter_get_attribute(bleio_adapter_obj_t *adapter, uint16_t handle);
 uint16_t bleio_adapter_max_attribute_handle(bleio_adapter_obj_t *adapter);
-void bleio_adapter_background(bleio_adapter_obj_t* adapter);
-void bleio_adapter_gc_collect(bleio_adapter_obj_t* adapter);
-void bleio_adapter_reset(bleio_adapter_obj_t* adapter);
+void bleio_adapter_background(bleio_adapter_obj_t *adapter);
+void bleio_adapter_gc_collect(bleio_adapter_obj_t *adapter);
+void bleio_adapter_reset(bleio_adapter_obj_t *adapter);
 
 #endif // MICROPY_INCLUDED_BLE_HCI_COMMON_HAL_ADAPTER_H
diff --git a/devices/ble_hci/common-hal/_bleio/Characteristic.c b/devices/ble_hci/common-hal/_bleio/Characteristic.c
index 393b80459..725566157 100644
--- a/devices/ble_hci/common-hal/_bleio/Characteristic.c
+++ b/devices/ble_hci/common-hal/_bleio/Characteristic.c
@@ -78,16 +78,16 @@ bleio_service_obj_t *common_hal_bleio_characteristic_get_service(bleio_character
     return self->service;
 }
 
-size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *self, uint8_t* buf, size_t len) {
+size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *self, uint8_t *buf, size_t len) {
     // Do GATT operations only if this characteristic has been added to a registered service.
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
-        //FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
+        // FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
         if (common_hal_bleio_service_get_is_remote(self->service)) {
-            //FIX read remote chars
-            //uint8_t rsp[MAX(len, 512)];
-            //FIX improve att_read_req to write into our requested buffer.
+            // FIX read remote chars
+            // uint8_t rsp[MAX(len, 512)];
+            // FIX improve att_read_req to write into our requested buffer.
             // return att_read_req(conn_handle, self->handle, rsp);
-            return 0; //FIX
+            return 0; // FIX
         } else {
             mp_buffer_info_t bufinfo;
             if (!mp_get_buffer(self->value, &bufinfo, MP_BUFFER_READ)) {
@@ -113,13 +113,13 @@ void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self,
     // Do GATT operations only if this characteristic has been added to a registered service.
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         if (common_hal_bleio_service_get_is_remote(self->service)) {
-            //FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
+            // FIX uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
             if (self->props & CHAR_PROP_WRITE) {
-                //FIX writing remote chars
-                //uint8_t rsp[sizeof(bt_att_error_rsp)];
-                //att_write_req(conn_handle, self->handle, bufinfo->buf, bufinfo->len, rsp);
+                // FIX writing remote chars
+                // uint8_t rsp[sizeof(bt_att_error_rsp)];
+                // att_write_req(conn_handle, self->handle, bufinfo->buf, bufinfo->len, rsp);
             } else if (self->props & CHAR_PROP_WRITE_NO_RESPONSE) {
-                //att_write_cmd(conn_handle, self->handle, bufinfo->buff, bufinfo->len);
+                // att_write_cmd(conn_handle, self->handle, bufinfo->buff, bufinfo->len);
             } else {
                 mp_raise_bleio_BluetoothError(translate("Characteristic not writable"));
             }
@@ -172,7 +172,7 @@ void common_hal_bleio_characteristic_add_descriptor(bleio_characteristic_obj_t *
     self->service->end_handle = descriptor->handle;
 
     mp_obj_list_append(MP_OBJ_FROM_PTR(self->descriptor_list),
-                       MP_OBJ_FROM_PTR(descriptor));
+        MP_OBJ_FROM_PTR(descriptor));
 }
 
 void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self, bool notify, bool indicate) {
@@ -191,8 +191,8 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
         (notify ? CCCD_NOTIFY : 0) |
         (indicate ? CCCD_INDICATE : 0);
 
-    //FIX do remote
-    (void) cccd_value;
+    // FIX do remote
+    (void)cccd_value;
     // uint8_t rsp[sizeof(bt_att_error_rsp)];
     // if (att_write_req(conn_handle, self->cccd->handle, &cccd_value, sizeof(cccd_value)) == 0) {
     //     mp_raise_bleio_BluetoothError(translate("Could not write CCCD"));
diff --git a/devices/ble_hci/common-hal/_bleio/CharacteristicBuffer.c b/devices/ble_hci/common-hal/_bleio/CharacteristicBuffer.c
index e8cd51880..8be1abef1 100644
--- a/devices/ble_hci/common-hal/_bleio/CharacteristicBuffer.c
+++ b/devices/ble_hci/common-hal/_bleio/CharacteristicBuffer.c
@@ -47,9 +47,9 @@ void bleio_characteristic_buffer_update(bleio_characteristic_buffer_obj_t *self,
 
 // Assumes that timeout and buffer_size have been validated before call.
 void common_hal_bleio_characteristic_buffer_construct(bleio_characteristic_buffer_obj_t *self,
-                                                      bleio_characteristic_obj_t *characteristic,
-                                                      mp_float_t timeout,
-                                                      size_t buffer_size) {
+    bleio_characteristic_obj_t *characteristic,
+    mp_float_t timeout,
+    size_t buffer_size) {
 
     self->characteristic = characteristic;
     self->timeout_ms = timeout * 1000;
@@ -64,10 +64,10 @@ uint32_t common_hal_bleio_characteristic_buffer_read(bleio_characteristic_buffer
     uint64_t start_ticks = supervisor_ticks_ms64();
 
     // Wait for all bytes received or timeout
-    while ( (ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms) ) {
+    while ((ringbuf_num_filled(&self->ringbuf) < len) && (supervisor_ticks_ms64() - start_ticks < self->timeout_ms)) {
         RUN_BACKGROUND_TASKS;
         // Allow user to break out of a timeout with a KeyboardInterrupt.
-        if ( mp_hal_is_interrupted() ) {
+        if (mp_hal_is_interrupted()) {
             return 0;
         }
     }
@@ -97,8 +97,8 @@ void common_hal_bleio_characteristic_buffer_deinit(bleio_characteristic_buffer_o
 
 bool common_hal_bleio_characteristic_buffer_connected(bleio_characteristic_buffer_obj_t *self) {
     return self->characteristic != NULL &&
-        self->characteristic->service != NULL &&
-        (!self->characteristic->service->is_remote ||
-         (self->characteristic->service->connection != MP_OBJ_NULL &&
-          common_hal_bleio_connection_get_connected(self->characteristic->service->connection)));
+           self->characteristic->service != NULL &&
+           (!self->characteristic->service->is_remote ||
+               (self->characteristic->service->connection != MP_OBJ_NULL &&
+                   common_hal_bleio_connection_get_connected(self->characteristic->service->connection)));
 }
diff --git a/devices/ble_hci/common-hal/_bleio/Connection.c b/devices/ble_hci/common-hal/_bleio/Connection.c
index ba4eb477d..a27c243f4 100644
--- a/devices/ble_hci/common-hal/_bleio/Connection.c
+++ b/devices/ble_hci/common-hal/_bleio/Connection.c
@@ -73,8 +73,8 @@
 static volatile bool m_discovery_in_process;
 static volatile bool m_discovery_successful;
 
-//FIX static bleio_service_obj_t *m_char_discovery_service;
-//FIX static bleio_characteristic_obj_t *m_desc_discovery_characteristic;
+// FIX static bleio_service_obj_t *m_char_discovery_service;
+// FIX static bleio_characteristic_obj_t *m_desc_discovery_characteristic;
 
 // bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in) {
 //     bleio_connection_internal_t *self = (bleio_connection_internal_t*)self_in;
@@ -326,7 +326,7 @@ void bleio_connection_clear(bleio_connection_internal_t *self) {
     self->conn_handle = BLE_CONN_HANDLE_INVALID;
     self->pair_status = PAIR_NOT_PAIRED;
     self->is_central = false;
-    //FIX bonding_clear_keys(&self->bonding_keys);
+    // FIX bonding_clear_keys(&self->bonding_keys);
 }
 
 bool common_hal_bleio_connection_get_paired(bleio_connection_obj_t *self) {
@@ -350,7 +350,7 @@ void common_hal_bleio_connection_disconnect(bleio_connection_internal_t *self) {
 void common_hal_bleio_connection_pair(bleio_connection_internal_t *self, bool bond) {
     self->pair_status = PAIR_WAITING;
 
-    //FIX check_nrf_error(sd_ble_gap_authenticate(self->conn_handle, &pairing_sec_params));
+    // FIX check_nrf_error(sd_ble_gap_authenticate(self->conn_handle, &pairing_sec_params));
 
     while (self->pair_status == PAIR_WAITING && !mp_hal_is_interrupted()) {
         RUN_BACKGROUND_TASKS;
@@ -358,14 +358,14 @@ void common_hal_bleio_connection_pair(bleio_connection_internal_t *self, bool bo
     if (mp_hal_is_interrupted()) {
         return;
     }
-    //FIX    check_sec_status(self->sec_status);
+    // FIX    check_sec_status(self->sec_status);
 }
 
 mp_float_t common_hal_bleio_connection_get_connection_interval(bleio_connection_internal_t *self) {
     while (self->conn_params_updating && !mp_hal_is_interrupted()) {
         RUN_BACKGROUND_TASKS;
     }
-    //FIX return 1.25f * self->conn_params.min_conn_interval;
+    // FIX return 1.25f * self->conn_params.min_conn_interval;
     return 0.0f;
 }
 
@@ -729,14 +729,14 @@ void common_hal_bleio_connection_set_connection_interval(bleio_connection_intern
 // }
 
 mp_obj_tuple_t *common_hal_bleio_connection_discover_remote_services(bleio_connection_obj_t *self, mp_obj_t service_uuids_whitelist) {
-    //FIX discover_remote_services(self->connection, service_uuids_whitelist);
+    // FIX discover_remote_services(self->connection, service_uuids_whitelist);
     bleio_connection_ensure_connected(self);
     // Convert to a tuple and then clear the list so the callee will take ownership.
-     mp_obj_tuple_t *services_tuple =
-         mp_obj_new_tuple(self->connection->remote_service_list->len,
-                          self->connection->remote_service_list->items);
-     mp_obj_list_clear(MP_OBJ_FROM_PTR(self->connection->remote_service_list));
-     return services_tuple;
+    mp_obj_tuple_t *services_tuple =
+        mp_obj_new_tuple(self->connection->remote_service_list->len,
+            self->connection->remote_service_list->items);
+    mp_obj_list_clear(MP_OBJ_FROM_PTR(self->connection->remote_service_list));
+    return services_tuple;
 }
 
 uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self) {
@@ -746,7 +746,7 @@ uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self) {
     return self->connection->conn_handle;
 }
 
-mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t* internal) {
+mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t *internal) {
     if (internal->connection_obj != mp_const_none) {
         return internal->connection_obj;
     }
diff --git a/devices/ble_hci/common-hal/_bleio/Connection.h b/devices/ble_hci/common-hal/_bleio/Connection.h
index 0b1f26a21..2933bb87a 100644
--- a/devices/ble_hci/common-hal/_bleio/Connection.h
+++ b/devices/ble_hci/common-hal/_bleio/Connection.h
@@ -60,7 +60,7 @@ typedef struct {
     volatile pair_status_t pair_status;
     uint8_t sec_status; // Internal security status.
     mp_obj_t connection_obj;
-    //REMOVE ble_gap_conn_params_t conn_params;
+    // REMOVE ble_gap_conn_params_t conn_params;
     volatile bool conn_params_updating;
     uint16_t mtu;
     // Request that CCCD values for this connection be saved, using sys_attr values.
@@ -70,20 +70,20 @@ typedef struct {
     // Time of setting do_bond_ccds: we delay a bit to consolidate multiple CCCD changes
     // into one write. Time is currently in ticks_ms.
     uint64_t do_bond_cccds_request_time;
-    //FIX from att.c
+    // FIX from att.c
     uint8_t role;
     bt_addr_le_t addr;
 } bleio_connection_internal_t;
 
 typedef struct {
     mp_obj_base_t base;
-    bleio_connection_internal_t* connection;
+    bleio_connection_internal_t *connection;
     // The HCI disconnect reason.
     uint8_t disconnect_reason;
 } bleio_connection_obj_t;
 
 uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self);
-mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t* connection);
+mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t *connection);
 bleio_connection_internal_t *bleio_conn_handle_to_connection(uint16_t conn_handle);
 
 #endif // MICROPY_INCLUDED_BLE_HCI_COMMON_HAL_CONNECTION_H
diff --git a/devices/ble_hci/common-hal/_bleio/Descriptor.c b/devices/ble_hci/common-hal/_bleio/Descriptor.c
index 645273e28..444d57fb3 100644
--- a/devices/ble_hci/common-hal/_bleio/Descriptor.c
+++ b/devices/ble_hci/common-hal/_bleio/Descriptor.c
@@ -44,7 +44,7 @@ void common_hal_bleio_descriptor_construct(bleio_descriptor_obj_t *self, bleio_c
     const mp_int_t max_length_max = fixed_length ? BLE_GATTS_FIX_ATTR_LEN_MAX : BLE_GATTS_VAR_ATTR_LEN_MAX;
     if (max_length < 0 || max_length > max_length_max) {
         mp_raise_ValueError_varg(translate("max_length must be 0-%d when fixed_length is %s"),
-                                 max_length_max, fixed_length ? "True" : "False");
+            max_length_max, fixed_length ? "True" : "False");
     }
     self->max_length = max_length;
     self->fixed_length = fixed_length;
@@ -60,14 +60,14 @@ bleio_characteristic_obj_t *common_hal_bleio_descriptor_get_characteristic(bleio
     return self->characteristic;
 }
 
-size_t common_hal_bleio_descriptor_get_value(bleio_descriptor_obj_t *self, uint8_t* buf, size_t len) {
+size_t common_hal_bleio_descriptor_get_value(bleio_descriptor_obj_t *self, uint8_t *buf, size_t len) {
     // Do GATT operations only if this descriptor has been registered
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         if (common_hal_bleio_service_get_is_remote(self->characteristic->service)) {
-            //uint16_t conn_handle = bleio_connection_get_conn_handle(self->characteristic->service->connection);
-            //FIX have att_read_req fill in a buffer
-            //uint8_t rsp[MAX(len, 512)];
-            //return att_read_req(conn_handle, self->handle, rsp, len);
+            // uint16_t conn_handle = bleio_connection_get_conn_handle(self->characteristic->service->connection);
+            // FIX have att_read_req fill in a buffer
+            // uint8_t rsp[MAX(len, 512)];
+            // return att_read_req(conn_handle, self->handle, rsp, len);
             return 0;
         } else {
             mp_buffer_info_t bufinfo;
@@ -96,7 +96,7 @@ void common_hal_bleio_descriptor_set_value(bleio_descriptor_obj_t *self, mp_buff
     // Do GATT operations only if this descriptor has been registered.
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         if (common_hal_bleio_service_get_is_remote(self->characteristic->service)) {
-            //FIX
+            // FIX
             // uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
             // att_write_req(conn_handle, self->handle, bufinfo->buf, bufinfo->len, rsp);
         } else {
diff --git a/devices/ble_hci/common-hal/_bleio/Descriptor.h b/devices/ble_hci/common-hal/_bleio/Descriptor.h
index 097a49f8e..ffa0c172a 100644
--- a/devices/ble_hci/common-hal/_bleio/Descriptor.h
+++ b/devices/ble_hci/common-hal/_bleio/Descriptor.h
@@ -47,7 +47,7 @@ typedef struct _bleio_descriptor_obj {
     uint16_t handle;
     bleio_attribute_security_mode_t read_perm;
     bleio_attribute_security_mode_t write_perm;
-    struct _bleio_descriptor_obj* next;
+    struct _bleio_descriptor_obj *next;
 } bleio_descriptor_obj_t;
 
 #endif // MICROPY_INCLUDED_BLE_HCI_COMMON_HAL_DESCRIPTOR_H
diff --git a/devices/ble_hci/common-hal/_bleio/PacketBuffer.c b/devices/ble_hci/common-hal/_bleio/PacketBuffer.c
index 98912ba90..9d8a21601 100644
--- a/devices/ble_hci/common-hal/_bleio/PacketBuffer.c
+++ b/devices/ble_hci/common-hal/_bleio/PacketBuffer.c
@@ -45,13 +45,13 @@ STATIC void write_to_ringbuf(bleio_packet_buffer_obj_t *self, uint8_t *data, uin
     // Make room for the new value by dropping the oldest packets first.
     while (ringbuf_capacity(&self->ringbuf) - ringbuf_num_filled(&self->ringbuf) < len + sizeof(uint16_t)) {
         uint16_t packet_length;
-        ringbuf_get_n(&self->ringbuf, (uint8_t*) &packet_length, sizeof(uint16_t));
+        ringbuf_get_n(&self->ringbuf, (uint8_t *)&packet_length, sizeof(uint16_t));
         for (uint16_t i = 0; i < packet_length; i++) {
             ringbuf_get(&self->ringbuf);
         }
         // set an overflow flag?
     }
-    ringbuf_put_n(&self->ringbuf, (uint8_t*) &len, sizeof(uint16_t));
+    ringbuf_put_n(&self->ringbuf, (uint8_t *)&len, sizeof(uint16_t));
     ringbuf_put_n(&self->ringbuf, data, len);
 }
 
@@ -80,8 +80,8 @@ void bleio_packet_buffer_update(bleio_packet_buffer_obj_t *self, mp_buffer_info_
 }
 
 void common_hal_bleio_packet_buffer_construct(
-        bleio_packet_buffer_obj_t *self, bleio_characteristic_obj_t *characteristic,
-        size_t buffer_size) {
+    bleio_packet_buffer_obj_t *self, bleio_characteristic_obj_t *characteristic,
+    size_t buffer_size) {
 
     self->characteristic = characteristic;
     self->client = self->characteristic->service->is_remote;
@@ -128,7 +128,7 @@ mp_int_t common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self
     // Copy received data.
     // Get packet length, which is in first two bytes of packet.
     uint16_t packet_length;
-    ringbuf_get_n(&self->ringbuf, (uint8_t*) &packet_length, sizeof(uint16_t));
+    ringbuf_get_n(&self->ringbuf, (uint8_t *)&packet_length, sizeof(uint16_t));
 
     mp_int_t ret;
     if (packet_length > len) {
@@ -136,7 +136,7 @@ mp_int_t common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self
         ret = len - packet_length;
         // Discard the packet if it's too large. Don't fill data.
         while (packet_length--) {
-            (void) ringbuf_get(&self->ringbuf);
+            (void)ringbuf_get(&self->ringbuf);
         }
     } else {
         // Read as much as possible, but might be shorter than len.
@@ -147,7 +147,7 @@ mp_int_t common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self
     return ret;
 }
 
-mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self, uint8_t *data, size_t len, uint8_t* header, size_t header_len) {
+mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self, uint8_t *data, size_t len, uint8_t *header, size_t header_len) {
     if (self->outgoing[0] == NULL) {
         mp_raise_bleio_BluetoothError(translate("Writes not supported on Characteristic"));
     }
@@ -174,7 +174,7 @@ mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self, u
 
     size_t num_bytes_written = 0;
 
-    uint8_t* pending = self->outgoing[self->pending_index];
+    uint8_t *pending = self->outgoing[self->pending_index];
 
     if (self->pending_size == 0) {
         memcpy(pending, header, header_len);
@@ -213,7 +213,7 @@ mp_int_t common_hal_bleio_packet_buffer_get_incoming_packet_length(bleio_packet_
             bleio_connection_internal_t *connection = bleio_conn_handle_to_connection(self->conn_handle);
             if (connection) {
                 return MIN(common_hal_bleio_connection_get_max_packet_length(connection),
-                           self->characteristic->max_length);
+                    self->characteristic->max_length);
             }
         }
         // There's no current connection, so we don't know the MTU, and
@@ -244,7 +244,7 @@ mp_int_t common_hal_bleio_packet_buffer_get_outgoing_packet_length(bleio_packet_
             bleio_connection_internal_t *connection = bleio_conn_handle_to_connection(self->conn_handle);
             if (connection) {
                 return MIN(common_hal_bleio_connection_get_max_packet_length(connection),
-                           self->characteristic->max_length);
+                    self->characteristic->max_length);
             }
         }
         // There's no current connection, so we don't know the MTU, and
diff --git a/devices/ble_hci/common-hal/_bleio/PacketBuffer.h b/devices/ble_hci/common-hal/_bleio/PacketBuffer.h
index 074c03dc6..7f351929d 100644
--- a/devices/ble_hci/common-hal/_bleio/PacketBuffer.h
+++ b/devices/ble_hci/common-hal/_bleio/PacketBuffer.h
@@ -37,7 +37,7 @@ typedef struct {
     ringbuf_t ringbuf;
     // Two outgoing buffers to alternate between. One will be queued for transmission by the SD and
     // the other is waiting to be queued and can be extended.
-    uint8_t* outgoing[2];
+    uint8_t *outgoing[2];
     volatile uint16_t pending_size;
     // We remember the conn_handle so we can do a NOTIFY/INDICATE to a client.
     // We can find out the conn_handle on a Characteristic write or a CCCD write (but not a read).
diff --git a/devices/ble_hci/common-hal/_bleio/Service.c b/devices/ble_hci/common-hal/_bleio/Service.c
index 5803f5309..0bf00566f 100644
--- a/devices/ble_hci/common-hal/_bleio/Service.c
+++ b/devices/ble_hci/common-hal/_bleio/Service.c
@@ -32,7 +32,7 @@
 #include "shared-bindings/_bleio/Service.h"
 #include "shared-bindings/_bleio/Adapter.h"
 
-uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary, mp_obj_list_t * characteristic_list) {
+uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary, mp_obj_list_t *characteristic_list) {
     self->uuid = uuid;
     self->characteristic_list = characteristic_list;
     self->is_remote = false;
@@ -52,7 +52,7 @@ uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uu
 
 void common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary) {
     if (_common_hal_bleio_service_construct(self, uuid, is_secondary,
-                                            mp_obj_new_list(0, NULL)) != 0) {
+        mp_obj_new_list(0, NULL)) != 0) {
         mp_raise_RuntimeError(translate("Failed to add service"));
     }
 }
@@ -83,8 +83,8 @@ bool common_hal_bleio_service_get_is_secondary(bleio_service_obj_t *self) {
 }
 
 void common_hal_bleio_service_add_characteristic(bleio_service_obj_t *self,
-                                                 bleio_characteristic_obj_t *characteristic,
-                                                 mp_buffer_info_t *initial_value_bufinfo) {
+    bleio_characteristic_obj_t *characteristic,
+    mp_buffer_info_t *initial_value_bufinfo) {
 
     if (self->handle != common_hal_bleio_adapter_obj.last_added_service_handle) {
         mp_raise_bleio_BluetoothError(
diff --git a/devices/ble_hci/common-hal/_bleio/Service.h b/devices/ble_hci/common-hal/_bleio/Service.h
index 11e7d1c96..dce6f1314 100644
--- a/devices/ble_hci/common-hal/_bleio/Service.h
+++ b/devices/ble_hci/common-hal/_bleio/Service.h
@@ -46,7 +46,7 @@ typedef struct bleio_service_obj {
     // Range of attribute handles of this service.
     uint16_t start_handle;
     uint16_t end_handle;
-    struct bleio_service_obj* next;
+    struct bleio_service_obj *next;
 } bleio_service_obj_t;
 
 void bleio_service_from_connection(bleio_service_obj_t *self, mp_obj_t connection);
diff --git a/devices/ble_hci/common-hal/_bleio/UUID.c b/devices/ble_hci/common-hal/_bleio/UUID.c
index a50efc3b1..f12d1e78f 100644
--- a/devices/ble_hci/common-hal/_bleio/UUID.c
+++ b/devices/ble_hci/common-hal/_bleio/UUID.c
@@ -60,7 +60,7 @@ void common_hal_bleio_uuid_get_uuid128(bleio_uuid_obj_t *self, uint8_t uuid128[1
     memcpy(uuid128, self->uuid128, 16);
 }
 
-void common_hal_bleio_uuid_pack_into(bleio_uuid_obj_t *self, uint8_t* buf) {
+void common_hal_bleio_uuid_pack_into(bleio_uuid_obj_t *self, uint8_t *buf) {
     if (self->size == 16) {
         buf[0] = self->uuid16 & 0xff;
         buf[1] = self->uuid16 >> 8;
diff --git a/devices/ble_hci/common-hal/_bleio/UUID.h b/devices/ble_hci/common-hal/_bleio/UUID.h
index 1a0ab91c4..59e09f747 100644
--- a/devices/ble_hci/common-hal/_bleio/UUID.h
+++ b/devices/ble_hci/common-hal/_bleio/UUID.h
@@ -33,17 +33,17 @@
 
 // Types returned by attribute table lookups. These are UUIDs.
 typedef enum {
-  BLE_UUID_UNKNOWN               = 0x0000,
-  BLE_UUID_SERVICE_PRIMARY       = 0x2800,
-  BLE_UUID_SERVICE_SECONDARY     = 0x2801,
-  BLE_UUID_SERVICE_INCLUDE       = 0x2802,  // not yet implemented by us
-  BLE_UUID_CHARACTERISTIC        = 0x2803,
-  BLE_UUID_CHAR_EXTENDED_PROPS   = 0x2900,  // not yet implemented by us
-  BLE_UUID_CHAR_USER_DESC        = 0x2901,  // not yet implemented by us
-  BLE_UUID_CCCD                  = 0x2902,
-  BLE_UUID_SCCD                  = 0x2903,  // not yet implemented by us
-  BLE_UUID_CHAR_PRESENTATION_FMT = 0x2904,  // not yet implemented by us
-  BLE_UUID_CHAR_AGGREGATE_FMT    = 0x2905,  // not yet implemented by us
+    BLE_UUID_UNKNOWN               = 0x0000,
+    BLE_UUID_SERVICE_PRIMARY       = 0x2800,
+    BLE_UUID_SERVICE_SECONDARY     = 0x2801,
+    BLE_UUID_SERVICE_INCLUDE       = 0x2802,// not yet implemented by us
+    BLE_UUID_CHARACTERISTIC        = 0x2803,
+    BLE_UUID_CHAR_EXTENDED_PROPS   = 0x2900,// not yet implemented by us
+    BLE_UUID_CHAR_USER_DESC        = 0x2901,// not yet implemented by us
+    BLE_UUID_CCCD                  = 0x2902,
+    BLE_UUID_SCCD                  = 0x2903,// not yet implemented by us
+    BLE_UUID_CHAR_PRESENTATION_FMT = 0x2904, // not yet implemented by us
+    BLE_UUID_CHAR_AGGREGATE_FMT    = 0x2905,// not yet implemented by us
 } ble_standard_uuid;
 
 typedef struct {
diff --git a/devices/ble_hci/common-hal/_bleio/__init__.c b/devices/ble_hci/common-hal/_bleio/__init__.c
index 8d6d76415..5b592de83 100644
--- a/devices/ble_hci/common-hal/_bleio/__init__.c
+++ b/devices/ble_hci/common-hal/_bleio/__init__.c
@@ -78,7 +78,7 @@ void bleio_reset() {
 
     bleio_set_adapter(mp_const_none);
 
-    //FIX bonding_reset();
+    // FIX bonding_reset();
     supervisor_start_bluetooth();
 }
 
diff --git a/devices/ble_hci/common-hal/_bleio/__init__.h b/devices/ble_hci/common-hal/_bleio/__init__.h
index cd9940bf0..18bf71834 100644
--- a/devices/ble_hci/common-hal/_bleio/__init__.h
+++ b/devices/ble_hci/common-hal/_bleio/__init__.h
@@ -47,7 +47,7 @@ typedef struct {
 // 20 bytes max (23 - 3).
 #define GATT_MAX_DATA_LENGTH (BT_ATT_DEFAULT_LE_MTU - 3)
 
-//FIX
+// FIX
 #define BLE_GATT_HANDLE_INVALID 0x0000
 #define BLE_CONN_HANDLE_INVALID 0xFFFF
 #define BLE_GATTS_FIX_ATTR_LEN_MAX (510)  /**< Maximum length for fixed length Attribute Values. */
diff --git a/devices/ble_hci/common-hal/_bleio/att.c b/devices/ble_hci/common-hal/_bleio/att.c
index 4573d5e9f..5a3eb9473 100644
--- a/devices/ble_hci/common-hal/_bleio/att.c
+++ b/devices/ble_hci/common-hal/_bleio/att.c
@@ -24,8 +24,8 @@
 #include "att.h"
 
 // Zephyr include files to define HCI communication values and structs.
-//#include "hci_include/hci.h"
-//#include "hci_include/hci_err.h"
+// #include "hci_include/hci.h"
+// #include "hci_include/hci_err.h"
 #include "hci_include/l2cap_internal.h"
 
 #include "py/obj.h"
@@ -44,7 +44,7 @@ STATIC unsigned long timeout = 5000;
 STATIC volatile bool confirm;
 
 STATIC uint16_t long_write_handle = BLE_GATT_HANDLE_INVALID;
-STATIC uint8_t* long_write_value = NULL;
+STATIC uint8_t *long_write_value = NULL;
 STATIC uint16_t long_write_value_length = 0;
 
 // When we send a request, fill this struct with info about the expected response.
@@ -52,7 +52,7 @@ STATIC uint16_t long_write_value_length = 0;
 STATIC struct {
     uint16_t conn_handle;       // Expected handle.
     uint8_t opcode;             // Expected RSP opcode.
-    uint8_t* buffer;            // Pointer to response packet
+    uint8_t *buffer;            // Pointer to response packet
     uint8_t length;             // Length of response packet.
 } expected_rsp;
 
@@ -88,7 +88,7 @@ STATIC uint8_t bleio_properties_to_ble_spec_properties(uint8_t bleio_properties)
     return ble_spec_properties;
 }
 
-//FIX not currently used; reenable when used.
+// FIX not currently used; reenable when used.
 #if 0
 STATIC uint8_t ble_spec_properties_to_bleio_properties(uint8_t ble_spec_properties) {
     uint8_t bleio_properties = 0;
@@ -120,20 +120,19 @@ STATIC void send_error(uint16_t conn_handle, uint8_t opcode, uint16_t handle, ui
         struct bt_att_hdr h;
         struct bt_att_error_rsp r;
     } rsp = { {
-            .code = BT_ATT_OP_ERROR_RSP,
-        }, {
-            .request = opcode,
-        }
-    };
+                  .code = BT_ATT_OP_ERROR_RSP,
+              }, {
+                  .request = opcode,
+              }};
 
-    hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, sizeof(rsp), (uint8_t *) &rsp);
+    hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, sizeof(rsp), (uint8_t *)&rsp);
 }
 
-STATIC void send_req(uint16_t conn_handle, size_t request_length, uint8_t* request_buffer) {
+STATIC void send_req(uint16_t conn_handle, size_t request_length, uint8_t *request_buffer) {
     hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, request_length, request_buffer);
 }
 
-STATIC int send_req_wait_for_rsp(uint16_t conn_handle, size_t request_length, uint8_t* request_buffer, uint8_t response_buffer[]) {
+STATIC int send_req_wait_for_rsp(uint16_t conn_handle, size_t request_length, uint8_t *request_buffer, uint8_t response_buffer[]) {
     // We expect a particular kind of response after this request.
     expected_rsp.conn_handle = conn_handle;
     // The response opcode is the request opcode + 1.
@@ -192,9 +191,9 @@ void bleio_att_reset(void) {
 }
 
 bool att_connect_to_address(bt_addr_le_t *addr) {
-    //FIX
+    // FIX
     if (hci_le_create_conn(0x0060, 0x0030, 0x00, addr, 0x00,
-                           0x0006, 0x000c, 0x0000, 0x00c8, 0x0004, 0x0006) != 0) {
+        0x0006, 0x000c, 0x0000, 0x00c8, 0x0004, 0x0006) != 0) {
         return false;
     }
 
@@ -229,7 +228,7 @@ bool att_disconnect(uint16_t conn_handle) {
     return !att_handle_is_connected(conn_handle);
 }
 
-//FIX
+// FIX
 // STATIC bool discover_services(uint16_t conn_handle, BLERemoteDevice* device, const char* serviceUuidFilter) {
 //     uint16_t reqStart_handle = 0x0001;
 //     uint16_t reqEnd_handle = 0xffff;
@@ -406,7 +405,7 @@ bool att_disconnect(uint16_t conn_handle) {
 //     return true;
 // }
 
-bool att_discover_attributes(bt_addr_le_t *addr, const char* service_uuid_filter) {
+bool att_discover_attributes(bt_addr_le_t *addr, const char *service_uuid_filter) {
     uint16_t conn_handle = att_conn_handle(addr);
     if (conn_handle == 0xffff) {
         return false;
@@ -418,7 +417,7 @@ bool att_discover_attributes(bt_addr_le_t *addr, const char* service_uuid_filter
     }
 
     // find the device entry for the peeer
-    //FIX BLERemoteDevice* device = NULL;
+    // FIX BLERemoteDevice* device = NULL;
 
     for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
         //     if (bleio_connections[i].conn_handle == conn_handle) {
@@ -454,7 +453,7 @@ bool att_discover_attributes(bt_addr_le_t *addr, const char* service_uuid_filter
     }
 
     // discover services
-    //FIX
+    // FIX
     // if (!att_discover_services(conn_handle, device, service_uuid_filter)) {
     //     return false;
     // }
@@ -481,10 +480,10 @@ void att_set_timeout(unsigned long timeout_in) {
 }
 
 void att_add_connection(uint16_t handle, uint8_t role, bt_addr_le_t *peer_addr, uint16_t interval, uint16_t latency, uint16_t supervision_timeout, uint8_t master_clock_accuracy) {
-    (void) interval;
-    (void) latency;
-    (void) supervision_timeout;
-    (void) master_clock_accuracy;
+    (void)interval;
+    (void)latency;
+    (void)supervision_timeout;
+    (void)master_clock_accuracy;
 
     int peer_index = -1;
 
@@ -508,7 +507,7 @@ void att_add_connection(uint16_t handle, uint8_t role, bt_addr_le_t *peer_addr,
 
 
 void att_remove_connection(uint16_t conn_handle, uint8_t reason) {
-    (void) reason;
+    (void)reason;
     int peer_index = -1;
     int peer_count = 0;
 
@@ -580,7 +579,7 @@ bool att_is_connected(void) {
 }
 
 bool att_address_is_connected(bt_addr_le_t *addr) {
-    return (att_conn_handle(addr) != 0xffff);
+    return att_conn_handle(addr) != 0xffff;
 }
 
 bool att_handle_is_connected(uint16_t handle) {
@@ -624,10 +623,10 @@ bool att_disconnect_all(void) {
         bleio_connections[i].mtu = BT_ATT_DEFAULT_LE_MTU;
     }
 
-    return (num_disconnects > 0);
+    return num_disconnects > 0;
 }
 
-bool att_notify(uint16_t handle, const uint8_t* value, int length) {
+bool att_notify(uint16_t handle, const uint8_t *value, int length) {
     int num_notifications = 0;
 
     for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
@@ -643,20 +642,21 @@ bool att_notify(uint16_t handle, const uint8_t* value, int length) {
         size_t allowed_length = MIN((uint16_t)(bleio_connections[i].mtu - sizeof(notify_t)), (uint16_t)length);
 
         uint8_t notify_bytes[sizeof(notify_t) + allowed_length];
-        notify_t *notify = (notify_t *) notify_bytes;
-        notify->hdr.code = BT_ATT_OP_NOTIFY;;
+        notify_t *notify = (notify_t *)notify_bytes;
+        notify->hdr.code = BT_ATT_OP_NOTIFY;
+        ;
         notify->ntf.handle = handle;
         memcpy(notify->ntf.value, value, allowed_length);
         hci_send_acl_pkt(bleio_connections[i].conn_handle, BT_L2CAP_CID_ATT,
-                         sizeof(notify_bytes), notify_bytes);
+            sizeof(notify_bytes), notify_bytes);
 
         num_notifications++;
     }
 
-    return (num_notifications > 0);
+    return num_notifications > 0;
 }
 
-bool att_indicate(uint16_t handle, const uint8_t* value, int length) {
+bool att_indicate(uint16_t handle, const uint8_t *value, int length) {
     int num_indications = 0;
 
     for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
@@ -672,15 +672,16 @@ bool att_indicate(uint16_t handle, const uint8_t* value, int length) {
         size_t allowed_length = MIN((uint16_t)(bleio_connections[i].mtu - sizeof(indicate_t)), (uint16_t)length);
 
         uint8_t indicate_bytes[sizeof(indicate_t) + allowed_length];
-        indicate_t *indicate = (indicate_t *) indicate_bytes;
-        indicate->hdr.code = BT_ATT_OP_INDICATE;;
+        indicate_t *indicate = (indicate_t *)indicate_bytes;
+        indicate->hdr.code = BT_ATT_OP_INDICATE;
+        ;
         indicate->ind.handle = handle;
         memcpy(indicate->ind.value, value, allowed_length);
 
         confirm = false;
 
         hci_send_acl_pkt(bleio_connections[i].conn_handle, BT_L2CAP_CID_ATT,
-                         sizeof(indicate_bytes), indicate_bytes);
+            sizeof(indicate_bytes), indicate_bytes);
 
         while (!confirm) {
             // RUN_BACKGROUND_TASKS includes hci_poll_for_incoming_pkt();
@@ -694,11 +695,11 @@ bool att_indicate(uint16_t handle, const uint8_t* value, int length) {
         num_indications++;
     }
 
-    return (num_indications > 0);
+    return num_indications > 0;
 }
 
 STATIC void process_error(uint16_t conn_handle, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_error_rsp *rsp = (struct bt_att_error_rsp *) data;
+    struct bt_att_error_rsp *rsp = (struct bt_att_error_rsp *)data;
 
     if (dlen != sizeof(struct bt_att_error_rsp)) {
         // Incorrect size; ignore.
@@ -714,7 +715,7 @@ STATIC void process_error(uint16_t conn_handle, uint8_t dlen, uint8_t data[]) {
 }
 
 STATIC void process_mtu_req(uint16_t conn_handle, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_exchange_mtu_req *req = (struct bt_att_exchange_mtu_req *) data;
+    struct bt_att_exchange_mtu_req *req = (struct bt_att_exchange_mtu_req *)data;
 
     if (dlen != sizeof(struct bt_att_exchange_mtu_req)) {
         send_error(conn_handle, BT_ATT_OP_MTU_REQ, BLE_GATT_HANDLE_INVALID, BT_ATT_ERR_INVALID_PDU);
@@ -738,17 +739,16 @@ STATIC void process_mtu_req(uint16_t conn_handle, uint8_t dlen, uint8_t data[])
         struct bt_att_hdr h;
         struct bt_att_exchange_mtu_rsp r;
     } rsp = { {
-            .code = BT_ATT_OP_MTU_RSP,
-        }, {
-            .mtu = mtu,
-        }
-    };
+                  .code = BT_ATT_OP_MTU_RSP,
+              }, {
+                  .mtu = mtu,
+              }};
 
-    hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, sizeof(rsp), (uint8_t *) &rsp);
+    hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, sizeof(rsp), (uint8_t *)&rsp);
 }
 
 STATIC void process_mtu_rsp(uint16_t conn_handle, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_exchange_mtu_rsp *rsp = (struct bt_att_exchange_mtu_rsp *) data;
+    struct bt_att_exchange_mtu_rsp *rsp = (struct bt_att_exchange_mtu_rsp *)data;
 
     if (dlen != sizeof(struct bt_att_exchange_mtu_rsp)) {
         return;
@@ -765,7 +765,7 @@ STATIC void process_mtu_rsp(uint16_t conn_handle, uint8_t dlen, uint8_t data[])
 }
 
 STATIC void process_find_info_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_find_info_req *req = (struct bt_att_find_info_req *) data;
+    struct bt_att_find_info_req *req = (struct bt_att_find_info_req *)data;
 
     if (dlen != sizeof(struct bt_att_find_info_req)) {
         send_error(conn_handle, BT_ATT_OP_FIND_INFO_REQ, req->start_handle, BT_ATT_ERR_INVALID_PDU);
@@ -778,7 +778,7 @@ STATIC void process_find_info_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
     } rsp_t;
 
     uint8_t rsp_bytes[mtu];
-    rsp_t *rsp = (rsp_t *) rsp_bytes;
+    rsp_t *rsp = (rsp_t *)rsp_bytes;
     rsp->h.code = BT_ATT_OP_FIND_INFO_RSP;
 
     // Keeps track of total length of the response.
@@ -832,20 +832,20 @@ STATIC void process_find_info_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
         }
 
         if (sizeof_uuid == 2) {
-            struct bt_att_info_16 *info_16 = (struct bt_att_info_16 *) &rsp_bytes[rsp_length];
+            struct bt_att_info_16 *info_16 = (struct bt_att_info_16 *)&rsp_bytes[rsp_length];
             info_16->handle = handle;
             info_16->uuid = common_hal_bleio_uuid_get_uuid16(uuid);
 
             rsp_length += sizeof(struct bt_att_info_16);
         } else {
-            struct bt_att_info_128 *info_128 = (struct bt_att_info_128 *) &rsp_bytes[rsp_length];
+            struct bt_att_info_128 *info_128 = (struct bt_att_info_128 *)&rsp_bytes[rsp_length];
             info_128->handle = handle;
             common_hal_bleio_uuid_get_uuid128(uuid, info_128->uuid);
 
             rsp_length += sizeof(struct bt_att_info_128);
         }
 
-        no_data =false;
+        no_data = false;
     } // end for
 
 
@@ -861,14 +861,13 @@ int att_find_info_req(uint16_t conn_handle, uint16_t start_handle, uint16_t end_
         struct bt_att_hdr h;
         struct bt_att_find_info_req r;
     } req = { {
-            .code = BT_ATT_OP_FIND_INFO_REQ,
-        }, {
-            .start_handle = start_handle,
-            .end_handle = end_handle,
-        }
-    };
+                  .code = BT_ATT_OP_FIND_INFO_REQ,
+              }, {
+                  .start_handle = start_handle,
+                  .end_handle = end_handle,
+              }};
 
-    return send_req_wait_for_rsp(conn_handle, sizeof(req), (uint8_t *) &req, response_buffer);
+    return send_req_wait_for_rsp(conn_handle, sizeof(req), (uint8_t *)&req, response_buffer);
 }
 
 STATIC void process_find_info_rsp(uint16_t conn_handle, uint8_t dlen, uint8_t data[]) {
@@ -880,7 +879,7 @@ STATIC void process_find_info_rsp(uint16_t conn_handle, uint8_t dlen, uint8_t da
 }
 
 STATIC void process_find_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_find_type_req *req = (struct bt_att_find_type_req *) data;
+    struct bt_att_find_type_req *req = (struct bt_att_find_type_req *)data;
 
     if (dlen < sizeof(struct bt_att_find_type_req)) {
         send_error(conn_handle, BT_ATT_OP_FIND_TYPE_RSP, req->start_handle, BT_ATT_ERR_INVALID_PDU);
@@ -893,7 +892,7 @@ STATIC void process_find_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
     response[0] = BT_ATT_OP_FIND_TYPE_RSP;
     response_length = 1;
 
-    //FIX
+    // FIX
     // if (find_type_req->type == BLE_UUID_SERVICE_PRIMARY) {
     //     for (uint16_t i = (find_type_req->start_handle - 1); i < GATT.attributeCount() && i <= (find_type_req->end_handle - 1); i++) {
     //         BLELocalAttribute* attribute = GATT.attribute(i);
@@ -926,7 +925,7 @@ STATIC void process_find_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
 }
 
 void process_read_group_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_read_group_req *req = (struct bt_att_read_group_req *) data;
+    struct bt_att_read_group_req *req = (struct bt_att_read_group_req *)data;
     uint16_t type_uuid = req->uuid[0] | (req->uuid[1] << 8);
 
     // We only support returning services for BT_ATT_OP_READ_GROUP_REQ, which is typically used
@@ -944,7 +943,7 @@ void process_read_group_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, ui
     } rsp_t;
 
     uint8_t rsp_bytes[mtu];
-    rsp_t *rsp = (rsp_t *) rsp_bytes;
+    rsp_t *rsp = (rsp_t *)rsp_bytes;
     rsp->h.code = BT_ATT_OP_READ_GROUP_RSP;
     rsp->r.len = 0;
 
@@ -991,7 +990,7 @@ void process_read_group_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, ui
             // There may be multiple chunks in this transmission.
             rsp->r.len = data_length;
 
-            struct bt_att_group_data *group_data = (struct bt_att_group_data *) &rsp_bytes[rsp_length];
+            struct bt_att_group_data *group_data = (struct bt_att_group_data *)&rsp_bytes[rsp_length];
 
             group_data->start_handle = service->start_handle;
             group_data->end_handle = service->end_handle;
@@ -1017,7 +1016,7 @@ int att_read_group_req(uint16_t conn_handle, uint16_t start_handle, uint16_t end
     } req_t;
 
     uint8_t req_bytes[sizeof(req_t) + sizeof(uuid)];
-    req_t *req = (req_t *) req_bytes;
+    req_t *req = (req_t *)req_bytes;
 
     req->h.code = BT_ATT_OP_READ_GROUP_REQ;
     req->r.start_handle = start_handle;
@@ -1047,7 +1046,7 @@ STATIC void process_read_or_read_blob_req(uint16_t conn_handle, uint16_t mtu, ui
             return;
         }
 
-        struct bt_att_read_req *req = (struct bt_att_read_req *) data;
+        struct bt_att_read_req *req = (struct bt_att_read_req *)data;
         handle = req->handle;
         response_opcode = BT_ATT_OP_READ_RSP;
 
@@ -1057,7 +1056,7 @@ STATIC void process_read_or_read_blob_req(uint16_t conn_handle, uint16_t mtu, ui
             return;
         }
 
-        struct bt_att_read_blob_req *req = (struct bt_att_read_blob_req *) data;
+        struct bt_att_read_blob_req *req = (struct bt_att_read_blob_req *)data;
         handle = req->handle;
         offset = req->offset;
         response_opcode = BT_ATT_OP_READ_BLOB_RSP;
@@ -1077,7 +1076,7 @@ STATIC void process_read_or_read_blob_req(uint16_t conn_handle, uint16_t mtu, ui
     } rsp_t;
 
     uint8_t rsp_bytes[mtu];
-    rsp_t *rsp = (rsp_t *) rsp_bytes;
+    rsp_t *rsp = (rsp_t *)rsp_bytes;
     rsp->h.code = response_opcode;
 
     // Keeps track of total length of the response.
@@ -1105,7 +1104,7 @@ STATIC void process_read_or_read_blob_req(uint16_t conn_handle, uint16_t mtu, ui
                 return;
             }
 
-            characteristic_declaration_t *char_decl = (characteristic_declaration_t *) rsp->r.value;
+            characteristic_declaration_t *char_decl = (characteristic_declaration_t *)rsp->r.value;
 
             // Convert from the bleio properties bit values to the BLE spec properties bit values.
             // They are not the same :(.
@@ -1160,7 +1159,7 @@ STATIC void process_read_rsp(uint16_t conn_handle, uint8_t dlen, uint8_t data[])
 }
 
 STATIC void process_read_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_read_type_req *req = (struct bt_att_read_type_req *) data;
+    struct bt_att_read_type_req *req = (struct bt_att_read_type_req *)data;
     uint16_t type_uuid = req->uuid[0] | (req->uuid[1] << 8);
 
     if (dlen != sizeof(struct bt_att_read_type_req) + sizeof(type_uuid)) {
@@ -1174,7 +1173,7 @@ STATIC void process_read_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
     } rsp_t;
 
     uint8_t rsp_bytes[mtu];
-    rsp_t *rsp = (rsp_t *) rsp_bytes;
+    rsp_t *rsp = (rsp_t *)rsp_bytes;
     rsp->h.code = BT_ATT_OP_READ_TYPE_RSP;
     rsp->r.len = 0;
 
@@ -1233,11 +1232,11 @@ STATIC void process_read_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
             // There may be multiple chunks in this transmission.
             rsp->r.len = data_length;
 
-            struct bt_att_data *att_data = (struct bt_att_data *) &rsp_bytes[rsp_length];
+            struct bt_att_data *att_data = (struct bt_att_data *)&rsp_bytes[rsp_length];
 
             att_data->handle = characteristic->decl_handle;
 
-            characteristic_declaration_t *char_decl = (characteristic_declaration_t *) att_data->value;
+            characteristic_declaration_t *char_decl = (characteristic_declaration_t *)att_data->value;
 
             // Convert from the bleio properties bit values to the BLE spec properties bit values.
             // They are not the same :(.
@@ -1255,7 +1254,7 @@ STATIC void process_read_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
             // See if request is for a descriptor value with a 16-bit UUID, such as the CCCD.
             bleio_descriptor_obj_t *descriptor = MP_OBJ_TO_PTR(attribute_obj);
             if (bleio_uuid_get_uuid16_or_unknown(descriptor->uuid) == type_uuid) {
-                struct bt_att_data *att_data = (struct bt_att_data *) &rsp_bytes[rsp_length];
+                struct bt_att_data *att_data = (struct bt_att_data *)&rsp_bytes[rsp_length];
 
                 att_data->handle = handle;
 
@@ -1277,7 +1276,7 @@ STATIC void process_read_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
             bleio_characteristic_obj_t *characteristic = MP_OBJ_TO_PTR(attribute_obj);
             if (bleio_uuid_get_uuid16_or_unknown(characteristic->uuid) == type_uuid) {
 
-                struct bt_att_data *att_data = (struct bt_att_data *) &rsp_bytes[rsp_length];
+                struct bt_att_data *att_data = (struct bt_att_data *)&rsp_bytes[rsp_length];
 
                 att_data->handle = handle;
 
@@ -1299,7 +1298,7 @@ STATIC void process_read_type_req(uint16_t conn_handle, uint16_t mtu, uint8_t dl
 
     if (no_data) {
         send_error(conn_handle, BT_ATT_OP_READ_TYPE_REQ,
-                   req->start_handle, BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
+            req->start_handle, BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
     } else {
         hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, rsp_length, rsp_bytes);
     }
@@ -1312,7 +1311,7 @@ int att_read_type_req(uint16_t conn_handle, uint16_t start_handle, uint16_t end_
     } req_t;
 
     uint8_t req_bytes[sizeof(req_t) + sizeof(type)];
-    req_t *req = (req_t *) req_bytes;
+    req_t *req = (req_t *)req_bytes;
 
     req->h.code = BT_ATT_OP_READ_TYPE_REQ;
     req->r.start_handle = start_handle;
@@ -1334,7 +1333,7 @@ STATIC void process_read_type_rsp(uint16_t conn_handle, uint8_t dlen, uint8_t da
 // Handles BT_ATT_OP_WRITE_REQ or BT_ATT_OP_WRITE_
 STATIC void process_write_req_or_cmd(uint16_t conn_handle, uint16_t mtu, uint8_t op, uint8_t dlen, uint8_t data[]) {
     // struct bt_att_write_cmd is identical, so don't bother to split code paths based on opcode.
-    struct bt_att_write_req *req = (struct bt_att_write_req *) data;
+    struct bt_att_write_req *req = (struct bt_att_write_req *)data;
 
     bool with_response = (op == BT_ATT_OP_WRITE_REQ);
 
@@ -1397,7 +1396,7 @@ STATIC void process_write_req_or_cmd(uint16_t conn_handle, uint16_t mtu, uint8_t
             .code = BT_ATT_OP_WRITE_RSP,
         };
 
-        hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, sizeof(rsp), (uint8_t *) &rsp);
+        hci_send_acl_pkt(conn_handle, BT_L2CAP_CID_ATT, sizeof(rsp), (uint8_t *)&rsp);
     }
 }
 
@@ -1410,7 +1409,7 @@ STATIC void process_write_rsp(uint16_t conn_handle, uint8_t dlen, uint8_t data[]
 }
 
 STATIC void process_prepare_write_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_prepare_write_req *req = (struct bt_att_prepare_write_req *) data;
+    struct bt_att_prepare_write_req *req = (struct bt_att_prepare_write_req *)data;
 
     if (dlen < sizeof(struct bt_att_prepare_write_req)) {
         send_error(conn_handle, BT_ATT_OP_PREPARE_WRITE_REQ, BLE_GATT_HANDLE_INVALID, BT_ATT_ERR_INVALID_PDU);
@@ -1419,7 +1418,7 @@ STATIC void process_prepare_write_req(uint16_t conn_handle, uint16_t mtu, uint8_
 
     uint16_t handle = req->handle;
     uint16_t offset = req->offset;
-    (void) offset;
+    (void)offset;
 
     if (handle > bleio_adapter_max_attribute_handle(&common_hal_bleio_adapter_obj)) {
         send_error(conn_handle, BT_ATT_OP_PREPARE_WRITE_REQ, handle, BT_ATT_ERR_ATTRIBUTE_NOT_FOUND);
@@ -1433,7 +1432,7 @@ STATIC void process_prepare_write_req(uint16_t conn_handle, uint16_t mtu, uint8_
         return;
     }
 
-    bleio_characteristic_obj_t* characteristic = MP_OBJ_TO_PTR(attribute);
+    bleio_characteristic_obj_t *characteristic = MP_OBJ_TO_PTR(attribute);
 
     if (handle != characteristic->handle) {
         send_error(conn_handle, BT_ATT_OP_PREPARE_WRITE_REQ, handle, BT_ATT_ERR_ATTRIBUTE_NOT_LONG);
@@ -1445,7 +1444,7 @@ STATIC void process_prepare_write_req(uint16_t conn_handle, uint16_t mtu, uint8_
         return;
     }
 
-    //FIX if (long_write_handle == BLE_GATT_HANDLE_INVALID)
+    // FIX if (long_write_handle == BLE_GATT_HANDLE_INVALID)
     //     int valueSize = characteristic->valueSize();
 
     //     long_write_value = (uint8_t*)realloc(long_write_value, valueSize);
@@ -1480,7 +1479,7 @@ STATIC void process_prepare_write_req(uint16_t conn_handle, uint16_t mtu, uint8_
 }
 
 STATIC void process_exec_write_req(uint16_t conn_handle, uint16_t mtu, uint8_t dlen, uint8_t data[]) {
-    struct bt_att_exec_write_req *req = (struct bt_att_exec_write_req *) data;
+    struct bt_att_exec_write_req *req = (struct bt_att_exec_write_req *)data;
 
     if (dlen != sizeof(struct bt_att_exec_write_req)) {
         send_error(conn_handle, BT_ATT_OP_EXEC_WRITE_REQ, BLE_GATT_HANDLE_INVALID, BT_ATT_ERR_INVALID_PDU);
@@ -1488,11 +1487,11 @@ STATIC void process_exec_write_req(uint16_t conn_handle, uint16_t mtu, uint8_t d
     }
 
     if (long_write_handle && (req->flags & 0x01)) {
-        //FIX BLELocalCharacteristic* characteristic = (BLELocalCharacteristic*)GATT.attribute(long_write_handle - 1);
+        // FIX BLELocalCharacteristic* characteristic = (BLELocalCharacteristic*)GATT.attribute(long_write_handle - 1);
 
         for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
             if (bleio_connections[i].conn_handle == conn_handle) {
-                //FIX characteristic->writeValue(BLEDevice(bleio_connections[i].address_type, bleio_connections[i].address), long_write_value, long_write_value_length);
+                // FIX characteristic->writeValue(BLEDevice(bleio_connections[i].address_type, bleio_connections[i].address), long_write_value, long_write_value_length);
                 break;
             }
         }
@@ -1516,16 +1515,16 @@ STATIC void process_notify_or_indicate(uint16_t conn_handle, uint8_t opcode, uin
     }
 
     // struct bt_att_notify and bt_att_indicate are identical.
-    //FIXunused struct bt_att_notify *req = (struct bt_att_notify *) data;
+    // FIXunused struct bt_att_notify *req = (struct bt_att_notify *) data;
 
-    //FIXunused uint8_t handle = req->handle;
+    // FIXunused uint8_t handle = req->handle;
 
     for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
         if (bleio_connections[i].conn_handle != conn_handle) {
             continue;
         }
 
-        //FIX BLERemoteDevice* device = bleio_connections[i].device;
+        // FIX BLERemoteDevice* device = bleio_connections[i].device;
 
         // if (!device) {
         //     break;
@@ -1562,9 +1561,9 @@ STATIC void process_notify_or_indicate(uint16_t conn_handle, uint8_t opcode, uin
 }
 
 STATIC void process_confirm(uint16_t conn_handle, uint8_t dlen, uint8_t data[]) {
-    (void) conn_handle;
-    (void) dlen;
-    (void) data;
+    (void)conn_handle;
+    (void)dlen;
+    (void)data;
 
     confirm = true;
 }
@@ -1574,7 +1573,7 @@ bool att_exchange_mtu(uint16_t conn_handle) {
     struct bt_att_exchange_mtu_req req = {
         .mtu = max_mtu,
     };
-    return send_req_wait_for_rsp(conn_handle, sizeof(req), (uint8_t *) &req, response_buffer);
+    return send_req_wait_for_rsp(conn_handle, sizeof(req), (uint8_t *)&req, response_buffer);
 }
 
 int att_read_req(uint16_t conn_handle, uint16_t handle, uint8_t response_buffer[]) {
@@ -1582,23 +1581,22 @@ int att_read_req(uint16_t conn_handle, uint16_t handle, uint8_t response_buffer[
         struct bt_att_hdr h;
         struct bt_att_read_req r;
     } req = { {
-            .code = BT_ATT_OP_READ_REQ,
-        }, {
-            .handle = handle,
-        }
-    };
+                  .code = BT_ATT_OP_READ_REQ,
+              }, {
+                  .handle = handle,
+              }};
 
-    return send_req_wait_for_rsp(conn_handle, sizeof(req), (uint8_t *) &req, response_buffer);
+    return send_req_wait_for_rsp(conn_handle, sizeof(req), (uint8_t *)&req, response_buffer);
 }
 
-int att_write_req(uint16_t conn_handle, uint16_t handle, const uint8_t* data, uint8_t data_len, uint8_t response_buffer[]) {
+int att_write_req(uint16_t conn_handle, uint16_t handle, const uint8_t *data, uint8_t data_len, uint8_t response_buffer[]) {
     typedef struct __packed {
         struct bt_att_hdr h;
         struct bt_att_write_req r;
     } req_t;
 
     uint8_t req_bytes[sizeof(req_t) + data_len];
-    req_t *req = (req_t *) req_bytes;
+    req_t *req = (req_t *)req_bytes;
     req->h.code = BT_ATT_OP_WRITE_REQ;
     req->r.handle = handle;
     memcpy(req->r.value, data, data_len);
@@ -1606,14 +1604,14 @@ int att_write_req(uint16_t conn_handle, uint16_t handle, const uint8_t* data, ui
     return send_req_wait_for_rsp(conn_handle, sizeof(req_bytes), req_bytes, response_buffer);
 }
 
-void att_write_cmd(uint16_t conn_handle, uint16_t handle, const uint8_t* data, uint8_t data_len) {
+void att_write_cmd(uint16_t conn_handle, uint16_t handle, const uint8_t *data, uint8_t data_len) {
     typedef struct __packed {
         struct bt_att_hdr h;
         struct bt_att_write_cmd r;
     } cmd_t;
 
     uint8_t cmd_bytes[sizeof(cmd_t) + data_len];
-    cmd_t *cmd = (cmd_t *) cmd_bytes;
+    cmd_t *cmd = (cmd_t *)cmd_bytes;
     cmd->h.code = BT_ATT_OP_WRITE_CMD;
     cmd->r.handle = handle;
     memcpy(cmd->r.value, data, data_len);
@@ -1715,7 +1713,7 @@ void att_process_data(uint16_t conn_handle, uint8_t dlen, uint8_t data[]) {
     }
 }
 
-//FIX Do we need all of these?
+// FIX Do we need all of these?
 void check_att_err(uint8_t err) {
     const compressed_string_t *msg = NULL;
     switch (err) {
diff --git a/devices/ble_hci/common-hal/_bleio/att.h b/devices/ble_hci/common-hal/_bleio/att.h
index b34b74dc3..e8fdd53fd 100644
--- a/devices/ble_hci/common-hal/_bleio/att.h
+++ b/devices/ble_hci/common-hal/_bleio/att.h
@@ -32,19 +32,19 @@
 
 void bleio_att_reset(void);
 
-//FIX void att_set_event_handler(BLEDeviceEvent event, BLEDeviceEventHandler eventHandler);
+// FIX void att_set_event_handler(BLEDeviceEvent event, BLEDeviceEventHandler eventHandler);
 bool att_address_is_connected(bt_addr_le_t *addr);
 bool att_connect_to_address(bt_addr_le_t *addr);
 bool att_disconnect(uint16_t conn_handle);
 bool att_disconnect_all(void);
-bool att_discover_attributes(bt_addr_le_t *addr, const char* service_uuid_filter);
+bool att_discover_attributes(bt_addr_le_t *addr, const char *service_uuid_filter);
 bool att_exchange_mtu(uint16_t conn_handle);
 bool att_handle_is_connected(uint16_t handle);
-bool att_indicate(uint16_t handle, const uint8_t* value, int length);
+bool att_indicate(uint16_t handle, const uint8_t *value, int length);
 bool att_is_connected(void);
-bool att_notify(uint16_t handle, const uint8_t* value, int length);
+bool att_notify(uint16_t handle, const uint8_t *value, int length);
 int att_read_req(uint16_t conn_handle, uint16_t handle, uint8_t response_buffer[]);
-int att_write_req(uint16_t conn_handle, uint16_t handle, const uint8_t* data, uint8_t data_len, uint8_t response_buffer[]);
+int att_write_req(uint16_t conn_handle, uint16_t handle, const uint8_t *data, uint8_t data_len, uint8_t response_buffer[]);
 uint16_t att_conn_handle(bt_addr_le_t *addr);
 uint16_t att_mtu(uint16_t handle);
 void att_add_connection(uint16_t handle, uint8_t role, bt_addr_le_t *peer_addr, uint16_t interval, uint16_t latency, uint16_t supervision_timeout, uint8_t master_clock_accuracy);
@@ -52,6 +52,6 @@ void att_process_data(uint16_t conn_handle, uint8_t dlen, uint8_t data[]);
 void att_remove_connection(uint16_t conn_handle, uint8_t reason);
 void att_set_max_mtu(uint16_t max_mtu);
 void att_set_timeout(unsigned long timeout);
-void att_write_cmd(uint16_t conn_handle, uint16_t handle, const uint8_t* data, uint8_t data_len);
+void att_write_cmd(uint16_t conn_handle, uint16_t handle, const uint8_t *data, uint8_t data_len);
 
 #endif // MICROPY_INCLUDED_DEVICES_BLE_HCI_COMMON_HAL_BLEIO_ATT_H
diff --git a/devices/ble_hci/common-hal/_bleio/hci.c b/devices/ble_hci/common-hal/_bleio/hci.c
index e261a9847..ec1663589 100644
--- a/devices/ble_hci/common-hal/_bleio/hci.c
+++ b/devices/ble_hci/common-hal/_bleio/hci.c
@@ -27,7 +27,7 @@
 
 #include <string.h>
 
-#include "py/mphal.h"  //*****************************
+#include "py/mphal.h"  // *****************************
 #include "supervisor/shared/tick.h"
 #include "shared-bindings/_bleio/__init__.h"
 #include "common-hal/_bleio/Adapter.h"
@@ -63,8 +63,8 @@ typedef struct __attribute__ ((packed)) {
 typedef struct __attribute__ ((packed)) {
     uint8_t pkt_type;
     uint16_t handle : 12;
-    uint8_t pb: 2;            // Packet boundary flag: ACL_DATA_PB values.
-    uint8_t bc: 2;            // Broadcast flag: always 0b00 for BLE.
+    uint8_t pb : 2;            // Packet boundary flag: ACL_DATA_PB values.
+    uint8_t bc : 2;            // Broadcast flag: always 0b00 for BLE.
     uint16_t data_len;        // length of data[] in this packet.
     uint8_t data[];
 }  h4_hci_acl_pkt_t;
@@ -89,7 +89,7 @@ typedef struct __attribute__ ((packed)) {
 //////////////////////////////////////////////////////////////////////
 // Static storage:
 
-//FIX size
+// FIX size
 #define RX_BUFFER_SIZE (3 + 255)
 #define ACL_DATA_BUFFER_SIZE (255)
 
@@ -107,7 +107,7 @@ STATIC bool cmd_response_received;
 STATIC uint16_t cmd_response_opcode;
 STATIC uint8_t cmd_response_status;
 STATIC size_t cmd_response_len;
-STATIC uint8_t* cmd_response_data;
+STATIC uint8_t *cmd_response_data;
 
 STATIC volatile bool hci_poll_in_progress = false;
 
@@ -119,7 +119,7 @@ STATIC volatile bool hci_poll_in_progress = false;
 #endif // HCI_DEBUG
 
 STATIC void process_acl_data_pkt(uint8_t pkt_len, uint8_t pkt_data[]) {
-    h4_hci_acl_pkt_t *pkt = (h4_hci_acl_pkt_t*) pkt_data;
+    h4_hci_acl_pkt_t *pkt = (h4_hci_acl_pkt_t *)pkt_data;
 
     if (pkt->pb != ACL_DATA_PB_MIDDLE) {
         // This is the start of a fragmented acl_data packet or is a full packet.
@@ -132,7 +132,7 @@ STATIC void process_acl_data_pkt(uint8_t pkt_len, uint8_t pkt_data[]) {
         acl_data_len += pkt->data_len;
     }
 
-    acl_data_t *acl = (acl_data_t *) &acl_data_buffer;
+    acl_data_t *acl = (acl_data_t *)&acl_data_buffer;
     if (acl_data_len != sizeof(acl) + acl->acl_data_len) {
         // We don't have the full packet yet.
         return;
@@ -167,18 +167,17 @@ STATIC void process_num_comp_pkts(uint16_t handle, uint16_t num_pkts) {
     }
 }
 
-STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
-{
-    h4_hci_evt_pkt_t *pkt = (h4_hci_evt_pkt_t*) pkt_data;
+STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[]) {
+    h4_hci_evt_pkt_t *pkt = (h4_hci_evt_pkt_t *)pkt_data;
 
     switch (pkt->evt) {
         case BT_HCI_EVT_DISCONN_COMPLETE: {
             struct bt_hci_evt_disconn_complete *disconn_complete =
-                (struct bt_hci_evt_disconn_complete*) pkt->params;
-            (void) disconn_complete;
+                (struct bt_hci_evt_disconn_complete *)pkt->params;
+            (void)disconn_complete;
 
             att_remove_connection(disconn_complete->handle, disconn_complete->reason);
-            //FIX L2CAPSignaling.removeConnection(disconn_complete->handle, disconn_complete->reason);
+            // FIX L2CAPSignaling.removeConnection(disconn_complete->handle, disconn_complete->reason);
             break;
         }
 
@@ -188,7 +187,7 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
                 struct bt_hci_evt_cc_status cc_status;
             } __packed;
 
-            struct cmd_complete_with_status *evt = (struct cmd_complete_with_status *) pkt->params;
+            struct cmd_complete_with_status *evt = (struct cmd_complete_with_status *)pkt->params;
 
             num_command_packets_allowed = evt->cmd_complete.ncmd;
 
@@ -197,7 +196,7 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
             cmd_response_status = evt->cc_status.status;
             // All the bytes following cmd_complete, -including- the status byte, which is
             // included in all the _bt_hci_rp_* structs.
-            cmd_response_data = (uint8_t *) &evt->cc_status;
+            cmd_response_data = (uint8_t *)&evt->cc_status;
             // Includes status byte.
             cmd_response_len = pkt->param_len - sizeof_field(struct cmd_complete_with_status, cmd_complete);
 
@@ -205,7 +204,7 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
         }
 
         case BT_HCI_EVT_CMD_STATUS: {
-            struct bt_hci_evt_cmd_status *evt = (struct bt_hci_evt_cmd_status *) pkt->params;
+            struct bt_hci_evt_cmd_status *evt = (struct bt_hci_evt_cmd_status *)pkt->params;
 
             num_command_packets_allowed = evt->ncmd;
 
@@ -220,7 +219,7 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
 
         case BT_HCI_EVT_NUM_COMPLETED_PACKETS: {
             struct bt_hci_evt_num_completed_packets *evt =
-                (struct bt_hci_evt_num_completed_packets *) pkt->params;
+                (struct bt_hci_evt_num_completed_packets *)pkt->params;
 
             // Start at zero-th pair: (conn handle, num completed packets).
             struct bt_hci_handle_count *handle_and_count = &(evt->h[0]);
@@ -232,8 +231,8 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
         }
 
         case BT_HCI_EVT_LE_META_EVENT: {
-            struct bt_hci_evt_le_meta_event *meta_evt = (struct bt_hci_evt_le_meta_event *) pkt->params;
-            uint8_t *le_evt =  pkt->params + sizeof (struct bt_hci_evt_le_meta_event);
+            struct bt_hci_evt_le_meta_event *meta_evt = (struct bt_hci_evt_le_meta_event *)pkt->params;
+            uint8_t *le_evt = pkt->params + sizeof (struct bt_hci_evt_le_meta_event);
 
             if (meta_evt->subevent == BT_HCI_EVT_LE_CONN_COMPLETE) {
                 // Advertising stops when connection occurs.
@@ -243,7 +242,7 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
                 bleio_adapter_advertising_was_stopped(&common_hal_bleio_adapter_obj);
 
                 struct bt_hci_evt_le_conn_complete *le_conn_complete =
-                    (struct bt_hci_evt_le_conn_complete *) le_evt;
+                    (struct bt_hci_evt_le_conn_complete *)le_evt;
 
                 if (le_conn_complete->status == BT_HCI_ERR_SUCCESS) {
                     att_add_connection(
@@ -258,9 +257,9 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
                 }
             } else if (meta_evt->subevent == BT_HCI_EVT_LE_ADVERTISING_REPORT) {
                 struct bt_hci_evt_le_advertising_info *le_advertising_info =
-                    (struct bt_hci_evt_le_advertising_info *) le_evt;
+                    (struct bt_hci_evt_le_advertising_info *)le_evt;
                 if (le_advertising_info->evt_type == BT_HCI_ADV_DIRECT_IND) {
-                    //FIX
+                    // FIX
                     // last byte is RSSI
                     // GAP.handleLeAdvertisingReport(leAdvertisingReport->type,
                     //                               leAdvertisingReport->peerBdaddrType,
@@ -275,9 +274,9 @@ STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt_data[])
         }
 
         default:
-#if HCI_DEBUG
+            #if HCI_DEBUG
             mp_printf(&mp_plat_print, "process_evt_pkt: Unknown event: %02x\n");
-#endif
+            #endif
             break;
     }
 }
@@ -333,7 +332,7 @@ hci_result_t hci_poll_for_incoming_pkt(void) {
             case H4_ACL:
                 if (rx_idx >= sizeof(h4_hci_acl_pkt_t)) {
                     const size_t total_len =
-                        sizeof(h4_hci_acl_pkt_t) + ((h4_hci_acl_pkt_t *) rx_buffer)->data_len;
+                        sizeof(h4_hci_acl_pkt_t) + ((h4_hci_acl_pkt_t *)rx_buffer)->data_len;
                     if (rx_idx == total_len) {
                         packet_is_complete = true;
                     }
@@ -346,7 +345,7 @@ hci_result_t hci_poll_for_incoming_pkt(void) {
             case H4_EVT:
                 if (rx_idx >= sizeof(h4_hci_evt_pkt_t)) {
                     const size_t total_len =
-                        sizeof(h4_hci_evt_pkt_t) + ((h4_hci_evt_pkt_t *) rx_buffer)->param_len;
+                        sizeof(h4_hci_evt_pkt_t) + ((h4_hci_evt_pkt_t *)rx_buffer)->param_len;
                     if (rx_idx == total_len) {
                         packet_is_complete = true;
                     }
@@ -374,23 +373,23 @@ hci_result_t hci_poll_for_incoming_pkt(void) {
 
         switch (rx_buffer[0]) {
             case H4_ACL:
-#if HCI_DEBUG
+                #if HCI_DEBUG
                 dump_acl_pkt(false, pkt_len, rx_buffer);
-#endif
+                #endif
                 process_acl_data_pkt(pkt_len, rx_buffer);
                 break;
 
             case H4_EVT:
-#if HCI_DEBUG
+                #if HCI_DEBUG
                 dump_evt_pkt(false, pkt_len, rx_buffer);
-#endif
+                #endif
                 process_evt_pkt(pkt_len, rx_buffer);
                 break;
 
             default:
-#if HCI_DEBUG
+                #if HCI_DEBUG
                 mp_printf(&mp_plat_print, "Unknown HCI packet type: %d\n", rx_buffer[0]);
-#endif
+                #endif
                 break;
         }
 
@@ -425,21 +424,21 @@ STATIC hci_result_t write_pkt(uint8_t *buffer, size_t len) {
     return HCI_OK;
 }
 
-STATIC hci_result_t send_command(uint16_t opcode, uint8_t params_len, void* params) {
+STATIC hci_result_t send_command(uint16_t opcode, uint8_t params_len, void *params) {
     uint8_t cmd_pkt_len = sizeof(h4_hci_cmd_pkt_t) + params_len;
     uint8_t tx_buffer[cmd_pkt_len];
 
     // cmd header is at the beginning of tx_buffer
-    h4_hci_cmd_pkt_t *cmd_pkt = (h4_hci_cmd_pkt_t *) tx_buffer;
+    h4_hci_cmd_pkt_t *cmd_pkt = (h4_hci_cmd_pkt_t *)tx_buffer;
     cmd_pkt->pkt_type = H4_CMD;
     cmd_pkt->opcode = opcode;
     cmd_pkt->param_len = params_len;
 
     memcpy(cmd_pkt->params, params, params_len);
 
-#if HCI_DEBUG
-        dump_cmd_pkt(true, sizeof(tx_buffer), tx_buffer);
-#endif
+    #if HCI_DEBUG
+    dump_cmd_pkt(true, sizeof(tx_buffer), tx_buffer);
+    #endif
 
     int result = write_pkt(tx_buffer, cmd_pkt_len);
     if (result != HCI_OK) {
@@ -478,8 +477,8 @@ hci_result_t hci_send_acl_pkt(uint16_t handle, uint8_t cid, uint16_t data_len, u
     const size_t buf_len = sizeof(h4_hci_acl_pkt_t) + sizeof(acl_data_t) + data_len;
     uint8_t tx_buffer[buf_len];
 
-    h4_hci_acl_pkt_t *acl_pkt = (h4_hci_acl_pkt_t *) tx_buffer;
-    acl_data_t *acl_data = (acl_data_t *) acl_pkt->data;
+    h4_hci_acl_pkt_t *acl_pkt = (h4_hci_acl_pkt_t *)tx_buffer;
+    acl_data_t *acl_data = (acl_data_t *)acl_pkt->data;
     acl_pkt->pkt_type = H4_ACL;
     acl_pkt->handle = handle;
     acl_pkt->pb = ACL_DATA_PB_FIRST_FLUSH;
@@ -490,9 +489,9 @@ hci_result_t hci_send_acl_pkt(uint16_t handle, uint8_t cid, uint16_t data_len, u
 
     memcpy(&acl_data->acl_data, data, data_len);
 
-#if HCI_DEBUG
-        dump_acl_pkt(true, buf_len, tx_buffer);
-#endif
+    #if HCI_DEBUG
+    dump_acl_pkt(true, buf_len, tx_buffer);
+    #endif
 
     pending_pkt++;
 
@@ -512,7 +511,7 @@ hci_result_t hci_read_local_version(uint8_t *hci_version, uint16_t *hci_revision
     hci_result_t result = send_command(BT_HCI_OP_READ_LOCAL_VERSION_INFO, 0, NULL);
     if (result == HCI_OK) {
         struct bt_hci_rp_read_local_version_info *response =
-            (struct bt_hci_rp_read_local_version_info *) cmd_response_data;
+            (struct bt_hci_rp_read_local_version_info *)cmd_response_data;
         *hci_version = response->hci_version;
         *hci_revision = response->hci_revision;
         *lmp_version = response->lmp_version;
@@ -526,7 +525,7 @@ hci_result_t hci_read_local_version(uint8_t *hci_version, uint16_t *hci_revision
 hci_result_t hci_read_bd_addr(bt_addr_t *addr) {
     int result = send_command(BT_HCI_OP_READ_BD_ADDR, 0, NULL);
     if (result == HCI_OK) {
-        struct bt_hci_rp_read_bd_addr *response = (struct bt_hci_rp_read_bd_addr *) cmd_response_data;
+        struct bt_hci_rp_read_bd_addr *response = (struct bt_hci_rp_read_bd_addr *)cmd_response_data;
         memcpy(addr->val, response->bdaddr.val, sizeof_field(bt_addr_t, val));
     }
 
@@ -536,7 +535,7 @@ hci_result_t hci_read_bd_addr(bt_addr_t *addr) {
 hci_result_t hci_read_rssi(uint16_t handle, int *rssi) {
     int result = send_command(BT_HCI_OP_READ_RSSI, sizeof(handle), &handle);
     if (result == HCI_OK) {
-        struct bt_hci_rp_read_rssi *response = (struct bt_hci_rp_read_rssi *) cmd_response_data;
+        struct bt_hci_rp_read_rssi *response = (struct bt_hci_rp_read_rssi *)cmd_response_data;
         *rssi = response->rssi;
     }
 
@@ -551,7 +550,7 @@ hci_result_t hci_le_read_buffer_size(uint16_t *le_max_len, uint8_t *le_max_num)
     int result = send_command(BT_HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL);
     if (result == HCI_OK) {
         struct bt_hci_rp_le_read_buffer_size *response =
-            (struct bt_hci_rp_le_read_buffer_size *) cmd_response_data;
+            (struct bt_hci_rp_le_read_buffer_size *)cmd_response_data;
         *le_max_len = response->le_max_len;
         *le_max_num = response->le_max_num;
     }
@@ -563,7 +562,7 @@ hci_result_t hci_read_buffer_size(uint16_t *acl_max_len, uint8_t *sco_max_len, u
     int result = send_command(BT_HCI_OP_READ_BUFFER_SIZE, 0, NULL);
     if (result == HCI_OK) {
         struct bt_hci_rp_read_buffer_size *response =
-            (struct bt_hci_rp_read_buffer_size *) cmd_response_data;
+            (struct bt_hci_rp_read_buffer_size *)cmd_response_data;
         *acl_max_len = response->acl_max_len;
         *sco_max_len = response->sco_max_len;
         *acl_max_num = response->acl_max_num;
@@ -608,10 +607,10 @@ hci_result_t hci_le_set_extended_advertising_parameters(uint8_t handle, uint16_t
         .scan_req_notify_enable = scan_req_notify_enable,
     };
     // Assumes little-endian.
-    memcpy(params.prim_min_interval, (void *) &prim_min_interval,
-           sizeof_field(struct bt_hci_cp_le_set_ext_adv_param, prim_min_interval));
-    memcpy(params.prim_max_interval, (void *) &prim_max_interval,
-           sizeof_field(struct bt_hci_cp_le_set_ext_adv_param, prim_max_interval));
+    memcpy(params.prim_min_interval, (void *)&prim_min_interval,
+        sizeof_field(struct bt_hci_cp_le_set_ext_adv_param, prim_min_interval));
+    memcpy(params.prim_max_interval, (void *)&prim_max_interval,
+        sizeof_field(struct bt_hci_cp_le_set_ext_adv_param, prim_max_interval));
     memcpy(params.peer_addr.a.val, peer_addr->a.val, sizeof_field(bt_addr_le_t, a.val));
     return send_command(BT_HCI_OP_LE_SET_EXT_ADV_PARAM, sizeof(params), &params);
 }
@@ -620,7 +619,7 @@ hci_result_t hci_le_read_maximum_advertising_data_length(uint16_t *max_adv_data_
     int result = send_command(BT_HCI_OP_LE_READ_MAX_ADV_DATA_LEN, 0, NULL);
     if (result == HCI_OK) {
         struct bt_hci_rp_le_read_max_adv_data_len *response =
-            (struct bt_hci_rp_le_read_max_adv_data_len *) cmd_response_data;
+            (struct bt_hci_rp_le_read_max_adv_data_len *)cmd_response_data;
         *max_adv_data_len = response->max_adv_data_len;
     }
 
@@ -631,9 +630,9 @@ hci_result_t hci_le_read_local_supported_features(uint8_t features[8]) {
     int result = send_command(BT_HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL);
     if (result == HCI_OK) {
         struct bt_hci_rp_le_read_local_features *response =
-            (struct bt_hci_rp_le_read_local_features *) cmd_response_data;
+            (struct bt_hci_rp_le_read_local_features *)cmd_response_data;
         memcpy(features, response->features,
-               sizeof_field(struct bt_hci_rp_le_read_local_features, features));
+            sizeof_field(struct bt_hci_rp_le_read_local_features, features));
     }
 
     return result;
@@ -685,7 +684,7 @@ hci_result_t hci_le_set_advertising_enable(uint8_t enable) {
 hci_result_t hci_le_set_extended_advertising_enable(uint8_t enable, uint8_t set_num, uint8_t handle[], uint16_t duration[], uint8_t max_ext_adv_evts[]) {
     uint8_t params[sizeof(struct bt_hci_cp_le_set_ext_adv_enable) +
                    set_num * (sizeof(struct bt_hci_ext_adv_set))];
-    struct bt_hci_cp_le_set_ext_adv_enable *params_p = (struct bt_hci_cp_le_set_ext_adv_enable *) &params;
+    struct bt_hci_cp_le_set_ext_adv_enable *params_p = (struct bt_hci_cp_le_set_ext_adv_enable *)&params;
     params_p->enable = enable;
     params_p->set_num = set_num;
     for (size_t i = 0; i < set_num; i++) {
diff --git a/devices/ble_hci/common-hal/_bleio/hci_debug.c b/devices/ble_hci/common-hal/_bleio/hci_debug.c
index 9cdd38981..5e57142c3 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_debug.c
+++ b/devices/ble_hci/common-hal/_bleio/hci_debug.c
@@ -26,248 +26,462 @@
 
 // This file is #include'd in hci.c when HCI_DEBUG is non-zero.
 
-STATIC const char* att_opcode_name(uint16_t opcode) {
+STATIC const char *att_opcode_name(uint16_t opcode) {
     switch (opcode) {
-        case BT_ATT_OP_ERROR_RSP: return "ERROR_RSP";
-        case BT_ATT_OP_MTU_REQ: return "MTU_REQ";
-        case BT_ATT_OP_MTU_RSP: return "MTU_RSP";
-        case BT_ATT_OP_FIND_INFO_REQ: return "FIND_INFO_REQ";
-        case BT_ATT_OP_FIND_INFO_RSP: return "FIND_INFO_RSP";
-        case BT_ATT_OP_FIND_TYPE_REQ: return "FIND_TYPE_REQ";
-        case BT_ATT_OP_FIND_TYPE_RSP: return "FIND_TYPE_RSP";
-        case BT_ATT_OP_READ_TYPE_REQ: return "READ_TYPE_REQ";
-        case BT_ATT_OP_READ_TYPE_RSP: return "READ_TYPE_RSP";
-        case BT_ATT_OP_READ_REQ: return "READ_REQ";
-        case BT_ATT_OP_READ_RSP: return "READ_RSP";
-        case BT_ATT_OP_READ_BLOB_REQ: return "READ_BLOB_REQ";
-        case BT_ATT_OP_READ_BLOB_RSP: return "READ_BLOB_RSP";
-        case BT_ATT_OP_READ_MULT_REQ: return "READ_MULT_REQ";
-        case BT_ATT_OP_READ_MULT_RSP: return "READ_MULT_RSP";
-        case BT_ATT_OP_READ_GROUP_REQ: return "READ_GROUP_REQ";
-        case BT_ATT_OP_READ_GROUP_RSP: return "READ_GROUP_RSP";
-        case BT_ATT_OP_WRITE_REQ: return "WRITE_REQ";
-        case BT_ATT_OP_WRITE_RSP: return "WRITE_RSP";
-        case BT_ATT_OP_PREPARE_WRITE_REQ: return "PREPARE_WRITE_REQ";
-        case BT_ATT_OP_PREPARE_WRITE_RSP: return "PREPARE_WRITE_RSP";
-        case BT_ATT_OP_EXEC_WRITE_REQ: return "EXEC_WRITE_REQ";
-        case BT_ATT_OP_EXEC_WRITE_RSP: return "EXEC_WRITE_RSP";
-        case BT_ATT_OP_NOTIFY: return "NOTIFY";
-        case BT_ATT_OP_INDICATE: return "INDICATE";
-        case BT_ATT_OP_CONFIRM: return "CONFIRM";
-        case BT_ATT_OP_READ_MULT_VL_REQ: return "READ_MULT_VL_REQ";
-        case BT_ATT_OP_READ_MULT_VL_RSP: return "READ_MULT_VL_RSP";
-        case BT_ATT_OP_NOTIFY_MULT: return "NOTIFY_MULT";
-        case BT_ATT_OP_WRITE_CMD: return "WRITE_CMD";
-        case BT_ATT_OP_SIGNED_WRITE_CMD: return "SIGNED_WRITE_CMD";
-        default: return "";
+        case BT_ATT_OP_ERROR_RSP:
+            return "ERROR_RSP";
+        case BT_ATT_OP_MTU_REQ:
+            return "MTU_REQ";
+        case BT_ATT_OP_MTU_RSP:
+            return "MTU_RSP";
+        case BT_ATT_OP_FIND_INFO_REQ:
+            return "FIND_INFO_REQ";
+        case BT_ATT_OP_FIND_INFO_RSP:
+            return "FIND_INFO_RSP";
+        case BT_ATT_OP_FIND_TYPE_REQ:
+            return "FIND_TYPE_REQ";
+        case BT_ATT_OP_FIND_TYPE_RSP:
+            return "FIND_TYPE_RSP";
+        case BT_ATT_OP_READ_TYPE_REQ:
+            return "READ_TYPE_REQ";
+        case BT_ATT_OP_READ_TYPE_RSP:
+            return "READ_TYPE_RSP";
+        case BT_ATT_OP_READ_REQ:
+            return "READ_REQ";
+        case BT_ATT_OP_READ_RSP:
+            return "READ_RSP";
+        case BT_ATT_OP_READ_BLOB_REQ:
+            return "READ_BLOB_REQ";
+        case BT_ATT_OP_READ_BLOB_RSP:
+            return "READ_BLOB_RSP";
+        case BT_ATT_OP_READ_MULT_REQ:
+            return "READ_MULT_REQ";
+        case BT_ATT_OP_READ_MULT_RSP:
+            return "READ_MULT_RSP";
+        case BT_ATT_OP_READ_GROUP_REQ:
+            return "READ_GROUP_REQ";
+        case BT_ATT_OP_READ_GROUP_RSP:
+            return "READ_GROUP_RSP";
+        case BT_ATT_OP_WRITE_REQ:
+            return "WRITE_REQ";
+        case BT_ATT_OP_WRITE_RSP:
+            return "WRITE_RSP";
+        case BT_ATT_OP_PREPARE_WRITE_REQ:
+            return "PREPARE_WRITE_REQ";
+        case BT_ATT_OP_PREPARE_WRITE_RSP:
+            return "PREPARE_WRITE_RSP";
+        case BT_ATT_OP_EXEC_WRITE_REQ:
+            return "EXEC_WRITE_REQ";
+        case BT_ATT_OP_EXEC_WRITE_RSP:
+            return "EXEC_WRITE_RSP";
+        case BT_ATT_OP_NOTIFY:
+            return "NOTIFY";
+        case BT_ATT_OP_INDICATE:
+            return "INDICATE";
+        case BT_ATT_OP_CONFIRM:
+            return "CONFIRM";
+        case BT_ATT_OP_READ_MULT_VL_REQ:
+            return "READ_MULT_VL_REQ";
+        case BT_ATT_OP_READ_MULT_VL_RSP:
+            return "READ_MULT_VL_RSP";
+        case BT_ATT_OP_NOTIFY_MULT:
+            return "NOTIFY_MULT";
+        case BT_ATT_OP_WRITE_CMD:
+            return "WRITE_CMD";
+        case BT_ATT_OP_SIGNED_WRITE_CMD:
+            return "SIGNED_WRITE_CMD";
+        default:
+            return "";
     }
 }
 
-STATIC const char* hci_evt_name(uint8_t evt) {
+STATIC const char *hci_evt_name(uint8_t evt) {
     switch (evt) {
-        case BT_HCI_EVT_UNKNOWN: return "UNKNOWN";
-        case BT_HCI_EVT_VENDOR: return "VENDOR";
-        case BT_HCI_EVT_INQUIRY_COMPLETE: return "INQUIRY_COMPLETE";
-        case BT_HCI_EVT_CONN_COMPLETE: return "CONN_COMPLETE";
-        case BT_HCI_EVT_CONN_REQUEST: return "CONN_REQUEST";
-        case BT_HCI_EVT_DISCONN_COMPLETE: return "DISCONN_COMPLETE";
-        case BT_HCI_EVT_AUTH_COMPLETE: return "AUTH_COMPLETE";
-        case BT_HCI_EVT_REMOTE_NAME_REQ_COMPLETE: return "REMOTE_NAME_REQ_COMPLETE";
-        case BT_HCI_EVT_ENCRYPT_CHANGE: return "ENCRYPT_CHANGE";
-        case BT_HCI_EVT_REMOTE_FEATURES: return "REMOTE_FEATURES";
-        case BT_HCI_EVT_REMOTE_VERSION_INFO: return "REMOTE_VERSION_INFO";
-        case BT_HCI_EVT_CMD_COMPLETE: return "CMD_COMPLETE";
-        case BT_HCI_EVT_CMD_STATUS: return "CMD_STATUS";
-        case BT_HCI_EVT_ROLE_CHANGE: return "ROLE_CHANGE";
-        case BT_HCI_EVT_NUM_COMPLETED_PACKETS: return "NUM_COMPLETED_PACKETS";
-        case BT_HCI_EVT_PIN_CODE_REQ: return "PIN_CODE_REQ";
-        case BT_HCI_EVT_LINK_KEY_REQ: return "LINK_KEY_REQ";
-        case BT_HCI_EVT_LINK_KEY_NOTIFY: return "LINK_KEY_NOTIFY";
-        case BT_HCI_EVT_DATA_BUF_OVERFLOW: return "DATA_BUF_OVERFLOW";
-        case BT_HCI_EVT_INQUIRY_RESULT_WITH_RSSI: return "INQUIRY_RESULT_WITH_RSSI";
-        case BT_HCI_EVT_REMOTE_EXT_FEATURES: return "REMOTE_EXT_FEATURES";
-        case BT_HCI_EVT_SYNC_CONN_COMPLETE: return "SYNC_CONN_COMPLETE";
-        case BT_HCI_EVT_EXTENDED_INQUIRY_RESULT: return "EXTENDED_INQUIRY_RESULT";
-        case BT_HCI_EVT_ENCRYPT_KEY_REFRESH_COMPLETE: return "ENCRYPT_KEY_REFRESH_COMPLETE";
-        case BT_HCI_EVT_IO_CAPA_REQ: return "IO_CAPA_REQ";
-        case BT_HCI_EVT_IO_CAPA_RESP: return "IO_CAPA_RESP";
-        case BT_HCI_EVT_USER_CONFIRM_REQ: return "USER_CONFIRM_REQ";
-        case BT_HCI_EVT_USER_PASSKEY_REQ: return "USER_PASSKEY_REQ";
-        case BT_HCI_EVT_SSP_COMPLETE: return "SSP_COMPLETE";
-        case BT_HCI_EVT_USER_PASSKEY_NOTIFY: return "USER_PASSKEY_NOTIFY";
-        case BT_HCI_EVT_LE_META_EVENT: return "LE_META_EVENT";
-        case BT_HCI_EVT_AUTH_PAYLOAD_TIMEOUT_EXP: return "AUTH_PAYLOAD_TIMEOUT_EXP";
-        default: return "";
+        case BT_HCI_EVT_UNKNOWN:
+            return "UNKNOWN";
+        case BT_HCI_EVT_VENDOR:
+            return "VENDOR";
+        case BT_HCI_EVT_INQUIRY_COMPLETE:
+            return "INQUIRY_COMPLETE";
+        case BT_HCI_EVT_CONN_COMPLETE:
+            return "CONN_COMPLETE";
+        case BT_HCI_EVT_CONN_REQUEST:
+            return "CONN_REQUEST";
+        case BT_HCI_EVT_DISCONN_COMPLETE:
+            return "DISCONN_COMPLETE";
+        case BT_HCI_EVT_AUTH_COMPLETE:
+            return "AUTH_COMPLETE";
+        case BT_HCI_EVT_REMOTE_NAME_REQ_COMPLETE:
+            return "REMOTE_NAME_REQ_COMPLETE";
+        case BT_HCI_EVT_ENCRYPT_CHANGE:
+            return "ENCRYPT_CHANGE";
+        case BT_HCI_EVT_REMOTE_FEATURES:
+            return "REMOTE_FEATURES";
+        case BT_HCI_EVT_REMOTE_VERSION_INFO:
+            return "REMOTE_VERSION_INFO";
+        case BT_HCI_EVT_CMD_COMPLETE:
+            return "CMD_COMPLETE";
+        case BT_HCI_EVT_CMD_STATUS:
+            return "CMD_STATUS";
+        case BT_HCI_EVT_ROLE_CHANGE:
+            return "ROLE_CHANGE";
+        case BT_HCI_EVT_NUM_COMPLETED_PACKETS:
+            return "NUM_COMPLETED_PACKETS";
+        case BT_HCI_EVT_PIN_CODE_REQ:
+            return "PIN_CODE_REQ";
+        case BT_HCI_EVT_LINK_KEY_REQ:
+            return "LINK_KEY_REQ";
+        case BT_HCI_EVT_LINK_KEY_NOTIFY:
+            return "LINK_KEY_NOTIFY";
+        case BT_HCI_EVT_DATA_BUF_OVERFLOW:
+            return "DATA_BUF_OVERFLOW";
+        case BT_HCI_EVT_INQUIRY_RESULT_WITH_RSSI:
+            return "INQUIRY_RESULT_WITH_RSSI";
+        case BT_HCI_EVT_REMOTE_EXT_FEATURES:
+            return "REMOTE_EXT_FEATURES";
+        case BT_HCI_EVT_SYNC_CONN_COMPLETE:
+            return "SYNC_CONN_COMPLETE";
+        case BT_HCI_EVT_EXTENDED_INQUIRY_RESULT:
+            return "EXTENDED_INQUIRY_RESULT";
+        case BT_HCI_EVT_ENCRYPT_KEY_REFRESH_COMPLETE:
+            return "ENCRYPT_KEY_REFRESH_COMPLETE";
+        case BT_HCI_EVT_IO_CAPA_REQ:
+            return "IO_CAPA_REQ";
+        case BT_HCI_EVT_IO_CAPA_RESP:
+            return "IO_CAPA_RESP";
+        case BT_HCI_EVT_USER_CONFIRM_REQ:
+            return "USER_CONFIRM_REQ";
+        case BT_HCI_EVT_USER_PASSKEY_REQ:
+            return "USER_PASSKEY_REQ";
+        case BT_HCI_EVT_SSP_COMPLETE:
+            return "SSP_COMPLETE";
+        case BT_HCI_EVT_USER_PASSKEY_NOTIFY:
+            return "USER_PASSKEY_NOTIFY";
+        case BT_HCI_EVT_LE_META_EVENT:
+            return "LE_META_EVENT";
+        case BT_HCI_EVT_AUTH_PAYLOAD_TIMEOUT_EXP:
+            return "AUTH_PAYLOAD_TIMEOUT_EXP";
+        default:
+            return "";
     }
 }
 
-STATIC const char* hci_evt_le_name(uint8_t evt_le) {
+STATIC const char *hci_evt_le_name(uint8_t evt_le) {
     switch (evt_le) {
-        case BT_HCI_EVT_LE_CONN_COMPLETE: return "LE_CONN_COMPLETE";
-        case BT_HCI_EVT_LE_ADVERTISING_REPORT: return "LE_ADVERTISING_REPORT";
-        case BT_HCI_EVT_LE_CONN_UPDATE_COMPLETE: return "LE_CONN_UPDATE_COMPLETE";
-        case BT_HCI_EVT_LE_LTK_REQUEST: return "LE_LTK_REQUEST";
-        case BT_HCI_EVT_LE_CONN_PARAM_REQ: return "LE_CONN_PARAM_REQ";
-        case BT_HCI_EVT_LE_DATA_LEN_CHANGE: return "LE_DATA_LEN_CHANGE";
-        case BT_HCI_EVT_LE_P256_PUBLIC_KEY_COMPLETE: return "LE_P256_PUBLIC_KEY_COMPLETE";
-        case BT_HCI_EVT_LE_GENERATE_DHKEY_COMPLETE: return "LE_GENERATE_DHKEY_COMPLETE";
-        case BT_HCI_EVT_LE_ENH_CONN_COMPLETE: return "LE_ENH_CONN_COMPLETE";
-        case BT_HCI_EVT_LE_DIRECT_ADV_REPORT: return "LE_DIRECT_ADV_REPORT";
-        case BT_HCI_EVT_LE_PHY_UPDATE_COMPLETE: return "LE_PHY_UPDATE_COMPLETE";
-        case BT_HCI_EVT_LE_EXT_ADVERTISING_REPORT: return "LE_EXT_ADVERTISING_REPORT";
-        case BT_HCI_EVT_LE_PER_ADV_SYNC_ESTABLISHED: return "LE_PER_ADV_SYNC_ESTABLISHED";
-        case BT_HCI_EVT_LE_PER_ADVERTISING_REPORT: return "LE_PER_ADVERTISING_REPORT";
-        case BT_HCI_EVT_LE_PER_ADV_SYNC_LOST: return "LE_PER_ADV_SYNC_LOST";
-        case BT_HCI_EVT_LE_SCAN_TIMEOUT: return "LE_SCAN_TIMEOUT";
-        case BT_HCI_EVT_LE_ADV_SET_TERMINATED: return "LE_ADV_SET_TERMINATED";
-        case BT_HCI_EVT_LE_SCAN_REQ_RECEIVED: return "LE_SCAN_REQ_RECEIVED";
-        case BT_HCI_EVT_LE_CHAN_SEL_ALGO: return "LE_CHAN_SEL_ALGO";
-        default: return "";
+        case BT_HCI_EVT_LE_CONN_COMPLETE:
+            return "LE_CONN_COMPLETE";
+        case BT_HCI_EVT_LE_ADVERTISING_REPORT:
+            return "LE_ADVERTISING_REPORT";
+        case BT_HCI_EVT_LE_CONN_UPDATE_COMPLETE:
+            return "LE_CONN_UPDATE_COMPLETE";
+        case BT_HCI_EVT_LE_LTK_REQUEST:
+            return "LE_LTK_REQUEST";
+        case BT_HCI_EVT_LE_CONN_PARAM_REQ:
+            return "LE_CONN_PARAM_REQ";
+        case BT_HCI_EVT_LE_DATA_LEN_CHANGE:
+            return "LE_DATA_LEN_CHANGE";
+        case BT_HCI_EVT_LE_P256_PUBLIC_KEY_COMPLETE:
+            return "LE_P256_PUBLIC_KEY_COMPLETE";
+        case BT_HCI_EVT_LE_GENERATE_DHKEY_COMPLETE:
+            return "LE_GENERATE_DHKEY_COMPLETE";
+        case BT_HCI_EVT_LE_ENH_CONN_COMPLETE:
+            return "LE_ENH_CONN_COMPLETE";
+        case BT_HCI_EVT_LE_DIRECT_ADV_REPORT:
+            return "LE_DIRECT_ADV_REPORT";
+        case BT_HCI_EVT_LE_PHY_UPDATE_COMPLETE:
+            return "LE_PHY_UPDATE_COMPLETE";
+        case BT_HCI_EVT_LE_EXT_ADVERTISING_REPORT:
+            return "LE_EXT_ADVERTISING_REPORT";
+        case BT_HCI_EVT_LE_PER_ADV_SYNC_ESTABLISHED:
+            return "LE_PER_ADV_SYNC_ESTABLISHED";
+        case BT_HCI_EVT_LE_PER_ADVERTISING_REPORT:
+            return "LE_PER_ADVERTISING_REPORT";
+        case BT_HCI_EVT_LE_PER_ADV_SYNC_LOST:
+            return "LE_PER_ADV_SYNC_LOST";
+        case BT_HCI_EVT_LE_SCAN_TIMEOUT:
+            return "LE_SCAN_TIMEOUT";
+        case BT_HCI_EVT_LE_ADV_SET_TERMINATED:
+            return "LE_ADV_SET_TERMINATED";
+        case BT_HCI_EVT_LE_SCAN_REQ_RECEIVED:
+            return "LE_SCAN_REQ_RECEIVED";
+        case BT_HCI_EVT_LE_CHAN_SEL_ALGO:
+            return "LE_CHAN_SEL_ALGO";
+        default:
+            return "";
     }
 }
 
-STATIC const char* hci_opcode_name(uint16_t opcode) {
+STATIC const char *hci_opcode_name(uint16_t opcode) {
     switch (opcode) {
-        case BT_OP_NOP: return "NOP";
-        case BT_HCI_OP_INQUIRY: return "INQUIRY";
-        case BT_HCI_OP_INQUIRY_CANCEL: return "INQUIRY_CANCEL";
-        case BT_HCI_OP_CONNECT: return "CONNECT";
-        case BT_HCI_OP_DISCONNECT: return "DISCONNECT";
-        case BT_HCI_OP_CONNECT_CANCEL: return "CONNECT_CANCEL";
-        case BT_HCI_OP_ACCEPT_CONN_REQ: return "ACCEPT_CONN_REQ";
-        case BT_HCI_OP_SETUP_SYNC_CONN: return "SETUP_SYNC_CONN";
-        case BT_HCI_OP_ACCEPT_SYNC_CONN_REQ: return "ACCEPT_SYNC_CONN_REQ";
-        case BT_HCI_OP_REJECT_CONN_REQ: return "REJECT_CONN_REQ";
-        case BT_HCI_OP_LINK_KEY_REPLY: return "LINK_KEY_REPLY";
-        case BT_HCI_OP_LINK_KEY_NEG_REPLY: return "LINK_KEY_NEG_REPLY";
-        case BT_HCI_OP_PIN_CODE_REPLY: return "PIN_CODE_REPLY";
-        case BT_HCI_OP_PIN_CODE_NEG_REPLY: return "PIN_CODE_NEG_REPLY";
-        case BT_HCI_OP_AUTH_REQUESTED: return "AUTH_REQUESTED";
-        case BT_HCI_OP_SET_CONN_ENCRYPT: return "SET_CONN_ENCRYPT";
-        case BT_HCI_OP_REMOTE_NAME_REQUEST: return "REMOTE_NAME_REQUEST";
-        case BT_HCI_OP_REMOTE_NAME_CANCEL: return "REMOTE_NAME_CANCEL";
-        case BT_HCI_OP_READ_REMOTE_FEATURES: return "READ_REMOTE_FEATURES";
-        case BT_HCI_OP_READ_REMOTE_EXT_FEATURES: return "READ_REMOTE_EXT_FEATURES";
-        case BT_HCI_OP_READ_REMOTE_VERSION_INFO: return "READ_REMOTE_VERSION_INFO";
-        case BT_HCI_OP_IO_CAPABILITY_REPLY: return "IO_CAPABILITY_REPLY";
-        case BT_HCI_OP_USER_CONFIRM_REPLY: return "USER_CONFIRM_REPLY";
-        case BT_HCI_OP_USER_CONFIRM_NEG_REPLY: return "USER_CONFIRM_NEG_REPLY";
-        case BT_HCI_OP_USER_PASSKEY_REPLY: return "USER_PASSKEY_REPLY";
-        case BT_HCI_OP_USER_PASSKEY_NEG_REPLY: return "USER_PASSKEY_NEG_REPLY";
-        case BT_HCI_OP_IO_CAPABILITY_NEG_REPLY: return "IO_CAPABILITY_NEG_REPLY";
-        case BT_HCI_OP_SET_EVENT_MASK: return "SET_EVENT_MASK";
-        case BT_HCI_OP_RESET: return "RESET";
-        case BT_HCI_OP_WRITE_LOCAL_NAME: return "WRITE_LOCAL_NAME";
-        case BT_HCI_OP_WRITE_PAGE_TIMEOUT: return "WRITE_PAGE_TIMEOUT";
-        case BT_HCI_OP_WRITE_SCAN_ENABLE: return "WRITE_SCAN_ENABLE";
-        case BT_HCI_OP_READ_TX_POWER_LEVEL: return "READ_TX_POWER_LEVEL";
-        case BT_HCI_OP_SET_CTL_TO_HOST_FLOW: return "SET_CTL_TO_HOST_FLOW";
-        case BT_HCI_OP_HOST_BUFFER_SIZE: return "HOST_BUFFER_SIZE";
-        case BT_HCI_OP_HOST_NUM_COMPLETED_PACKETS: return "HOST_NUM_COMPLETED_PACKETS";
-        case BT_HCI_OP_WRITE_INQUIRY_MODE: return "WRITE_INQUIRY_MODE";
-        case BT_HCI_OP_WRITE_SSP_MODE: return "WRITE_SSP_MODE";
-        case BT_HCI_OP_SET_EVENT_MASK_PAGE_2: return "SET_EVENT_MASK_PAGE_2";
-        case BT_HCI_OP_LE_WRITE_LE_HOST_SUPP: return "LE_WRITE_LE_HOST_SUPP";
-        case BT_HCI_OP_WRITE_SC_HOST_SUPP: return "WRITE_SC_HOST_SUPP";
-        case BT_HCI_OP_READ_AUTH_PAYLOAD_TIMEOUT: return "READ_AUTH_PAYLOAD_TIMEOUT";
-        case BT_HCI_OP_WRITE_AUTH_PAYLOAD_TIMEOUT: return "WRITE_AUTH_PAYLOAD_TIMEOUT";
-        case BT_HCI_OP_READ_LOCAL_VERSION_INFO: return "READ_LOCAL_VERSION_INFO";
-        case BT_HCI_OP_READ_SUPPORTED_COMMANDS: return "READ_SUPPORTED_COMMANDS";
-        case BT_HCI_OP_READ_LOCAL_EXT_FEATURES: return "READ_LOCAL_EXT_FEATURES";
-        case BT_HCI_OP_READ_LOCAL_FEATURES: return "READ_LOCAL_FEATURES";
-        case BT_HCI_OP_READ_BUFFER_SIZE: return "READ_BUFFER_SIZE";
-        case BT_HCI_OP_READ_BD_ADDR: return "READ_BD_ADDR";
-        case BT_HCI_OP_READ_RSSI: return "READ_RSSI";
-        case BT_HCI_OP_READ_ENCRYPTION_KEY_SIZE: return "READ_ENCRYPTION_KEY_SIZE";
-        case BT_HCI_OP_LE_SET_EVENT_MASK: return "LE_SET_EVENT_MASK";
-        case BT_HCI_OP_LE_READ_BUFFER_SIZE: return "LE_READ_BUFFER_SIZE";
-        case BT_HCI_OP_LE_READ_LOCAL_FEATURES: return "LE_READ_LOCAL_FEATURES";
-        case BT_HCI_OP_LE_SET_RANDOM_ADDRESS: return "LE_SET_RANDOM_ADDRESS";
-        case BT_HCI_OP_LE_SET_ADV_PARAM: return "LE_SET_ADV_PARAM";
-        case BT_HCI_OP_LE_READ_ADV_CHAN_TX_POWER: return "LE_READ_ADV_CHAN_TX_POWER";
-        case BT_HCI_OP_LE_SET_ADV_DATA: return "LE_SET_ADV_DATA";
-        case BT_HCI_OP_LE_SET_SCAN_RSP_DATA: return "LE_SET_SCAN_RSP_DATA";
-        case BT_HCI_OP_LE_SET_ADV_ENABLE: return "LE_SET_ADV_ENABLE";
-        case BT_HCI_OP_LE_SET_SCAN_PARAM: return "LE_SET_SCAN_PARAM";
-        case BT_HCI_OP_LE_SET_SCAN_ENABLE: return "LE_SET_SCAN_ENABLE";
-        case BT_HCI_OP_LE_CREATE_CONN: return "LE_CREATE_CONN";
-        case BT_HCI_OP_LE_CREATE_CONN_CANCEL: return "LE_CREATE_CONN_CANCEL";
-        case BT_HCI_OP_LE_READ_WL_SIZE: return "LE_READ_WL_SIZE";
-        case BT_HCI_OP_LE_CLEAR_WL: return "LE_CLEAR_WL";
-        case BT_HCI_OP_LE_ADD_DEV_TO_WL: return "LE_ADD_DEV_TO_WL";
-        case BT_HCI_OP_LE_REM_DEV_FROM_WL: return "LE_REM_DEV_FROM_WL";
-        case BT_HCI_OP_LE_CONN_UPDATE: return "LE_CONN_UPDATE";
-        case BT_HCI_OP_LE_SET_HOST_CHAN_CLASSIF: return "LE_SET_HOST_CHAN_CLASSIF";
-        case BT_HCI_OP_LE_READ_CHAN_MAP: return "LE_READ_CHAN_MAP";
-        case BT_HCI_OP_LE_READ_REMOTE_FEATURES: return "LE_READ_REMOTE_FEATURES";
-        case BT_HCI_OP_LE_ENCRYPT: return "LE_ENCRYPT";
-        case BT_HCI_OP_LE_RAND: return "LE_RAND";
-        case BT_HCI_OP_LE_START_ENCRYPTION: return "LE_START_ENCRYPTION";
-        case BT_HCI_OP_LE_LTK_REQ_REPLY: return "LE_LTK_REQ_REPLY";
-        case BT_HCI_OP_LE_LTK_REQ_NEG_REPLY: return "LE_LTK_REQ_NEG_REPLY";
-        case BT_HCI_OP_LE_READ_SUPP_STATES: return "LE_READ_SUPP_STATES";
-        case BT_HCI_OP_LE_RX_TEST: return "LE_RX_TEST";
-        case BT_HCI_OP_LE_TX_TEST: return "LE_TX_TEST";
-        case BT_HCI_OP_LE_TEST_END: return "LE_TEST_END";
-        case BT_HCI_OP_LE_CONN_PARAM_REQ_REPLY: return "LE_CONN_PARAM_REQ_REPLY";
-        case BT_HCI_OP_LE_CONN_PARAM_REQ_NEG_REPLY: return "LE_CONN_PARAM_REQ_NEG_REPLY";
-        case BT_HCI_OP_LE_SET_DATA_LEN: return "LE_SET_DATA_LEN";
-        case BT_HCI_OP_LE_READ_DEFAULT_DATA_LEN: return "LE_READ_DEFAULT_DATA_LEN";
-        case BT_HCI_OP_LE_WRITE_DEFAULT_DATA_LEN: return "LE_WRITE_DEFAULT_DATA_LEN";
-        case BT_HCI_OP_LE_P256_PUBLIC_KEY: return "LE_P256_PUBLIC_KEY";
-        case BT_HCI_OP_LE_GENERATE_DHKEY: return "LE_GENERATE_DHKEY";
-        case BT_HCI_OP_LE_ADD_DEV_TO_RL: return "LE_ADD_DEV_TO_RL";
-        case BT_HCI_OP_LE_REM_DEV_FROM_RL: return "LE_REM_DEV_FROM_RL";
-        case BT_HCI_OP_LE_CLEAR_RL: return "LE_CLEAR_RL";
-        case BT_HCI_OP_LE_READ_RL_SIZE: return "LE_READ_RL_SIZE";
-        case BT_HCI_OP_LE_READ_PEER_RPA: return "LE_READ_PEER_RPA";
-        case BT_HCI_OP_LE_READ_LOCAL_RPA: return "LE_READ_LOCAL_RPA";
-        case BT_HCI_OP_LE_SET_ADDR_RES_ENABLE: return "LE_SET_ADDR_RES_ENABLE";
-        case BT_HCI_OP_LE_SET_RPA_TIMEOUT: return "LE_SET_RPA_TIMEOUT";
-        case BT_HCI_OP_LE_READ_MAX_DATA_LEN: return "LE_READ_MAX_DATA_LEN";
-        case BT_HCI_OP_LE_READ_PHY: return "LE_READ_PHY";
-        case BT_HCI_OP_LE_SET_DEFAULT_PHY: return "LE_SET_DEFAULT_PHY";
-        case BT_HCI_OP_LE_SET_PHY: return "LE_SET_PHY";
-        case BT_HCI_OP_LE_ENH_RX_TEST: return "LE_ENH_RX_TEST";
-        case BT_HCI_OP_LE_ENH_TX_TEST: return "LE_ENH_TX_TEST";
-        case BT_HCI_OP_LE_SET_ADV_SET_RANDOM_ADDR: return "LE_SET_ADV_SET_RANDOM_ADDR";
-        case BT_HCI_OP_LE_SET_EXT_ADV_PARAM: return "LE_SET_EXT_ADV_PARAM";
-        case BT_HCI_OP_LE_SET_EXT_ADV_DATA: return "LE_SET_EXT_ADV_DATA";
-        case BT_HCI_OP_LE_SET_EXT_SCAN_RSP_DATA: return "LE_SET_EXT_SCAN_RSP_DATA";
-        case BT_HCI_OP_LE_SET_EXT_ADV_ENABLE: return "LE_SET_EXT_ADV_ENABLE";
-        case BT_HCI_OP_LE_READ_MAX_ADV_DATA_LEN: return "LE_READ_MAX_ADV_DATA_LEN";
-        case BT_HCI_OP_LE_READ_NUM_ADV_SETS: return "LE_READ_NUM_ADV_SETS";
-        case BT_HCI_OP_LE_REMOVE_ADV_SET: return "LE_REMOVE_ADV_SET";
-        case BT_HCI_OP_CLEAR_ADV_SETS: return "CLEAR_ADV_SETS";
-        case BT_HCI_OP_LE_SET_PER_ADV_PARAM: return "LE_SET_PER_ADV_PARAM";
-        case BT_HCI_OP_LE_SET_PER_ADV_DATA: return "LE_SET_PER_ADV_DATA";
-        case BT_HCI_OP_LE_SET_PER_ADV_ENABLE: return "LE_SET_PER_ADV_ENABLE";
-        case BT_HCI_OP_LE_SET_EXT_SCAN_PARAM: return "LE_SET_EXT_SCAN_PARAM";
-        case BT_HCI_OP_LE_SET_EXT_SCAN_ENABLE: return "LE_SET_EXT_SCAN_ENABLE";
-        case BT_HCI_OP_LE_EXT_CREATE_CONN: return "LE_EXT_CREATE_CONN";
-        case BT_HCI_OP_LE_PER_ADV_CREATE_SYNC: return "LE_PER_ADV_CREATE_SYNC";
-        case BT_HCI_OP_LE_PER_ADV_CREATE_SYNC_CANCEL: return "LE_PER_ADV_CREATE_SYNC_CANCEL";
-        case BT_HCI_OP_LE_PER_ADV_TERMINATE_SYNC: return "LE_PER_ADV_TERMINATE_SYNC";
-        case BT_HCI_OP_LE_ADD_DEV_TO_PER_ADV_LIST: return "LE_ADD_DEV_TO_PER_ADV_LIST";
-        case BT_HCI_OP_LE_REM_DEV_FROM_PER_ADV_LIST: return "LE_REM_DEV_FROM_PER_ADV_LIST";
-        case BT_HCI_OP_LE_CLEAR_PER_ADV_LIST: return "LE_CLEAR_PER_ADV_LIST";
-        case BT_HCI_OP_LE_READ_PER_ADV_LIST_SIZE: return "LE_READ_PER_ADV_LIST_SIZE";
-        case BT_HCI_OP_LE_READ_TX_POWER: return "LE_READ_TX_POWER";
-        case BT_HCI_OP_LE_READ_RF_PATH_COMP: return "LE_READ_RF_PATH_COMP";
-        case BT_HCI_OP_LE_WRITE_RF_PATH_COMP: return "LE_WRITE_RF_PATH_COMP";
-        case BT_HCI_OP_LE_SET_PRIVACY_MODE: return "LE_SET_PRIVACY_MODE";
-        default: return "";
+        case BT_OP_NOP:
+            return "NOP";
+        case BT_HCI_OP_INQUIRY:
+            return "INQUIRY";
+        case BT_HCI_OP_INQUIRY_CANCEL:
+            return "INQUIRY_CANCEL";
+        case BT_HCI_OP_CONNECT:
+            return "CONNECT";
+        case BT_HCI_OP_DISCONNECT:
+            return "DISCONNECT";
+        case BT_HCI_OP_CONNECT_CANCEL:
+            return "CONNECT_CANCEL";
+        case BT_HCI_OP_ACCEPT_CONN_REQ:
+            return "ACCEPT_CONN_REQ";
+        case BT_HCI_OP_SETUP_SYNC_CONN:
+            return "SETUP_SYNC_CONN";
+        case BT_HCI_OP_ACCEPT_SYNC_CONN_REQ:
+            return "ACCEPT_SYNC_CONN_REQ";
+        case BT_HCI_OP_REJECT_CONN_REQ:
+            return "REJECT_CONN_REQ";
+        case BT_HCI_OP_LINK_KEY_REPLY:
+            return "LINK_KEY_REPLY";
+        case BT_HCI_OP_LINK_KEY_NEG_REPLY:
+            return "LINK_KEY_NEG_REPLY";
+        case BT_HCI_OP_PIN_CODE_REPLY:
+            return "PIN_CODE_REPLY";
+        case BT_HCI_OP_PIN_CODE_NEG_REPLY:
+            return "PIN_CODE_NEG_REPLY";
+        case BT_HCI_OP_AUTH_REQUESTED:
+            return "AUTH_REQUESTED";
+        case BT_HCI_OP_SET_CONN_ENCRYPT:
+            return "SET_CONN_ENCRYPT";
+        case BT_HCI_OP_REMOTE_NAME_REQUEST:
+            return "REMOTE_NAME_REQUEST";
+        case BT_HCI_OP_REMOTE_NAME_CANCEL:
+            return "REMOTE_NAME_CANCEL";
+        case BT_HCI_OP_READ_REMOTE_FEATURES:
+            return "READ_REMOTE_FEATURES";
+        case BT_HCI_OP_READ_REMOTE_EXT_FEATURES:
+            return "READ_REMOTE_EXT_FEATURES";
+        case BT_HCI_OP_READ_REMOTE_VERSION_INFO:
+            return "READ_REMOTE_VERSION_INFO";
+        case BT_HCI_OP_IO_CAPABILITY_REPLY:
+            return "IO_CAPABILITY_REPLY";
+        case BT_HCI_OP_USER_CONFIRM_REPLY:
+            return "USER_CONFIRM_REPLY";
+        case BT_HCI_OP_USER_CONFIRM_NEG_REPLY:
+            return "USER_CONFIRM_NEG_REPLY";
+        case BT_HCI_OP_USER_PASSKEY_REPLY:
+            return "USER_PASSKEY_REPLY";
+        case BT_HCI_OP_USER_PASSKEY_NEG_REPLY:
+            return "USER_PASSKEY_NEG_REPLY";
+        case BT_HCI_OP_IO_CAPABILITY_NEG_REPLY:
+            return "IO_CAPABILITY_NEG_REPLY";
+        case BT_HCI_OP_SET_EVENT_MASK:
+            return "SET_EVENT_MASK";
+        case BT_HCI_OP_RESET:
+            return "RESET";
+        case BT_HCI_OP_WRITE_LOCAL_NAME:
+            return "WRITE_LOCAL_NAME";
+        case BT_HCI_OP_WRITE_PAGE_TIMEOUT:
+            return "WRITE_PAGE_TIMEOUT";
+        case BT_HCI_OP_WRITE_SCAN_ENABLE:
+            return "WRITE_SCAN_ENABLE";
+        case BT_HCI_OP_READ_TX_POWER_LEVEL:
+            return "READ_TX_POWER_LEVEL";
+        case BT_HCI_OP_SET_CTL_TO_HOST_FLOW:
+            return "SET_CTL_TO_HOST_FLOW";
+        case BT_HCI_OP_HOST_BUFFER_SIZE:
+            return "HOST_BUFFER_SIZE";
+        case BT_HCI_OP_HOST_NUM_COMPLETED_PACKETS:
+            return "HOST_NUM_COMPLETED_PACKETS";
+        case BT_HCI_OP_WRITE_INQUIRY_MODE:
+            return "WRITE_INQUIRY_MODE";
+        case BT_HCI_OP_WRITE_SSP_MODE:
+            return "WRITE_SSP_MODE";
+        case BT_HCI_OP_SET_EVENT_MASK_PAGE_2:
+            return "SET_EVENT_MASK_PAGE_2";
+        case BT_HCI_OP_LE_WRITE_LE_HOST_SUPP:
+            return "LE_WRITE_LE_HOST_SUPP";
+        case BT_HCI_OP_WRITE_SC_HOST_SUPP:
+            return "WRITE_SC_HOST_SUPP";
+        case BT_HCI_OP_READ_AUTH_PAYLOAD_TIMEOUT:
+            return "READ_AUTH_PAYLOAD_TIMEOUT";
+        case BT_HCI_OP_WRITE_AUTH_PAYLOAD_TIMEOUT:
+            return "WRITE_AUTH_PAYLOAD_TIMEOUT";
+        case BT_HCI_OP_READ_LOCAL_VERSION_INFO:
+            return "READ_LOCAL_VERSION_INFO";
+        case BT_HCI_OP_READ_SUPPORTED_COMMANDS:
+            return "READ_SUPPORTED_COMMANDS";
+        case BT_HCI_OP_READ_LOCAL_EXT_FEATURES:
+            return "READ_LOCAL_EXT_FEATURES";
+        case BT_HCI_OP_READ_LOCAL_FEATURES:
+            return "READ_LOCAL_FEATURES";
+        case BT_HCI_OP_READ_BUFFER_SIZE:
+            return "READ_BUFFER_SIZE";
+        case BT_HCI_OP_READ_BD_ADDR:
+            return "READ_BD_ADDR";
+        case BT_HCI_OP_READ_RSSI:
+            return "READ_RSSI";
+        case BT_HCI_OP_READ_ENCRYPTION_KEY_SIZE:
+            return "READ_ENCRYPTION_KEY_SIZE";
+        case BT_HCI_OP_LE_SET_EVENT_MASK:
+            return "LE_SET_EVENT_MASK";
+        case BT_HCI_OP_LE_READ_BUFFER_SIZE:
+            return "LE_READ_BUFFER_SIZE";
+        case BT_HCI_OP_LE_READ_LOCAL_FEATURES:
+            return "LE_READ_LOCAL_FEATURES";
+        case BT_HCI_OP_LE_SET_RANDOM_ADDRESS:
+            return "LE_SET_RANDOM_ADDRESS";
+        case BT_HCI_OP_LE_SET_ADV_PARAM:
+            return "LE_SET_ADV_PARAM";
+        case BT_HCI_OP_LE_READ_ADV_CHAN_TX_POWER:
+            return "LE_READ_ADV_CHAN_TX_POWER";
+        case BT_HCI_OP_LE_SET_ADV_DATA:
+            return "LE_SET_ADV_DATA";
+        case BT_HCI_OP_LE_SET_SCAN_RSP_DATA:
+            return "LE_SET_SCAN_RSP_DATA";
+        case BT_HCI_OP_LE_SET_ADV_ENABLE:
+            return "LE_SET_ADV_ENABLE";
+        case BT_HCI_OP_LE_SET_SCAN_PARAM:
+            return "LE_SET_SCAN_PARAM";
+        case BT_HCI_OP_LE_SET_SCAN_ENABLE:
+            return "LE_SET_SCAN_ENABLE";
+        case BT_HCI_OP_LE_CREATE_CONN:
+            return "LE_CREATE_CONN";
+        case BT_HCI_OP_LE_CREATE_CONN_CANCEL:
+            return "LE_CREATE_CONN_CANCEL";
+        case BT_HCI_OP_LE_READ_WL_SIZE:
+            return "LE_READ_WL_SIZE";
+        case BT_HCI_OP_LE_CLEAR_WL:
+            return "LE_CLEAR_WL";
+        case BT_HCI_OP_LE_ADD_DEV_TO_WL:
+            return "LE_ADD_DEV_TO_WL";
+        case BT_HCI_OP_LE_REM_DEV_FROM_WL:
+            return "LE_REM_DEV_FROM_WL";
+        case BT_HCI_OP_LE_CONN_UPDATE:
+            return "LE_CONN_UPDATE";
+        case BT_HCI_OP_LE_SET_HOST_CHAN_CLASSIF:
+            return "LE_SET_HOST_CHAN_CLASSIF";
+        case BT_HCI_OP_LE_READ_CHAN_MAP:
+            return "LE_READ_CHAN_MAP";
+        case BT_HCI_OP_LE_READ_REMOTE_FEATURES:
+            return "LE_READ_REMOTE_FEATURES";
+        case BT_HCI_OP_LE_ENCRYPT:
+            return "LE_ENCRYPT";
+        case BT_HCI_OP_LE_RAND:
+            return "LE_RAND";
+        case BT_HCI_OP_LE_START_ENCRYPTION:
+            return "LE_START_ENCRYPTION";
+        case BT_HCI_OP_LE_LTK_REQ_REPLY:
+            return "LE_LTK_REQ_REPLY";
+        case BT_HCI_OP_LE_LTK_REQ_NEG_REPLY:
+            return "LE_LTK_REQ_NEG_REPLY";
+        case BT_HCI_OP_LE_READ_SUPP_STATES:
+            return "LE_READ_SUPP_STATES";
+        case BT_HCI_OP_LE_RX_TEST:
+            return "LE_RX_TEST";
+        case BT_HCI_OP_LE_TX_TEST:
+            return "LE_TX_TEST";
+        case BT_HCI_OP_LE_TEST_END:
+            return "LE_TEST_END";
+        case BT_HCI_OP_LE_CONN_PARAM_REQ_REPLY:
+            return "LE_CONN_PARAM_REQ_REPLY";
+        case BT_HCI_OP_LE_CONN_PARAM_REQ_NEG_REPLY:
+            return "LE_CONN_PARAM_REQ_NEG_REPLY";
+        case BT_HCI_OP_LE_SET_DATA_LEN:
+            return "LE_SET_DATA_LEN";
+        case BT_HCI_OP_LE_READ_DEFAULT_DATA_LEN:
+            return "LE_READ_DEFAULT_DATA_LEN";
+        case BT_HCI_OP_LE_WRITE_DEFAULT_DATA_LEN:
+            return "LE_WRITE_DEFAULT_DATA_LEN";
+        case BT_HCI_OP_LE_P256_PUBLIC_KEY:
+            return "LE_P256_PUBLIC_KEY";
+        case BT_HCI_OP_LE_GENERATE_DHKEY:
+            return "LE_GENERATE_DHKEY";
+        case BT_HCI_OP_LE_ADD_DEV_TO_RL:
+            return "LE_ADD_DEV_TO_RL";
+        case BT_HCI_OP_LE_REM_DEV_FROM_RL:
+            return "LE_REM_DEV_FROM_RL";
+        case BT_HCI_OP_LE_CLEAR_RL:
+            return "LE_CLEAR_RL";
+        case BT_HCI_OP_LE_READ_RL_SIZE:
+            return "LE_READ_RL_SIZE";
+        case BT_HCI_OP_LE_READ_PEER_RPA:
+            return "LE_READ_PEER_RPA";
+        case BT_HCI_OP_LE_READ_LOCAL_RPA:
+            return "LE_READ_LOCAL_RPA";
+        case BT_HCI_OP_LE_SET_ADDR_RES_ENABLE:
+            return "LE_SET_ADDR_RES_ENABLE";
+        case BT_HCI_OP_LE_SET_RPA_TIMEOUT:
+            return "LE_SET_RPA_TIMEOUT";
+        case BT_HCI_OP_LE_READ_MAX_DATA_LEN:
+            return "LE_READ_MAX_DATA_LEN";
+        case BT_HCI_OP_LE_READ_PHY:
+            return "LE_READ_PHY";
+        case BT_HCI_OP_LE_SET_DEFAULT_PHY:
+            return "LE_SET_DEFAULT_PHY";
+        case BT_HCI_OP_LE_SET_PHY:
+            return "LE_SET_PHY";
+        case BT_HCI_OP_LE_ENH_RX_TEST:
+            return "LE_ENH_RX_TEST";
+        case BT_HCI_OP_LE_ENH_TX_TEST:
+            return "LE_ENH_TX_TEST";
+        case BT_HCI_OP_LE_SET_ADV_SET_RANDOM_ADDR:
+            return "LE_SET_ADV_SET_RANDOM_ADDR";
+        case BT_HCI_OP_LE_SET_EXT_ADV_PARAM:
+            return "LE_SET_EXT_ADV_PARAM";
+        case BT_HCI_OP_LE_SET_EXT_ADV_DATA:
+            return "LE_SET_EXT_ADV_DATA";
+        case BT_HCI_OP_LE_SET_EXT_SCAN_RSP_DATA:
+            return "LE_SET_EXT_SCAN_RSP_DATA";
+        case BT_HCI_OP_LE_SET_EXT_ADV_ENABLE:
+            return "LE_SET_EXT_ADV_ENABLE";
+        case BT_HCI_OP_LE_READ_MAX_ADV_DATA_LEN:
+            return "LE_READ_MAX_ADV_DATA_LEN";
+        case BT_HCI_OP_LE_READ_NUM_ADV_SETS:
+            return "LE_READ_NUM_ADV_SETS";
+        case BT_HCI_OP_LE_REMOVE_ADV_SET:
+            return "LE_REMOVE_ADV_SET";
+        case BT_HCI_OP_CLEAR_ADV_SETS:
+            return "CLEAR_ADV_SETS";
+        case BT_HCI_OP_LE_SET_PER_ADV_PARAM:
+            return "LE_SET_PER_ADV_PARAM";
+        case BT_HCI_OP_LE_SET_PER_ADV_DATA:
+            return "LE_SET_PER_ADV_DATA";
+        case BT_HCI_OP_LE_SET_PER_ADV_ENABLE:
+            return "LE_SET_PER_ADV_ENABLE";
+        case BT_HCI_OP_LE_SET_EXT_SCAN_PARAM:
+            return "LE_SET_EXT_SCAN_PARAM";
+        case BT_HCI_OP_LE_SET_EXT_SCAN_ENABLE:
+            return "LE_SET_EXT_SCAN_ENABLE";
+        case BT_HCI_OP_LE_EXT_CREATE_CONN:
+            return "LE_EXT_CREATE_CONN";
+        case BT_HCI_OP_LE_PER_ADV_CREATE_SYNC:
+            return "LE_PER_ADV_CREATE_SYNC";
+        case BT_HCI_OP_LE_PER_ADV_CREATE_SYNC_CANCEL:
+            return "LE_PER_ADV_CREATE_SYNC_CANCEL";
+        case BT_HCI_OP_LE_PER_ADV_TERMINATE_SYNC:
+            return "LE_PER_ADV_TERMINATE_SYNC";
+        case BT_HCI_OP_LE_ADD_DEV_TO_PER_ADV_LIST:
+            return "LE_ADD_DEV_TO_PER_ADV_LIST";
+        case BT_HCI_OP_LE_REM_DEV_FROM_PER_ADV_LIST:
+            return "LE_REM_DEV_FROM_PER_ADV_LIST";
+        case BT_HCI_OP_LE_CLEAR_PER_ADV_LIST:
+            return "LE_CLEAR_PER_ADV_LIST";
+        case BT_HCI_OP_LE_READ_PER_ADV_LIST_SIZE:
+            return "LE_READ_PER_ADV_LIST_SIZE";
+        case BT_HCI_OP_LE_READ_TX_POWER:
+            return "LE_READ_TX_POWER";
+        case BT_HCI_OP_LE_READ_RF_PATH_COMP:
+            return "LE_READ_RF_PATH_COMP";
+        case BT_HCI_OP_LE_WRITE_RF_PATH_COMP:
+            return "LE_WRITE_RF_PATH_COMP";
+        case BT_HCI_OP_LE_SET_PRIVACY_MODE:
+            return "LE_SET_PRIVACY_MODE";
+        default:
+            return "";
     }
 }
 
 
 STATIC void dump_cmd_pkt(bool tx, uint8_t pkt_len, uint8_t pkt_data[]) {
-    h4_hci_cmd_pkt_t *pkt = (h4_hci_cmd_pkt_t *) pkt_data;
+    h4_hci_cmd_pkt_t *pkt = (h4_hci_cmd_pkt_t *)pkt_data;
     mp_printf(&mp_plat_print,
-              "%s HCI COMMAND (%x) op:  %s (%04x), len: %d, data: ",
-              tx ? "TX->" : "RX<-",
-              pkt->pkt_type,
-              hci_opcode_name(pkt->opcode), pkt->opcode, pkt->param_len);
+        "%s HCI COMMAND (%x) op:  %s (%04x), len: %d, data: ",
+        tx ? "TX->" : "RX<-",
+        pkt->pkt_type,
+        hci_opcode_name(pkt->opcode), pkt->opcode, pkt->param_len);
     for (size_t i = 0; i < pkt->param_len; i++) {
         mp_printf(&mp_plat_print, "%02x ", pkt->params[i]);
     }
@@ -278,12 +492,12 @@ STATIC void dump_cmd_pkt(bool tx, uint8_t pkt_len, uint8_t pkt_data[]) {
 }
 
 STATIC void dump_acl_pkt(bool tx, uint8_t pkt_len, uint8_t pkt_data[]) {
-    h4_hci_acl_pkt_t *pkt = (h4_hci_acl_pkt_t *) pkt_data;
-    acl_data_t *acl = (acl_data_t *) pkt->data;
+    h4_hci_acl_pkt_t *pkt = (h4_hci_acl_pkt_t *)pkt_data;
+    acl_data_t *acl = (acl_data_t *)pkt->data;
 
     mp_printf(&mp_plat_print,
-              "%s HCI ACLDATA (%x) ",
-              tx ? "TX->" : "RX<-", pkt->pkt_type);
+        "%s HCI ACLDATA (%x) ",
+        tx ? "TX->" : "RX<-", pkt->pkt_type);
 
     if (pkt->pb != ACL_DATA_PB_MIDDLE && acl->cid == BT_L2CAP_CID_ATT) {
         // This is the start of a fragmented acl_data packet or is a full packet,
@@ -292,14 +506,14 @@ STATIC void dump_acl_pkt(bool tx, uint8_t pkt_len, uint8_t pkt_data[]) {
     }
 
     mp_printf(&mp_plat_print,
-              "handle: %04x, pb: %d, bc: %d, data_len: %d, ",
-              pkt->handle, pkt->pb, pkt->bc, pkt->data_len);
+        "handle: %04x, pb: %d, bc: %d, data_len: %d, ",
+        pkt->handle, pkt->pb, pkt->bc, pkt->data_len);
 
     if (pkt->pb != ACL_DATA_PB_MIDDLE) {
         // This is the start of a fragmented acl_data packet or is a full packet.
         mp_printf(&mp_plat_print,
-                  "acl data_len: %d, cid: %04x, data: ",
-                  acl->acl_data_len, acl->cid);
+            "acl data_len: %d, cid: %04x, data: ",
+            acl->acl_data_len, acl->cid);
         for (size_t i = 0; i < acl->acl_data_len; i++) {
             mp_printf(&mp_plat_print, "%02x ", acl->acl_data[i]);
         }
@@ -316,15 +530,15 @@ STATIC void dump_acl_pkt(bool tx, uint8_t pkt_len, uint8_t pkt_data[]) {
 }
 
 STATIC void dump_evt_pkt(bool tx, uint8_t pkt_len, uint8_t pkt_data[]) {
-    h4_hci_evt_pkt_t *pkt = (h4_hci_evt_pkt_t *) pkt_data;
+    h4_hci_evt_pkt_t *pkt = (h4_hci_evt_pkt_t *)pkt_data;
     mp_printf(&mp_plat_print,
-              "%s HCI EVENT   (%x) evt: %s (%02x),  param_len: %d,  data: ",
-              tx ? "TX->" : "RX<-",
-              pkt->pkt_type,
-              pkt->evt == BT_HCI_EVT_LE_META_EVENT
+        "%s HCI EVENT   (%x) evt: %s (%02x),  param_len: %d,  data: ",
+        tx ? "TX->" : "RX<-",
+        pkt->pkt_type,
+        pkt->evt == BT_HCI_EVT_LE_META_EVENT
                 ? hci_evt_le_name(pkt->params[0])
                 : hci_evt_name(pkt->evt),
-              pkt->evt, pkt->param_len);
+        pkt->evt, pkt->param_len);
     for (size_t i = 0; i < pkt->param_len; i++) {
         mp_printf(&mp_plat_print, "%02x ", pkt->params[i]);
     }
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/addr.h b/devices/ble_hci/common-hal/_bleio/hci_include/addr.h
index fd74a95e8..44f057e43 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_include/addr.h
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/addr.h
@@ -29,40 +29,36 @@
 
 /** Bluetooth Device Address */
 typedef struct {
-	uint8_t  val[6];
+    uint8_t val[6];
 } bt_addr_t;
 
 /** Bluetooth LE Device Address */
 typedef struct {
-	uint8_t      type;
-	bt_addr_t a;
+    uint8_t type;
+    bt_addr_t a;
 } bt_addr_le_t;
 
 #define BT_ADDR_ANY     ((bt_addr_t[]) { { { 0, 0, 0, 0, 0, 0 } } })
 #define BT_ADDR_NONE    ((bt_addr_t[]) { { \
-			 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } })
+                                             { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } })
 #define BT_ADDR_LE_ANY  ((bt_addr_le_t[]) { { 0, { { 0, 0, 0, 0, 0, 0 } } } })
 #define BT_ADDR_LE_NONE ((bt_addr_le_t[]) { { 0, \
-			 { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } } })
+                                              { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } } })
 
-static inline int bt_addr_cmp(const bt_addr_t *a, const bt_addr_t *b)
-{
-	return memcmp(a, b, sizeof(*a));
+static inline int bt_addr_cmp(const bt_addr_t *a, const bt_addr_t *b) {
+    return memcmp(a, b, sizeof(*a));
 }
 
-static inline int bt_addr_le_cmp(const bt_addr_le_t *a, const bt_addr_le_t *b)
-{
-	return memcmp(a, b, sizeof(*a));
+static inline int bt_addr_le_cmp(const bt_addr_le_t *a, const bt_addr_le_t *b) {
+    return memcmp(a, b, sizeof(*a));
 }
 
-static inline void bt_addr_copy(bt_addr_t *dst, const bt_addr_t *src)
-{
-	memcpy(dst, src, sizeof(*dst));
+static inline void bt_addr_copy(bt_addr_t *dst, const bt_addr_t *src) {
+    memcpy(dst, src, sizeof(*dst));
 }
 
-static inline void bt_addr_le_copy(bt_addr_le_t *dst, const bt_addr_le_t *src)
-{
-	memcpy(dst, src, sizeof(*dst));
+static inline void bt_addr_le_copy(bt_addr_le_t *dst, const bt_addr_le_t *src) {
+    memcpy(dst, src, sizeof(*dst));
 }
 
 #define BT_ADDR_IS_RPA(a)     (((a)->val[5] & 0xc0) == 0x40)
@@ -76,22 +72,20 @@ static inline void bt_addr_le_copy(bt_addr_le_t *dst, const bt_addr_le_t *src)
 int bt_addr_le_create_nrpa(bt_addr_le_t *addr);
 int bt_addr_le_create_static(bt_addr_le_t *addr);
 
-static inline bool bt_addr_le_is_rpa(const bt_addr_le_t *addr)
-{
-	if (addr->type != BT_ADDR_LE_RANDOM) {
-		return false;
-	}
+static inline bool bt_addr_le_is_rpa(const bt_addr_le_t *addr) {
+    if (addr->type != BT_ADDR_LE_RANDOM) {
+        return false;
+    }
 
-	return BT_ADDR_IS_RPA(&addr->a);
+    return BT_ADDR_IS_RPA(&addr->a);
 }
 
-static inline bool bt_addr_le_is_identity(const bt_addr_le_t *addr)
-{
-	if (addr->type == BT_ADDR_LE_PUBLIC) {
-		return true;
-	}
+static inline bool bt_addr_le_is_identity(const bt_addr_le_t *addr) {
+    if (addr->type == BT_ADDR_LE_PUBLIC) {
+        return true;
+    }
 
-	return BT_ADDR_IS_STATIC(&addr->a);
+    return BT_ADDR_IS_STATIC(&addr->a);
 }
 
 /**
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/att.h b/devices/ble_hci/common-hal/_bleio/hci_include/att.h
index 8117a48f4..f292ceb4c 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_include/att.h
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/att.h
@@ -12,30 +12,30 @@
 #define ZEPHYR_INCLUDE_BLUETOOTH_ATT_H_
 
 /* Error codes for Error response PDU */
-#define BT_ATT_ERR_INVALID_HANDLE		0x01
-#define BT_ATT_ERR_READ_NOT_PERMITTED		0x02
-#define BT_ATT_ERR_WRITE_NOT_PERMITTED		0x03
-#define BT_ATT_ERR_INVALID_PDU			0x04
-#define BT_ATT_ERR_AUTHENTICATION		0x05
-#define BT_ATT_ERR_NOT_SUPPORTED		0x06
-#define BT_ATT_ERR_INVALID_OFFSET		0x07
-#define BT_ATT_ERR_AUTHORIZATION		0x08
-#define BT_ATT_ERR_PREPARE_QUEUE_FULL		0x09
-#define BT_ATT_ERR_ATTRIBUTE_NOT_FOUND		0x0a
-#define BT_ATT_ERR_ATTRIBUTE_NOT_LONG		0x0b
-#define BT_ATT_ERR_ENCRYPTION_KEY_SIZE		0x0c
-#define BT_ATT_ERR_INVALID_ATTRIBUTE_LEN	0x0d
-#define BT_ATT_ERR_UNLIKELY			0x0e
-#define BT_ATT_ERR_INSUFFICIENT_ENCRYPTION	0x0f
-#define BT_ATT_ERR_UNSUPPORTED_GROUP_TYPE	0x10
-#define BT_ATT_ERR_INSUFFICIENT_RESOURCES	0x11
-#define BT_ATT_ERR_DB_OUT_OF_SYNC		0x12
-#define BT_ATT_ERR_VALUE_NOT_ALLOWED		0x13
+#define BT_ATT_ERR_INVALID_HANDLE               0x01
+#define BT_ATT_ERR_READ_NOT_PERMITTED           0x02
+#define BT_ATT_ERR_WRITE_NOT_PERMITTED          0x03
+#define BT_ATT_ERR_INVALID_PDU                  0x04
+#define BT_ATT_ERR_AUTHENTICATION               0x05
+#define BT_ATT_ERR_NOT_SUPPORTED                0x06
+#define BT_ATT_ERR_INVALID_OFFSET               0x07
+#define BT_ATT_ERR_AUTHORIZATION                0x08
+#define BT_ATT_ERR_PREPARE_QUEUE_FULL           0x09
+#define BT_ATT_ERR_ATTRIBUTE_NOT_FOUND          0x0a
+#define BT_ATT_ERR_ATTRIBUTE_NOT_LONG           0x0b
+#define BT_ATT_ERR_ENCRYPTION_KEY_SIZE          0x0c
+#define BT_ATT_ERR_INVALID_ATTRIBUTE_LEN        0x0d
+#define BT_ATT_ERR_UNLIKELY                     0x0e
+#define BT_ATT_ERR_INSUFFICIENT_ENCRYPTION      0x0f
+#define BT_ATT_ERR_UNSUPPORTED_GROUP_TYPE       0x10
+#define BT_ATT_ERR_INSUFFICIENT_RESOURCES       0x11
+#define BT_ATT_ERR_DB_OUT_OF_SYNC               0x12
+#define BT_ATT_ERR_VALUE_NOT_ALLOWED            0x13
 
 /* Common Profile Error Codes (from CSS) */
-#define BT_ATT_ERR_WRITE_REQ_REJECTED		0xfc
-#define BT_ATT_ERR_CCC_IMPROPER_CONF		0xfd
-#define BT_ATT_ERR_PROCEDURE_IN_PROGRESS	0xfe
-#define BT_ATT_ERR_OUT_OF_RANGE			0xff
+#define BT_ATT_ERR_WRITE_REQ_REJECTED           0xfc
+#define BT_ATT_ERR_CCC_IMPROPER_CONF            0xfd
+#define BT_ATT_ERR_PROCEDURE_IN_PROGRESS        0xfe
+#define BT_ATT_ERR_OUT_OF_RANGE                 0xff
 
 #endif /* ZEPHYR_INCLUDE_BLUETOOTH_ATT_H_ */
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/att_internal.h b/devices/ble_hci/common-hal/_bleio/hci_include/att_internal.h
index b8efccaf4..820246dec 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_include/att_internal.h
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/att_internal.h
@@ -13,260 +13,260 @@
 // for __packed
 #include <sys/cdefs.h>
 
-#define BT_EATT_PSM		0x27
-#define BT_ATT_DEFAULT_LE_MTU	23
-#define BT_ATT_TIMEOUT		K_SECONDS(30)
+#define BT_EATT_PSM             0x27
+#define BT_ATT_DEFAULT_LE_MTU   23
+#define BT_ATT_TIMEOUT          K_SECONDS(30)
 
-//FIX #if BT_L2CAP_RX_MTU < CONFIG_BT_L2CAP_TX_MTU
+// FIX #if BT_L2CAP_RX_MTU < CONFIG_BT_L2CAP_TX_MTU
 // #define BT_ATT_MTU BT_L2CAP_RX_MTU
 // #else
 // #define BT_ATT_MTU CONFIG_BT_L2CAP_TX_MTU
 // #endif
 
 struct bt_att_hdr {
-	uint8_t  code;
+    uint8_t code;
 } __packed;
 
-#define BT_ATT_OP_ERROR_RSP			0x01
+#define BT_ATT_OP_ERROR_RSP                     0x01
 struct bt_att_error_rsp {
-	uint8_t  request;
-	uint16_t handle;
-	uint8_t  error;
+    uint8_t request;
+    uint16_t handle;
+    uint8_t error;
 } __packed;
 
-#define BT_ATT_OP_MTU_REQ			0x02
+#define BT_ATT_OP_MTU_REQ                       0x02
 struct bt_att_exchange_mtu_req {
-	uint16_t mtu;
+    uint16_t mtu;
 } __packed;
 
-#define BT_ATT_OP_MTU_RSP			0x03
+#define BT_ATT_OP_MTU_RSP                       0x03
 struct bt_att_exchange_mtu_rsp {
-	uint16_t mtu;
+    uint16_t mtu;
 } __packed;
 
 /* Find Information Request */
-#define BT_ATT_OP_FIND_INFO_REQ			0x04
+#define BT_ATT_OP_FIND_INFO_REQ                 0x04
 struct bt_att_find_info_req {
-	uint16_t start_handle;
-	uint16_t end_handle;
+    uint16_t start_handle;
+    uint16_t end_handle;
 } __packed;
 
 /* Format field values for BT_ATT_OP_FIND_INFO_RSP */
-#define BT_ATT_INFO_16				0x01
-#define BT_ATT_INFO_128				0x02
+#define BT_ATT_INFO_16                          0x01
+#define BT_ATT_INFO_128                         0x02
 
 struct bt_att_info_16 {
-	uint16_t handle;
-	uint16_t uuid;
+    uint16_t handle;
+    uint16_t uuid;
 } __packed;
 
 struct bt_att_info_128 {
-	uint16_t handle;
-	uint8_t  uuid[16];
+    uint16_t handle;
+    uint8_t uuid[16];
 } __packed;
 
 /* Find Information Response */
-#define BT_ATT_OP_FIND_INFO_RSP			0x05
+#define BT_ATT_OP_FIND_INFO_RSP                 0x05
 struct bt_att_find_info_rsp {
-	uint8_t  format;
-	uint8_t  info[];
+    uint8_t format;
+    uint8_t info[];
 } __packed;
 
 /* Find By Type Value Request */
-#define BT_ATT_OP_FIND_TYPE_REQ			0x06
+#define BT_ATT_OP_FIND_TYPE_REQ                 0x06
 struct bt_att_find_type_req {
-	uint16_t start_handle;
-	uint16_t end_handle;
-	uint16_t type;
-	uint8_t  value[];
+    uint16_t start_handle;
+    uint16_t end_handle;
+    uint16_t type;
+    uint8_t value[];
 } __packed;
 
 struct bt_att_handle_group {
-	uint16_t start_handle;
-	uint16_t end_handle;
+    uint16_t start_handle;
+    uint16_t end_handle;
 } __packed;
 
 /* Find By Type Value Response */
-#define BT_ATT_OP_FIND_TYPE_RSP			0x07
+#define BT_ATT_OP_FIND_TYPE_RSP                 0x07
 struct bt_att_find_type_rsp {
-        uint8_t _dummy[0];
-	struct bt_att_handle_group list[];
+    uint8_t _dummy[0];
+    struct bt_att_handle_group list[];
 } __packed;
 
 /* Read By Type Request */
-#define BT_ATT_OP_READ_TYPE_REQ			0x08
+#define BT_ATT_OP_READ_TYPE_REQ                 0x08
 struct bt_att_read_type_req {
-	uint16_t start_handle;
-	uint16_t end_handle;
-	uint8_t  uuid[];
+    uint16_t start_handle;
+    uint16_t end_handle;
+    uint8_t uuid[];
 } __packed;
 
 struct bt_att_data {
-	uint16_t handle;
-	uint8_t  value[];
+    uint16_t handle;
+    uint8_t value[];
 } __packed;
 
 /* Read By Type Response */
-#define BT_ATT_OP_READ_TYPE_RSP			0x09
+#define BT_ATT_OP_READ_TYPE_RSP                 0x09
 struct bt_att_read_type_rsp {
-	uint8_t  len;
-	struct bt_att_data data[];
+    uint8_t len;
+    struct bt_att_data data[];
 } __packed;
 
 /* Read Request */
-#define BT_ATT_OP_READ_REQ			0x0a
+#define BT_ATT_OP_READ_REQ                      0x0a
 struct bt_att_read_req {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 /* Read Response */
-#define BT_ATT_OP_READ_RSP			0x0b
+#define BT_ATT_OP_READ_RSP                      0x0b
 struct bt_att_read_rsp {
-        uint8_t _dummy[0];
-	uint8_t  value[];
+    uint8_t _dummy[0];
+    uint8_t value[];
 } __packed;
 
 /* Read Blob Request */
-#define BT_ATT_OP_READ_BLOB_REQ			0x0c
+#define BT_ATT_OP_READ_BLOB_REQ                 0x0c
 struct bt_att_read_blob_req {
-	uint16_t handle;
-	uint16_t offset;
+    uint16_t handle;
+    uint16_t offset;
 } __packed;
 
 /* Read Blob Response */
-#define BT_ATT_OP_READ_BLOB_RSP			0x0d
+#define BT_ATT_OP_READ_BLOB_RSP                 0x0d
 struct bt_att_read_blob_rsp {
-        uint8_t _dummy[0];
-	uint8_t  value[];
+    uint8_t _dummy[0];
+    uint8_t value[];
 } __packed;
 
 /* Read Multiple Request */
-#define BT_ATT_READ_MULT_MIN_LEN_REQ		0x04
+#define BT_ATT_READ_MULT_MIN_LEN_REQ            0x04
 
-#define BT_ATT_OP_READ_MULT_REQ			0x0e
+#define BT_ATT_OP_READ_MULT_REQ                 0x0e
 struct bt_att_read_mult_req {
-        uint8_t _dummy[0];
-	uint16_t handles[];
+    uint8_t _dummy[0];
+    uint16_t handles[];
 } __packed;
 
 /* Read Multiple Respose */
-#define BT_ATT_OP_READ_MULT_RSP			0x0f
+#define BT_ATT_OP_READ_MULT_RSP                 0x0f
 struct bt_att_read_mult_rsp {
-        uint8_t _dummy[0];
-	uint8_t  value[];
+    uint8_t _dummy[0];
+    uint8_t value[];
 } __packed;
 
 /* Read by Group Type Request */
-#define BT_ATT_OP_READ_GROUP_REQ		0x10
+#define BT_ATT_OP_READ_GROUP_REQ                0x10
 struct bt_att_read_group_req {
-	uint16_t start_handle;
-	uint16_t end_handle;
-	uint8_t  uuid[];
+    uint16_t start_handle;
+    uint16_t end_handle;
+    uint8_t uuid[];
 } __packed;
 
 struct bt_att_group_data {
-	uint16_t start_handle;
-	uint16_t end_handle;
-	uint8_t  value[];
+    uint16_t start_handle;
+    uint16_t end_handle;
+    uint8_t value[];
 } __packed;
 
 /* Read by Group Type Response */
-#define BT_ATT_OP_READ_GROUP_RSP		0x11
+#define BT_ATT_OP_READ_GROUP_RSP                0x11
 struct bt_att_read_group_rsp {
-	uint8_t  len;
-	struct bt_att_group_data data[];
+    uint8_t len;
+    struct bt_att_group_data data[];
 } __packed;
 
 /* Write Request */
-#define BT_ATT_OP_WRITE_REQ			0x12
+#define BT_ATT_OP_WRITE_REQ                     0x12
 struct bt_att_write_req {
-	uint16_t handle;
-	uint8_t  value[];
+    uint16_t handle;
+    uint8_t value[];
 } __packed;
 
 /* Write Response */
-#define BT_ATT_OP_WRITE_RSP			0x13
+#define BT_ATT_OP_WRITE_RSP                     0x13
 
 /* Prepare Write Request */
-#define BT_ATT_OP_PREPARE_WRITE_REQ		0x16
+#define BT_ATT_OP_PREPARE_WRITE_REQ             0x16
 struct bt_att_prepare_write_req {
-	uint16_t handle;
-	uint16_t offset;
-	uint8_t  value[];
+    uint16_t handle;
+    uint16_t offset;
+    uint8_t value[];
 } __packed;
 
 /* Prepare Write Respond */
-#define BT_ATT_OP_PREPARE_WRITE_RSP		0x17
+#define BT_ATT_OP_PREPARE_WRITE_RSP             0x17
 struct bt_att_prepare_write_rsp {
-	uint16_t handle;
-	uint16_t offset;
-	uint8_t  value[];
+    uint16_t handle;
+    uint16_t offset;
+    uint8_t value[];
 } __packed;
 
 /* Execute Write Request */
-#define BT_ATT_FLAG_CANCEL			0x00
-#define BT_ATT_FLAG_EXEC			0x01
+#define BT_ATT_FLAG_CANCEL                      0x00
+#define BT_ATT_FLAG_EXEC                        0x01
 
-#define BT_ATT_OP_EXEC_WRITE_REQ		0x18
+#define BT_ATT_OP_EXEC_WRITE_REQ                0x18
 struct bt_att_exec_write_req {
-	uint8_t  flags;
+    uint8_t flags;
 } __packed;
 
 /* Execute Write Response */
-#define BT_ATT_OP_EXEC_WRITE_RSP		0x19
+#define BT_ATT_OP_EXEC_WRITE_RSP                0x19
 
 /* Handle Value Notification */
-#define BT_ATT_OP_NOTIFY			0x1b
+#define BT_ATT_OP_NOTIFY                        0x1b
 struct bt_att_notify {
-	uint16_t handle;
-	uint8_t  value[];
+    uint16_t handle;
+    uint8_t value[];
 } __packed;
 
 /* Handle Value Indication */
-#define BT_ATT_OP_INDICATE			0x1d
+#define BT_ATT_OP_INDICATE                      0x1d
 struct bt_att_indicate {
-	uint16_t handle;
-	uint8_t  value[];
+    uint16_t handle;
+    uint8_t value[];
 } __packed;
 
 /* Handle Value Confirm */
-#define BT_ATT_OP_CONFIRM			0x1e
+#define BT_ATT_OP_CONFIRM                       0x1e
 
 struct bt_att_signature {
-	uint8_t  value[12];
+    uint8_t value[12];
 } __packed;
 
-#define BT_ATT_OP_READ_MULT_VL_REQ		0x20
+#define BT_ATT_OP_READ_MULT_VL_REQ              0x20
 struct bt_att_read_mult_vl_req {
-        uint8_t _dummy[0];
-	uint16_t handles[];
+    uint8_t _dummy[0];
+    uint16_t handles[];
 } __packed;
 
 /* Read Multiple Respose */
-#define BT_ATT_OP_READ_MULT_VL_RSP		0x21
+#define BT_ATT_OP_READ_MULT_VL_RSP              0x21
 struct bt_att_read_mult_vl_rsp {
-	uint16_t len;
-	uint8_t  value[];
+    uint16_t len;
+    uint8_t value[];
 } __packed;
 
 /* Handle Multiple Value Notification */
-#define BT_ATT_OP_NOTIFY_MULT			0x23
+#define BT_ATT_OP_NOTIFY_MULT                   0x23
 struct bt_att_notify_mult {
-	uint16_t handle;
-	uint16_t len;
-	uint8_t  value[];
+    uint16_t handle;
+    uint16_t len;
+    uint8_t value[];
 } __packed;
 
 /* Write Command */
-#define BT_ATT_OP_WRITE_CMD			0x52
+#define BT_ATT_OP_WRITE_CMD                     0x52
 struct bt_att_write_cmd {
-	uint16_t handle;
-	uint8_t  value[];
+    uint16_t handle;
+    uint8_t value[];
 } __packed;
 
 /* Signed Write Command */
-#define BT_ATT_OP_SIGNED_WRITE_CMD		0xd2
+#define BT_ATT_OP_SIGNED_WRITE_CMD              0xd2
 struct bt_att_signed_write_cmd {
-	uint16_t handle;
-	uint8_t  value[];
+    uint16_t handle;
+    uint8_t value[];
 } __packed;
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/hci.h b/devices/ble_hci/common-hal/_bleio/hci_include/hci.h
index 797278946..b5f950618 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_include/hci.h
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/hci.h
@@ -34,8 +34,8 @@
 #define BT_ENC_KEY_SIZE_MAX                     0x10
 
 struct bt_hci_evt_hdr {
-	uint8_t  evt;
-	uint8_t  len;
+    uint8_t evt;
+    uint8_t len;
 } __packed;
 #define BT_HCI_EVT_HDR_SIZE             2
 
@@ -54,14 +54,14 @@ struct bt_hci_evt_hdr {
 #define bt_acl_handle_pack(h, f)        ((h) | ((f) << 12))
 
 struct bt_hci_acl_hdr {
-	uint16_t handle;
-	uint16_t len;
+    uint16_t handle;
+    uint16_t len;
 } __packed;
 #define BT_HCI_ACL_HDR_SIZE             4
 
 struct bt_hci_cmd_hdr {
-	uint16_t opcode;
-	uint8_t  param_len;
+    uint16_t opcode;
+    uint8_t param_len;
 } __packed;
 #define BT_HCI_CMD_HDR_SIZE             3
 
@@ -125,24 +125,24 @@ struct bt_hci_cmd_hdr {
 #define BT_LE_FEAT_BIT_PATH_LOSS_MONITOR        35
 
 #define BT_LE_FEAT_TEST(feat, n)                (feat[(n) >> 3] & \
-						 BIT((n) & 7))
+    BIT((n) & 7))
 
 #define BT_FEAT_LE_ENCR(feat)                   BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_ENC)
+    BT_LE_FEAT_BIT_ENC)
 #define BT_FEAT_LE_CONN_PARAM_REQ_PROC(feat)    BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_CONN_PARAM_REQ)
+    BT_LE_FEAT_BIT_CONN_PARAM_REQ)
 #define BT_FEAT_LE_SLAVE_FEATURE_XCHG(feat)     BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_SLAVE_FEAT_REQ)
+    BT_LE_FEAT_BIT_SLAVE_FEAT_REQ)
 #define BT_FEAT_LE_DLE(feat)                    BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_DLE)
+    BT_LE_FEAT_BIT_DLE)
 #define BT_FEAT_LE_PHY_2M(feat)                 BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_PHY_2M)
+    BT_LE_FEAT_BIT_PHY_2M)
 #define BT_FEAT_LE_PHY_CODED(feat)              BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_PHY_CODED)
+    BT_LE_FEAT_BIT_PHY_CODED)
 #define BT_FEAT_LE_PRIVACY(feat)                BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_PRIVACY)
+    BT_LE_FEAT_BIT_PRIVACY)
 #define BT_FEAT_LE_EXT_ADV(feat)                BT_LE_FEAT_TEST(feat, \
-						BT_LE_FEAT_BIT_EXT_ADV)
+    BT_LE_FEAT_BIT_EXT_ADV)
 
 /* LE States */
 #define BT_LE_STATES_SLAVE_CONN_ADV(states)     (states & 0x0000004000000000)
@@ -186,15 +186,15 @@ struct bt_hci_cmd_hdr {
 
 
 #define ESCO_PKT_MASK                           (HCI_PKT_TYPE_ESCO_HV1 | \
-						 HCI_PKT_TYPE_ESCO_HV2 | \
-						 HCI_PKT_TYPE_ESCO_HV3)
+    HCI_PKT_TYPE_ESCO_HV2 | \
+    HCI_PKT_TYPE_ESCO_HV3)
 #define SCO_PKT_MASK                            (HCI_PKT_TYPE_HV1 | \
-						 HCI_PKT_TYPE_HV2 | \
-						 HCI_PKT_TYPE_HV3)
+    HCI_PKT_TYPE_HV2 | \
+    HCI_PKT_TYPE_HV3)
 #define EDR_ESCO_PKT_MASK                       (HCI_PKT_TYPE_ESCO_2EV3 | \
-						 HCI_PKT_TYPE_ESCO_3EV3 | \
-						 HCI_PKT_TYPE_ESCO_2EV5 | \
-						 HCI_PKT_TYPE_ESCO_3EV5)
+    HCI_PKT_TYPE_ESCO_3EV3 | \
+    HCI_PKT_TYPE_ESCO_2EV5 | \
+    HCI_PKT_TYPE_ESCO_3EV5)
 
 /* HCI BR/EDR link types */
 #define BT_HCI_SCO                              0x00
@@ -213,7 +213,7 @@ struct bt_hci_cmd_hdr {
 #define BT_OP(ogf, ocf)                         ((ocf) | ((ogf) << 10))
 
 /* Invalid opcode */
-#define BT_OP_NOP				0x0000
+#define BT_OP_NOP                               0x0000
 
 /* Obtain OGF from OpCode */
 #define BT_OGF(opcode)                          (((opcode) >> 10) & BIT_MASK(6))
@@ -222,192 +222,192 @@ struct bt_hci_cmd_hdr {
 
 #define BT_HCI_OP_INQUIRY                       BT_OP(BT_OGF_LINK_CTRL, 0x0001)
 struct bt_hci_op_inquiry {
-	uint8_t lap[3];
-	uint8_t length;
-	uint8_t num_rsp;
+    uint8_t lap[3];
+    uint8_t length;
+    uint8_t num_rsp;
 } __packed;
 
 #define BT_HCI_OP_INQUIRY_CANCEL                BT_OP(BT_OGF_LINK_CTRL, 0x0002)
 
 #define BT_HCI_OP_CONNECT                       BT_OP(BT_OGF_LINK_CTRL, 0x0005)
 struct bt_hci_cp_connect {
-	bt_addr_t bdaddr;
-	uint16_t  packet_type;
-	uint8_t   pscan_rep_mode;
-	uint8_t   reserved;
-	uint16_t  clock_offset;
-	uint8_t   allow_role_switch;
+    bt_addr_t bdaddr;
+    uint16_t packet_type;
+    uint8_t pscan_rep_mode;
+    uint8_t reserved;
+    uint16_t clock_offset;
+    uint8_t allow_role_switch;
 } __packed;
 
 #define BT_HCI_OP_DISCONNECT                    BT_OP(BT_OGF_LINK_CTRL, 0x0006)
 struct bt_hci_cp_disconnect {
-	uint16_t handle;
-	uint8_t  reason;
+    uint16_t handle;
+    uint8_t reason;
 } __packed;
 
 #define BT_HCI_OP_CONNECT_CANCEL                BT_OP(BT_OGF_LINK_CTRL, 0x0008)
 struct bt_hci_cp_connect_cancel {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 struct bt_hci_rp_connect_cancel {
-	uint8_t   status;
-	bt_addr_t bdaddr;
+    uint8_t status;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_ACCEPT_CONN_REQ               BT_OP(BT_OGF_LINK_CTRL, 0x0009)
 struct bt_hci_cp_accept_conn_req {
-	bt_addr_t bdaddr;
-	uint8_t   role;
+    bt_addr_t bdaddr;
+    uint8_t role;
 } __packed;
 
 #define BT_HCI_OP_SETUP_SYNC_CONN               BT_OP(BT_OGF_LINK_CTRL, 0x0028)
 struct bt_hci_cp_setup_sync_conn {
-	uint16_t  handle;
-	uint32_t  tx_bandwidth;
-	uint32_t  rx_bandwidth;
-	uint16_t  max_latency;
-	uint16_t  content_format;
-	uint8_t   retrans_effort;
-	uint16_t  pkt_type;
+    uint16_t handle;
+    uint32_t tx_bandwidth;
+    uint32_t rx_bandwidth;
+    uint16_t max_latency;
+    uint16_t content_format;
+    uint8_t retrans_effort;
+    uint16_t pkt_type;
 } __packed;
 
 #define BT_HCI_OP_ACCEPT_SYNC_CONN_REQ          BT_OP(BT_OGF_LINK_CTRL, 0x0029)
 struct bt_hci_cp_accept_sync_conn_req {
-	bt_addr_t bdaddr;
-	uint32_t  tx_bandwidth;
-	uint32_t  rx_bandwidth;
-	uint16_t  max_latency;
-	uint16_t  content_format;
-	uint8_t   retrans_effort;
-	uint16_t  pkt_type;
+    bt_addr_t bdaddr;
+    uint32_t tx_bandwidth;
+    uint32_t rx_bandwidth;
+    uint16_t max_latency;
+    uint16_t content_format;
+    uint8_t retrans_effort;
+    uint16_t pkt_type;
 } __packed;
 
 #define BT_HCI_OP_REJECT_CONN_REQ               BT_OP(BT_OGF_LINK_CTRL, 0x000a)
 struct bt_hci_cp_reject_conn_req {
-	bt_addr_t bdaddr;
-	uint8_t   reason;
+    bt_addr_t bdaddr;
+    uint8_t reason;
 } __packed;
 
 #define BT_HCI_OP_LINK_KEY_REPLY                BT_OP(BT_OGF_LINK_CTRL, 0x000b)
 struct bt_hci_cp_link_key_reply {
-	bt_addr_t bdaddr;
-	uint8_t   link_key[16];
+    bt_addr_t bdaddr;
+    uint8_t link_key[16];
 } __packed;
 
 #define BT_HCI_OP_LINK_KEY_NEG_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x000c)
 struct bt_hci_cp_link_key_neg_reply {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_PIN_CODE_REPLY                BT_OP(BT_OGF_LINK_CTRL, 0x000d)
 struct bt_hci_cp_pin_code_reply {
-	bt_addr_t bdaddr;
-	uint8_t   pin_len;
-	uint8_t   pin_code[16];
+    bt_addr_t bdaddr;
+    uint8_t pin_len;
+    uint8_t pin_code[16];
 } __packed;
 struct bt_hci_rp_pin_code_reply {
-	uint8_t      status;
-	bt_addr_t bdaddr;
+    uint8_t status;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_PIN_CODE_NEG_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x000e)
 struct bt_hci_cp_pin_code_neg_reply {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 struct bt_hci_rp_pin_code_neg_reply {
-	uint8_t   status;
-	bt_addr_t bdaddr;
+    uint8_t status;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_AUTH_REQUESTED                BT_OP(BT_OGF_LINK_CTRL, 0x0011)
 struct bt_hci_cp_auth_requested {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_SET_CONN_ENCRYPT              BT_OP(BT_OGF_LINK_CTRL, 0x0013)
 struct bt_hci_cp_set_conn_encrypt {
-	uint16_t handle;
-	uint8_t  encrypt;
+    uint16_t handle;
+    uint8_t encrypt;
 } __packed;
 
 #define BT_HCI_OP_REMOTE_NAME_REQUEST           BT_OP(BT_OGF_LINK_CTRL, 0x0019)
 struct bt_hci_cp_remote_name_request {
-	bt_addr_t bdaddr;
-	uint8_t   pscan_rep_mode;
-	uint8_t   reserved;
-	uint16_t  clock_offset;
+    bt_addr_t bdaddr;
+    uint8_t pscan_rep_mode;
+    uint8_t reserved;
+    uint16_t clock_offset;
 } __packed;
 
 #define BT_HCI_OP_REMOTE_NAME_CANCEL            BT_OP(BT_OGF_LINK_CTRL, 0x001a)
 struct bt_hci_cp_remote_name_cancel {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 struct bt_hci_rp_remote_name_cancel {
-	uint8_t   status;
-	bt_addr_t bdaddr;
+    uint8_t status;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_READ_REMOTE_FEATURES          BT_OP(BT_OGF_LINK_CTRL, 0x001b)
 struct bt_hci_cp_read_remote_features {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_READ_REMOTE_EXT_FEATURES      BT_OP(BT_OGF_LINK_CTRL, 0x001c)
 struct bt_hci_cp_read_remote_ext_features {
-	uint16_t handle;
-	uint8_t  page;
+    uint16_t handle;
+    uint8_t page;
 } __packed;
 
 #define BT_HCI_OP_READ_REMOTE_VERSION_INFO      BT_OP(BT_OGF_LINK_CTRL, 0x001d)
 struct bt_hci_cp_read_remote_version_info {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_IO_CAPABILITY_REPLY           BT_OP(BT_OGF_LINK_CTRL, 0x002b)
 struct bt_hci_cp_io_capability_reply {
-	bt_addr_t bdaddr;
-	uint8_t   capability;
-	uint8_t   oob_data;
-	uint8_t   authentication;
+    bt_addr_t bdaddr;
+    uint8_t capability;
+    uint8_t oob_data;
+    uint8_t authentication;
 } __packed;
 
 #define BT_HCI_OP_USER_CONFIRM_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x002c)
 #define BT_HCI_OP_USER_CONFIRM_NEG_REPLY        BT_OP(BT_OGF_LINK_CTRL, 0x002d)
 struct bt_hci_cp_user_confirm_reply {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 struct bt_hci_rp_user_confirm_reply {
-	uint8_t   status;
-	bt_addr_t bdaddr;
+    uint8_t status;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_USER_PASSKEY_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x002e)
 struct bt_hci_cp_user_passkey_reply {
-	bt_addr_t bdaddr;
-	uint32_t  passkey;
+    bt_addr_t bdaddr;
+    uint32_t passkey;
 } __packed;
 
 #define BT_HCI_OP_USER_PASSKEY_NEG_REPLY        BT_OP(BT_OGF_LINK_CTRL, 0x002f)
 struct bt_hci_cp_user_passkey_neg_reply {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_IO_CAPABILITY_NEG_REPLY       BT_OP(BT_OGF_LINK_CTRL, 0x0034)
 struct bt_hci_cp_io_capability_neg_reply {
-	bt_addr_t bdaddr;
-	uint8_t   reason;
+    bt_addr_t bdaddr;
+    uint8_t reason;
 } __packed;
 
 #define BT_HCI_OP_SET_EVENT_MASK                BT_OP(BT_OGF_BASEBAND, 0x0001)
 struct bt_hci_cp_set_event_mask {
-	uint8_t  events[8];
+    uint8_t events[8];
 } __packed;
 
 #define BT_HCI_OP_RESET                         BT_OP(BT_OGF_BASEBAND, 0x0003)
 
 #define BT_HCI_OP_WRITE_LOCAL_NAME              BT_OP(BT_OGF_BASEBAND, 0x0013)
 struct bt_hci_write_local_name {
-	uint8_t local_name[248];
+    uint8_t local_name[248];
 } __packed;
 
 #define BT_HCI_OP_WRITE_PAGE_TIMEOUT            BT_OP(BT_OGF_BASEBAND, 0x0018)
@@ -421,88 +421,88 @@ struct bt_hci_write_local_name {
 #define BT_TX_POWER_LEVEL_MAX                   0x01
 #define BT_HCI_OP_READ_TX_POWER_LEVEL           BT_OP(BT_OGF_BASEBAND, 0x002d)
 struct bt_hci_cp_read_tx_power_level {
-	uint16_t handle;
-	uint8_t  type;
+    uint16_t handle;
+    uint8_t type;
 } __packed;
 
 struct bt_hci_rp_read_tx_power_level {
-	uint8_t  status;
-	uint16_t handle;
-	int8_t   tx_power_level;
+    uint8_t status;
+    uint16_t handle;
+    int8_t tx_power_level;
 } __packed;
 
 #define BT_HCI_CTL_TO_HOST_FLOW_DISABLE         0x00
 #define BT_HCI_CTL_TO_HOST_FLOW_ENABLE          0x01
 #define BT_HCI_OP_SET_CTL_TO_HOST_FLOW          BT_OP(BT_OGF_BASEBAND, 0x0031)
 struct bt_hci_cp_set_ctl_to_host_flow {
-	uint8_t  flow_enable;
+    uint8_t flow_enable;
 } __packed;
 
 #define BT_HCI_OP_HOST_BUFFER_SIZE              BT_OP(BT_OGF_BASEBAND, 0x0033)
 struct bt_hci_cp_host_buffer_size {
-	uint16_t acl_mtu;
-	uint8_t  sco_mtu;
-	uint16_t acl_pkts;
-	uint16_t sco_pkts;
+    uint16_t acl_mtu;
+    uint8_t sco_mtu;
+    uint16_t acl_pkts;
+    uint16_t sco_pkts;
 } __packed;
 
 struct bt_hci_handle_count {
-	uint16_t handle;
-	uint16_t count;
+    uint16_t handle;
+    uint16_t count;
 } __packed;
 
 #define BT_HCI_OP_HOST_NUM_COMPLETED_PACKETS    BT_OP(BT_OGF_BASEBAND, 0x0035)
 struct bt_hci_cp_host_num_completed_packets {
-	uint8_t  num_handles;
-	struct bt_hci_handle_count h[];
+    uint8_t num_handles;
+    struct bt_hci_handle_count h[];
 } __packed;
 
 #define BT_HCI_OP_WRITE_INQUIRY_MODE            BT_OP(BT_OGF_BASEBAND, 0x0045)
 struct bt_hci_cp_write_inquiry_mode {
-	uint8_t  mode;
+    uint8_t mode;
 } __packed;
 
 #define BT_HCI_OP_WRITE_SSP_MODE                BT_OP(BT_OGF_BASEBAND, 0x0056)
 struct bt_hci_cp_write_ssp_mode {
-	uint8_t mode;
+    uint8_t mode;
 } __packed;
 
 #define BT_HCI_OP_SET_EVENT_MASK_PAGE_2         BT_OP(BT_OGF_BASEBAND, 0x0063)
 struct bt_hci_cp_set_event_mask_page_2 {
-	uint8_t  events_page_2[8];
+    uint8_t events_page_2[8];
 } __packed;
 
 #define BT_HCI_OP_LE_WRITE_LE_HOST_SUPP         BT_OP(BT_OGF_BASEBAND, 0x006d)
 struct bt_hci_cp_write_le_host_supp {
-	uint8_t  le;
-	uint8_t  simul;
+    uint8_t le;
+    uint8_t simul;
 } __packed;
 
 #define BT_HCI_OP_WRITE_SC_HOST_SUPP            BT_OP(BT_OGF_BASEBAND, 0x007a)
 struct bt_hci_cp_write_sc_host_supp {
-	uint8_t  sc_support;
+    uint8_t sc_support;
 } __packed;
 
 #define BT_HCI_OP_READ_AUTH_PAYLOAD_TIMEOUT     BT_OP(BT_OGF_BASEBAND, 0x007b)
 struct bt_hci_cp_read_auth_payload_timeout {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 struct bt_hci_rp_read_auth_payload_timeout {
-	uint8_t  status;
-	uint16_t handle;
-	uint16_t auth_payload_timeout;
+    uint8_t status;
+    uint16_t handle;
+    uint16_t auth_payload_timeout;
 } __packed;
 
 #define BT_HCI_OP_WRITE_AUTH_PAYLOAD_TIMEOUT    BT_OP(BT_OGF_BASEBAND, 0x007c)
 struct bt_hci_cp_write_auth_payload_timeout {
-	uint16_t handle;
-	uint16_t auth_payload_timeout;
+    uint16_t handle;
+    uint16_t auth_payload_timeout;
 } __packed;
 
 struct bt_hci_rp_write_auth_payload_timeout {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 /* HCI version from Assigned Numbers */
@@ -521,60 +521,60 @@ struct bt_hci_rp_write_auth_payload_timeout {
 
 #define BT_HCI_OP_READ_LOCAL_VERSION_INFO       BT_OP(BT_OGF_INFO, 0x0001)
 struct bt_hci_rp_read_local_version_info {
-	uint8_t  status;
-	uint8_t  hci_version;
-	uint16_t hci_revision;
-	uint8_t  lmp_version;
-	uint16_t manufacturer;
-	uint16_t lmp_subversion;
+    uint8_t status;
+    uint8_t hci_version;
+    uint16_t hci_revision;
+    uint8_t lmp_version;
+    uint16_t manufacturer;
+    uint16_t lmp_subversion;
 } __packed;
 
 #define BT_HCI_OP_READ_SUPPORTED_COMMANDS       BT_OP(BT_OGF_INFO, 0x0002)
 struct bt_hci_rp_read_supported_commands {
-	uint8_t  status;
-	uint8_t  commands[64];
+    uint8_t status;
+    uint8_t commands[64];
 } __packed;
 
 #define BT_HCI_OP_READ_LOCAL_EXT_FEATURES       BT_OP(BT_OGF_INFO, 0x0004)
 struct bt_hci_cp_read_local_ext_features {
-	uint8_t page;
+    uint8_t page;
 };
 struct bt_hci_rp_read_local_ext_features {
-	uint8_t  status;
-	uint8_t  page;
-	uint8_t  max_page;
-	uint8_t  ext_features[8];
+    uint8_t status;
+    uint8_t page;
+    uint8_t max_page;
+    uint8_t ext_features[8];
 } __packed;
 
 #define BT_HCI_OP_READ_LOCAL_FEATURES           BT_OP(BT_OGF_INFO, 0x0003)
 struct bt_hci_rp_read_local_features {
-	uint8_t  status;
-	uint8_t  features[8];
+    uint8_t status;
+    uint8_t features[8];
 } __packed;
 
 #define BT_HCI_OP_READ_BUFFER_SIZE              BT_OP(BT_OGF_INFO, 0x0005)
 struct bt_hci_rp_read_buffer_size {
-	uint8_t  status;
-	uint16_t acl_max_len;
-	uint8_t  sco_max_len;
-	uint16_t acl_max_num;
-	uint16_t sco_max_num;
+    uint8_t status;
+    uint16_t acl_max_len;
+    uint8_t sco_max_len;
+    uint16_t acl_max_num;
+    uint16_t sco_max_num;
 } __packed;
 
 #define BT_HCI_OP_READ_BD_ADDR                  BT_OP(BT_OGF_INFO, 0x0009)
 struct bt_hci_rp_read_bd_addr {
-	uint8_t   status;
-	bt_addr_t bdaddr;
+    uint8_t status;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_OP_READ_RSSI                     BT_OP(BT_OGF_STATUS, 0x0005)
 struct bt_hci_cp_read_rssi {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 struct bt_hci_rp_read_rssi {
-	uint8_t  status;
-	uint16_t handle;
-	int8_t   rssi;
+    uint8_t status;
+    uint16_t handle;
+    int8_t rssi;
 } __packed;
 
 #define BT_HCI_ENCRYPTION_KEY_SIZE_MIN          7
@@ -582,37 +582,37 @@ struct bt_hci_rp_read_rssi {
 
 #define BT_HCI_OP_READ_ENCRYPTION_KEY_SIZE      BT_OP(BT_OGF_STATUS, 0x0008)
 struct bt_hci_cp_read_encryption_key_size {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 struct bt_hci_rp_read_encryption_key_size {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  key_size;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t key_size;
 } __packed;
 
 /* BLE */
 
 #define BT_HCI_OP_LE_SET_EVENT_MASK             BT_OP(BT_OGF_LE, 0x0001)
 struct bt_hci_cp_le_set_event_mask {
-	uint8_t events[8];
+    uint8_t events[8];
 } __packed;
 
 #define BT_HCI_OP_LE_READ_BUFFER_SIZE           BT_OP(BT_OGF_LE, 0x0002)
 struct bt_hci_rp_le_read_buffer_size {
-	uint8_t  status;
-	uint16_t le_max_len;
-	uint8_t  le_max_num;
+    uint8_t status;
+    uint16_t le_max_len;
+    uint8_t le_max_num;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_LOCAL_FEATURES        BT_OP(BT_OGF_LE, 0x0003)
 struct bt_hci_rp_le_read_local_features {
-	uint8_t  status;
-	uint8_t  features[8];
+    uint8_t status;
+    uint8_t features[8];
 } __packed;
 
 #define BT_HCI_OP_LE_SET_RANDOM_ADDRESS         BT_OP(BT_OGF_LE, 0x0005)
 struct bt_hci_cp_le_set_random_address {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 /* LE Advertising Types (LE Advertising Parameters Set)*/
@@ -638,31 +638,31 @@ struct bt_hci_cp_le_set_random_address {
 
 #define BT_HCI_OP_LE_SET_ADV_PARAM              BT_OP(BT_OGF_LE, 0x0006)
 struct bt_hci_cp_le_set_adv_param {
-	uint16_t     min_interval;
-	uint16_t     max_interval;
-	uint8_t      type;
-	uint8_t      own_addr_type;
-	bt_addr_le_t direct_addr;
-	uint8_t      channel_map;
-	uint8_t      filter_policy;
+    uint16_t min_interval;
+    uint16_t max_interval;
+    uint8_t type;
+    uint8_t own_addr_type;
+    bt_addr_le_t direct_addr;
+    uint8_t channel_map;
+    uint8_t filter_policy;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_ADV_CHAN_TX_POWER     BT_OP(BT_OGF_LE, 0x0007)
 struct bt_hci_rp_le_read_chan_tx_power {
-	uint8_t status;
-	int8_t  tx_power_level;
+    uint8_t status;
+    int8_t tx_power_level;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_ADV_DATA               BT_OP(BT_OGF_LE, 0x0008)
 struct bt_hci_cp_le_set_adv_data {
-	uint8_t  len;
-	uint8_t  data[31];
+    uint8_t len;
+    uint8_t data[31];
 } __packed;
 
 #define BT_HCI_OP_LE_SET_SCAN_RSP_DATA          BT_OP(BT_OGF_LE, 0x0009)
 struct bt_hci_cp_le_set_scan_rsp_data {
-	uint8_t  len;
-	uint8_t  data[31];
+    uint8_t len;
+    uint8_t data[31];
 } __packed;
 
 #define BT_HCI_LE_ADV_DISABLE                   0x00
@@ -670,7 +670,7 @@ struct bt_hci_cp_le_set_scan_rsp_data {
 
 #define BT_HCI_OP_LE_SET_ADV_ENABLE             BT_OP(BT_OGF_LE, 0x000a)
 struct bt_hci_cp_le_set_adv_enable {
-	uint8_t  enable;
+    uint8_t enable;
 } __packed;
 
 /* Scan types */
@@ -682,11 +682,11 @@ struct bt_hci_cp_le_set_adv_enable {
 #define BT_HCI_LE_SCAN_FP_USE_WHITELIST         0x01
 
 struct bt_hci_cp_le_set_scan_param {
-	uint8_t  scan_type;
-	uint16_t interval;
-	uint16_t window;
-	uint8_t  addr_type;
-	uint8_t  filter_policy;
+    uint8_t scan_type;
+    uint16_t interval;
+    uint16_t window;
+    uint8_t addr_type;
+    uint8_t filter_policy;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_SCAN_ENABLE            BT_OP(BT_OGF_LE, 0x000c)
@@ -698,8 +698,8 @@ struct bt_hci_cp_le_set_scan_param {
 #define BT_HCI_LE_SCAN_FILTER_DUP_ENABLE        0x01
 
 struct bt_hci_cp_le_set_scan_enable {
-	uint8_t  enable;
-	uint8_t  filter_dup;
+    uint8_t enable;
+    uint8_t filter_dup;
 } __packed;
 
 #define BT_HCI_OP_LE_CREATE_CONN                BT_OP(BT_OGF_LE, 0x000d)
@@ -708,229 +708,229 @@ struct bt_hci_cp_le_set_scan_enable {
 #define BT_HCI_LE_CREATE_CONN_FP_WHITELIST      0x01
 
 struct bt_hci_cp_le_create_conn {
-	uint16_t     scan_interval;
-	uint16_t     scan_window;
-	uint8_t      filter_policy;
-	bt_addr_le_t peer_addr;
-	uint8_t      own_addr_type;
-	uint16_t     conn_interval_min;
-	uint16_t     conn_interval_max;
-	uint16_t     conn_latency;
-	uint16_t     supervision_timeout;
-	uint16_t     min_ce_len;
-	uint16_t     max_ce_len;
+    uint16_t scan_interval;
+    uint16_t scan_window;
+    uint8_t filter_policy;
+    bt_addr_le_t peer_addr;
+    uint8_t own_addr_type;
+    uint16_t conn_interval_min;
+    uint16_t conn_interval_max;
+    uint16_t conn_latency;
+    uint16_t supervision_timeout;
+    uint16_t min_ce_len;
+    uint16_t max_ce_len;
 } __packed;
 
 #define BT_HCI_OP_LE_CREATE_CONN_CANCEL         BT_OP(BT_OGF_LE, 0x000e)
 
 #define BT_HCI_OP_LE_READ_WL_SIZE               BT_OP(BT_OGF_LE, 0x000f)
 struct bt_hci_rp_le_read_wl_size {
-	uint8_t  status;
-	uint8_t  wl_size;
+    uint8_t status;
+    uint8_t wl_size;
 } __packed;
 
 #define BT_HCI_OP_LE_CLEAR_WL                   BT_OP(BT_OGF_LE, 0x0010)
 
 #define BT_HCI_OP_LE_ADD_DEV_TO_WL              BT_OP(BT_OGF_LE, 0x0011)
 struct bt_hci_cp_le_add_dev_to_wl {
-	bt_addr_le_t  addr;
+    bt_addr_le_t addr;
 } __packed;
 
 #define BT_HCI_OP_LE_REM_DEV_FROM_WL            BT_OP(BT_OGF_LE, 0x0012)
 struct bt_hci_cp_le_rem_dev_from_wl {
-	bt_addr_le_t  addr;
+    bt_addr_le_t addr;
 } __packed;
 
 #define BT_HCI_OP_LE_CONN_UPDATE                BT_OP(BT_OGF_LE, 0x0013)
 struct hci_cp_le_conn_update {
-	uint16_t handle;
-	uint16_t conn_interval_min;
-	uint16_t conn_interval_max;
-	uint16_t conn_latency;
-	uint16_t supervision_timeout;
-	uint16_t min_ce_len;
-	uint16_t max_ce_len;
+    uint16_t handle;
+    uint16_t conn_interval_min;
+    uint16_t conn_interval_max;
+    uint16_t conn_latency;
+    uint16_t supervision_timeout;
+    uint16_t min_ce_len;
+    uint16_t max_ce_len;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_HOST_CHAN_CLASSIF      BT_OP(BT_OGF_LE, 0x0014)
 struct bt_hci_cp_le_set_host_chan_classif {
-	uint8_t  ch_map[5];
+    uint8_t ch_map[5];
 } __packed;
 
 #define BT_HCI_OP_LE_READ_CHAN_MAP              BT_OP(BT_OGF_LE, 0x0015)
 struct bt_hci_cp_le_read_chan_map {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 struct bt_hci_rp_le_read_chan_map {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  ch_map[5];
+    uint8_t status;
+    uint16_t handle;
+    uint8_t ch_map[5];
 } __packed;
 
 #define BT_HCI_OP_LE_READ_REMOTE_FEATURES       BT_OP(BT_OGF_LE, 0x0016)
 struct bt_hci_cp_le_read_remote_features {
-	uint16_t  handle;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_ENCRYPT                    BT_OP(BT_OGF_LE, 0x0017)
 struct bt_hci_cp_le_encrypt {
-	uint8_t  key[16];
-	uint8_t  plaintext[16];
+    uint8_t key[16];
+    uint8_t plaintext[16];
 } __packed;
 struct bt_hci_rp_le_encrypt {
-	uint8_t  status;
-	uint8_t  enc_data[16];
+    uint8_t status;
+    uint8_t enc_data[16];
 } __packed;
 
 #define BT_HCI_OP_LE_RAND                       BT_OP(BT_OGF_LE, 0x0018)
 struct bt_hci_rp_le_rand {
-	uint8_t  status;
-	uint8_t  rand[8];
+    uint8_t status;
+    uint8_t rand[8];
 } __packed;
 
 #define BT_HCI_OP_LE_START_ENCRYPTION           BT_OP(BT_OGF_LE, 0x0019)
 struct bt_hci_cp_le_start_encryption {
-	uint16_t handle;
-	uint64_t rand;
-	uint16_t ediv;
-	uint8_t  ltk[16];
+    uint16_t handle;
+    uint64_t rand;
+    uint16_t ediv;
+    uint8_t ltk[16];
 } __packed;
 
 #define BT_HCI_OP_LE_LTK_REQ_REPLY              BT_OP(BT_OGF_LE, 0x001a)
 struct bt_hci_cp_le_ltk_req_reply {
-	uint16_t handle;
-	uint8_t  ltk[16];
+    uint16_t handle;
+    uint8_t ltk[16];
 } __packed;
 struct bt_hci_rp_le_ltk_req_reply {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_LTK_REQ_NEG_REPLY          BT_OP(BT_OGF_LE, 0x001b)
 struct bt_hci_cp_le_ltk_req_neg_reply {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 struct bt_hci_rp_le_ltk_req_neg_reply {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_SUPP_STATES           BT_OP(BT_OGF_LE, 0x001c)
 struct bt_hci_rp_le_read_supp_states {
-	uint8_t  status;
-	uint8_t  le_states[8];
+    uint8_t status;
+    uint8_t le_states[8];
 } __packed;
 
 #define BT_HCI_OP_LE_RX_TEST                    BT_OP(BT_OGF_LE, 0x001d)
 struct bt_hci_cp_le_rx_test {
-	uint8_t  rx_ch;
+    uint8_t rx_ch;
 } __packed;
 
 #define BT_HCI_OP_LE_TX_TEST                    BT_OP(BT_OGF_LE, 0x001e)
 struct bt_hci_cp_le_tx_test {
-	uint8_t  tx_ch;
-	uint8_t  test_data_len;
-	uint8_t  pkt_payload;
+    uint8_t tx_ch;
+    uint8_t test_data_len;
+    uint8_t pkt_payload;
 } __packed;
 
 #define BT_HCI_OP_LE_TEST_END                   BT_OP(BT_OGF_LE, 0x001f)
 struct bt_hci_rp_le_test_end {
-	uint8_t  status;
-	uint16_t rx_pkt_count;
+    uint8_t status;
+    uint16_t rx_pkt_count;
 } __packed;
 
 #define BT_HCI_OP_LE_CONN_PARAM_REQ_REPLY       BT_OP(BT_OGF_LE, 0x0020)
 struct bt_hci_cp_le_conn_param_req_reply {
-	uint16_t handle;
-	uint16_t interval_min;
-	uint16_t interval_max;
-	uint16_t latency;
-	uint16_t timeout;
-	uint16_t min_ce_len;
-	uint16_t max_ce_len;
+    uint16_t handle;
+    uint16_t interval_min;
+    uint16_t interval_max;
+    uint16_t latency;
+    uint16_t timeout;
+    uint16_t min_ce_len;
+    uint16_t max_ce_len;
 } __packed;
 struct bt_hci_rp_le_conn_param_req_reply {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_CONN_PARAM_REQ_NEG_REPLY   BT_OP(BT_OGF_LE, 0x0021)
 struct bt_hci_cp_le_conn_param_req_neg_reply {
-	uint16_t handle;
-	uint8_t  reason;
+    uint16_t handle;
+    uint8_t reason;
 } __packed;
 struct bt_hci_rp_le_conn_param_req_neg_reply {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_DATA_LEN               BT_OP(BT_OGF_LE, 0x0022)
 struct bt_hci_cp_le_set_data_len {
-	uint16_t handle;
-	uint16_t tx_octets;
-	uint16_t tx_time;
+    uint16_t handle;
+    uint16_t tx_octets;
+    uint16_t tx_time;
 } __packed;
 struct bt_hci_rp_le_set_data_len {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_DEFAULT_DATA_LEN      BT_OP(BT_OGF_LE, 0x0023)
 struct bt_hci_rp_le_read_default_data_len {
-	uint8_t  status;
-	uint16_t max_tx_octets;
-	uint16_t max_tx_time;
+    uint8_t status;
+    uint16_t max_tx_octets;
+    uint16_t max_tx_time;
 } __packed;
 
 #define BT_HCI_OP_LE_WRITE_DEFAULT_DATA_LEN     BT_OP(BT_OGF_LE, 0x0024)
 struct bt_hci_cp_le_write_default_data_len {
-	uint16_t max_tx_octets;
-	uint16_t max_tx_time;
+    uint16_t max_tx_octets;
+    uint16_t max_tx_time;
 } __packed;
 
 #define BT_HCI_OP_LE_P256_PUBLIC_KEY            BT_OP(BT_OGF_LE, 0x0025)
 
 #define BT_HCI_OP_LE_GENERATE_DHKEY             BT_OP(BT_OGF_LE, 0x0026)
 struct bt_hci_cp_le_generate_dhkey {
-	uint8_t key[64];
+    uint8_t key[64];
 } __packed;
 
 #define BT_HCI_OP_LE_ADD_DEV_TO_RL              BT_OP(BT_OGF_LE, 0x0027)
 struct bt_hci_cp_le_add_dev_to_rl {
-	bt_addr_le_t  peer_id_addr;
-	uint8_t       peer_irk[16];
-	uint8_t       local_irk[16];
+    bt_addr_le_t peer_id_addr;
+    uint8_t peer_irk[16];
+    uint8_t local_irk[16];
 } __packed;
 
 #define BT_HCI_OP_LE_REM_DEV_FROM_RL            BT_OP(BT_OGF_LE, 0x0028)
 struct bt_hci_cp_le_rem_dev_from_rl {
-	bt_addr_le_t  peer_id_addr;
+    bt_addr_le_t peer_id_addr;
 } __packed;
 
 #define BT_HCI_OP_LE_CLEAR_RL                   BT_OP(BT_OGF_LE, 0x0029)
 
 #define BT_HCI_OP_LE_READ_RL_SIZE               BT_OP(BT_OGF_LE, 0x002a)
 struct bt_hci_rp_le_read_rl_size {
-	uint8_t  status;
-	uint8_t  rl_size;
+    uint8_t status;
+    uint8_t rl_size;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_PEER_RPA              BT_OP(BT_OGF_LE, 0x002b)
 struct bt_hci_cp_le_read_peer_rpa {
-	bt_addr_le_t  peer_id_addr;
+    bt_addr_le_t peer_id_addr;
 } __packed;
 struct bt_hci_rp_le_read_peer_rpa {
-	uint8_t    status;
-	bt_addr_t  peer_rpa;
+    uint8_t status;
+    bt_addr_t peer_rpa;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_LOCAL_RPA             BT_OP(BT_OGF_LE, 0x002c)
 struct bt_hci_cp_le_read_local_rpa {
-	bt_addr_le_t  peer_id_addr;
+    bt_addr_le_t peer_id_addr;
 } __packed;
 struct bt_hci_rp_le_read_local_rpa {
-	uint8_t    status;
-	bt_addr_t  local_rpa;
+    uint8_t status;
+    bt_addr_t local_rpa;
 } __packed;
 
 #define BT_HCI_ADDR_RES_DISABLE                 0x00
@@ -938,21 +938,21 @@ struct bt_hci_rp_le_read_local_rpa {
 
 #define BT_HCI_OP_LE_SET_ADDR_RES_ENABLE        BT_OP(BT_OGF_LE, 0x002d)
 struct bt_hci_cp_le_set_addr_res_enable {
-	uint8_t  enable;
+    uint8_t enable;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_RPA_TIMEOUT            BT_OP(BT_OGF_LE, 0x002e)
 struct bt_hci_cp_le_set_rpa_timeout {
-	uint16_t rpa_timeout;
+    uint16_t rpa_timeout;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_MAX_DATA_LEN          BT_OP(BT_OGF_LE, 0x002f)
 struct bt_hci_rp_le_read_max_data_len {
-	uint8_t  status;
-	uint16_t max_tx_octets;
-	uint16_t max_tx_time;
-	uint16_t max_rx_octets;
-	uint16_t max_rx_time;
+    uint8_t status;
+    uint16_t max_tx_octets;
+    uint16_t max_tx_time;
+    uint16_t max_rx_octets;
+    uint16_t max_rx_time;
 } __packed;
 
 #define BT_HCI_LE_PHY_1M                        0x01
@@ -961,13 +961,13 @@ struct bt_hci_rp_le_read_max_data_len {
 
 #define BT_HCI_OP_LE_READ_PHY                   BT_OP(BT_OGF_LE, 0x0030)
 struct bt_hci_cp_le_read_phy {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 struct bt_hci_rp_le_read_phy {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  tx_phy;
-	uint8_t  rx_phy;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t tx_phy;
+    uint8_t rx_phy;
 } __packed;
 
 #define BT_HCI_LE_PHY_TX_ANY                    BIT(0)
@@ -979,9 +979,9 @@ struct bt_hci_rp_le_read_phy {
 
 #define BT_HCI_OP_LE_SET_DEFAULT_PHY            BT_OP(BT_OGF_LE, 0x0031)
 struct bt_hci_cp_le_set_default_phy {
-	uint8_t all_phys;
-	uint8_t tx_phys;
-	uint8_t rx_phys;
+    uint8_t all_phys;
+    uint8_t tx_phys;
+    uint8_t rx_phys;
 } __packed;
 
 #define BT_HCI_LE_PHY_CODED_ANY                 0x00
@@ -990,11 +990,11 @@ struct bt_hci_cp_le_set_default_phy {
 
 #define BT_HCI_OP_LE_SET_PHY                    BT_OP(BT_OGF_LE, 0x0032)
 struct bt_hci_cp_le_set_phy {
-	uint16_t  handle;
-	uint8_t   all_phys;
-	uint8_t   tx_phys;
-	uint8_t   rx_phys;
-	uint16_t  phy_opts;
+    uint16_t handle;
+    uint8_t all_phys;
+    uint8_t tx_phys;
+    uint8_t rx_phys;
+    uint16_t phy_opts;
 } __packed;
 
 #define BT_HCI_LE_MOD_INDEX_STANDARD            0x00
@@ -1002,9 +1002,9 @@ struct bt_hci_cp_le_set_phy {
 
 #define BT_HCI_OP_LE_ENH_RX_TEST                BT_OP(BT_OGF_LE, 0x0033)
 struct bt_hci_cp_le_enh_rx_test {
-	uint8_t  rx_ch;
-	uint8_t  phy;
-	uint8_t  mod_index;
+    uint8_t rx_ch;
+    uint8_t phy;
+    uint8_t mod_index;
 } __packed;
 
 /* Extends BT_HCI_LE_PHY */
@@ -1013,16 +1013,16 @@ struct bt_hci_cp_le_enh_rx_test {
 
 #define BT_HCI_OP_LE_ENH_TX_TEST                BT_OP(BT_OGF_LE, 0x0034)
 struct bt_hci_cp_le_enh_tx_test {
-	uint8_t  tx_ch;
-	uint8_t  test_data_len;
-	uint8_t  pkt_payload;
-	uint8_t  phy;
+    uint8_t tx_ch;
+    uint8_t test_data_len;
+    uint8_t pkt_payload;
+    uint8_t phy;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_ADV_SET_RANDOM_ADDR    BT_OP(BT_OGF_LE, 0x0035)
 struct bt_hci_cp_le_set_adv_set_random_addr {
-	uint8_t   handle;
-	bt_addr_t bdaddr;
+    uint8_t handle;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_LE_ADV_PROP_CONN                 BIT(0)
@@ -1040,24 +1040,24 @@ struct bt_hci_cp_le_set_adv_set_random_addr {
 
 #define BT_HCI_OP_LE_SET_EXT_ADV_PARAM          BT_OP(BT_OGF_LE, 0x0036)
 struct bt_hci_cp_le_set_ext_adv_param {
-	uint8_t      handle;
-	uint16_t     props;
-	uint8_t      prim_min_interval[3];
-	uint8_t      prim_max_interval[3];
-	uint8_t      prim_channel_map;
-	uint8_t      own_addr_type;
-	bt_addr_le_t peer_addr;
-	uint8_t      filter_policy;
-	int8_t       tx_power;
-	uint8_t      prim_adv_phy;
-	uint8_t      sec_adv_max_skip;
-	uint8_t      sec_adv_phy;
-	uint8_t      sid;
-	uint8_t      scan_req_notify_enable;
+    uint8_t handle;
+    uint16_t props;
+    uint8_t prim_min_interval[3];
+    uint8_t prim_max_interval[3];
+    uint8_t prim_channel_map;
+    uint8_t own_addr_type;
+    bt_addr_le_t peer_addr;
+    uint8_t filter_policy;
+    int8_t tx_power;
+    uint8_t prim_adv_phy;
+    uint8_t sec_adv_max_skip;
+    uint8_t sec_adv_phy;
+    uint8_t sid;
+    uint8_t scan_req_notify_enable;
 } __packed;
 struct bt_hci_rp_le_set_ext_adv_param {
-	uint8_t status;
-	int8_t  tx_power;
+    uint8_t status;
+    int8_t tx_power;
 } __packed;
 
 #define BT_HCI_LE_EXT_ADV_OP_INTERM_FRAG        0x00
@@ -1073,81 +1073,81 @@ struct bt_hci_rp_le_set_ext_adv_param {
 
 #define BT_HCI_OP_LE_SET_EXT_ADV_DATA           BT_OP(BT_OGF_LE, 0x0037)
 struct bt_hci_cp_le_set_ext_adv_data {
-	uint8_t  handle;
-	uint8_t  op;
-	uint8_t  frag_pref;
-	uint8_t  len;
-	uint8_t  data[251];
+    uint8_t handle;
+    uint8_t op;
+    uint8_t frag_pref;
+    uint8_t len;
+    uint8_t data[251];
 } __packed;
 
 #define BT_HCI_OP_LE_SET_EXT_SCAN_RSP_DATA      BT_OP(BT_OGF_LE, 0x0038)
 struct bt_hci_cp_le_set_ext_scan_rsp_data {
-	uint8_t  handle;
-	uint8_t  op;
-	uint8_t  frag_pref;
-	uint8_t  len;
-	uint8_t  data[251];
+    uint8_t handle;
+    uint8_t op;
+    uint8_t frag_pref;
+    uint8_t len;
+    uint8_t data[251];
 } __packed;
 
 #define BT_HCI_OP_LE_SET_EXT_ADV_ENABLE         BT_OP(BT_OGF_LE, 0x0039)
 struct bt_hci_ext_adv_set {
-	uint8_t  handle;
-	uint16_t duration;
-	uint8_t  max_ext_adv_evts;
+    uint8_t handle;
+    uint16_t duration;
+    uint8_t max_ext_adv_evts;
 } __packed;
 
 struct bt_hci_cp_le_set_ext_adv_enable {
-	uint8_t  enable;
-	uint8_t  set_num;
-	struct bt_hci_ext_adv_set s[];
+    uint8_t enable;
+    uint8_t set_num;
+    struct bt_hci_ext_adv_set s[];
 } __packed;
 
 #define BT_HCI_OP_LE_READ_MAX_ADV_DATA_LEN      BT_OP(BT_OGF_LE, 0x003a)
 struct bt_hci_rp_le_read_max_adv_data_len {
-	uint8_t  status;
-	uint16_t max_adv_data_len;
+    uint8_t status;
+    uint16_t max_adv_data_len;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_NUM_ADV_SETS          BT_OP(BT_OGF_LE, 0x003b)
 struct bt_hci_rp_le_read_num_adv_sets {
-	uint8_t  status;
-	uint8_t  num_sets;
+    uint8_t status;
+    uint8_t num_sets;
 } __packed;
 
 #define BT_HCI_OP_LE_REMOVE_ADV_SET             BT_OP(BT_OGF_LE, 0x003c)
 struct bt_hci_cp_le_remove_adv_set {
-	uint8_t  handle;
+    uint8_t handle;
 } __packed;
 
 #define BT_HCI_OP_CLEAR_ADV_SETS                BT_OP(BT_OGF_LE, 0x003d)
 
 #define BT_HCI_OP_LE_SET_PER_ADV_PARAM          BT_OP(BT_OGF_LE, 0x003e)
 struct bt_hci_cp_le_set_per_adv_param {
-	uint8_t  handle;
-	uint16_t min_interval;
-	uint16_t max_interval;
-	uint16_t props;
+    uint8_t handle;
+    uint16_t min_interval;
+    uint16_t max_interval;
+    uint16_t props;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_PER_ADV_DATA           BT_OP(BT_OGF_LE, 0x003f)
 struct bt_hci_cp_le_set_per_adv_data {
-	uint8_t  handle;
-	uint8_t  op;
-	uint8_t  len;
-	uint8_t  data[251];
+    uint8_t handle;
+    uint8_t op;
+    uint8_t len;
+    uint8_t data[251];
 } __packed;
 
 #define BT_HCI_OP_LE_SET_PER_ADV_ENABLE         BT_OP(BT_OGF_LE, 0x0040)
 struct bt_hci_cp_le_set_per_adv_enable {
-	uint8_t  enable;
-	uint8_t  handle;
+    uint8_t enable;
+    uint8_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_SET_EXT_SCAN_PARAM         BT_OP(BT_OGF_LE, 0x0041)
 struct bt_hci_ext_scan_phy {
-	uint8_t  type;
-	uint16_t interval;
-	uint16_t window;
+    uint8_t type;
+    uint16_t interval;
+    uint16_t window;
 } __packed;
 
 #define BT_HCI_LE_EXT_SCAN_PHY_1M               BIT(0)
@@ -1155,10 +1155,10 @@ struct bt_hci_ext_scan_phy {
 #define BT_HCI_LE_EXT_SCAN_PHY_CODED            BIT(2)
 
 struct bt_hci_cp_le_set_ext_scan_param {
-	uint8_t  own_addr_type;
-	uint8_t  filter_policy;
-	uint8_t  phys;
-	struct bt_hci_ext_scan_phy p[];
+    uint8_t own_addr_type;
+    uint8_t filter_policy;
+    uint8_t phys;
+    struct bt_hci_ext_scan_phy p[];
 } __packed;
 
 /* Extends BT_HCI_LE_SCAN_FILTER_DUP */
@@ -1166,87 +1166,87 @@ struct bt_hci_cp_le_set_ext_scan_param {
 
 #define BT_HCI_OP_LE_SET_EXT_SCAN_ENABLE        BT_OP(BT_OGF_LE, 0x0042)
 struct bt_hci_cp_le_set_ext_scan_enable {
-	uint8_t  enable;
-	uint8_t  filter_dup;
-	uint16_t duration;
-	uint16_t period;
+    uint8_t enable;
+    uint8_t filter_dup;
+    uint16_t duration;
+    uint16_t period;
 } __packed;
 
 #define BT_HCI_OP_LE_EXT_CREATE_CONN            BT_OP(BT_OGF_LE, 0x0043)
 struct bt_hci_ext_conn_phy {
-	uint16_t scan_interval;
-	uint16_t scan_window;
-	uint16_t conn_interval_min;
-	uint16_t conn_interval_max;
-	uint16_t conn_latency;
-	uint16_t supervision_timeout;
-	uint16_t min_ce_len;
-	uint16_t max_ce_len;
+    uint16_t scan_interval;
+    uint16_t scan_window;
+    uint16_t conn_interval_min;
+    uint16_t conn_interval_max;
+    uint16_t conn_latency;
+    uint16_t supervision_timeout;
+    uint16_t min_ce_len;
+    uint16_t max_ce_len;
 } __packed;
 
 struct bt_hci_cp_le_ext_create_conn {
-	uint8_t      filter_policy;
-	uint8_t      own_addr_type;
-	bt_addr_le_t peer_addr;
-	uint8_t      phys;
-	struct bt_hci_ext_conn_phy p[];
+    uint8_t filter_policy;
+    uint8_t own_addr_type;
+    bt_addr_le_t peer_addr;
+    uint8_t phys;
+    struct bt_hci_ext_conn_phy p[];
 } __packed;
 
 #define BT_HCI_OP_LE_PER_ADV_CREATE_SYNC        BT_OP(BT_OGF_LE, 0x0044)
 struct bt_hci_cp_le_per_adv_create_sync {
-	uint8_t      filter_policy;
-	uint8_t      sid;
-	bt_addr_le_t addr;
-	uint16_t     skip;
-	uint16_t     sync_timeout;
-	uint8_t      unused;
+    uint8_t filter_policy;
+    uint8_t sid;
+    bt_addr_le_t addr;
+    uint16_t skip;
+    uint16_t sync_timeout;
+    uint8_t unused;
 } __packed;
 
 #define BT_HCI_OP_LE_PER_ADV_CREATE_SYNC_CANCEL BT_OP(BT_OGF_LE, 0x0045)
 
 #define BT_HCI_OP_LE_PER_ADV_TERMINATE_SYNC     BT_OP(BT_OGF_LE, 0x0046)
 struct bt_hci_cp_le_per_adv_terminate_sync {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_OP_LE_ADD_DEV_TO_PER_ADV_LIST    BT_OP(BT_OGF_LE, 0x0047)
 struct bt_hci_cp_le_add_dev_to_per_adv_list {
-	bt_addr_le_t addr;
-	uint8_t      sid;
+    bt_addr_le_t addr;
+    uint8_t sid;
 } __packed;
 
 #define BT_HCI_OP_LE_REM_DEV_FROM_PER_ADV_LIST  BT_OP(BT_OGF_LE, 0x0048)
 struct bt_hci_cp_le_rem_dev_from_per_adv_list {
-	bt_addr_le_t addr;
-	uint8_t      sid;
+    bt_addr_le_t addr;
+    uint8_t sid;
 } __packed;
 
 #define BT_HCI_OP_LE_CLEAR_PER_ADV_LIST         BT_OP(BT_OGF_LE, 0x0049)
 
 #define BT_HCI_OP_LE_READ_PER_ADV_LIST_SIZE     BT_OP(BT_OGF_LE, 0x004a)
 struct bt_hci_rp_le_read_per_adv_list_size {
-	uint8_t  status;
-	uint8_t  list_size;
+    uint8_t status;
+    uint8_t list_size;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_TX_POWER              BT_OP(BT_OGF_LE, 0x004b)
 struct bt_hci_rp_le_read_tx_power {
-	uint8_t status;
-	int8_t  min_tx_power;
-	int8_t  max_tx_power;
+    uint8_t status;
+    int8_t min_tx_power;
+    int8_t max_tx_power;
 } __packed;
 
 #define BT_HCI_OP_LE_READ_RF_PATH_COMP          BT_OP(BT_OGF_LE, 0x004c)
 struct bt_hci_rp_le_read_rf_path_comp {
-	uint8_t status;
-	int16_t tx_path_comp;
-	int16_t rx_path_comp;
+    uint8_t status;
+    int16_t tx_path_comp;
+    int16_t rx_path_comp;
 } __packed;
 
 #define BT_HCI_OP_LE_WRITE_RF_PATH_COMP         BT_OP(BT_OGF_LE, 0x004d)
 struct bt_hci_cp_le_write_rf_path_comp {
-	int16_t  tx_path_comp;
-	int16_t  rx_path_comp;
+    int16_t tx_path_comp;
+    int16_t rx_path_comp;
 } __packed;
 
 #define BT_HCI_LE_PRIVACY_MODE_NETWORK          0x00
@@ -1254,8 +1254,8 @@ struct bt_hci_cp_le_write_rf_path_comp {
 
 #define BT_HCI_OP_LE_SET_PRIVACY_MODE           BT_OP(BT_OGF_LE, 0x004e)
 struct bt_hci_cp_le_set_privacy_mode {
-	bt_addr_le_t id_addr;
-	uint8_t         mode;
+    bt_addr_le_t id_addr;
+    uint8_t mode;
 } __packed;
 
 /* Event definitions */
@@ -1265,106 +1265,106 @@ struct bt_hci_cp_le_set_privacy_mode {
 
 #define BT_HCI_EVT_INQUIRY_COMPLETE             0x01
 struct bt_hci_evt_inquiry_complete {
-	uint8_t status;
+    uint8_t status;
 } __packed;
 
 #define BT_HCI_EVT_CONN_COMPLETE                0x03
 struct bt_hci_evt_conn_complete {
-	uint8_t   status;
-	uint16_t  handle;
-	bt_addr_t bdaddr;
-	uint8_t   link_type;
-	uint8_t   encr_enabled;
+    uint8_t status;
+    uint16_t handle;
+    bt_addr_t bdaddr;
+    uint8_t link_type;
+    uint8_t encr_enabled;
 } __packed;
 
 #define BT_HCI_EVT_CONN_REQUEST                 0x04
 struct bt_hci_evt_conn_request {
-	bt_addr_t bdaddr;
-	uint8_t   dev_class[3];
-	uint8_t   link_type;
+    bt_addr_t bdaddr;
+    uint8_t dev_class[3];
+    uint8_t link_type;
 } __packed;
 
 #define BT_HCI_EVT_DISCONN_COMPLETE             0x05
 struct bt_hci_evt_disconn_complete {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  reason;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t reason;
 } __packed;
 
 #define BT_HCI_EVT_AUTH_COMPLETE                0x06
 struct bt_hci_evt_auth_complete {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_EVT_REMOTE_NAME_REQ_COMPLETE     0x07
 struct bt_hci_evt_remote_name_req_complete {
-	uint8_t   status;
-	bt_addr_t bdaddr;
-	uint8_t   name[248];
+    uint8_t status;
+    bt_addr_t bdaddr;
+    uint8_t name[248];
 } __packed;
 
 #define BT_HCI_EVT_ENCRYPT_CHANGE               0x08
 struct bt_hci_evt_encrypt_change {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  encrypt;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t encrypt;
 } __packed;
 
 #define BT_HCI_EVT_REMOTE_FEATURES              0x0b
 struct bt_hci_evt_remote_features {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  features[8];
+    uint8_t status;
+    uint16_t handle;
+    uint8_t features[8];
 } __packed;
 
 #define BT_HCI_EVT_REMOTE_VERSION_INFO          0x0c
 struct bt_hci_evt_remote_version_info {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  version;
-	uint16_t manufacturer;
-	uint16_t subversion;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t version;
+    uint16_t manufacturer;
+    uint16_t subversion;
 } __packed;
 
 #define BT_HCI_EVT_CMD_COMPLETE                 0x0e
 struct bt_hci_evt_cmd_complete {
-	uint8_t  ncmd;
-	uint16_t opcode;
+    uint8_t ncmd;
+    uint16_t opcode;
 } __packed;
 
 struct bt_hci_evt_cc_status {
-	uint8_t  status;
+    uint8_t status;
 } __packed;
 
 #define BT_HCI_EVT_CMD_STATUS                   0x0f
 struct bt_hci_evt_cmd_status {
-	uint8_t  status;
-	uint8_t  ncmd;
-	uint16_t opcode;
+    uint8_t status;
+    uint8_t ncmd;
+    uint16_t opcode;
 } __packed;
 
 #define BT_HCI_EVT_ROLE_CHANGE                  0x12
 struct bt_hci_evt_role_change {
-	uint8_t   status;
-	bt_addr_t bdaddr;
-	uint8_t   role;
+    uint8_t status;
+    bt_addr_t bdaddr;
+    uint8_t role;
 } __packed;
 
 #define BT_HCI_EVT_NUM_COMPLETED_PACKETS        0x13
 struct bt_hci_evt_num_completed_packets {
-	uint8_t  num_handles;
-	struct bt_hci_handle_count h[];
+    uint8_t num_handles;
+    struct bt_hci_handle_count h[];
 } __packed;
 
 #define BT_HCI_EVT_PIN_CODE_REQ                 0x16
 struct bt_hci_evt_pin_code_req {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_EVT_LINK_KEY_REQ                 0x17
 struct bt_hci_evt_link_key_req {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 /* Link Key types */
@@ -1380,9 +1380,9 @@ struct bt_hci_evt_link_key_req {
 
 #define BT_HCI_EVT_LINK_KEY_NOTIFY              0x18
 struct bt_hci_evt_link_key_notify {
-	bt_addr_t bdaddr;
-	uint8_t   link_key[16];
-	uint8_t   key_type;
+    bt_addr_t bdaddr;
+    uint8_t link_key[16];
+    uint8_t key_type;
 } __packed;
 
 /* Overflow link types */
@@ -1391,103 +1391,103 @@ struct bt_hci_evt_link_key_notify {
 
 #define BT_HCI_EVT_DATA_BUF_OVERFLOW            0x1a
 struct bt_hci_evt_data_buf_overflow {
-	uint8_t  link_type;
+    uint8_t link_type;
 } __packed;
 
 #define BT_HCI_EVT_INQUIRY_RESULT_WITH_RSSI     0x22
 struct bt_hci_evt_inquiry_result_with_rssi {
-	bt_addr_t addr;
-	uint8_t   pscan_rep_mode;
-	uint8_t   reserved;
-	uint8_t   cod[3];
-	uint16_t  clock_offset;
-	int8_t    rssi;
+    bt_addr_t addr;
+    uint8_t pscan_rep_mode;
+    uint8_t reserved;
+    uint8_t cod[3];
+    uint16_t clock_offset;
+    int8_t rssi;
 } __packed;
 
 #define BT_HCI_EVT_REMOTE_EXT_FEATURES          0x23
 struct bt_hci_evt_remote_ext_features {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  page;
-	uint8_t  max_page;
-	uint8_t  features[8];
+    uint8_t status;
+    uint16_t handle;
+    uint8_t page;
+    uint8_t max_page;
+    uint8_t features[8];
 } __packed;
 
 #define BT_HCI_EVT_SYNC_CONN_COMPLETE           0x2c
 struct bt_hci_evt_sync_conn_complete {
-	uint8_t    status;
-	uint16_t   handle;
-	bt_addr_t  bdaddr;
-	uint8_t    link_type;
-	uint8_t    tx_interval;
-	uint8_t    retansmission_window;
-	uint16_t   rx_pkt_length;
-	uint16_t   tx_pkt_length;
-	uint8_t    air_mode;
+    uint8_t status;
+    uint16_t handle;
+    bt_addr_t bdaddr;
+    uint8_t link_type;
+    uint8_t tx_interval;
+    uint8_t retansmission_window;
+    uint16_t rx_pkt_length;
+    uint16_t tx_pkt_length;
+    uint8_t air_mode;
 } __packed;
 
 #define BT_HCI_EVT_EXTENDED_INQUIRY_RESULT      0x2f
 struct bt_hci_evt_extended_inquiry_result {
-	uint8_t    num_reports;
-	bt_addr_t  addr;
-	uint8_t    pscan_rep_mode;
-	uint8_t    reserved;
-	uint8_t    cod[3];
-	uint16_t   clock_offset;
-	int8_t     rssi;
-	uint8_t    eir[240];
+    uint8_t num_reports;
+    bt_addr_t addr;
+    uint8_t pscan_rep_mode;
+    uint8_t reserved;
+    uint8_t cod[3];
+    uint16_t clock_offset;
+    int8_t rssi;
+    uint8_t eir[240];
 } __packed;
 
 #define BT_HCI_EVT_ENCRYPT_KEY_REFRESH_COMPLETE 0x30
 struct bt_hci_evt_encrypt_key_refresh_complete {
-	uint8_t  status;
-	uint16_t handle;
+    uint8_t status;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_EVT_IO_CAPA_REQ                  0x31
 struct bt_hci_evt_io_capa_req {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_EVT_IO_CAPA_RESP                 0x32
 struct bt_hci_evt_io_capa_resp {
-	bt_addr_t bdaddr;
-	uint8_t   capability;
-	uint8_t   oob_data;
-	uint8_t   authentication;
+    bt_addr_t bdaddr;
+    uint8_t capability;
+    uint8_t oob_data;
+    uint8_t authentication;
 } __packed;
 
 #define BT_HCI_EVT_USER_CONFIRM_REQ             0x33
 struct bt_hci_evt_user_confirm_req {
-	bt_addr_t bdaddr;
-	uint32_t  passkey;
+    bt_addr_t bdaddr;
+    uint32_t passkey;
 } __packed;
 
 #define BT_HCI_EVT_USER_PASSKEY_REQ             0x34
 struct bt_hci_evt_user_passkey_req {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_EVT_SSP_COMPLETE                 0x36
 struct bt_hci_evt_ssp_complete {
-	uint8_t   status;
-	bt_addr_t bdaddr;
+    uint8_t status;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_EVT_USER_PASSKEY_NOTIFY          0x3b
 struct bt_hci_evt_user_passkey_notify {
-	bt_addr_t bdaddr;
-	uint32_t  passkey;
+    bt_addr_t bdaddr;
+    uint32_t passkey;
 } __packed;
 
 #define BT_HCI_EVT_LE_META_EVENT                0x3e
 struct bt_hci_evt_le_meta_event {
-	uint8_t  subevent;
+    uint8_t subevent;
 } __packed;
 
 #define BT_HCI_EVT_AUTH_PAYLOAD_TIMEOUT_EXP     0x57
 struct bt_hci_evt_auth_payload_timeout_exp {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_ROLE_MASTER                      0x00
@@ -1495,113 +1495,113 @@ struct bt_hci_evt_auth_payload_timeout_exp {
 
 #define BT_HCI_EVT_LE_CONN_COMPLETE             0x01
 struct bt_hci_evt_le_conn_complete {
-	uint8_t      status;
-	uint16_t     handle;
-	uint8_t      role;
-	bt_addr_le_t peer_addr;
-	uint16_t     interval;
-	uint16_t     latency;
-	uint16_t     supv_timeout;
-	uint8_t      clock_accuracy;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t role;
+    bt_addr_le_t peer_addr;
+    uint16_t interval;
+    uint16_t latency;
+    uint16_t supv_timeout;
+    uint8_t clock_accuracy;
 } __packed;
 
 #define BT_HCI_EVT_LE_ADVERTISING_REPORT        0x02
 struct bt_hci_evt_le_advertising_info {
-	uint8_t      evt_type;
-	bt_addr_le_t addr;
-	uint8_t      length;
-	uint8_t      data[];
+    uint8_t evt_type;
+    bt_addr_le_t addr;
+    uint8_t length;
+    uint8_t data[];
 } __packed;
 struct bt_hci_evt_le_advertising_report {
-	uint8_t num_reports;
-	struct bt_hci_evt_le_advertising_info adv_info[];
+    uint8_t num_reports;
+    struct bt_hci_evt_le_advertising_info adv_info[];
 } __packed;
 
 #define BT_HCI_EVT_LE_CONN_UPDATE_COMPLETE      0x03
 struct bt_hci_evt_le_conn_update_complete {
-	uint8_t  status;
-	uint16_t handle;
-	uint16_t interval;
-	uint16_t latency;
-	uint16_t supv_timeout;
+    uint8_t status;
+    uint16_t handle;
+    uint16_t interval;
+    uint16_t latency;
+    uint16_t supv_timeout;
 } __packed;
 
 #define BT_HCI_EV_LE_REMOTE_FEAT_COMPLETE       0x04
 struct bt_hci_evt_le_remote_feat_complete {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  features[8];
+    uint8_t status;
+    uint16_t handle;
+    uint8_t features[8];
 } __packed;
 
 #define BT_HCI_EVT_LE_LTK_REQUEST               0x05
 struct bt_hci_evt_le_ltk_request {
-	uint16_t handle;
-	uint64_t rand;
-	uint16_t ediv;
+    uint16_t handle;
+    uint64_t rand;
+    uint16_t ediv;
 } __packed;
 
 #define BT_HCI_EVT_LE_CONN_PARAM_REQ            0x06
 struct bt_hci_evt_le_conn_param_req {
-	uint16_t handle;
-	uint16_t interval_min;
-	uint16_t interval_max;
-	uint16_t latency;
-	uint16_t timeout;
+    uint16_t handle;
+    uint16_t interval_min;
+    uint16_t interval_max;
+    uint16_t latency;
+    uint16_t timeout;
 } __packed;
 
 #define BT_HCI_EVT_LE_DATA_LEN_CHANGE           0x07
 struct bt_hci_evt_le_data_len_change {
-	uint16_t handle;
-	uint16_t max_tx_octets;
-	uint16_t max_tx_time;
-	uint16_t max_rx_octets;
-	uint16_t max_rx_time;
+    uint16_t handle;
+    uint16_t max_tx_octets;
+    uint16_t max_tx_time;
+    uint16_t max_rx_octets;
+    uint16_t max_rx_time;
 } __packed;
 
 #define BT_HCI_EVT_LE_P256_PUBLIC_KEY_COMPLETE  0x08
 struct bt_hci_evt_le_p256_public_key_complete {
-	uint8_t status;
-	uint8_t key[64];
+    uint8_t status;
+    uint8_t key[64];
 } __packed;
 
 #define BT_HCI_EVT_LE_GENERATE_DHKEY_COMPLETE   0x09
 struct bt_hci_evt_le_generate_dhkey_complete {
-	uint8_t status;
-	uint8_t dhkey[32];
+    uint8_t status;
+    uint8_t dhkey[32];
 } __packed;
 
 #define BT_HCI_EVT_LE_ENH_CONN_COMPLETE         0x0a
 struct bt_hci_evt_le_enh_conn_complete {
-	uint8_t      status;
-	uint16_t     handle;
-	uint8_t      role;
-	bt_addr_le_t peer_addr;
-	bt_addr_t    local_rpa;
-	bt_addr_t    peer_rpa;
-	uint16_t     interval;
-	uint16_t     latency;
-	uint16_t     supv_timeout;
-	uint8_t      clock_accuracy;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t role;
+    bt_addr_le_t peer_addr;
+    bt_addr_t local_rpa;
+    bt_addr_t peer_rpa;
+    uint16_t interval;
+    uint16_t latency;
+    uint16_t supv_timeout;
+    uint8_t clock_accuracy;
 } __packed;
 
 #define BT_HCI_EVT_LE_DIRECT_ADV_REPORT         0x0b
 struct bt_hci_evt_le_direct_adv_info {
-	uint8_t      evt_type;
-	bt_addr_le_t addr;
-	bt_addr_le_t dir_addr;
-	int8_t       rssi;
+    uint8_t evt_type;
+    bt_addr_le_t addr;
+    bt_addr_le_t dir_addr;
+    int8_t rssi;
 } __packed;
 struct bt_hci_evt_le_direct_adv_report {
-	uint8_t num_reports;
-	struct bt_hci_evt_le_direct_adv_info direct_adv_info[];
+    uint8_t num_reports;
+    struct bt_hci_evt_le_direct_adv_info direct_adv_info[];
 } __packed;
 
 #define BT_HCI_EVT_LE_PHY_UPDATE_COMPLETE       0x0c
 struct bt_hci_evt_le_phy_update_complete {
-	uint8_t  status;
-	uint16_t handle;
-	uint8_t  tx_phy;
-	uint8_t  rx_phy;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t tx_phy;
+    uint8_t rx_phy;
 } __packed;
 
 #define BT_HCI_EVT_LE_EXT_ADVERTISING_REPORT    0x0d
@@ -1618,64 +1618,64 @@ struct bt_hci_evt_le_phy_update_complete {
 #define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS_INCOMPLETE 2
 
 struct bt_hci_evt_le_ext_advertising_info {
-	uint16_t     evt_type;
-	bt_addr_le_t addr;
-	uint8_t      prim_phy;
-	uint8_t      sec_phy;
-	uint8_t      sid;
-	int8_t       tx_power;
-	int8_t       rssi;
-	uint16_t     interval;
-	bt_addr_le_t direct_addr;
-	uint8_t      length;
-	uint8_t      data[];
+    uint16_t evt_type;
+    bt_addr_le_t addr;
+    uint8_t prim_phy;
+    uint8_t sec_phy;
+    uint8_t sid;
+    int8_t tx_power;
+    int8_t rssi;
+    uint16_t interval;
+    bt_addr_le_t direct_addr;
+    uint8_t length;
+    uint8_t data[];
 } __packed;
 struct bt_hci_evt_le_ext_advertising_report {
-	uint8_t num_reports;
-	struct bt_hci_evt_le_ext_advertising_info adv_info[];
+    uint8_t num_reports;
+    struct bt_hci_evt_le_ext_advertising_info adv_info[];
 } __packed;
 
 #define BT_HCI_EVT_LE_PER_ADV_SYNC_ESTABLISHED  0x0e
 struct bt_hci_evt_le_per_adv_sync_established {
-	uint8_t      status;
-	uint16_t     handle;
-	uint8_t      sid;
-	bt_addr_le_t adv_addr;
-	uint8_t      phy;
-	uint16_t     interval;
-	uint8_t      clock_accuracy;
+    uint8_t status;
+    uint16_t handle;
+    uint8_t sid;
+    bt_addr_le_t adv_addr;
+    uint8_t phy;
+    uint16_t interval;
+    uint8_t clock_accuracy;
 } __packed;
 
 #define BT_HCI_EVT_LE_PER_ADVERTISING_REPORT    0x0f
 struct bt_hci_evt_le_per_advertising_report {
-	uint16_t handle;
-	int8_t   tx_power;
-	int8_t   rssi;
-	uint8_t  unused;
-	uint8_t  data_status;
-	uint8_t  length;
-	uint8_t  data[];
+    uint16_t handle;
+    int8_t tx_power;
+    int8_t rssi;
+    uint8_t unused;
+    uint8_t data_status;
+    uint8_t length;
+    uint8_t data[];
 } __packed;
 
 #define BT_HCI_EVT_LE_PER_ADV_SYNC_LOST         0x10
 struct bt_hci_evt_le_per_adv_sync_lost {
-	uint16_t handle;
+    uint16_t handle;
 } __packed;
 
 #define BT_HCI_EVT_LE_SCAN_TIMEOUT              0x11
 
 #define BT_HCI_EVT_LE_ADV_SET_TERMINATED        0x12
 struct bt_hci_evt_le_adv_set_terminated {
-	uint8_t  status;
-	uint8_t  adv_handle;
-	uint16_t conn_handle;
-	uint8_t  num_completed_ext_adv_evts;
+    uint8_t status;
+    uint8_t adv_handle;
+    uint16_t conn_handle;
+    uint8_t num_completed_ext_adv_evts;
 } __packed;
 
 #define BT_HCI_EVT_LE_SCAN_REQ_RECEIVED         0x13
 struct bt_hci_evt_le_scan_req_received {
-	uint8_t      handle;
-	bt_addr_le_t addr;
+    uint8_t handle;
+    bt_addr_le_t addr;
 } __packed;
 
 #define BT_HCI_LE_CHAN_SEL_ALGO_1               0x00
@@ -1683,8 +1683,8 @@ struct bt_hci_evt_le_scan_req_received {
 
 #define BT_HCI_EVT_LE_CHAN_SEL_ALGO             0x14
 struct bt_hci_evt_le_chan_sel_algo {
-	uint16_t handle;
-	uint8_t  chan_sel_algo;
+    uint16_t handle;
+    uint8_t chan_sel_algo;
 } __packed;
 
 /* Event mask bits */
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/hci_raw.h b/devices/ble_hci/common-hal/_bleio/hci_include/hci_raw.h
index 030fb0ca3..8fb5564eb 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_include/hci_raw.h
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/hci_raw.h
@@ -50,20 +50,20 @@ extern "C" {
 int bt_send(struct net_buf *buf);
 
 enum {
-	/** Passthrough mode
-	 *
-	 *  While in this mode the buffers are passed as is between the stack
-	 *  and the driver.
-	 */
-	BT_HCI_RAW_MODE_PASSTHROUGH = 0x00,
-
-	/** H:4 mode
-	 *
-	 *  While in this mode H:4 headers will added into the buffers
-	 *  according to the buffer type when coming from the stack and will be
-	 *  removed and used to set the buffer type.
-	 */
-	BT_HCI_RAW_MODE_H4 = 0x01,
+    /** Passthrough mode
+     *
+     *  While in this mode the buffers are passed as is between the stack
+     *  and the driver.
+     */
+    BT_HCI_RAW_MODE_PASSTHROUGH = 0x00,
+
+    /** H:4 mode
+     *
+     *  While in this mode H:4 headers will added into the buffers
+     *  according to the buffer type when coming from the stack and will be
+     *  removed and used to set the buffer type.
+     */
+    BT_HCI_RAW_MODE_H4 = 0x01,
 };
 
 /** @brief Set Bluetooth RAW channel mode
@@ -93,31 +93,31 @@ uint8_t bt_hci_raw_get_mode(void);
  *  @param _func Handler function to be called.
  */
 #define BT_HCI_RAW_CMD_EXT(_op, _min_len, _func) \
-	{ \
-		.op = _op, \
-		.min_len = _min_len, \
-		.func = _func, \
-	}
+    { \
+        .op = _op, \
+        .min_len = _min_len, \
+        .func = _func, \
+    }
 
 struct bt_hci_raw_cmd_ext {
-	/** Opcode of the command */
-	uint16_t  op;
-
-	/** Minimal length of the command */
-	size_t min_len;
-
-	/** Handler function.
-	 *
-	 *  Handler function to be called when a command is intercepted.
-	 *
-	 *  @param buf Buffer containing the command.
-	 *
-	 *  @return HCI Status code or BT_HCI_ERR_EXT_HANDLED if command has
-	 *  been handled already and a response has been sent as oppose to
-	 *  BT_HCI_ERR_SUCCESS which just indicates that the command can be
-	 *  sent to the controller to be processed.
-	 */
-	uint8_t   (*func)(struct net_buf *buf);
+    /** Opcode of the command */
+    uint16_t op;
+
+    /** Minimal length of the command */
+    size_t min_len;
+
+    /** Handler function.
+     *
+     *  Handler function to be called when a command is intercepted.
+     *
+     *  @param buf Buffer containing the command.
+     *
+     *  @return HCI Status code or BT_HCI_ERR_EXT_HANDLED if command has
+     *  been handled already and a response has been sent as oppose to
+     *  BT_HCI_ERR_SUCCESS which just indicates that the command can be
+     *  sent to the controller to be processed.
+     */
+    uint8_t (*func)(struct net_buf *buf);
 };
 
 /** @brief Register Bluetooth RAW command extension table
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/hci_vs.h b/devices/ble_hci/common-hal/_bleio/hci_include/hci_vs.h
index 660691398..02452a788 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_include/hci_vs.h
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/hci_vs.h
@@ -32,11 +32,11 @@ extern "C" {
 #define BT_VS_CMD_BIT_READ_TX_POWER                14
 
 #define BT_VS_CMD_SUP_FEAT(cmd)                 BT_LE_FEAT_TEST(cmd, \
-						BT_VS_CMD_BIT_SUP_FEAT)
+    BT_VS_CMD_BIT_SUP_FEAT)
 #define BT_VS_CMD_READ_STATIC_ADDRS(cmd)        BT_LE_FEAT_TEST(cmd, \
-						BT_VS_CMD_BIT_READ_STATIC_ADDRS)
+    BT_VS_CMD_BIT_READ_STATIC_ADDRS)
 #define BT_VS_CMD_READ_KEY_ROOTS(cmd)           BT_LE_FEAT_TEST(cmd, \
-						BT_VS_CMD_BIT_READ_KEY_ROOTS)
+    BT_VS_CMD_BIT_READ_KEY_ROOTS)
 
 #define BT_HCI_VS_HW_PLAT_INTEL                 0x0001
 #define BT_HCI_VS_HW_PLAT_NORDIC                0x0002
@@ -50,44 +50,44 @@ extern "C" {
 #define BT_HCI_VS_FW_VAR_VS_CTLR                0x0002
 #define BT_HCI_VS_FW_VAR_FW_LOADER              0x0003
 #define BT_HCI_VS_FW_VAR_RESCUE_IMG             0x0004
-#define BT_HCI_OP_VS_READ_VERSION_INFO		BT_OP(BT_OGF_VS, 0x0001)
+#define BT_HCI_OP_VS_READ_VERSION_INFO          BT_OP(BT_OGF_VS, 0x0001)
 struct bt_hci_rp_vs_read_version_info {
-	uint8_t  status;
-	uint16_t hw_platform;
-	uint16_t hw_variant;
-	uint8_t  fw_variant;
-	uint8_t  fw_version;
-	uint16_t fw_revision;
-	uint32_t fw_build;
+    uint8_t status;
+    uint16_t hw_platform;
+    uint16_t hw_variant;
+    uint8_t fw_variant;
+    uint8_t fw_version;
+    uint16_t fw_revision;
+    uint32_t fw_build;
 } __packed;
 
-#define BT_HCI_OP_VS_READ_SUPPORTED_COMMANDS	BT_OP(BT_OGF_VS, 0x0002)
+#define BT_HCI_OP_VS_READ_SUPPORTED_COMMANDS    BT_OP(BT_OGF_VS, 0x0002)
 struct bt_hci_rp_vs_read_supported_commands {
-	uint8_t  status;
-	uint8_t  commands[64];
+    uint8_t status;
+    uint8_t commands[64];
 } __packed;
 
-#define BT_HCI_OP_VS_READ_SUPPORTED_FEATURES	BT_OP(BT_OGF_VS, 0x0003)
+#define BT_HCI_OP_VS_READ_SUPPORTED_FEATURES    BT_OP(BT_OGF_VS, 0x0003)
 struct bt_hci_rp_vs_read_supported_features {
-	uint8_t  status;
-	uint8_t  features[8];
+    uint8_t status;
+    uint8_t features[8];
 } __packed;
 
 #define BT_HCI_OP_VS_SET_EVENT_MASK             BT_OP(BT_OGF_VS, 0x0004)
 struct bt_hci_cp_vs_set_event_mask {
-	uint8_t  event_mask[8];
+    uint8_t event_mask[8];
 } __packed;
 
 #define BT_HCI_VS_RESET_SOFT                    0x00
 #define BT_HCI_VS_RESET_HARD                    0x01
 #define BT_HCI_OP_VS_RESET                      BT_OP(BT_OGF_VS, 0x0005)
 struct bt_hci_cp_vs_reset {
-	uint8_t  type;
+    uint8_t type;
 } __packed;
 
 #define BT_HCI_OP_VS_WRITE_BD_ADDR              BT_OP(BT_OGF_VS, 0x0006)
 struct bt_hci_cp_vs_write_bd_addr {
-	bt_addr_t bdaddr;
+    bt_addr_t bdaddr;
 } __packed;
 
 #define BT_HCI_VS_TRACE_DISABLED                0x00
@@ -97,60 +97,60 @@ struct bt_hci_cp_vs_write_bd_addr {
 #define BT_HCI_VS_TRACE_VDC                     0x01
 #define BT_HCI_OP_VS_SET_TRACE_ENABLE           BT_OP(BT_OGF_VS, 0x0007)
 struct bt_hci_cp_vs_set_trace_enable {
-	uint8_t  enable;
-	uint8_t  type;
+    uint8_t enable;
+    uint8_t type;
 } __packed;
 
 #define BT_HCI_OP_VS_READ_BUILD_INFO            BT_OP(BT_OGF_VS, 0x0008)
 struct bt_hci_rp_vs_read_build_info {
-	uint8_t  status;
-	uint8_t  info[];
+    uint8_t status;
+    uint8_t info[];
 } __packed;
 
 struct bt_hci_vs_static_addr {
-	bt_addr_t bdaddr;
-	uint8_t      ir[16];
+    bt_addr_t bdaddr;
+    uint8_t ir[16];
 } __packed;
 
 #define BT_HCI_OP_VS_READ_STATIC_ADDRS          BT_OP(BT_OGF_VS, 0x0009)
 struct bt_hci_rp_vs_read_static_addrs {
-	uint8_t   status;
-	uint8_t   num_addrs;
-	struct bt_hci_vs_static_addr a[];
+    uint8_t status;
+    uint8_t num_addrs;
+    struct bt_hci_vs_static_addr a[];
 } __packed;
 
 #define BT_HCI_OP_VS_READ_KEY_HIERARCHY_ROOTS   BT_OP(BT_OGF_VS, 0x000a)
 struct bt_hci_rp_vs_read_key_hierarchy_roots {
-	uint8_t  status;
-	uint8_t  ir[16];
-	uint8_t  er[16];
+    uint8_t status;
+    uint8_t ir[16];
+    uint8_t er[16];
 } __packed;
 
 #define BT_HCI_OP_VS_READ_CHIP_TEMP             BT_OP(BT_OGF_VS, 0x000b)
 struct bt_hci_rp_vs_read_chip_temp {
-	uint8_t  status;
-	int8_t  temps;
+    uint8_t status;
+    int8_t temps;
 } __packed;
 
 struct bt_hci_vs_cmd {
-	uint16_t vendor_id;
-	uint16_t opcode_base;
+    uint16_t vendor_id;
+    uint16_t opcode_base;
 } __packed;
 
 #define BT_HCI_VS_VID_ANDROID                   0x0001
 #define BT_HCI_VS_VID_MICROSOFT                 0x0002
 #define BT_HCI_OP_VS_READ_HOST_STACK_CMDS       BT_OP(BT_OGF_VS, 0x000c)
 struct bt_hci_rp_vs_read_host_stack_cmds {
-	uint8_t   status;
-	uint8_t   num_cmds;
-	struct bt_hci_vs_cmd c[];
+    uint8_t status;
+    uint8_t num_cmds;
+    struct bt_hci_vs_cmd c[];
 } __packed;
 
 #define BT_HCI_VS_SCAN_REQ_REPORTS_DISABLED     0x00
 #define BT_HCI_VS_SCAN_REQ_REPORTS_ENABLED      0x01
 #define BT_HCI_OP_VS_SET_SCAN_REQ_REPORTS       BT_OP(BT_OGF_VS, 0x000d)
 struct bt_hci_cp_vs_set_scan_req_reports {
-	uint8_t  enable;
+    uint8_t enable;
 } __packed;
 
 #define BT_HCI_VS_LL_HANDLE_TYPE_ADV       0x00
@@ -159,37 +159,37 @@ struct bt_hci_cp_vs_set_scan_req_reports {
 #define BT_HCI_VS_LL_TX_POWER_LEVEL_NO_PREF     0x7F
 #define BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL       BT_OP(BT_OGF_VS, 0x000e)
 struct bt_hci_cp_vs_write_tx_power_level {
-	uint8_t  handle_type;
-	uint16_t handle;
-	int8_t  tx_power_level;
+    uint8_t handle_type;
+    uint16_t handle;
+    int8_t tx_power_level;
 } __packed;
 
 struct bt_hci_rp_vs_write_tx_power_level {
-	uint8_t  status;
-	uint8_t  handle_type;
-	uint16_t handle;
-	int8_t  selected_tx_power;
+    uint8_t status;
+    uint8_t handle_type;
+    uint16_t handle;
+    int8_t selected_tx_power;
 } __packed;
 
 #define BT_HCI_OP_VS_READ_TX_POWER_LEVEL        BT_OP(BT_OGF_VS, 0x000f)
 struct bt_hci_cp_vs_read_tx_power_level {
-	uint8_t  handle_type;
-	uint16_t handle;
+    uint8_t handle_type;
+    uint16_t handle;
 } __packed;
 
 struct bt_hci_rp_vs_read_tx_power_level {
-	uint8_t  status;
-	uint8_t  handle_type;
-	uint16_t handle;
-	int8_t  tx_power_level;
+    uint8_t status;
+    uint8_t handle_type;
+    uint16_t handle;
+    int8_t tx_power_level;
 } __packed;
 
 #define BT_HCI_OP_VS_READ_USB_TRANSPORT_MODE    BT_OP(BT_OGF_VS, 0x0010)
 
 struct bt_hci_rp_vs_read_usb_transport_mode {
-	uint8_t  status;
-	uint8_t  num_supported_modes;
-	uint8_t  supported_mode[];
+    uint8_t status;
+    uint8_t num_supported_modes;
+    uint8_t supported_mode[];
 } __packed;
 
 #define BT_HCI_VS_USB_H2_MODE                  0x00
@@ -198,19 +198,19 @@ struct bt_hci_rp_vs_read_usb_transport_mode {
 #define BT_HCI_OP_VS_SET_USB_TRANSPORT_MODE    BT_OP(BT_OGF_VS, 0x0011)
 
 struct bt_hci_cp_vs_set_usb_transport_mode {
-	uint8_t  mode;
+    uint8_t mode;
 } __packed;
 
 /* Events */
 
 struct bt_hci_evt_vs {
-	uint8_t  subevent;
+    uint8_t subevent;
 } __packed;
 
 #define BT_HCI_EVT_VS_FATAL_ERROR              0x02
 struct bt_hci_evt_vs_fatal_error {
-	uint64_t pc;
-	uint8_t  err_info[];
+    uint64_t pc;
+    uint8_t err_info[];
 } __packed;
 
 #define BT_HCI_VS_TRACE_LMP_TX                 0x01
@@ -220,14 +220,14 @@ struct bt_hci_evt_vs_fatal_error {
 #define BT_HCI_VS_TRACE_LE_CONN_IND            0x05
 #define BT_HCI_EVT_VS_TRACE_INFO               0x03
 struct bt_hci_evt_vs_trace_info {
-	uint8_t  type;
-	uint8_t  data[];
+    uint8_t type;
+    uint8_t data[];
 } __packed;
 
 #define BT_HCI_EVT_VS_SCAN_REQ_RX              0x04
 struct bt_hci_evt_vs_scan_req_rx {
-	bt_addr_le_t addr;
-	int8_t         rssi;
+    bt_addr_le_t addr;
+    int8_t rssi;
 } __packed;
 
 /* Event mask bits */
@@ -243,133 +243,133 @@ struct bt_hci_evt_vs_scan_req_rx {
 #define BT_HCI_MESH_EVT_PREFIX                 0xF0
 
 struct bt_hci_cp_mesh {
-	uint8_t         opcode;
+    uint8_t opcode;
 } __packed;
 
 #define BT_HCI_OC_MESH_GET_OPTS                0x00
 struct bt_hci_rp_mesh_get_opts {
-	uint8_t      status;
-	uint8_t      opcode;
-	uint8_t      revision;
-	uint8_t      ch_map;
-	int8_t      min_tx_power;
-	int8_t      max_tx_power;
-	uint8_t      max_scan_filter;
-	uint8_t      max_filter_pattern;
-	uint8_t      max_adv_slot;
-	uint8_t      max_tx_window;
-	uint8_t      evt_prefix_len;
-	uint8_t      evt_prefix;
+    uint8_t status;
+    uint8_t opcode;
+    uint8_t revision;
+    uint8_t ch_map;
+    int8_t min_tx_power;
+    int8_t max_tx_power;
+    uint8_t max_scan_filter;
+    uint8_t max_filter_pattern;
+    uint8_t max_adv_slot;
+    uint8_t max_tx_window;
+    uint8_t evt_prefix_len;
+    uint8_t evt_prefix;
 } __packed;
 
 #define BT_HCI_MESH_PATTERN_LEN_MAX            0x0f
 
 #define BT_HCI_OC_MESH_SET_SCAN_FILTER         0x01
 struct bt_hci_mesh_pattern {
-	uint8_t pattern_len;
-	uint8_t pattern[];
+    uint8_t pattern_len;
+    uint8_t pattern[];
 } __packed;
 
 struct bt_hci_cp_mesh_set_scan_filter {
-	uint8_t      scan_filter;
-	uint8_t      filter_dup;
-	uint8_t      num_patterns;
-	struct    bt_hci_mesh_pattern patterns[];
+    uint8_t scan_filter;
+    uint8_t filter_dup;
+    uint8_t num_patterns;
+    struct    bt_hci_mesh_pattern patterns[];
 } __packed;
 struct bt_hci_rp_mesh_set_scan_filter {
-	uint8_t      status;
-	uint8_t      opcode;
-	uint8_t      scan_filter;
+    uint8_t status;
+    uint8_t opcode;
+    uint8_t scan_filter;
 } __packed;
 
 #define BT_HCI_OC_MESH_ADVERTISE               0x02
 struct bt_hci_cp_mesh_advertise {
-	uint8_t      adv_slot;
-	uint8_t      own_addr_type;
-	bt_addr_t random_addr;
-	uint8_t      ch_map;
-	int8_t      tx_power;
-	uint8_t      min_tx_delay;
-	uint8_t      max_tx_delay;
-	uint8_t      retx_count;
-	uint8_t      retx_interval;
-	uint8_t      scan_delay;
-	uint16_t     scan_duration;
-	uint8_t      scan_filter;
-	uint8_t      data_len;
-	uint8_t      data[31];
+    uint8_t adv_slot;
+    uint8_t own_addr_type;
+    bt_addr_t random_addr;
+    uint8_t ch_map;
+    int8_t tx_power;
+    uint8_t min_tx_delay;
+    uint8_t max_tx_delay;
+    uint8_t retx_count;
+    uint8_t retx_interval;
+    uint8_t scan_delay;
+    uint16_t scan_duration;
+    uint8_t scan_filter;
+    uint8_t data_len;
+    uint8_t data[31];
 } __packed;
 struct bt_hci_rp_mesh_advertise {
-	uint8_t      status;
-	uint8_t      opcode;
-	uint8_t      adv_slot;
+    uint8_t status;
+    uint8_t opcode;
+    uint8_t adv_slot;
 } __packed;
 
 #define BT_HCI_OC_MESH_ADVERTISE_TIMED         0x03
 struct bt_hci_cp_mesh_advertise_timed {
-	uint8_t      adv_slot;
-	uint8_t      own_addr_type;
-	bt_addr_t random_addr;
-	uint8_t      ch_map;
-	int8_t      tx_power;
-	uint8_t      retx_count;
-	uint8_t      retx_interval;
-	uint32_t     instant;
-	uint16_t     tx_delay;
-	uint16_t     tx_window;
-	uint8_t      data_len;
-	uint8_t      data[31];
+    uint8_t adv_slot;
+    uint8_t own_addr_type;
+    bt_addr_t random_addr;
+    uint8_t ch_map;
+    int8_t tx_power;
+    uint8_t retx_count;
+    uint8_t retx_interval;
+    uint32_t instant;
+    uint16_t tx_delay;
+    uint16_t tx_window;
+    uint8_t data_len;
+    uint8_t data[31];
 } __packed;
 struct bt_hci_rp_mesh_advertise_timed {
-	uint8_t      status;
-	uint8_t      opcode;
-	uint8_t      adv_slot;
+    uint8_t status;
+    uint8_t opcode;
+    uint8_t adv_slot;
 } __packed;
 
 #define BT_HCI_OC_MESH_ADVERTISE_CANCEL        0x04
 struct bt_hci_cp_mesh_advertise_cancel {
-	uint8_t      adv_slot;
+    uint8_t adv_slot;
 } __packed;
 struct bt_hci_rp_mesh_advertise_cancel {
-	uint8_t      status;
-	uint8_t      opcode;
-	uint8_t      adv_slot;
+    uint8_t status;
+    uint8_t opcode;
+    uint8_t adv_slot;
 } __packed;
 
 #define BT_HCI_OC_MESH_SET_SCANNING            0x05
 struct bt_hci_cp_mesh_set_scanning {
-	uint8_t      enable;
-	uint8_t      ch_map;
-	uint8_t      scan_filter;
+    uint8_t enable;
+    uint8_t ch_map;
+    uint8_t scan_filter;
 } __packed;
 struct bt_hci_rp_mesh_set_scanning {
-	uint8_t      status;
-	uint8_t      opcode;
+    uint8_t status;
+    uint8_t opcode;
 } __packed;
 
 /* Events */
 struct bt_hci_evt_mesh {
-	uint8_t  prefix;
-	uint8_t  subevent;
+    uint8_t prefix;
+    uint8_t subevent;
 } __packed;
 
 #define BT_HCI_EVT_MESH_ADV_COMPLETE           0x00
 struct bt_hci_evt_mesh_adv_complete {
-	uint8_t         adv_slot;
+    uint8_t adv_slot;
 } __packed;
 
 #define BT_HCI_EVT_MESH_SCANNING_REPORT        0x01
 struct bt_hci_evt_mesh_scan_report {
-	bt_addr_le_t addr;
-	uint8_t         chan;
-	int8_t         rssi;
-	uint32_t        instant;
-	uint8_t         data_len;
-	uint8_t         data[];
+    bt_addr_le_t addr;
+    uint8_t chan;
+    int8_t rssi;
+    uint32_t instant;
+    uint8_t data_len;
+    uint8_t data[];
 } __packed;
 struct bt_hci_evt_mesh_scanning_report {
-	uint8_t num_reports;
-	struct bt_hci_evt_mesh_scan_report reports[];
+    uint8_t num_reports;
+    struct bt_hci_evt_mesh_scan_report reports[];
 } __packed;
 
 #ifdef __cplusplus
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/l2cap_internal.h b/devices/ble_hci/common-hal/_bleio/hci_include/l2cap_internal.h
index a0a2ed056..b2e7fb450 100644
--- a/devices/ble_hci/common-hal/_bleio/hci_include/l2cap_internal.h
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/l2cap_internal.h
@@ -15,8 +15,8 @@
 #include <string.h>
 
 enum l2cap_conn_list_action {
-	BT_L2CAP_CHAN_LOOKUP,
-	BT_L2CAP_CHAN_DETACH,
+    BT_L2CAP_CHAN_LOOKUP,
+    BT_L2CAP_CHAN_DETACH,
 };
 
 #define BT_L2CAP_CID_BR_SIG             0x0001
@@ -28,14 +28,14 @@ enum l2cap_conn_list_action {
 #define BT_L2CAP_PSM_RFCOMM             0x0003
 
 struct bt_l2cap_hdr {
-	uint16_t len;
-	uint16_t cid;
+    uint16_t len;
+    uint16_t cid;
 } __packed;
 
 struct bt_l2cap_sig_hdr {
-	uint8_t  code;
-	uint8_t  ident;
-	uint16_t len;
+    uint8_t code;
+    uint8_t ident;
+    uint16_t len;
 } __packed;
 
 #define BT_L2CAP_REJ_NOT_UNDERSTOOD     0x0000
@@ -44,19 +44,19 @@ struct bt_l2cap_sig_hdr {
 
 #define BT_L2CAP_CMD_REJECT             0x01
 struct bt_l2cap_cmd_reject {
-	uint16_t reason;
-	uint8_t  data[];
+    uint16_t reason;
+    uint8_t data[];
 } __packed;
 
 struct bt_l2cap_cmd_reject_cid_data {
-	uint16_t scid;
-	uint16_t dcid;
+    uint16_t scid;
+    uint16_t dcid;
 } __packed;
 
 #define BT_L2CAP_CONN_REQ               0x02
 struct bt_l2cap_conn_req {
-	uint16_t psm;
-	uint16_t scid;
+    uint16_t psm;
+    uint16_t scid;
 } __packed;
 
 /* command statuses in reposnse */
@@ -74,10 +74,10 @@ struct bt_l2cap_conn_req {
 
 #define BT_L2CAP_CONN_RSP               0x03
 struct bt_l2cap_conn_rsp {
-	uint16_t dcid;
-	uint16_t scid;
-	uint16_t result;
-	uint16_t status;
+    uint16_t dcid;
+    uint16_t scid;
+    uint16_t result;
+    uint16_t status;
 } __packed;
 
 #define BT_L2CAP_CONF_SUCCESS           0x0000
@@ -86,17 +86,17 @@ struct bt_l2cap_conn_rsp {
 
 #define BT_L2CAP_CONF_REQ               0x04
 struct bt_l2cap_conf_req {
-	uint16_t dcid;
-	uint16_t flags;
-	uint8_t  data[];
+    uint16_t dcid;
+    uint16_t flags;
+    uint8_t data[];
 } __packed;
 
 #define BT_L2CAP_CONF_RSP               0x05
 struct bt_l2cap_conf_rsp {
-	uint16_t scid;
-	uint16_t flags;
-	uint16_t result;
-	uint8_t  data[];
+    uint16_t scid;
+    uint16_t flags;
+    uint16_t result;
+    uint8_t data[];
 } __packed;
 
 /* Option type used by MTU config request data */
@@ -106,21 +106,21 @@ struct bt_l2cap_conf_rsp {
 #define BT_L2CAP_CONF_MASK              0x7f
 
 struct bt_l2cap_conf_opt {
-	uint8_t type;
-	uint8_t len;
-	uint8_t data[];
+    uint8_t type;
+    uint8_t len;
+    uint8_t data[];
 } __packed;
 
 #define BT_L2CAP_DISCONN_REQ            0x06
 struct bt_l2cap_disconn_req {
-	uint16_t dcid;
-	uint16_t scid;
+    uint16_t dcid;
+    uint16_t scid;
 } __packed;
 
 #define BT_L2CAP_DISCONN_RSP            0x07
 struct bt_l2cap_disconn_rsp {
-	uint16_t dcid;
-	uint16_t scid;
+    uint16_t dcid;
+    uint16_t scid;
 } __packed;
 
 #define BT_L2CAP_INFO_FEAT_MASK         0x0002
@@ -128,7 +128,7 @@ struct bt_l2cap_disconn_rsp {
 
 #define BT_L2CAP_INFO_REQ               0x0a
 struct bt_l2cap_info_req {
-	uint16_t type;
+    uint16_t type;
 } __packed;
 
 /* info result */
@@ -137,17 +137,17 @@ struct bt_l2cap_info_req {
 
 #define BT_L2CAP_INFO_RSP               0x0b
 struct bt_l2cap_info_rsp {
-	uint16_t type;
-	uint16_t result;
-	uint8_t  data[];
+    uint16_t type;
+    uint16_t result;
+    uint8_t data[];
 } __packed;
 
 #define BT_L2CAP_CONN_PARAM_REQ         0x12
 struct bt_l2cap_conn_param_req {
-	uint16_t min_interval;
-	uint16_t max_interval;
-	uint16_t latency;
-	uint16_t timeout;
+    uint16_t min_interval;
+    uint16_t max_interval;
+    uint16_t latency;
+    uint16_t timeout;
 } __packed;
 
 #define BT_L2CAP_CONN_PARAM_ACCEPTED    0x0000
@@ -155,16 +155,16 @@ struct bt_l2cap_conn_param_req {
 
 #define BT_L2CAP_CONN_PARAM_RSP         0x13
 struct bt_l2cap_conn_param_rsp {
-	uint16_t result;
+    uint16_t result;
 } __packed;
 
 #define BT_L2CAP_LE_CONN_REQ            0x14
 struct bt_l2cap_le_conn_req {
-	uint16_t psm;
-	uint16_t scid;
-	uint16_t mtu;
-	uint16_t mps;
-	uint16_t credits;
+    uint16_t psm;
+    uint16_t scid;
+    uint16_t mtu;
+    uint16_t mps;
+    uint16_t credits;
 } __packed;
 
 /* valid results in conn response on LE */
@@ -182,42 +182,42 @@ struct bt_l2cap_le_conn_req {
 
 #define BT_L2CAP_LE_CONN_RSP            0x15
 struct bt_l2cap_le_conn_rsp {
-	uint16_t dcid;
-	uint16_t mtu;
-	uint16_t mps;
-	uint16_t credits;
-	uint16_t result;
+    uint16_t dcid;
+    uint16_t mtu;
+    uint16_t mps;
+    uint16_t credits;
+    uint16_t result;
 } __packed;
 
 #define BT_L2CAP_LE_CREDITS             0x16
 struct bt_l2cap_le_credits {
-	uint16_t cid;
-	uint16_t credits;
+    uint16_t cid;
+    uint16_t credits;
 } __packed;
 
 #define BT_L2CAP_ECRED_CONN_REQ         0x17
 struct bt_l2cap_ecred_conn_req {
-	uint16_t psm;
-	uint16_t mtu;
-	uint16_t mps;
-	uint16_t credits;
-	uint16_t scid[];
+    uint16_t psm;
+    uint16_t mtu;
+    uint16_t mps;
+    uint16_t credits;
+    uint16_t scid[];
 } __packed;
 
 #define BT_L2CAP_ECRED_CONN_RSP         0x18
 struct bt_l2cap_ecred_conn_rsp {
-	uint16_t mtu;
-	uint16_t mps;
-	uint16_t credits;
-	uint16_t result;
-	uint16_t dcid[];
+    uint16_t mtu;
+    uint16_t mps;
+    uint16_t credits;
+    uint16_t result;
+    uint16_t dcid[];
 } __packed;
 
 #define BT_L2CAP_ECRED_RECONF_REQ       0x19
 struct bt_l2cap_ecred_reconf_req {
-	uint16_t mtu;
-	uint16_t mps;
-	uint16_t scid[];
+    uint16_t mtu;
+    uint16_t mps;
+    uint16_t scid[];
 } __packed;
 
 #define BT_L2CAP_RECONF_SUCCESS         0x0000
@@ -226,5 +226,5 @@ struct bt_l2cap_ecred_reconf_req {
 
 #define BT_L2CAP_ECRED_RECONF_RSP       0x1a
 struct bt_l2cap_ecred_reconf_rsp {
-	uint16_t result;
+    uint16_t result;
 } __packed;