diff --git a/devices/ble_hci/common-hal/_bleio/Characteristic.c b/devices/ble_hci/common-hal/_bleio/Characteristic.c
index a33b8ff478472..49b66d38e7256 100644
--- a/devices/ble_hci/common-hal/_bleio/Characteristic.c
+++ b/devices/ble_hci/common-hal/_bleio/Characteristic.c
@@ -180,7 +180,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
     }
 
     const uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
-    common_hal_bleio_check_connected(conn_handle);
+    bleio_check_connected(conn_handle);
 
     uint16_t cccd_value =
         (notify ? CCCD_NOTIFY : 0) |
diff --git a/devices/ble_hci/common-hal/_bleio/Connection.h b/devices/ble_hci/common-hal/_bleio/Connection.h
index 04edb104ddcb2..02a000501bfde 100644
--- a/devices/ble_hci/common-hal/_bleio/Connection.h
+++ b/devices/ble_hci/common-hal/_bleio/Connection.h
@@ -61,6 +61,7 @@ typedef struct {
     uint8_t disconnect_reason;
 } bleio_connection_obj_t;
 
+void bleio_check_connected(uint16_t conn_handle);
 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);
 bleio_connection_internal_t *bleio_conn_handle_to_connection(uint16_t conn_handle);
diff --git a/devices/ble_hci/common-hal/_bleio/__init__.c b/devices/ble_hci/common-hal/_bleio/__init__.c
index 6376f6f10c8c9..f9fdbc50f6489 100644
--- a/devices/ble_hci/common-hal/_bleio/__init__.c
+++ b/devices/ble_hci/common-hal/_bleio/__init__.c
@@ -84,7 +84,7 @@ bleio_adapter_obj_t *common_hal_bleio_allocate_adapter_or_raise(void) {
     return &common_hal_bleio_adapter_obj;
 }
 
-void common_hal_bleio_check_connected(uint16_t conn_handle) {
+void bleio_check_connected(uint16_t conn_handle) {
     if (conn_handle == BLE_CONN_HANDLE_INVALID) {
         mp_raise_ConnectionError(MP_ERROR_TEXT("Not connected"));
     }
diff --git a/locale/circuitpython.pot b/locale/circuitpython.pot
index e2eebdea0fe04..2b67216cf506a 100644
--- a/locale/circuitpython.pot
+++ b/locale/circuitpython.pot
@@ -476,7 +476,7 @@ msgstr ""
 msgid "AP could not be started"
 msgstr ""
 
-#: shared-bindings/_bleio/Address.c shared-bindings/ipaddress/IPv4Address.c
+#: shared-bindings/ipaddress/IPv4Address.c
 #, c-format
 msgid "Address must be %d bytes long"
 msgstr ""
@@ -673,11 +673,6 @@ msgstr ""
 msgid "Brightness not adjustable"
 msgstr ""
 
-#: shared-bindings/_bleio/UUID.c
-#, c-format
-msgid "Buffer + offset too small %d %d %d"
-msgstr ""
-
 #: ports/raspberrypi/bindings/rp2pio/StateMachine.c
 msgid "Buffer elements must be 4 bytes long or less"
 msgstr ""
@@ -720,10 +715,6 @@ msgstr ""
 msgid "Bus pin %d is already in use"
 msgstr ""
 
-#: shared-bindings/_bleio/UUID.c
-msgid "Byte buffer must be 16 bytes."
-msgstr ""
-
 #: shared-bindings/aesio/aes.c
 msgid "CBC blocks must be multiples of 16 bytes"
 msgstr ""
@@ -1029,12 +1020,18 @@ msgstr ""
 msgid "Failed to buffer the sample"
 msgstr ""
 
+#: ports/zephyr-cp/common-hal/_bleio/Adapter.c
+msgid "Failed to connect"
+msgstr ""
+
 #: ports/espressif/common-hal/_bleio/Adapter.c
 #: ports/nordic/common-hal/_bleio/Adapter.c
+#: ports/zephyr-cp/common-hal/_bleio/Adapter.c
 msgid "Failed to connect: internal error"
 msgstr ""
 
 #: ports/nordic/common-hal/_bleio/Adapter.c
+#: ports/zephyr-cp/common-hal/_bleio/Adapter.c
 msgid "Failed to connect: timeout"
 msgstr ""
 
@@ -2247,10 +2244,6 @@ msgstr ""
 msgid "USB error"
 msgstr ""
 
-#: shared-bindings/_bleio/UUID.c
-msgid "UUID integer value must be 0-0xffff"
-msgstr ""
-
 #: shared-bindings/_bleio/UUID.c
 msgid "UUID string not 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'"
 msgstr ""
@@ -3393,10 +3386,6 @@ msgstr ""
 msgid "initial values must be iterable"
 msgstr ""
 
-#: shared-bindings/_bleio/Characteristic.c shared-bindings/_bleio/Descriptor.c
-msgid "initial_value length is wrong"
-msgstr ""
-
 #: py/compile.c
 msgid "inline assembler must be a function"
 msgstr ""
@@ -3808,7 +3797,6 @@ msgid "non-hex digit"
 msgstr ""
 
 #: ports/nordic/common-hal/_bleio/Adapter.c
-#: ports/zephyr-cp/common-hal/_bleio/Adapter.c
 msgid "non-zero timeout must be > 0.01"
 msgstr ""
 
@@ -4292,7 +4280,6 @@ msgid "timeout duration exceeded the maximum supported value"
 msgstr ""
 
 #: ports/nordic/common-hal/_bleio/Adapter.c
-#: ports/zephyr-cp/common-hal/_bleio/Adapter.c
 msgid "timeout must be < 655.35 secs"
 msgstr ""
 
diff --git a/ports/espressif/common-hal/_bleio/Characteristic.c b/ports/espressif/common-hal/_bleio/Characteristic.c
index 805c6d160f325..736c61c650eb4 100644
--- a/ports/espressif/common-hal/_bleio/Characteristic.c
+++ b/ports/espressif/common-hal/_bleio/Characteristic.c
@@ -320,7 +320,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
     }
 
     const uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
-    common_hal_bleio_check_connected(conn_handle);
+    bleio_check_connected(conn_handle);
 
     uint16_t cccd_value =
         (notify ? 1 << 0 : 0) |
diff --git a/ports/espressif/common-hal/_bleio/Connection.h b/ports/espressif/common-hal/_bleio/Connection.h
index 326eca02ecd8a..5f33eb43b5df9 100644
--- a/ports/espressif/common-hal/_bleio/Connection.h
+++ b/ports/espressif/common-hal/_bleio/Connection.h
@@ -64,6 +64,7 @@ void bleio_connection_clear(bleio_connection_internal_t *self);
 
 int bleio_connection_event_cb(struct ble_gap_event *event, void *connection_in);
 
+void bleio_check_connected(uint16_t conn_handle);
 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);
 bleio_connection_internal_t *bleio_conn_handle_to_connection(uint16_t conn_handle);
diff --git a/ports/espressif/common-hal/_bleio/__init__.c b/ports/espressif/common-hal/_bleio/__init__.c
index 119fe55921e8a..4fdd0a48a2000 100644
--- a/ports/espressif/common-hal/_bleio/__init__.c
+++ b/ports/espressif/common-hal/_bleio/__init__.c
@@ -155,7 +155,7 @@ void check_notify(BaseType_t result) {
     mp_raise_msg(&mp_type_TimeoutError, NULL);
 }
 
-void common_hal_bleio_check_connected(uint16_t conn_handle) {
+void bleio_check_connected(uint16_t conn_handle) {
     if (conn_handle == BLEIO_HANDLE_INVALID) {
         mp_raise_ConnectionError(MP_ERROR_TEXT("Not connected"));
     }
diff --git a/ports/nordic/common-hal/_bleio/Attribute.h b/ports/nordic/common-hal/_bleio/Attribute.h
index 5fa6b4d637767..9a58e16bb862e 100644
--- a/ports/nordic/common-hal/_bleio/Attribute.h
+++ b/ports/nordic/common-hal/_bleio/Attribute.h
@@ -6,6 +6,15 @@
 
 #pragma once
 
+#include <stdbool.h>
+
+#include "py/obj.h"
+
 #include "shared-module/_bleio/Attribute.h"
 
 extern void bleio_attribute_gatts_set_security_mode(ble_gap_conn_sec_mode_t *perm, bleio_attribute_security_mode_t security_mode);
+
+size_t bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len);
+void bleio_gatts_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo);
+size_t bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len);
+void bleio_gattc_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo, bool write_no_response);
diff --git a/ports/nordic/common-hal/_bleio/Characteristic.c b/ports/nordic/common-hal/_bleio/Characteristic.c
index 51335be9e59be..2e6042e48e7fb 100644
--- a/ports/nordic/common-hal/_bleio/Characteristic.c
+++ b/ports/nordic/common-hal/_bleio/Characteristic.c
@@ -138,10 +138,10 @@ size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *sel
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
         if (common_hal_bleio_service_get_is_remote(self->service)) {
-            return common_hal_bleio_gattc_read(self->handle, conn_handle, buf, len);
+            return bleio_gattc_read(self->handle, conn_handle, buf, len);
         } else {
             // conn_handle is ignored for non-system attributes.
-            return common_hal_bleio_gatts_read(self->handle, conn_handle, buf, len);
+            return bleio_gatts_read(self->handle, conn_handle, buf, len);
         }
     }
 
@@ -159,7 +159,7 @@ void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self,
         if (common_hal_bleio_service_get_is_remote(self->service)) {
             uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
             // Last argument is true if write-no-reponse desired.
-            common_hal_bleio_gattc_write(self->handle, conn_handle, bufinfo,
+            bleio_gattc_write(self->handle, conn_handle, bufinfo,
                 (self->props & CHAR_PROP_WRITE_NO_RESPONSE));
         } else {
             // Validate data length for local characteristics only.
@@ -172,7 +172,7 @@ void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self,
 
             // Always write the value locally even if no connections are active.
             // conn_handle is ignored for non-system attributes, so we use BLE_CONN_HANDLE_INVALID.
-            common_hal_bleio_gatts_write(self->handle, BLE_CONN_HANDLE_INVALID, bufinfo);
+            bleio_gatts_write(self->handle, BLE_CONN_HANDLE_INVALID, bufinfo);
             // Check to see if we need to notify or indicate any active connections.
             for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
                 bleio_connection_internal_t *connection = &bleio_connections[i];
@@ -255,7 +255,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
     }
 
     const uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
-    common_hal_bleio_check_connected(conn_handle);
+    bleio_check_connected(conn_handle);
 
     uint16_t cccd_value =
         (notify ? BLE_GATT_HVX_NOTIFICATION : 0) |
diff --git a/ports/nordic/common-hal/_bleio/Connection.h b/ports/nordic/common-hal/_bleio/Connection.h
index 110677dc78b41..ea1edf1760311 100644
--- a/ports/nordic/common-hal/_bleio/Connection.h
+++ b/ports/nordic/common-hal/_bleio/Connection.h
@@ -65,6 +65,7 @@ typedef struct {
 void bleio_connection_clear(bleio_connection_internal_t *self);
 bool connection_on_ble_evt(ble_evt_t *ble_evt, void *self_in);
 
+void bleio_check_connected(uint16_t conn_handle);
 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);
 bleio_connection_internal_t *bleio_conn_handle_to_connection(uint16_t conn_handle);
diff --git a/ports/nordic/common-hal/_bleio/Descriptor.c b/ports/nordic/common-hal/_bleio/Descriptor.c
index 959c8e5c9c0c0..0d27ca5dc2edf 100644
--- a/ports/nordic/common-hal/_bleio/Descriptor.c
+++ b/ports/nordic/common-hal/_bleio/Descriptor.c
@@ -43,9 +43,9 @@ size_t common_hal_bleio_descriptor_get_value(bleio_descriptor_obj_t *self, uint8
     if (self->handle != BLE_GATT_HANDLE_INVALID) {
         uint16_t conn_handle = bleio_connection_get_conn_handle(self->characteristic->service->connection);
         if (common_hal_bleio_service_get_is_remote(self->characteristic->service)) {
-            return common_hal_bleio_gattc_read(self->handle, conn_handle, buf, len);
+            return bleio_gattc_read(self->handle, conn_handle, buf, len);
         } else {
-            return common_hal_bleio_gatts_read(self->handle, conn_handle, buf, len);
+            return bleio_gatts_read(self->handle, conn_handle, buf, len);
         }
     }
 
@@ -58,7 +58,7 @@ void common_hal_bleio_descriptor_set_value(bleio_descriptor_obj_t *self, mp_buff
         uint16_t conn_handle = bleio_connection_get_conn_handle(self->characteristic->service->connection);
         if (common_hal_bleio_service_get_is_remote(self->characteristic->service)) {
             // false means WRITE_REQ, not write-no-response
-            common_hal_bleio_gattc_write(self->handle, conn_handle, bufinfo, false);
+            bleio_gattc_write(self->handle, conn_handle, bufinfo, false);
         } else {
             // Validate data length for local descriptors only.
             if (self->fixed_length && bufinfo->len != self->max_length) {
@@ -68,7 +68,7 @@ void common_hal_bleio_descriptor_set_value(bleio_descriptor_obj_t *self, mp_buff
                 mp_raise_ValueError(MP_ERROR_TEXT("Value length > max_length"));
             }
 
-            common_hal_bleio_gatts_write(self->handle, conn_handle, bufinfo);
+            bleio_gatts_write(self->handle, conn_handle, bufinfo);
         }
     }
 
diff --git a/ports/nordic/common-hal/_bleio/__init__.c b/ports/nordic/common-hal/_bleio/__init__.c
index 454937dcd354a..9dc58d7687c90 100644
--- a/ports/nordic/common-hal/_bleio/__init__.c
+++ b/ports/nordic/common-hal/_bleio/__init__.c
@@ -112,14 +112,14 @@ void bleio_reset(void) {
 // It currently only has properties and no state. Inited by bleio_reset
 bleio_adapter_obj_t common_hal_bleio_adapter_obj;
 
-void common_hal_bleio_check_connected(uint16_t conn_handle) {
+void bleio_check_connected(uint16_t conn_handle) {
     if (conn_handle == BLE_CONN_HANDLE_INVALID) {
         mp_raise_ConnectionError(MP_ERROR_TEXT("Not connected"));
     }
 }
 
 // GATTS read of a Characteristic or Descriptor.
-size_t common_hal_bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
+size_t bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
     // conn_handle is ignored unless this is a system attribute.
     // If we're not connected, that's OK, because we can still read and write the local value.
 
@@ -133,7 +133,7 @@ size_t common_hal_bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_
     return gatts_value.len;
 }
 
-void common_hal_bleio_gatts_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo) {
+void bleio_gatts_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo) {
     // conn_handle is ignored unless this is a system attribute.
     // If we're not connected, that's OK, because we can still read and write the local value.
 
@@ -188,8 +188,8 @@ static bool _on_gattc_read_rsp_evt(ble_evt_t *ble_evt, void *param) {
     return true;
 }
 
-size_t common_hal_bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
-    common_hal_bleio_check_connected(conn_handle);
+size_t bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
+    bleio_check_connected(conn_handle);
 
     read_info_t read_info;
     read_info.buf = buf;
@@ -213,15 +213,15 @@ size_t common_hal_bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_
         RUN_BACKGROUND_TASKS;
     }
     // Test if we were disconnected while reading
-    common_hal_bleio_check_connected(read_info.conn_handle);
+    bleio_check_connected(read_info.conn_handle);
 
     ble_drv_remove_event_handler(_on_gattc_read_rsp_evt, &read_info);
     check_gatt_status(read_info.status);
     return read_info.final_len;
 }
 
-void common_hal_bleio_gattc_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo, bool write_no_response) {
-    common_hal_bleio_check_connected(conn_handle);
+void bleio_gattc_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo, bool write_no_response) {
+    bleio_check_connected(conn_handle);
 
     ble_gattc_write_params_t write_params = {
         .write_op = write_no_response ? BLE_GATT_OP_WRITE_CMD: BLE_GATT_OP_WRITE_REQ,
diff --git a/ports/silabs/common-hal/_bleio/Characteristic.c b/ports/silabs/common-hal/_bleio/Characteristic.c
index a707b0ef1acc3..9ccc6ad9c364e 100644
--- a/ports/silabs/common-hal/_bleio/Characteristic.c
+++ b/ports/silabs/common-hal/_bleio/Characteristic.c
@@ -395,7 +395,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
 
     const uint16_t conn_handle = bleio_connection_get_conn_handle(
         self->service->connection);
-    common_hal_bleio_check_connected(conn_handle);
+    bleio_check_connected(conn_handle);
     notify = 1;
     indicate = 0;
     if (notify) {
diff --git a/ports/silabs/common-hal/_bleio/Connection.h b/ports/silabs/common-hal/_bleio/Connection.h
index 56872024c932c..148caecba1101 100644
--- a/ports/silabs/common-hal/_bleio/Connection.h
+++ b/ports/silabs/common-hal/_bleio/Connection.h
@@ -85,6 +85,7 @@ typedef struct
 
 void bleio_connection_clear(bleio_connection_internal_t *self);
 
+void bleio_check_connected(uint16_t conn_handle);
 uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self);
 
 mp_obj_t bleio_connection_new_from_internal(
diff --git a/ports/silabs/common-hal/_bleio/__init__.c b/ports/silabs/common-hal/_bleio/__init__.c
index c6ae8a0b606c8..4c5ce1f045d72 100644
--- a/ports/silabs/common-hal/_bleio/__init__.c
+++ b/ports/silabs/common-hal/_bleio/__init__.c
@@ -102,7 +102,7 @@ void check_ble_error(int error_code) {
     }
 }
 
-void common_hal_bleio_check_connected(uint16_t conn_handle) {
+void bleio_check_connected(uint16_t conn_handle) {
     if (conn_handle == BLEIO_HANDLE_INVALID) {
         mp_raise_ConnectionError(MP_ERROR_TEXT("Not connected"));
     }
diff --git a/ports/zephyr-cp/boards/nrf5340bsim_nrf5340_cpuapp.conf b/ports/zephyr-cp/boards/nrf5340bsim_nrf5340_cpuapp.conf
index 02e4e0d0d5647..57628a61e2057 100644
--- a/ports/zephyr-cp/boards/nrf5340bsim_nrf5340_cpuapp.conf
+++ b/ports/zephyr-cp/boards/nrf5340bsim_nrf5340_cpuapp.conf
@@ -6,9 +6,22 @@ CONFIG_GPIO=y
 # Enable Bluetooth stack - bsim is for BT simulation
 CONFIG_BT=y
 CONFIG_BT_HCI=y
+CONFIG_BT_PERIPHERAL=y
+CONFIG_BT_CENTRAL=y
 CONFIG_BT_OBSERVER=y
 CONFIG_BT_BROADCASTER=y
 
+CONFIG_BT_L2CAP_TX_MTU=253
+CONFIG_BT_BUF_CMD_TX_COUNT=2
+CONFIG_BT_BUF_CMD_TX_SIZE=255
+CONFIG_BT_HCI_VS=y
+CONFIG_BT_BUF_EVT_RX_COUNT=16
+CONFIG_BT_BUF_EVT_RX_SIZE=255
+CONFIG_BT_BUF_ACL_TX_COUNT=3
+CONFIG_BT_BUF_ACL_TX_SIZE=251
+CONFIG_BT_BUF_ACL_RX_COUNT_EXTRA=1
+CONFIG_BT_BUF_ACL_RX_SIZE=255
+
 CONFIG_BT_DEVICE_NAME_DYNAMIC=y
 CONFIG_BT_DEVICE_NAME_MAX=28
 
diff --git a/ports/zephyr-cp/common-hal/_bleio/Adapter.c b/ports/zephyr-cp/common-hal/_bleio/Adapter.c
index d72a7bed865af..d1410f02e1b12 100644
--- a/ports/zephyr-cp/common-hal/_bleio/Adapter.c
+++ b/ports/zephyr-cp/common-hal/_bleio/Adapter.c
@@ -11,9 +11,11 @@
 
 #include <zephyr/bluetooth/addr.h>
 #include <zephyr/bluetooth/bluetooth.h>
+#include <zephyr/bluetooth/conn.h>
 #include <zephyr/bluetooth/hci.h>
-#include <zephyr/kernel.h>
+#include <zephyr/bluetooth/hci_vs.h>
 
+#include "py/gc.h"
 #include "py/runtime.h"
 #include "bindings/zephyr_kernel/__init__.h"
 #include "shared-bindings/_bleio/__init__.h"
@@ -62,6 +64,110 @@ static uint8_t bleio_address_type_from_zephyr(const bt_addr_le_t *addr) {
     }
 }
 
+static uint8_t bleio_address_type_to_zephyr(uint8_t type) {
+    switch (type) {
+        case BLEIO_ADDRESS_TYPE_PUBLIC:
+            return BT_ADDR_LE_PUBLIC;
+        case BLEIO_ADDRESS_TYPE_RANDOM_STATIC:
+        case BLEIO_ADDRESS_TYPE_RANDOM_PRIVATE_RESOLVABLE:
+        case BLEIO_ADDRESS_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE:
+            return BT_ADDR_LE_RANDOM;
+        default:
+            return BT_ADDR_LE_PUBLIC;
+    }
+}
+
+static bleio_connection_internal_t *bleio_connection_find_by_conn(const struct bt_conn *conn) {
+    for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
+        bleio_connection_internal_t *connection = &bleio_connections[i];
+        if (connection->conn == conn) {
+            return connection;
+        }
+    }
+
+    return NULL;
+}
+
+static bleio_connection_internal_t *bleio_connection_track(struct bt_conn *conn) {
+    bleio_connection_internal_t *connection = bleio_connection_find_by_conn(conn);
+    if (connection == NULL) {
+        for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
+            bleio_connection_internal_t *candidate = &bleio_connections[i];
+            if (candidate->conn == NULL) {
+                connection = candidate;
+                break;
+            }
+        }
+    }
+
+    if (connection == NULL) {
+        return NULL;
+    }
+
+    if (connection->conn == NULL) {
+        connection->conn = bt_conn_ref(conn);
+    }
+
+    return connection;
+}
+
+static void bleio_connection_clear(bleio_connection_internal_t *self) {
+    if (self == NULL) {
+        return;
+    }
+
+    if (self->conn != NULL) {
+        bt_conn_unref(self->conn);
+        self->conn = NULL;
+    }
+
+    self->connection_obj = mp_const_none;
+}
+
+static void bleio_connection_release(bleio_connection_internal_t *connection, uint8_t reason) {
+    if (connection == NULL) {
+        return;
+    }
+
+    if (connection->connection_obj != mp_const_none) {
+        bleio_connection_obj_t *connection_obj = MP_OBJ_TO_PTR(connection->connection_obj);
+        connection_obj->connection = NULL;
+        connection_obj->disconnect_reason = reason;
+    }
+
+    bleio_connection_clear(connection);
+    common_hal_bleio_adapter_obj.connection_objs = NULL;
+}
+
+static void bleio_connected_cb(struct bt_conn *conn, uint8_t err) {
+    if (err != 0) {
+        return;
+    }
+
+    if (bleio_connection_track(conn) == NULL) {
+        bt_conn_disconnect(conn, BT_HCI_ERR_CONN_LIMIT_EXCEEDED);
+        return;
+    }
+
+    // When connectable advertising results in a connection, the controller
+    // auto-stops advertising.  Clear our flag to match (we cannot call
+    // stop_advertising() here because this callback runs in Zephyr's BT
+    // thread context).
+    ble_advertising = false;
+
+    common_hal_bleio_adapter_obj.connection_objs = NULL;
+}
+
+static void bleio_disconnected_cb(struct bt_conn *conn, uint8_t reason) {
+    printk("disconnected %p\n", conn);
+    bleio_connection_release(bleio_connection_find_by_conn(conn), reason);
+}
+
+BT_CONN_CB_DEFINE(bleio_connection_callbacks) = {
+    .connected = bleio_connected_cb,
+    .disconnected = bleio_disconnected_cb,
+};
+
 static void scan_recv_cb(const struct bt_le_scan_recv_info *info, struct net_buf_simple *buf) {
     if (active_scan_results == NULL || info == NULL || buf == NULL) {
         return;
@@ -129,8 +235,27 @@ static size_t bleio_parse_adv_data(const uint8_t *raw, size_t raw_len, struct bt
     return count;
 }
 
+static uint16_t bleio_validate_and_convert_timeout(mp_float_t timeout) {
+    mp_arg_validate_float_range(timeout, 0, UINT16_MAX, MP_QSTR_timeout);
+
+    if (timeout <= 0.0f) {
+        return 0;
+    }
+
+    const mp_int_t timeout_units =
+        mp_arg_validate_int_range((mp_int_t)(timeout * 100.0f + 0.5f), 1, UINT16_MAX, MP_QSTR_timeout);
+
+    return (uint16_t)timeout_units;
+}
+
 void common_hal_bleio_adapter_set_enabled(bleio_adapter_obj_t *self, bool enabled) {
+    if (enabled == ble_adapter_enabled) {
+        return;
+    }
     if (enabled) {
+        for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
+            bleio_connection_clear(&bleio_connections[i]);
+        }
         if (!bt_is_ready()) {
             int err = bt_enable(NULL);
             if (err != 0) {
@@ -154,11 +279,48 @@ bool common_hal_bleio_adapter_get_enabled(bleio_adapter_obj_t *self) {
 }
 
 mp_int_t common_hal_bleio_adapter_get_tx_power(bleio_adapter_obj_t *self) {
-    mp_raise_NotImplementedError(NULL);
+    struct bt_hci_cp_vs_read_tx_power_level *cp;
+    struct bt_hci_rp_vs_read_tx_power_level *rp;
+    struct net_buf *buf, *rsp = NULL;
+
+    buf = bt_hci_cmd_alloc(K_MSEC(1000));
+    if (!buf) {
+        mp_raise_msg(&mp_type_MemoryError, NULL);
+    }
+    cp = net_buf_add(buf, sizeof(*cp));
+    cp->handle_type = BT_HCI_VS_LL_HANDLE_TYPE_ADV;
+    cp->handle = 0;
+
+    int err = bt_hci_cmd_send_sync(BT_HCI_OP_VS_READ_TX_POWER_LEVEL, buf, &rsp);
+    if (err) {
+        raise_zephyr_error(err);
+    }
+
+    rp = (void *)rsp->data;
+    int8_t power = rp->tx_power_level;
+    net_buf_unref(rsp);
+    return power;
 }
 
 void common_hal_bleio_adapter_set_tx_power(bleio_adapter_obj_t *self, mp_int_t tx_power) {
-    mp_raise_NotImplementedError(NULL);
+    struct bt_hci_cp_vs_write_tx_power_level *cp;
+    struct net_buf *buf, *rsp = NULL;
+
+    buf = bt_hci_cmd_alloc(K_MSEC(3000));
+    if (!buf) {
+        mp_raise_msg(&mp_type_MemoryError, NULL);
+    }
+    cp = net_buf_add(buf, sizeof(*cp));
+    cp->handle_type = BT_HCI_VS_LL_HANDLE_TYPE_ADV;
+    cp->handle = 0;
+    cp->tx_power_level = (int8_t)tx_power;
+
+    int err = bt_hci_cmd_send_sync(BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL, buf, &rsp);
+    if (err) {
+        raise_zephyr_error(err);
+    }
+
+    net_buf_unref(rsp);
 }
 
 bleio_address_obj_t *common_hal_bleio_adapter_get_address(bleio_adapter_obj_t *self) {
@@ -197,7 +359,6 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
     mp_buffer_info_t *advertising_data_bufinfo,
     mp_buffer_info_t *scan_response_data_bufinfo,
     mp_int_t tx_power, const bleio_address_obj_t *directed_to) {
-    (void)tx_power;
     (void)directed_to;
     (void)interval;
 
@@ -267,6 +428,8 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
             NULL);
     }
 
+    common_hal_bleio_adapter_set_tx_power(self, tx_power);
+
     raise_zephyr_error(bt_le_adv_start(&adv_params,
         adv_data,
         adv_count,
@@ -320,17 +483,7 @@ mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t
 
     uint16_t interval_units = (uint16_t)((interval / 0.000625f) + 0.5f);
     uint16_t window_units = (uint16_t)((window / 0.000625f) + 0.5f);
-    uint32_t timeout_units = 0;
-
-    if (timeout > 0.0f) {
-        timeout_units = (uint32_t)(timeout * 100.0f + 0.5f);
-        if (timeout_units > UINT16_MAX) {
-            mp_raise_ValueError(MP_ERROR_TEXT("timeout must be < 655.35 secs"));
-        }
-        if (timeout_units == 0) {
-            mp_raise_ValueError(MP_ERROR_TEXT("non-zero timeout must be > 0.01"));
-        }
-    }
+    uint16_t timeout_units = bleio_validate_and_convert_timeout(timeout);
 
     struct bt_le_scan_param scan_params = {
         .type = active ? BT_LE_SCAN_TYPE_ACTIVE : BT_LE_SCAN_TYPE_PASSIVE,
@@ -363,15 +516,110 @@ void common_hal_bleio_adapter_stop_scan(bleio_adapter_obj_t *self) {
 }
 
 bool common_hal_bleio_adapter_get_connected(bleio_adapter_obj_t *self) {
+    if (!ble_adapter_enabled) {
+        return false;
+    }
+
+    for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
+        if (bleio_connections[i].conn != NULL) {
+            return true;
+        }
+    }
+
     return false;
 }
 
 mp_obj_t common_hal_bleio_adapter_get_connections(bleio_adapter_obj_t *self) {
-    mp_raise_NotImplementedError(NULL);
+    if (!ble_adapter_enabled) {
+        self->connection_objs = NULL;
+        return mp_const_empty_tuple;
+    }
+
+    if (self->connection_objs != NULL) {
+        return self->connection_objs;
+    }
+
+    size_t total_connected = 0;
+    mp_obj_t items[BLEIO_TOTAL_CONNECTION_COUNT];
+    for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
+        bleio_connection_internal_t *connection = &bleio_connections[i];
+        if (connection->conn == NULL) {
+            continue;
+        }
+
+        if (connection->connection_obj == mp_const_none) {
+            connection->connection_obj = bleio_connection_new_from_internal(connection);
+        }
+
+        items[total_connected] = connection->connection_obj;
+        total_connected++;
+    }
+
+    self->connection_objs = mp_obj_new_tuple(total_connected, items);
+    return self->connection_objs;
 }
 
 mp_obj_t common_hal_bleio_adapter_connect(bleio_adapter_obj_t *self, bleio_address_obj_t *address, mp_float_t timeout) {
-    mp_raise_NotImplementedError(NULL);
+    common_hal_bleio_adapter_stop_scan(self);
+
+    const uint16_t timeout_units = bleio_validate_and_convert_timeout(timeout);
+
+    mp_buffer_info_t address_bufinfo;
+    mp_get_buffer_raise(address->bytes, &address_bufinfo, MP_BUFFER_READ);
+
+    bt_addr_le_t peer = {
+        .type = bleio_address_type_to_zephyr(address->type),
+    };
+    memcpy(peer.a.val, address_bufinfo.buf, NUM_BLEIO_ADDRESS_BYTES);
+
+    struct bt_conn_le_create_param create_params = BT_CONN_LE_CREATE_PARAM_INIT(
+        BT_CONN_LE_OPT_NONE,
+        BT_GAP_SCAN_FAST_INTERVAL,
+        BT_GAP_SCAN_FAST_INTERVAL);
+    create_params.timeout = timeout_units;
+
+    struct bt_conn *conn = NULL;
+    int err = bt_conn_le_create(&peer, &create_params, BT_LE_CONN_PARAM_DEFAULT, &conn);
+    if (err != 0) {
+        raise_zephyr_error(err);
+    }
+
+    while (true) {
+        struct bt_conn_info info;
+        err = bt_conn_get_info(conn, &info);
+        if (err == 0) {
+            if (info.state == BT_CONN_STATE_CONNECTED) {
+                break;
+            }
+
+            if (info.state == BT_CONN_STATE_DISCONNECTED) {
+                bt_conn_unref(conn);
+                mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Failed to connect: timeout"));
+            }
+        } else if (err != -ENOTCONN) {
+            bt_conn_unref(conn);
+            raise_zephyr_error(err);
+        }
+
+        RUN_BACKGROUND_TASKS;
+    }
+
+    bleio_connection_internal_t *connection = bleio_connection_find_by_conn(conn);
+    if (connection == NULL) {
+        connection = bleio_connection_track(conn);
+    }
+
+    if (connection == NULL) {
+        bt_conn_unref(conn);
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Failed to connect: internal error"));
+    }
+
+    // bt_conn_le_create() gave us a ref in `conn`; `connection` keeps its own
+    // ref via bleio_connection_track(). Drop the create ref now.
+    bt_conn_unref(conn);
+
+    self->connection_objs = NULL;
+    return bleio_connection_new_from_internal(connection);
 }
 
 void common_hal_bleio_adapter_erase_bonding(bleio_adapter_obj_t *self) {
@@ -383,13 +631,32 @@ bool common_hal_bleio_adapter_is_bonded_to_central(bleio_adapter_obj_t *self) {
 }
 
 void bleio_adapter_gc_collect(bleio_adapter_obj_t *adapter) {
-    // Nothing to do for now.
+    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) {
     if (adapter == NULL) {
         return;
     }
+
+    common_hal_bleio_adapter_stop_scan(adapter);
+    common_hal_bleio_adapter_stop_advertising(adapter);
+
+    for (size_t i = 0; i < BLEIO_TOTAL_CONNECTION_COUNT; i++) {
+        bleio_connection_internal_t *connection = &bleio_connections[i];
+        if (connection->conn != NULL) {
+            bt_conn_disconnect(connection->conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
+        }
+        if (connection->connection_obj != MP_OBJ_NULL &&
+            connection->connection_obj != mp_const_none) {
+            bleio_connection_obj_t *connection_obj = MP_OBJ_TO_PTR(connection->connection_obj);
+            connection_obj->connection = NULL;
+            connection_obj->disconnect_reason = BT_HCI_ERR_REMOTE_USER_TERM_CONN;
+        }
+        bleio_connection_clear(connection);
+    }
+
     adapter->scan_results = NULL;
     adapter->connection_objs = NULL;
     active_scan_results = NULL;
diff --git a/ports/zephyr-cp/common-hal/_bleio/Adapter.h b/ports/zephyr-cp/common-hal/_bleio/Adapter.h
index dda9075776e6e..c15c698e2a525 100644
--- a/ports/zephyr-cp/common-hal/_bleio/Adapter.h
+++ b/ports/zephyr-cp/common-hal/_bleio/Adapter.h
@@ -13,8 +13,7 @@
 #include "shared-bindings/_bleio/Connection.h"
 #include "shared-bindings/_bleio/ScanResults.h"
 
-#define BLEIO_TOTAL_CONNECTION_COUNT 5
-#define BLEIO_HANDLE_INVALID 0xffff
+#define BLEIO_TOTAL_CONNECTION_COUNT CONFIG_BT_MAX_CONN
 
 extern bleio_connection_internal_t bleio_connections[BLEIO_TOTAL_CONNECTION_COUNT];
 
diff --git a/ports/zephyr-cp/common-hal/_bleio/Connection.c b/ports/zephyr-cp/common-hal/_bleio/Connection.c
index 2e93b6ab127b6..938359c79caf7 100644
--- a/ports/zephyr-cp/common-hal/_bleio/Connection.c
+++ b/ports/zephyr-cp/common-hal/_bleio/Connection.c
@@ -5,7 +5,14 @@
 //
 // SPDX-License-Identifier: MIT
 
+#include <errno.h>
+
+#include <zephyr/bluetooth/conn.h>
+#include <zephyr/bluetooth/gatt.h>
+
 #include "py/runtime.h"
+#include "bindings/zephyr_kernel/__init__.h"
+#include "shared-bindings/_bleio/__init__.h"
 #include "shared-bindings/_bleio/Connection.h"
 
 void common_hal_bleio_connection_pair(bleio_connection_internal_t *self, bool bond) {
@@ -13,15 +20,47 @@ void common_hal_bleio_connection_pair(bleio_connection_internal_t *self, bool bo
 }
 
 void common_hal_bleio_connection_disconnect(bleio_connection_internal_t *self) {
-    mp_raise_NotImplementedError(NULL);
+    if (self == NULL || self->conn == NULL) {
+        return;
+    }
+
+    int err = bt_conn_disconnect(self->conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
+    if (err != 0 && err != -ENOTCONN) {
+        raise_zephyr_error(err);
+    }
+
+    // The connection may now be disconnecting; force connections tuple rebuild.
+    common_hal_bleio_adapter_obj.connection_objs = NULL;
 }
 
 bool common_hal_bleio_connection_get_connected(bleio_connection_obj_t *self) {
-    return false;
+    if (self == NULL || self->connection == NULL) {
+        return false;
+    }
+
+    bleio_connection_internal_t *connection = self->connection;
+    if (connection->conn == NULL) {
+        return false;
+    }
+
+    struct bt_conn_info info;
+    if (bt_conn_get_info(connection->conn, &info) != 0) {
+        return false;
+    }
+
+    return info.state == BT_CONN_STATE_CONNECTED || info.state == BT_CONN_STATE_DISCONNECTING;
 }
 
 mp_int_t common_hal_bleio_connection_get_max_packet_length(bleio_connection_internal_t *self) {
-    return 20;
+    if (self == NULL || self->conn == NULL) {
+        return 20;
+    }
+
+    uint16_t mtu = bt_gatt_get_mtu(self->conn);
+    if (mtu < 3) {
+        return 20;
+    }
+    return mtu - 3;
 }
 
 bool common_hal_bleio_connection_get_paired(bleio_connection_obj_t *self) {
@@ -40,18 +79,19 @@ void common_hal_bleio_connection_set_connection_interval(bleio_connection_intern
     mp_raise_NotImplementedError(NULL);
 }
 
-void bleio_connection_clear(bleio_connection_internal_t *self) {
-    // Nothing to do
-}
+mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t *connection) {
+    if (connection == NULL) {
+        return mp_const_none;
+    }
 
-uint16_t bleio_connection_get_conn_handle(bleio_connection_obj_t *self) {
-    return self->connection->conn_handle;
-}
+    if (connection->connection_obj != mp_const_none) {
+        return connection->connection_obj;
+    }
 
-mp_obj_t bleio_connection_new_from_internal(bleio_connection_internal_t *connection) {
-    mp_raise_NotImplementedError(NULL);
-}
+    bleio_connection_obj_t *connection_obj = mp_obj_malloc(bleio_connection_obj_t, &bleio_connection_type);
+    connection_obj->connection = connection;
+    connection_obj->disconnect_reason = 0;
+    connection->connection_obj = MP_OBJ_FROM_PTR(connection_obj);
 
-bleio_connection_internal_t *bleio_conn_handle_to_connection(uint16_t conn_handle) {
-    return NULL;
+    return connection->connection_obj;
 }
diff --git a/ports/zephyr-cp/common-hal/_bleio/Connection.h b/ports/zephyr-cp/common-hal/_bleio/Connection.h
index f8f9581ad00bb..dc14125db5f7c 100644
--- a/ports/zephyr-cp/common-hal/_bleio/Connection.h
+++ b/ports/zephyr-cp/common-hal/_bleio/Connection.h
@@ -10,31 +10,12 @@
 #include <stdbool.h>
 
 #include "py/obj.h"
-#include "py/objlist.h"
 
-#include "common-hal/_bleio/__init__.h"
-#include "shared-module/_bleio/Address.h"
-#include "common-hal/_bleio/Service.h"
-
-typedef enum {
-    PAIR_NOT_PAIRED,
-    PAIR_WAITING,
-    PAIR_PAIRED,
-} pair_status_t;
+struct bt_conn;
 
 typedef struct {
-    uint16_t conn_handle;
-    bool is_central;
-    mp_obj_list_t *remote_service_list;
-    uint16_t ediv;
-    volatile pair_status_t pair_status;
-    uint8_t sec_status;
+    struct bt_conn *conn;
     mp_obj_t connection_obj;
-    volatile bool conn_params_updating;
-    uint16_t mtu;
-    volatile bool do_bond_cccds;
-    volatile bool do_bond_keys;
-    uint64_t do_bond_cccds_request_time;
 } bleio_connection_internal_t;
 
 typedef struct {
@@ -43,7 +24,4 @@ typedef struct {
     uint8_t disconnect_reason;
 } bleio_connection_obj_t;
 
-void bleio_connection_clear(bleio_connection_internal_t *self);
-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);
-bleio_connection_internal_t *bleio_conn_handle_to_connection(uint16_t conn_handle);
diff --git a/ports/zephyr-cp/common-hal/_bleio/__init__.c b/ports/zephyr-cp/common-hal/_bleio/__init__.c
index fca1eae98278d..719564c1cd47e 100644
--- a/ports/zephyr-cp/common-hal/_bleio/__init__.c
+++ b/ports/zephyr-cp/common-hal/_bleio/__init__.c
@@ -8,6 +8,7 @@
 #include "py/runtime.h"
 #include "shared-bindings/_bleio/__init__.h"
 #include "shared-bindings/_bleio/Adapter.h"
+#include "common-hal/_bleio/Adapter.h"
 #include "supervisor/shared/bluetooth/bluetooth.h"
 
 // The singleton _bleio.Adapter object
@@ -15,61 +16,36 @@ bleio_adapter_obj_t common_hal_bleio_adapter_obj;
 
 void common_hal_bleio_init(void) {
     common_hal_bleio_adapter_obj.base.type = &bleio_adapter_type;
+    bleio_adapter_reset(&common_hal_bleio_adapter_obj);
 }
 
 void bleio_user_reset(void) {
-    common_hal_bleio_adapter_stop_scan(&common_hal_bleio_adapter_obj);
-    common_hal_bleio_adapter_stop_advertising(&common_hal_bleio_adapter_obj);
-    bleio_adapter_reset(&common_hal_bleio_adapter_obj);
-
-    if (supervisor_bluetooth_workflow_is_enabled()) {
-        supervisor_bluetooth_background();
+    if (common_hal_bleio_adapter_get_enabled(&common_hal_bleio_adapter_obj)) {
+        // Stop any user scanning or advertising.
+        common_hal_bleio_adapter_stop_scan(&common_hal_bleio_adapter_obj);
+        common_hal_bleio_adapter_stop_advertising(&common_hal_bleio_adapter_obj);
     }
+
+    // Maybe start advertising the BLE workflow.
+    supervisor_bluetooth_background();
 }
 
 void bleio_reset(void) {
     common_hal_bleio_adapter_obj.base.type = &bleio_adapter_type;
+    if (!common_hal_bleio_adapter_get_enabled(&common_hal_bleio_adapter_obj)) {
+        return;
+    }
 
-    common_hal_bleio_adapter_stop_scan(&common_hal_bleio_adapter_obj);
-    common_hal_bleio_adapter_stop_advertising(&common_hal_bleio_adapter_obj);
-
-    // Keep Zephyr BLE transport up, but present a disabled adapter state.
-    common_hal_bleio_adapter_set_enabled(&common_hal_bleio_adapter_obj, false);
+    supervisor_stop_bluetooth();
     bleio_adapter_reset(&common_hal_bleio_adapter_obj);
-
-    if (supervisor_bluetooth_workflow_is_enabled()) {
-        supervisor_start_bluetooth();
-    }
+    common_hal_bleio_adapter_set_enabled(&common_hal_bleio_adapter_obj, false);
+    supervisor_start_bluetooth();
 }
 
 void common_hal_bleio_gc_collect(void) {
-    // Nothing to do for stubs
-}
-
-void common_hal_bleio_check_connected(uint16_t conn_handle) {
-    mp_raise_NotImplementedError(NULL);
-}
-
-uint16_t common_hal_bleio_device_get_conn_handle(mp_obj_t device) {
-    mp_raise_NotImplementedError(NULL);
+    bleio_adapter_gc_collect(&common_hal_bleio_adapter_obj);
 }
 
 void common_hal_bleio_device_discover_remote_services(mp_obj_t device, mp_obj_t service_uuids_whitelist) {
     mp_raise_NotImplementedError(NULL);
 }
-
-size_t common_hal_bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
-    mp_raise_NotImplementedError(NULL);
-}
-
-void common_hal_bleio_gatts_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo) {
-    mp_raise_NotImplementedError(NULL);
-}
-
-size_t common_hal_bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len) {
-    mp_raise_NotImplementedError(NULL);
-}
-
-void common_hal_bleio_gattc_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo, bool write_no_response) {
-    mp_raise_NotImplementedError(NULL);
-}
diff --git a/ports/zephyr-cp/cptools/build_circuitpython.py b/ports/zephyr-cp/cptools/build_circuitpython.py
index e00cf6cac8dc1..3da878e0f5b7c 100644
--- a/ports/zephyr-cp/cptools/build_circuitpython.py
+++ b/ports/zephyr-cp/cptools/build_circuitpython.py
@@ -414,7 +414,8 @@ async def build_circuitpython():
     supervisor_source = [pathlib.Path(p) for p in supervisor_source]
     supervisor_source.extend(board_info["source_files"])
     supervisor_source.extend(top.glob("supervisor/shared/*.c"))
-    supervisor_source.append(top / "supervisor/shared/bluetooth/bluetooth.c")
+    if "_bleio" in enabled_modules:
+        supervisor_source.append(top / "supervisor/shared/bluetooth/bluetooth.c")
     supervisor_source.append(top / "supervisor/shared/translate/translate.c")
     if web_workflow_enabled:
         supervisor_source.extend(top.glob("supervisor/shared/web_workflow/*.c"))
diff --git a/ports/zephyr-cp/supervisor/port.c b/ports/zephyr-cp/supervisor/port.c
index 08a84043e8eeb..0d8a2f48c1356 100644
--- a/ports/zephyr-cp/supervisor/port.c
+++ b/ports/zephyr-cp/supervisor/port.c
@@ -9,10 +9,6 @@
 #include "mpconfigboard.h"
 #include "supervisor/shared/tick.h"
 
-#if CIRCUITPY_BLEIO
-#include "shared-bindings/_bleio/__init__.h"
-#endif
-
 #include <zephyr/autoconf.h>
 #include <zephyr/kernel.h>
 #include <zephyr/sys/reboot.h>
@@ -93,10 +89,6 @@ void reset_cpu(void) {
 }
 
 void reset_port(void) {
-    #if CIRCUITPY_BLEIO
-    bleio_reset();
-    #endif
-
     #if defined(CONFIG_ARCH_POSIX)
     native_sim_reset_port_count++;
     if (native_sim_vm_runs != INT32_MAX &&
diff --git a/ports/zephyr-cp/tests/bsim/conftest.py b/ports/zephyr-cp/tests/bsim/conftest.py
index 67b76469fa030..493f4c92b3ba0 100644
--- a/ports/zephyr-cp/tests/bsim/conftest.py
+++ b/ports/zephyr-cp/tests/bsim/conftest.py
@@ -107,6 +107,8 @@ def bsim_phy(request, bsim_phy_binary, native_sim_env, sim_id):
         "-v=9",  # Cleaning up level is on 9. Connecting is 7.
         f"-s={sim_id}",
         f"-D={devices}",
+        "-argschannel",
+        "-at=40",  # 40 dB attenuation (default 60) so RSSI ~ -40 dBm
     ]
     print("Running:", " ".join(cmd))
     proc = subprocess.Popen(
@@ -213,11 +215,13 @@ def zephyr_sample(request, bsim_phy, native_sim_env, sim_id):
     print(sample_proc.serial.all_output)
 
 
+# pytest markers are defined inside out meaning the bottom one is first in the
+# list and the top is last. So use negative indices to reverse them.
 @pytest.fixture
 def circuitpython1(circuitpython):
-    return circuitpython[0]
+    return circuitpython[-1]
 
 
 @pytest.fixture
 def circuitpython2(circuitpython):
-    return circuitpython[1]
+    return circuitpython[-2]
diff --git a/ports/zephyr-cp/tests/bsim/test_bsim_ble_advertising.py b/ports/zephyr-cp/tests/bsim/test_bsim_ble_advertising.py
index 35d85b416d627..33680fe2506f5 100644
--- a/ports/zephyr-cp/tests/bsim/test_bsim_ble_advertising.py
+++ b/ports/zephyr-cp/tests/bsim/test_bsim_ble_advertising.py
@@ -4,6 +4,7 @@
 """BLE advertising tests for nrf5340bsim."""
 
 import logging
+import re
 
 import pytest
 
@@ -44,6 +45,39 @@
 """
 
 
+BSIM_TX_POWER_DEFAULT_CODE = """\
+import _bleio
+import time
+
+adapter = _bleio.adapter
+
+name = b"CPTXPWR"
+advertisement = bytes((2, 0x01, 0x06, len(name) + 1, 0x09)) + name
+
+print("advertising default")
+adapter.start_advertising(advertisement)
+time.sleep(4)
+adapter.stop_advertising()
+print("done")
+"""
+
+BSIM_TX_POWER_LOW_CODE = """\
+import _bleio
+import time
+
+adapter = _bleio.adapter
+
+name = b"CPTXPWR"
+advertisement = bytes((2, 0x01, 0x06, len(name) + 1, 0x09)) + name
+
+print("advertising low")
+adapter.start_advertising(advertisement, tx_power=-20)
+time.sleep(4)
+adapter.stop_advertising()
+print("done")
+"""
+
+
 @pytest.mark.zephyr_sample("bluetooth/observer")
 @pytest.mark.circuitpy_drive({"code.py": BSIM_ADV_CODE})
 def test_bsim_advertise_and_scan(bsim_phy, circuitpython, zephyr_sample):
@@ -90,3 +124,51 @@ def test_bsim_advertise_ctrl_c_reload(bsim_phy, circuitpython, zephyr_sample):
     assert cp_output.count("adv run done") >= 1
     assert observer_output.count("Device found:") >= observer_count_before + 1
     assert "Already advertising" not in cp_output
+
+
+@pytest.mark.zephyr_sample("bluetooth/observer")
+@pytest.mark.circuitpy_drive({"code.py": BSIM_TX_POWER_DEFAULT_CODE})
+def test_bsim_tx_power_default_rssi(bsim_phy, circuitpython, zephyr_sample):
+    """Verify default TX power produces expected RSSI."""
+    observer = zephyr_sample
+
+    circuitpython.wait_until_done()
+
+    cp_output = circuitpython.serial.all_output
+    obs_output = observer.serial.all_output
+
+    assert "advertising default" in cp_output
+    assert "done" in cp_output
+
+    # Observer: "Device found: <addr> (RSSI <n>), type <t>, AD data len <l>"
+    # Advertisement is 12 bytes: flags (3) + name (9).
+    # With 40 dB channel attenuation and 0 dBm TX → RSSI ~ -39
+    rssi_pattern = re.compile(r"RSSI (-?\d+)\), type \d+, AD data len 12")
+    all_rssi = [int(m.group(1)) for m in rssi_pattern.finditer(obs_output)]
+    logger.info("RSSI values: %s", all_rssi)
+
+    assert len(all_rssi) > 0, "Observer saw no advertisements"
+    assert all_rssi[0] == -39, f"Expected RSSI -39 (0 dBm TX), got {all_rssi[0]}"
+
+
+@pytest.mark.zephyr_sample("bluetooth/observer")
+@pytest.mark.circuitpy_drive({"code.py": BSIM_TX_POWER_LOW_CODE})
+def test_bsim_tx_power_low_rssi(bsim_phy, circuitpython, zephyr_sample):
+    """Verify low TX power reduces RSSI."""
+    observer = zephyr_sample
+
+    circuitpython.wait_until_done()
+
+    cp_output = circuitpython.serial.all_output
+    obs_output = observer.serial.all_output
+
+    assert "advertising low" in cp_output
+    assert "done" in cp_output
+
+    # With 40 dB channel attenuation and -20 dBm TX → RSSI ~ -59
+    rssi_pattern = re.compile(r"RSSI (-?\d+)\), type \d+, AD data len 12")
+    all_rssi = [int(m.group(1)) for m in rssi_pattern.finditer(obs_output)]
+    logger.info("RSSI values: %s", all_rssi)
+
+    assert len(all_rssi) > 0, "Observer saw no advertisements"
+    assert all_rssi[0] < -39, f"Expected lower RSSI with -20 dBm TX, got {all_rssi[0]}"
diff --git a/ports/zephyr-cp/tests/bsim/test_bsim_ble_connect.py b/ports/zephyr-cp/tests/bsim/test_bsim_ble_connect.py
new file mode 100644
index 0000000000000..21cfeaf79da50
--- /dev/null
+++ b/ports/zephyr-cp/tests/bsim/test_bsim_ble_connect.py
@@ -0,0 +1,119 @@
+# SPDX-FileCopyrightText: 2026 Scott Shawcroft for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+"""BLE central connection tests for nrf5340bsim."""
+
+import pytest
+
+pytestmark = pytest.mark.circuitpython_board("native_nrf5340bsim")
+
+BSIM_CONNECT_CODE = """\
+import _bleio
+import time
+
+adapter = _bleio.adapter
+
+print("connect start")
+target = None
+for entry in adapter.start_scan(timeout=6.0, active=True):
+    if entry.connectable:
+        target = entry.address
+        print("found target")
+        break
+adapter.stop_scan()
+print("have target", target is not None)
+
+if target is None:
+    raise RuntimeError("No connectable target found")
+
+connection = adapter.connect(target, timeout=5.0)
+print("connected", connection.connected, adapter.connected, len(adapter.connections))
+connection.disconnect()
+
+for _ in range(40):
+    if not connection.connected and not adapter.connected:
+        break
+    time.sleep(0.1)
+
+print("disconnected", connection.connected, adapter.connected, len(adapter.connections))
+"""
+
+BSIM_RECONNECT_CODE = """\
+import _bleio
+import time
+
+adapter = _bleio.adapter
+
+print("run start")
+target = None
+for entry in adapter.start_scan(timeout=6.0, active=True):
+    if entry.connectable:
+        target = entry.address
+        print("run found target")
+        break
+adapter.stop_scan()
+print("run have target", target is not None)
+
+if target is None:
+    raise RuntimeError("No connectable target found")
+
+connection = adapter.connect(target, timeout=5.0)
+print("run connected", connection.connected, adapter.connected, len(adapter.connections))
+connection.disconnect()
+
+for _ in range(50):
+    if not connection.connected and not adapter.connected and len(adapter.connections) == 0:
+        break
+    time.sleep(0.1)
+
+print("run disconnected", connection.connected, adapter.connected, len(adapter.connections))
+"""
+
+
+@pytest.mark.zephyr_sample("bluetooth/peripheral")
+@pytest.mark.duration(14)
+@pytest.mark.circuitpy_drive({"code.py": BSIM_CONNECT_CODE})
+def test_bsim_connect_zephyr_peripheral(bsim_phy, circuitpython, zephyr_sample):
+    """Connect to the Zephyr peripheral sample and disconnect cleanly."""
+    peripheral = zephyr_sample
+
+    circuitpython.wait_until_done()
+
+    cp_output = circuitpython.serial.all_output
+    peripheral_output = peripheral.serial.all_output
+
+    assert "connect start" in cp_output
+    assert "found target" in cp_output
+    assert "have target True" in cp_output
+    assert "connected True True 1" in cp_output
+    assert "disconnected False False 0" in cp_output
+
+    assert "Advertising successfully started" in peripheral_output
+    assert "Connected" in peripheral_output
+
+
+@pytest.mark.zephyr_sample("bluetooth/peripheral_sc_only")
+@pytest.mark.code_py_runs(2)
+@pytest.mark.duration(26)
+@pytest.mark.circuitpy_drive({"code.py": BSIM_RECONNECT_CODE})
+def test_bsim_reconnect_zephyr_peripheral(bsim_phy, circuitpython, zephyr_sample):
+    """Connect/disconnect, soft reload, then connect/disconnect again."""
+    peripheral = zephyr_sample
+
+    circuitpython.serial.wait_for("run disconnected")
+    circuitpython.serial.wait_for("Press any key to enter the REPL")
+    circuitpython.serial.write("\x04")
+
+    circuitpython.wait_until_done()
+
+    cp_output = circuitpython.serial.all_output
+    peripheral_output = peripheral.serial.all_output
+
+    assert cp_output.count("run start") >= 2
+    assert cp_output.count("run found target") >= 2
+    assert cp_output.count("run have target True") >= 2
+    assert cp_output.count("run connected True True 1") >= 2
+    assert cp_output.count("run disconnected False False 0") >= 2
+
+    assert "Advertising successfully started" in peripheral_output
+    assert peripheral_output.count("Connected") >= 2
diff --git a/ports/zephyr-cp/tests/bsim/test_bsim_ble_peripheral.py b/ports/zephyr-cp/tests/bsim/test_bsim_ble_peripheral.py
new file mode 100644
index 0000000000000..7a4bbfaecd942
--- /dev/null
+++ b/ports/zephyr-cp/tests/bsim/test_bsim_ble_peripheral.py
@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: 2026 Scott Shawcroft for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+"""BLE peripheral connection tests for nrf5340bsim."""
+
+import pytest
+
+pytestmark = pytest.mark.circuitpython_board("native_nrf5340bsim")
+
+BSIM_PERIPHERAL_CODE = """\
+import _bleio
+import time
+import sys
+
+adapter = _bleio.adapter
+
+name = b"CPPERIPH"
+advertisement = bytes((2, 0x01, 0x06, len(name) + 1, 0x09)) + name
+
+print("peripheral start")
+adapter.start_advertising(advertisement, connectable=True)
+print("advertising", adapter.advertising)
+
+was_connected = False
+timeout = time.monotonic() + 8.0
+while not was_connected and time.monotonic() < timeout:
+    time.sleep(0.01)
+    was_connected = adapter.connected
+
+if not was_connected:
+    print("connect timed out")
+    sys.exit(-1)
+
+print("connected", was_connected, "advertising", adapter.advertising)
+
+if was_connected:
+    timeout = time.monotonic() + 8.0
+    while adapter.connected and time.monotonic() < timeout:
+        time.sleep(0.1)
+
+print("disconnected", adapter.connected, len(adapter.connections))
+"""
+
+BSIM_CENTRAL_CODE = """\
+import _bleio
+import time
+
+adapter = _bleio.adapter
+
+print("central start")
+target = None
+for entry in adapter.start_scan(timeout=6.0, active=True):
+    if entry.connectable and b"CPPERIPH" in entry.advertisement_bytes:
+        target = entry.address
+        print("found peripheral")
+        break
+adapter.stop_scan()
+print("have target", target is not None)
+
+if target is None:
+    raise RuntimeError("No connectable peripheral found")
+
+connection = adapter.connect(target, timeout=5.0)
+print("connected", connection.connected, adapter.connected, len(adapter.connections))
+connection.disconnect()
+
+timeout = time.monotonic() + 4.0
+while (connection.connected or adapter.connected) and time.monotonic() < timeout:
+    time.sleep(0.1)
+
+print("disconnected", connection.connected, adapter.connected, len(adapter.connections))
+"""
+
+
+@pytest.mark.zephyr_sample("bluetooth/central")
+@pytest.mark.duration(14)
+@pytest.mark.circuitpy_drive({"code.py": BSIM_PERIPHERAL_CODE})
+def test_bsim_peripheral_zephyr_central(bsim_phy, circuitpython, zephyr_sample):
+    """Advertise as connectable from CP; Zephyr central connects and disconnects."""
+    central = zephyr_sample
+
+    circuitpython.wait_until_done()
+
+    cp_output = circuitpython.serial.all_output
+    central_output = central.serial.all_output
+
+    assert "peripheral start" in cp_output
+    assert "advertising True" in cp_output
+    assert "connected True advertising False" in cp_output
+    assert "disconnected False 0" in cp_output
+
+    assert "Scanning successfully started" in central_output
+    assert "Connected:" in central_output
+    assert "Disconnected:" in central_output
+
+
+@pytest.mark.duration(14)
+@pytest.mark.circuitpy_drive({"code.py": BSIM_PERIPHERAL_CODE})
+@pytest.mark.circuitpy_drive({"code.py": BSIM_CENTRAL_CODE})
+def test_bsim_peripheral_cp_central(bsim_phy, circuitpython1, circuitpython2):
+    """Two CP instances: device 0 peripheral, device 1 central."""
+    peripheral = circuitpython1
+    central = circuitpython2
+
+    central.wait_until_done()
+    peripheral.wait_until_done()
+
+    periph_output = peripheral.serial.all_output
+    central_output = central.serial.all_output
+
+    assert "peripheral start" in periph_output
+    assert "advertising True" in periph_output
+    assert "connected True advertising False" in periph_output
+    assert "disconnected False 0" in periph_output
+
+    assert "central start" in central_output
+    assert "found peripheral" in central_output
+    assert "have target True" in central_output
+    assert "connected True True 1" in central_output
+    assert "disconnected False False 0" in central_output
diff --git a/shared-bindings/_bleio/Adapter.c b/shared-bindings/_bleio/Adapter.c
index 839b8b19addfa..a1f81a063fdaa 100644
--- a/shared-bindings/_bleio/Adapter.c
+++ b/shared-bindings/_bleio/Adapter.c
@@ -215,7 +215,7 @@ static mp_obj_t bleio_adapter_start_advertising(mp_uint_t n_args, const mp_obj_t
         args[ARG_interval].u_obj = mp_obj_new_float(ADV_INTERVAL_DEFAULT);
     }
 
-    const mp_float_t interval = mp_obj_get_float(args[ARG_interval].u_obj);
+    const mp_float_t interval = mp_arg_validate_type_float(args[ARG_interval].u_obj, MP_QSTR_interval);
     if (interval < ADV_INTERVAL_MIN || interval > ADV_INTERVAL_MAX) {
         mp_raise_ValueError_varg(MP_ERROR_TEXT("interval must be in range %s-%s"),
             ADV_INTERVAL_MIN_STRING, ADV_INTERVAL_MAX_STRING);
@@ -223,7 +223,7 @@ static mp_obj_t bleio_adapter_start_advertising(mp_uint_t n_args, const mp_obj_t
 
     bool connectable = args[ARG_connectable].u_bool;
     bool anonymous = args[ARG_anonymous].u_bool;
-    uint32_t timeout = args[ARG_timeout].u_int;
+    const uint32_t timeout = (uint32_t)mp_arg_validate_int_min(args[ARG_timeout].u_int, 0, MP_QSTR_timeout);
     if (data_bufinfo.len > 31 && connectable && scan_response_bufinfo.len > 0) {
         mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Cannot have scan responses for extended, connectable advertisements."));
     }
@@ -306,7 +306,7 @@ static mp_obj_t bleio_adapter_start_scan(size_t n_args, const mp_obj_t *pos_args
 
     mp_float_t timeout = 0.0f;
     if (args[ARG_timeout].u_obj != mp_const_none) {
-        timeout = mp_obj_get_float(args[ARG_timeout].u_obj);
+        timeout = mp_arg_validate_obj_float_non_negative(args[ARG_timeout].u_obj, 0.0f, MP_QSTR_timeout);
     }
 
     if (args[ARG_interval].u_obj == MP_OBJ_NULL) {
@@ -317,7 +317,7 @@ static mp_obj_t bleio_adapter_start_scan(size_t n_args, const mp_obj_t *pos_args
         args[ARG_window].u_obj = mp_obj_new_float(WINDOW_DEFAULT);
     }
 
-    const mp_float_t interval = mp_obj_get_float(args[ARG_interval].u_obj);
+    const mp_float_t interval = mp_arg_validate_type_float(args[ARG_interval].u_obj, MP_QSTR_interval);
     if (interval < INTERVAL_MIN || interval > INTERVAL_MAX) {
         mp_raise_ValueError_varg(MP_ERROR_TEXT("interval must be in range %s-%s"), INTERVAL_MIN_STRING, INTERVAL_MAX_STRING);
     }
@@ -329,7 +329,7 @@ static mp_obj_t bleio_adapter_start_scan(size_t n_args, const mp_obj_t *pos_args
     }
     #pragma GCC diagnostic pop
 
-    const mp_float_t window = mp_obj_get_float(args[ARG_window].u_obj);
+    const mp_float_t window = mp_arg_validate_type_float(args[ARG_window].u_obj, MP_QSTR_window);
     if (window > interval) {
         mp_raise_ValueError(MP_ERROR_TEXT("window must be <= interval"));
     }
@@ -344,7 +344,9 @@ static mp_obj_t bleio_adapter_start_scan(size_t n_args, const mp_obj_t *pos_args
         }
     }
 
-    return common_hal_bleio_adapter_start_scan(self, prefix_bufinfo.buf, prefix_bufinfo.len, args[ARG_extended].u_bool, args[ARG_buffer_size].u_int, timeout, interval, window, args[ARG_minimum_rssi].u_int, args[ARG_active].u_bool);
+    const mp_int_t buffer_size = mp_arg_validate_int_min(args[ARG_buffer_size].u_int, 1, MP_QSTR_buffer_size);
+
+    return common_hal_bleio_adapter_start_scan(self, prefix_bufinfo.buf, prefix_bufinfo.len, args[ARG_extended].u_bool, buffer_size, timeout, interval, window, args[ARG_minimum_rssi].u_int, args[ARG_active].u_bool);
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(bleio_adapter_start_scan_obj, 1, bleio_adapter_start_scan);
 
@@ -416,7 +418,8 @@ static mp_obj_t bleio_adapter_connect(mp_uint_t n_args, const mp_obj_t *pos_args
     mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
     bleio_address_obj_t *address = mp_arg_validate_type(args[ARG_address].u_obj, &bleio_address_type, MP_QSTR_address);
-    mp_float_t timeout = mp_obj_get_float(args[ARG_timeout].u_obj);
+    const mp_float_t timeout =
+        mp_arg_validate_obj_float_non_negative(args[ARG_timeout].u_obj, 0.0f, MP_QSTR_timeout);
 
     return common_hal_bleio_adapter_connect(self, address, timeout);
 }
diff --git a/shared-bindings/_bleio/Address.c b/shared-bindings/_bleio/Address.c
index 58f8a8adc1e61..e39fa4fe40ba0 100644
--- a/shared-bindings/_bleio/Address.c
+++ b/shared-bindings/_bleio/Address.c
@@ -42,14 +42,13 @@ static mp_obj_t bleio_address_make_new(const mp_obj_type_t *type, size_t n_args,
     const mp_obj_t address = args[ARG_address].u_obj;
     mp_buffer_info_t buf_info;
     mp_get_buffer_raise(address, &buf_info, MP_BUFFER_READ);
-    if (buf_info.len != NUM_BLEIO_ADDRESS_BYTES) {
-        mp_raise_ValueError_varg(MP_ERROR_TEXT("Address must be %d bytes long"), NUM_BLEIO_ADDRESS_BYTES);
-    }
+    mp_arg_validate_length(buf_info.len, NUM_BLEIO_ADDRESS_BYTES, MP_QSTR_address);
 
-    const mp_int_t address_type = args[ARG_address_type].u_int;
-    if (address_type < BLEIO_ADDRESS_TYPE_MIN || address_type > BLEIO_ADDRESS_TYPE_MAX) {
-        mp_arg_error_invalid(MP_QSTR_address_type);
-    }
+    const mp_int_t address_type =
+        mp_arg_validate_int_range(args[ARG_address_type].u_int,
+            BLEIO_ADDRESS_TYPE_MIN,
+            BLEIO_ADDRESS_TYPE_MAX,
+            MP_QSTR_address_type);
 
     common_hal_bleio_address_construct(self, buf_info.buf, address_type);
 
diff --git a/shared-bindings/_bleio/Characteristic.c b/shared-bindings/_bleio/Characteristic.c
index 8d6ac43e487d1..0ed4c2b7eaa97 100644
--- a/shared-bindings/_bleio/Characteristic.c
+++ b/shared-bindings/_bleio/Characteristic.c
@@ -116,9 +116,10 @@ static mp_obj_t bleio_characteristic_add_to_service(size_t n_args, const mp_obj_
     }
 
     mp_get_buffer_raise(initial_value, &initial_value_bufinfo, MP_BUFFER_READ);
-    if (initial_value_bufinfo.len > max_length ||
-        (fixed_length && initial_value_bufinfo.len != max_length)) {
-        mp_raise_ValueError(MP_ERROR_TEXT("initial_value length is wrong"));
+    if (fixed_length) {
+        mp_arg_validate_length(initial_value_bufinfo.len, max_length, MP_QSTR_initial_value);
+    } else {
+        mp_arg_validate_length_max(initial_value_bufinfo.len, max_length, MP_QSTR_initial_value);
     }
 
     const char *user_description = NULL;
diff --git a/shared-bindings/_bleio/Descriptor.c b/shared-bindings/_bleio/Descriptor.c
index 57cc605029f4a..9e29f57d8dd2b 100644
--- a/shared-bindings/_bleio/Descriptor.c
+++ b/shared-bindings/_bleio/Descriptor.c
@@ -99,9 +99,10 @@ static mp_obj_t bleio_descriptor_add_to_characteristic(size_t n_args, const mp_o
         }
     }
     mp_get_buffer_raise(initial_value, &initial_value_bufinfo, MP_BUFFER_READ);
-    if (initial_value_bufinfo.len > max_length ||
-        (fixed_length && initial_value_bufinfo.len != max_length)) {
-        mp_raise_ValueError(MP_ERROR_TEXT("initial_value length is wrong"));
+    if (fixed_length) {
+        mp_arg_validate_length(initial_value_bufinfo.len, max_length, MP_QSTR_initial_value);
+    } else {
+        mp_arg_validate_length_max(initial_value_bufinfo.len, max_length, MP_QSTR_initial_value);
     }
 
     bleio_descriptor_obj_t *descriptor = mp_obj_malloc(bleio_descriptor_obj_t, &bleio_descriptor_type);
diff --git a/shared-bindings/_bleio/PacketBuffer.c b/shared-bindings/_bleio/PacketBuffer.c
index 47d71ebd55af4..aa1e6e8645a61 100644
--- a/shared-bindings/_bleio/PacketBuffer.c
+++ b/shared-bindings/_bleio/PacketBuffer.c
@@ -57,7 +57,10 @@ static mp_obj_t bleio_packet_buffer_make_new(const mp_obj_type_t *type, size_t n
 
     size_t max_packet_size = common_hal_bleio_characteristic_get_max_length(characteristic);
     if (args[ARG_max_packet_size].u_obj != mp_const_none) {
-        max_packet_size = mp_obj_get_int(args[ARG_max_packet_size].u_obj);
+        const mp_int_t max_packet_size_int =
+            mp_arg_validate_type_int(args[ARG_max_packet_size].u_obj, MP_QSTR_max_packet_size);
+        max_packet_size =
+            (size_t)mp_arg_validate_int_min(max_packet_size_int, 1, MP_QSTR_max_packet_size);
     }
 
     bleio_packet_buffer_obj_t *self = mp_obj_malloc(bleio_packet_buffer_obj_t, &bleio_packet_buffer_type);
diff --git a/shared-bindings/_bleio/UUID.c b/shared-bindings/_bleio/UUID.c
index 2d28d5a9b61a6..165c2982f08a4 100644
--- a/shared-bindings/_bleio/UUID.c
+++ b/shared-bindings/_bleio/UUID.c
@@ -40,10 +40,8 @@ static mp_obj_t bleio_uuid_make_new(const mp_obj_type_t *type, size_t n_args, si
     uint8_t uuid128[16];
 
     if (mp_obj_is_int(value)) {
-        mp_int_t uuid16 = mp_obj_get_int(value);
-        if (uuid16 < 0 || uuid16 > 0xffff) {
-            mp_raise_ValueError(MP_ERROR_TEXT("UUID integer value must be 0-0xffff"));
-        }
+        const mp_int_t uuid16 =
+            mp_arg_validate_int_range(mp_obj_get_int(value), 0, 0xffff, MP_QSTR_value);
 
         // NULL means no 128-bit value.
         common_hal_bleio_uuid_construct(self, uuid16, NULL);
@@ -82,9 +80,7 @@ static mp_obj_t bleio_uuid_make_new(const mp_obj_type_t *type, size_t n_args, si
                 mp_raise_ValueError(MP_ERROR_TEXT("UUID value is not str, int or byte buffer"));
             }
 
-            if (bufinfo.len != 16) {
-                mp_raise_ValueError(MP_ERROR_TEXT("Byte buffer must be 16 bytes."));
-            }
+            mp_arg_validate_length(bufinfo.len, 16, MP_QSTR_value);
 
             memcpy(uuid128, bufinfo.buf, 16);
         }
@@ -171,12 +167,12 @@ static mp_obj_t bleio_uuid_pack_into(mp_uint_t n_args, const mp_obj_t *pos_args,
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[ARG_buffer].u_obj, &bufinfo, MP_BUFFER_WRITE);
 
-    size_t offset = args[ARG_offset].u_int;
-    if (offset + common_hal_bleio_uuid_get_size(self) / 8 > bufinfo.len) {
-        mp_raise_ValueError(MP_ERROR_TEXT("Buffer + offset too small %d %d %d"));
-    }
+    const mp_int_t offset =
+        mp_arg_validate_int_range(args[ARG_offset].u_int, 0, (mp_int_t)bufinfo.len, MP_QSTR_offset);
+    const size_t packed_len = common_hal_bleio_uuid_get_size(self) / 8;
+    mp_arg_validate_length_min(bufinfo.len - (size_t)offset, packed_len, MP_QSTR_buffer);
 
-    common_hal_bleio_uuid_pack_into(self, bufinfo.buf + offset);
+    common_hal_bleio_uuid_pack_into(self, (uint8_t *)bufinfo.buf + (size_t)offset);
     return mp_const_none;
 }
 static MP_DEFINE_CONST_FUN_OBJ_KW(bleio_uuid_pack_into_obj, 1, bleio_uuid_pack_into);
diff --git a/shared-bindings/_bleio/__init__.h b/shared-bindings/_bleio/__init__.h
index faf11ea1d0637..f7428d2fb2138 100644
--- a/shared-bindings/_bleio/__init__.h
+++ b/shared-bindings/_bleio/__init__.h
@@ -50,14 +50,6 @@ NORETURN void mp_raise_bleio_RoleError(mp_rom_error_text_t msg);
 NORETURN void mp_raise_bleio_SecurityError(mp_rom_error_text_t msg, ...);
 
 bleio_adapter_obj_t *common_hal_bleio_allocate_adapter_or_raise(void);
-void common_hal_bleio_check_connected(uint16_t conn_handle);
-
-uint16_t common_hal_bleio_device_get_conn_handle(mp_obj_t device);
 void common_hal_bleio_device_discover_remote_services(mp_obj_t device, mp_obj_t service_uuids_whitelist);
 
-size_t common_hal_bleio_gatts_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len);
-void common_hal_bleio_gatts_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo);
-size_t common_hal_bleio_gattc_read(uint16_t handle, uint16_t conn_handle, uint8_t *buf, size_t len);
-void common_hal_bleio_gattc_write(uint16_t handle, uint16_t conn_handle, mp_buffer_info_t *bufinfo, bool write_no_response);
-
 void common_hal_bleio_gc_collect(void);