bumble 0.0.204__py3-none-any.whl → 0.0.208__py3-none-any.whl

bumble/device.py

@@ -17,7 +17,8 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 import asyncio
-from collections.abc import Iterable
+import collections
+from collections.abc import Iterable, Sequence
 from contextlib import (
     asynccontextmanager,
     AsyncExitStack,
@@ -36,10 +37,9 @@ from typing import (
     Any,
     Callable,
     ClassVar,
+    Deque,
     Dict,
-    List,
     Optional,
-    Tuple,
     Type,
     TypeVar,
     Union,
@@ -53,8 +53,8 @@ from pyee import EventEmitter
 
 from .colors import color
 from .att import ATT_CID, ATT_DEFAULT_MTU, ATT_PDU
-from .gatt import Characteristic, Descriptor, Service
-from .host import Host
+from .gatt import Attribute, Characteristic, Descriptor, Service
+from .host import DataPacketQueue, Host
 from .profiles.gap import GenericAccessService
 from .core import (
     BT_BR_EDR_TRANSPORT,
@@ -95,6 +95,7 @@ from bumble import smp
 from bumble import sdp
 from bumble import l2cap
 from bumble import core
+from bumble.profiles import gatt_service
 
 if TYPE_CHECKING:
     from .transport.common import TransportSource, TransportSink
@@ -119,6 +120,10 @@ DEVICE_MIN_LE_RSSI                            = -127
 DEVICE_MAX_LE_RSSI                            = 20
 DEVICE_MIN_EXTENDED_ADVERTISING_SET_HANDLE    = 0x00
 DEVICE_MAX_EXTENDED_ADVERTISING_SET_HANDLE    = 0xEF
+DEVICE_MIN_BIG_HANDLE                         = 0x00
+DEVICE_MAX_BIG_HANDLE                         = 0xEF
+DEVICE_MIN_CS_CONFIG_ID                       = 0x00
+DEVICE_MAX_CS_CONFIG_ID                       = 0x03
 
 DEVICE_DEFAULT_ADDRESS                        = '00:00:00:00:00:00'
 DEVICE_DEFAULT_ADVERTISING_INTERVAL           = 1000  # ms
@@ -254,7 +259,7 @@ class ExtendedAdvertisement(Advertisement):
             secondary_phy    = report.secondary_phy,
             tx_power         = report.tx_power,
             sid              = report.advertising_sid,
-            data_bytes       = report.data
+            data_bytes       = report.data,
         )
         # fmt: on
 
@@ -380,8 +385,12 @@ class LegacyAdvertiser:
         # Set the advertising parameters
         await self.device.send_command(
             hci.HCI_LE_Set_Advertising_Parameters_Command(
-                advertising_interval_min=self.device.advertising_interval_min,
-                advertising_interval_max=self.device.advertising_interval_max,
+                advertising_interval_min=int(
+                    self.device.advertising_interval_min / 0.625
+                ),
+                advertising_interval_max=int(
+                    self.device.advertising_interval_max / 0.625
+                ),
                 advertising_type=int(self.advertising_type),
                 own_address_type=self.own_address_type,
                 peer_address_type=self.peer_address.address_type,
@@ -905,11 +914,11 @@ class PeriodicAdvertisingSync(EventEmitter):
 
     def on_establishment(
         self,
-        status,
-        sync_handle,
-        advertiser_phy,
-        periodic_advertising_interval,
-        advertiser_clock_accuracy,
+        status: int,
+        sync_handle: int,
+        advertiser_phy: int,
+        periodic_advertising_interval: int,
+        advertiser_clock_accuracy: int,
     ) -> None:
         self.status = status
 
@@ -992,6 +1001,196 @@ class PeriodicAdvertisingSync(EventEmitter):
         )
 
 
+# -----------------------------------------------------------------------------
+@dataclass
+class BigParameters:
+    num_bis: int
+    sdu_interval: int
+    max_sdu: int
+    max_transport_latency: int
+    rtn: int
+    phy: hci.PhyBit = hci.PhyBit.LE_2M
+    packing: int = 0
+    framing: int = 0
+    broadcast_code: bytes | None = None
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class Big(EventEmitter):
+    class State(IntEnum):
+        PENDING = 0
+        ACTIVE = 1
+        TERMINATED = 2
+
+    class Event(str, Enum):
+        ESTABLISHMENT = 'establishment'
+        ESTABLISHMENT_FAILURE = 'establishment_failure'
+        TERMINATION = 'termination'
+
+    big_handle: int
+    advertising_set: AdvertisingSet
+    parameters: BigParameters
+    state: State = State.PENDING
+
+    # Attributes provided by BIG Create Complete event
+    big_sync_delay: int = 0
+    transport_latency_big: int = 0
+    phy: int = 0
+    nse: int = 0
+    bn: int = 0
+    pto: int = 0
+    irc: int = 0
+    max_pdu: int = 0
+    iso_interval: int = 0
+    bis_links: Sequence[BisLink] = ()
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        self.device = self.advertising_set.device
+
+    async def terminate(
+        self,
+        reason: int = hci.HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR,
+    ) -> None:
+        if self.state != Big.State.ACTIVE:
+            logger.error('BIG %d is not active.', self.big_handle)
+            return
+
+        with closing(EventWatcher()) as watcher:
+            terminated = asyncio.Event()
+            watcher.once(self, Big.Event.TERMINATION, lambda _: terminated.set())
+            await self.device.send_command(
+                hci.HCI_LE_Terminate_BIG_Command(
+                    big_handle=self.big_handle, reason=reason
+                ),
+                check_result=True,
+            )
+            await terminated.wait()
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class BigSyncParameters:
+    big_sync_timeout: int
+    bis: Sequence[int]
+    mse: int = 0
+    broadcast_code: bytes | None = None
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class BigSync(EventEmitter):
+    class State(IntEnum):
+        PENDING = 0
+        ACTIVE = 1
+        TERMINATED = 2
+
+    class Event(str, Enum):
+        ESTABLISHMENT = 'establishment'
+        ESTABLISHMENT_FAILURE = 'establishment_failure'
+        TERMINATION = 'termination'
+
+    big_handle: int
+    pa_sync: PeriodicAdvertisingSync
+    parameters: BigSyncParameters
+    state: State = State.PENDING
+
+    # Attributes provided by BIG Create Sync Complete event
+    transport_latency_big: int = 0
+    nse: int = 0
+    bn: int = 0
+    pto: int = 0
+    irc: int = 0
+    max_pdu: int = 0
+    iso_interval: int = 0
+    bis_links: Sequence[BisLink] = ()
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        self.device = self.pa_sync.device
+
+    async def terminate(self) -> None:
+        if self.state != BigSync.State.ACTIVE:
+            logger.error('BIG Sync %d is not active.', self.big_handle)
+            return
+
+        with closing(EventWatcher()) as watcher:
+            terminated = asyncio.Event()
+            watcher.once(self, BigSync.Event.TERMINATION, lambda _: terminated.set())
+            await self.device.send_command(
+                hci.HCI_LE_BIG_Terminate_Sync_Command(big_handle=self.big_handle),
+                check_result=True,
+            )
+            await terminated.wait()
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class ChannelSoundingCapabilities:
+    num_config_supported: int
+    max_consecutive_procedures_supported: int
+    num_antennas_supported: int
+    max_antenna_paths_supported: int
+    roles_supported: int
+    modes_supported: int
+    rtt_capability: int
+    rtt_aa_only_n: int
+    rtt_sounding_n: int
+    rtt_random_payload_n: int
+    nadm_sounding_capability: int
+    nadm_random_capability: int
+    cs_sync_phys_supported: int
+    subfeatures_supported: int
+    t_ip1_times_supported: int
+    t_ip2_times_supported: int
+    t_fcs_times_supported: int
+    t_pm_times_supported: int
+    t_sw_time_supported: int
+    tx_snr_capability: int
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class ChannelSoundingConfig:
+    config_id: int
+    main_mode_type: int
+    sub_mode_type: int
+    min_main_mode_steps: int
+    max_main_mode_steps: int
+    main_mode_repetition: int
+    mode_0_steps: int
+    role: int
+    rtt_type: int
+    cs_sync_phy: int
+    channel_map: bytes
+    channel_map_repetition: int
+    channel_selection_type: int
+    ch3c_shape: int
+    ch3c_jump: int
+    reserved: int
+    t_ip1_time: int
+    t_ip2_time: int
+    t_fcs_time: int
+    t_pm_time: int
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class ChannelSoundingProcedure:
+    config_id: int
+    state: int
+    tone_antenna_config_selection: int
+    selected_tx_power: int
+    subevent_len: int
+    subevents_per_event: int
+    subevent_interval: int
+    event_interval: int
+    procedure_interval: int
+    procedure_count: int
+    max_procedure_len: int
+
+
 # -----------------------------------------------------------------------------
 class LePhyOptions:
     # Coded PHY preference
@@ -1019,7 +1218,7 @@ class Peer:
         connection.gatt_client = self.gatt_client
 
     @property
-    def services(self) -> List[gatt_client.ServiceProxy]:
+    def services(self) -> list[gatt_client.ServiceProxy]:
         return self.gatt_client.services
 
     async def request_mtu(self, mtu: int) -> int:
@@ -1029,24 +1228,24 @@ class Peer:
 
     async def discover_service(
         self, uuid: Union[core.UUID, str]
-    ) -> List[gatt_client.ServiceProxy]:
+    ) -> list[gatt_client.ServiceProxy]:
         return await self.gatt_client.discover_service(uuid)
 
     async def discover_services(
         self, uuids: Iterable[core.UUID] = ()
-    ) -> List[gatt_client.ServiceProxy]:
+    ) -> list[gatt_client.ServiceProxy]:
         return await self.gatt_client.discover_services(uuids)
 
     async def discover_included_services(
         self, service: gatt_client.ServiceProxy
-    ) -> List[gatt_client.ServiceProxy]:
+    ) -> list[gatt_client.ServiceProxy]:
         return await self.gatt_client.discover_included_services(service)
 
     async def discover_characteristics(
         self,
         uuids: Iterable[Union[core.UUID, str]] = (),
         service: Optional[gatt_client.ServiceProxy] = None,
-    ) -> List[gatt_client.CharacteristicProxy]:
+    ) -> list[gatt_client.CharacteristicProxy]:
         return await self.gatt_client.discover_characteristics(
             uuids=uuids, service=service
         )
@@ -1061,7 +1260,7 @@ class Peer:
             characteristic, start_handle, end_handle
         )
 
-    async def discover_attributes(self) -> List[gatt_client.AttributeProxy]:
+    async def discover_attributes(self) -> list[gatt_client.AttributeProxy]:
         return await self.gatt_client.discover_attributes()
 
     async def discover_all(self):
@@ -1105,17 +1304,17 @@ class Peer:
 
     async def read_characteristics_by_uuid(
         self, uuid: core.UUID, service: Optional[gatt_client.ServiceProxy] = None
-    ) -> List[bytes]:
+    ) -> list[bytes]:
         return await self.gatt_client.read_characteristics_by_uuid(uuid, service)
 
-    def get_services_by_uuid(self, uuid: core.UUID) -> List[gatt_client.ServiceProxy]:
+    def get_services_by_uuid(self, uuid: core.UUID) -> list[gatt_client.ServiceProxy]:
         return self.gatt_client.get_services_by_uuid(uuid)
 
     def get_characteristics_by_uuid(
         self,
         uuid: core.UUID,
         service: Optional[Union[gatt_client.ServiceProxy, core.UUID]] = None,
-    ) -> List[gatt_client.CharacteristicProxy]:
+    ) -> list[gatt_client.CharacteristicProxy]:
         if isinstance(service, core.UUID):
             return list(
                 itertools.chain(
@@ -1172,8 +1371,8 @@ class Peer:
 @dataclass
 class ConnectionParametersPreferences:
     default: ClassVar[ConnectionParametersPreferences]
-    connection_interval_min: int = DEVICE_DEFAULT_CONNECTION_INTERVAL_MIN
-    connection_interval_max: int = DEVICE_DEFAULT_CONNECTION_INTERVAL_MAX
+    connection_interval_min: float = DEVICE_DEFAULT_CONNECTION_INTERVAL_MIN
+    connection_interval_max: float = DEVICE_DEFAULT_CONNECTION_INTERVAL_MAX
     max_latency: int = DEVICE_DEFAULT_CONNECTION_MAX_LATENCY
     supervision_timeout: int = DEVICE_DEFAULT_CONNECTION_SUPERVISION_TIMEOUT
     min_ce_length: int = DEVICE_DEFAULT_CONNECTION_MIN_CE_LENGTH
@@ -1201,9 +1400,82 @@ class ScoLink(CompositeEventEmitter):
         await self.device.disconnect(self, reason)
 
 
+# -----------------------------------------------------------------------------
+class _IsoLink:
+    handle: int
+    device: Device
+    sink: Callable[[hci.HCI_IsoDataPacket], Any] | None = None
+
+    class Direction(IntEnum):
+        HOST_TO_CONTROLLER = (
+            hci.HCI_LE_Setup_ISO_Data_Path_Command.Direction.HOST_TO_CONTROLLER
+        )
+        CONTROLLER_TO_HOST = (
+            hci.HCI_LE_Setup_ISO_Data_Path_Command.Direction.CONTROLLER_TO_HOST
+        )
+
+    async def setup_data_path(
+        self,
+        direction: _IsoLink.Direction,
+        data_path_id: int = 0,
+        codec_id: hci.CodingFormat | None = None,
+        controller_delay: int = 0,
+        codec_configuration: bytes = b'',
+    ) -> None:
+        """Create a data path between controller and given entry.
+
+        Args:
+            direction: Direction of data path.
+            data_path_id: ID of data path. Default is 0 (HCI).
+            codec_id: Codec ID. Default is Transparent.
+            controller_delay: Controller delay in microseconds. Default is 0.
+            codec_configuration: Codec-specific configuration.
+
+        Raises:
+            HCI_Error: When command complete status is not HCI_SUCCESS.
+        """
+        await self.device.send_command(
+            hci.HCI_LE_Setup_ISO_Data_Path_Command(
+                connection_handle=self.handle,
+                data_path_direction=direction,
+                data_path_id=data_path_id,
+                codec_id=codec_id or hci.CodingFormat(hci.CodecID.TRANSPARENT),
+                controller_delay=controller_delay,
+                codec_configuration=codec_configuration,
+            ),
+            check_result=True,
+        )
+
+    async def remove_data_path(self, direction: _IsoLink.Direction) -> int:
+        """Remove a data path with controller on given direction.
+
+        Args:
+            direction: Direction of data path.
+
+        Returns:
+            Command status.
+        """
+        response = await self.device.send_command(
+            hci.HCI_LE_Remove_ISO_Data_Path_Command(
+                connection_handle=self.handle,
+                data_path_direction=direction,
+            ),
+            check_result=False,
+        )
+        return response.return_parameters.status
+
+    def write(self, sdu: bytes) -> None:
+        """Write an ISO SDU."""
+        self.device.host.send_iso_sdu(connection_handle=self.handle, sdu=sdu)
+
+    @property
+    def data_packet_queue(self) -> DataPacketQueue | None:
+        return self.device.host.get_data_packet_queue(self.handle)
+
+
 # -----------------------------------------------------------------------------
 @dataclass
-class CisLink(CompositeEventEmitter):
+class CisLink(CompositeEventEmitter, _IsoLink):
     class State(IntEnum):
         PENDING = 0
         ESTABLISHED = 1
@@ -1214,7 +1486,7 @@ class CisLink(CompositeEventEmitter):
     cis_id: int  # CIS ID assigned by Central device
     cig_id: int  # CIG ID assigned by Central device
     state: State = State.PENDING
-    sink: Optional[Callable[[hci.HCI_IsoDataPacket], Any]] = None
+    sink: Callable[[hci.HCI_IsoDataPacket], Any] | None = None
 
     def __post_init__(self) -> None:
         super().__init__()
@@ -1225,6 +1497,60 @@ class CisLink(CompositeEventEmitter):
         await self.device.disconnect(self, reason)
 
 
+# -----------------------------------------------------------------------------
+@dataclass
+class BisLink(_IsoLink):
+    handle: int
+    big: Big | BigSync
+    sink: Callable[[hci.HCI_IsoDataPacket], Any] | None = None
+
+    def __post_init__(self) -> None:
+        self.device = self.big.device
+
+
+# -----------------------------------------------------------------------------
+class IsoPacketStream:
+    """Async stream that can write SDUs to a CIS or BIS, with a maximum queue size."""
+
+    iso_link: _IsoLink
+    data_packet_queue: DataPacketQueue
+
+    def __init__(self, iso_link: _IsoLink, max_queue_size: int) -> None:
+        if iso_link.data_packet_queue is None:
+            raise ValueError('link has no data packet queue')
+
+        self.iso_link = iso_link
+        self.data_packet_queue = iso_link.data_packet_queue
+        self.data_packet_queue.on('flow', self._on_flow)
+        self._thresholds: Deque[int] = collections.deque()
+        self._semaphore = asyncio.Semaphore(max_queue_size)
+
+    def _on_flow(self) -> None:
+        # Release the semaphore once for each completed packet.
+        while (
+            self._thresholds and self.data_packet_queue.completed >= self._thresholds[0]
+        ):
+            self._thresholds.popleft()
+            self._semaphore.release()
+
+    async def write(self, sdu: bytes) -> None:
+        """
+        Write an SDU to the queue.
+
+        This method blocks until there are fewer than max_queue_size packets queued
+        but not yet completed.
+        """
+
+        # Wait until there's space in the queue.
+        await self._semaphore.acquire()
+
+        # Queue the packet.
+        self.iso_link.write(sdu)
+
+        # Remember the position of the packet so we can know when it is completed.
+        self._thresholds.append(self.data_packet_queue.queued)
+
+
 # -----------------------------------------------------------------------------
 class Connection(CompositeEventEmitter):
     device: Device
@@ -1243,6 +1569,8 @@ class Connection(CompositeEventEmitter):
     gatt_client: gatt_client.Client
     pairing_peer_io_capability: Optional[int]
     pairing_peer_authentication_requirements: Optional[int]
+    cs_configs: dict[int, ChannelSoundingConfig]  # Config ID to Configuration
+    cs_procedures: dict[int, ChannelSoundingProcedure]  # Config ID to Procedures
 
     @composite_listener
     class Listener:
@@ -1258,7 +1586,7 @@ class Connection(CompositeEventEmitter):
         def on_connection_data_length_change(self):
             pass
 
-        def on_connection_phy_update(self):
+        def on_connection_phy_update(self, phy):
             pass
 
         def on_connection_phy_update_failure(self, error):
@@ -1284,7 +1612,6 @@ class Connection(CompositeEventEmitter):
         peer_resolvable_address,
         role,
         parameters,
-        phy,
     ):
         super().__init__()
         self.device = device
@@ -1301,7 +1628,6 @@ class Connection(CompositeEventEmitter):
         self.authenticated = False
         self.sc = False
         self.link_key_type = None
-        self.phy = phy
         self.att_mtu = ATT_DEFAULT_MTU
         self.data_length = DEVICE_DEFAULT_DATA_LENGTH
         self.gatt_client = None  # Per-connection client
@@ -1311,6 +1637,8 @@ class Connection(CompositeEventEmitter):
         self.pairing_peer_io_capability = None
         self.pairing_peer_authentication_requirements = None
         self.peer_le_features = None
+        self.cs_configs = {}
+        self.cs_procedures = {}
 
     # [Classic only]
     @classmethod
@@ -1330,7 +1658,6 @@ class Connection(CompositeEventEmitter):
             None,
             role,
             None,
-            None,
         )
 
     # [Classic only]
@@ -1446,12 +1773,12 @@ class Connection(CompositeEventEmitter):
     async def set_phy(self, tx_phys=None, rx_phys=None, phy_options=None):
         return await self.device.set_connection_phy(self, tx_phys, rx_phys, phy_options)
 
+    async def get_phy(self) -> ConnectionPHY:
+        return await self.device.get_connection_phy(self)
+
     async def get_rssi(self):
         return await self.device.get_connection_rssi(self)
 
-    async def get_phy(self):
-        return await self.device.get_connection_phy(self)
-
     async def transfer_periodic_sync(
         self, sync_handle: int, service_data: int = 0
     ) -> None:
@@ -1470,6 +1797,10 @@ class Connection(CompositeEventEmitter):
         self.peer_le_features = await self.device.get_remote_le_features(self)
         return self.peer_le_features
 
+    @property
+    def data_packet_queue(self) -> DataPacketQueue | None:
+        return self.device.host.get_data_packet_queue(self.handle)
+
     async def __aenter__(self):
         return self
 
@@ -1533,11 +1864,14 @@ class DeviceConfiguration:
     address_resolution_offload: bool = False
     address_generation_offload: bool = False
     cis_enabled: bool = False
+    channel_sounding_enabled: bool = False
     identity_address_type: Optional[int] = None
     io_capability: int = pairing.PairingDelegate.IoCapability.NO_OUTPUT_NO_INPUT
+    gap_service_enabled: bool = True
+    gatt_service_enabled: bool = True
 
     def __post_init__(self) -> None:
-        self.gatt_services: List[Dict[str, Any]] = []
+        self.gatt_services: list[Dict[str, Any]] = []
 
     def load_from_dict(self, config: Dict[str, Any]) -> None:
         config = copy.deepcopy(config)
@@ -1684,7 +2018,7 @@ def host_event_handler(function):
 # List of host event handlers for the Device class.
 # (we define this list outside the class, because referencing a class in method
 #  decorators is not straightforward)
-device_host_event_handlers: List[str] = []
+device_host_event_handlers: list[str] = []
 
 
 # -----------------------------------------------------------------------------
@@ -1701,19 +2035,24 @@ class Device(CompositeEventEmitter):
     gatt_server: gatt_server.Server
     advertising_data: bytes
     scan_response_data: bytes
+    cs_capabilities: ChannelSoundingCapabilities | None = None
     connections: Dict[int, Connection]
     pending_connections: Dict[hci.Address, Connection]
     classic_pending_accepts: Dict[
         hci.Address,
-        List[asyncio.Future[Union[Connection, Tuple[hci.Address, int, int]]]],
+        list[asyncio.Future[Union[Connection, tuple[hci.Address, int, int]]]],
     ]
     advertisement_accumulators: Dict[hci.Address, AdvertisementDataAccumulator]
-    periodic_advertising_syncs: List[PeriodicAdvertisingSync]
+    periodic_advertising_syncs: list[PeriodicAdvertisingSync]
     config: DeviceConfiguration
     legacy_advertiser: Optional[LegacyAdvertiser]
     sco_links: Dict[int, ScoLink]
     cis_links: Dict[int, CisLink]
-    _pending_cis: Dict[int, Tuple[int, int]]
+    bigs: dict[int, Big]
+    bis_links: dict[int, BisLink]
+    big_syncs: dict[int, BigSync]
+    _pending_cis: Dict[int, tuple[int, int]]
+    gatt_service: gatt_service.GenericAttributeProfileService | None = None
 
     @composite_listener
     class Listener:
@@ -1780,7 +2119,6 @@ class Device(CompositeEventEmitter):
         address: Optional[hci.Address] = None,
         config: Optional[DeviceConfiguration] = None,
         host: Optional[Host] = None,
-        generic_access_service: bool = True,
     ) -> None:
         super().__init__()
 
@@ -1805,6 +2143,9 @@ class Device(CompositeEventEmitter):
         self.sco_links = {}  # ScoLinks, by connection handle (BR/EDR only)
         self.cis_links = {}  # CisLinks, by connection handle (LE only)
         self._pending_cis = {}  # (CIS_ID, CIG_ID), by CIS_handle
+        self.bigs = {}
+        self.bis_links = {}
+        self.big_syncs = {}
         self.classic_enabled = False
         self.inquiry_response = None
         self.address_resolver = None
@@ -1882,7 +2223,7 @@ class Device(CompositeEventEmitter):
                         permissions=descriptor["permissions"],
                     )
                     descriptors.append(new_descriptor)
-                new_characteristic = Characteristic(
+                new_characteristic: Characteristic[bytes] = Characteristic(
                     uuid=characteristic["uuid"],
                     properties=Characteristic.Properties.from_string(
                         characteristic["properties"]
@@ -1927,7 +2268,10 @@ class Device(CompositeEventEmitter):
         # Register the SDP server with the L2CAP Channel Manager
         self.sdp_server.register(self.l2cap_channel_manager)
 
-        self.add_default_services(generic_access_service)
+        self.add_default_services(
+            add_gap_service=config.gap_service_enabled,
+            add_gatt_service=config.gatt_service_enabled,
+        )
         self.l2cap_channel_manager.register_fixed_channel(ATT_CID, self.on_gatt_pdu)
 
         # Forward some events
@@ -2009,6 +2353,17 @@ class Device(CompositeEventEmitter):
             None,
         )
 
+    def next_big_handle(self) -> int | None:
+        return next(
+            (
+                handle
+                for handle in range(DEVICE_MIN_BIG_HANDLE, DEVICE_MAX_BIG_HANDLE + 1)
+                if handle
+                not in itertools.chain(self.bigs.keys(), self.big_syncs.keys())
+            ),
+            None,
+        )
+
     @deprecated("Please use create_l2cap_server()")
     def register_l2cap_server(self, psm, server) -> int:
         return self.l2cap_channel_manager.register_server(psm, server)
@@ -2167,7 +2522,7 @@ class Device(CompositeEventEmitter):
             if self.random_address != hci.Address.ANY_RANDOM:
                 logger.debug(
                     color(
-                        f'LE Random hci.Address: {self.random_address}',
+                        f'LE Random Address: {self.random_address}',
                         'yellow',
                     )
                 )
@@ -2200,6 +2555,41 @@ class Device(CompositeEventEmitter):
                     check_result=True,
                 )
 
+            if self.config.channel_sounding_enabled:
+                await self.send_command(
+                    hci.HCI_LE_Set_Host_Feature_Command(
+                        bit_number=hci.LeFeature.CHANNEL_SOUNDING_HOST_SUPPORT,
+                        bit_value=1,
+                    ),
+                    check_result=True,
+                )
+                result = await self.send_command(
+                    hci.HCI_LE_CS_Read_Local_Supported_Capabilities_Command(),
+                    check_result=True,
+                )
+                self.cs_capabilities = ChannelSoundingCapabilities(
+                    num_config_supported=result.return_parameters.num_config_supported,
+                    max_consecutive_procedures_supported=result.return_parameters.max_consecutive_procedures_supported,
+                    num_antennas_supported=result.return_parameters.num_antennas_supported,
+                    max_antenna_paths_supported=result.return_parameters.max_antenna_paths_supported,
+                    roles_supported=result.return_parameters.roles_supported,
+                    modes_supported=result.return_parameters.modes_supported,
+                    rtt_capability=result.return_parameters.rtt_capability,
+                    rtt_aa_only_n=result.return_parameters.rtt_aa_only_n,
+                    rtt_sounding_n=result.return_parameters.rtt_sounding_n,
+                    rtt_random_payload_n=result.return_parameters.rtt_random_payload_n,
+                    nadm_sounding_capability=result.return_parameters.nadm_sounding_capability,
+                    nadm_random_capability=result.return_parameters.nadm_random_capability,
+                    cs_sync_phys_supported=result.return_parameters.cs_sync_phys_supported,
+                    subfeatures_supported=result.return_parameters.subfeatures_supported,
+                    t_ip1_times_supported=result.return_parameters.t_ip1_times_supported,
+                    t_ip2_times_supported=result.return_parameters.t_ip2_times_supported,
+                    t_fcs_times_supported=result.return_parameters.t_fcs_times_supported,
+                    t_pm_times_supported=result.return_parameters.t_pm_times_supported,
+                    t_sw_time_supported=result.return_parameters.t_sw_time_supported,
+                    tx_snr_capability=result.return_parameters.tx_snr_capability,
+                )
+
         if self.classic_enabled:
             await self.send_command(
                 hci.HCI_Write_Local_Name_Command(local_name=self.name.encode('utf8'))
@@ -2283,7 +2673,7 @@ class Device(CompositeEventEmitter):
         """Update the RPA periodically"""
         while self.le_rpa_timeout != 0:
             await asyncio.sleep(self.le_rpa_timeout)
-            if not self.update_rpa():
+            if not await self.update_rpa():
                 logger.debug("periodic RPA update failed")
 
     async def refresh_resolving_list(self) -> None:
@@ -2623,11 +3013,11 @@ class Device(CompositeEventEmitter):
         self,
         legacy: bool = False,
         active: bool = True,
-        scan_interval: int = DEVICE_DEFAULT_SCAN_INTERVAL,  # Scan interval in ms
-        scan_window: int = DEVICE_DEFAULT_SCAN_WINDOW,  # Scan window in ms
+        scan_interval: float = DEVICE_DEFAULT_SCAN_INTERVAL,  # Scan interval in ms
+        scan_window: float = DEVICE_DEFAULT_SCAN_WINDOW,  # Scan window in ms
         own_address_type: int = hci.OwnAddressType.RANDOM,
         filter_duplicates: bool = False,
-        scanning_phys: List[int] = [hci.HCI_LE_1M_PHY, hci.HCI_LE_CODED_PHY],
+        scanning_phys: Sequence[int] = (hci.HCI_LE_1M_PHY, hci.HCI_LE_CODED_PHY),
     ) -> None:
         # Check that the arguments are legal
         if scan_interval < scan_window:
@@ -2674,7 +3064,7 @@ class Device(CompositeEventEmitter):
                     scanning_filter_policy=scanning_filter_policy,
                     scanning_phys=scanning_phys_bits,
                     scan_types=[scan_type] * scanning_phy_count,
-                    scan_intervals=[int(scan_window / 0.625)] * scanning_phy_count,
+                    scan_intervals=[int(scan_interval / 0.625)] * scanning_phy_count,
                     scan_windows=[int(scan_window / 0.625)] * scanning_phy_count,
                 ),
                 check_result=True,
@@ -2840,6 +3230,41 @@ class Device(CompositeEventEmitter):
             "periodic advertising sync establishment for unknown address/sid"
         )
 
+    @host_event_handler
+    def on_periodic_advertising_sync_transfer(
+        self,
+        status: int,
+        connection_handle: int,
+        sync_handle: int,
+        advertising_sid: int,
+        advertiser_address: hci.Address,
+        advertiser_phy: int,
+        periodic_advertising_interval: int,
+        advertiser_clock_accuracy: int,
+    ) -> None:
+        if not (connection := self.lookup_connection(connection_handle)):
+            logger.error(
+                "Receive PAST from unknown connection 0x%04X", connection_handle
+            )
+
+        pa_sync = PeriodicAdvertisingSync(
+            device=self,
+            advertiser_address=advertiser_address,
+            sid=advertising_sid,
+            skip=0,
+            sync_timeout=0.0,
+            filter_duplicates=False,
+        )
+        self.periodic_advertising_syncs.append(pa_sync)
+        pa_sync.on_establishment(
+            status=status,
+            sync_handle=sync_handle,
+            advertiser_phy=advertiser_phy,
+            periodic_advertising_interval=periodic_advertising_interval,
+            advertiser_clock_accuracy=advertiser_clock_accuracy,
+        )
+        self.emit('periodic_advertising_sync_transfer', pa_sync, connection)
+
     @host_event_handler
     @with_periodic_advertising_sync_from_handle
     def on_periodic_advertising_sync_loss(
@@ -3514,12 +3939,14 @@ class Device(CompositeEventEmitter):
         )
         return result.return_parameters.rssi
 
-    async def get_connection_phy(self, connection):
+    async def get_connection_phy(self, connection: Connection) -> ConnectionPHY:
         result = await self.send_command(
             hci.HCI_LE_Read_PHY_Command(connection_handle=connection.handle),
             check_result=True,
         )
-        return (result.return_parameters.tx_phy, result.return_parameters.rx_phy)
+        return ConnectionPHY(
+            result.return_parameters.tx_phy, result.return_parameters.rx_phy
+        )
 
     async def set_connection_phy(
         self, connection, tx_phys=None, rx_phys=None, phy_options=None
@@ -3583,13 +4010,12 @@ class Device(CompositeEventEmitter):
         # Create a future to wait for an address to be found
         peer_address = asyncio.get_running_loop().create_future()
 
-        def on_peer_found(address, ad_data):
-            local_name = ad_data.get(AdvertisingData.COMPLETE_LOCAL_NAME, raw=True)
-            if local_name is None:
-                local_name = ad_data.get(AdvertisingData.SHORTENED_LOCAL_NAME, raw=True)
-            if local_name is not None:
-                if local_name.decode('utf-8') == name:
-                    peer_address.set_result(address)
+        def on_peer_found(address: hci.Address, ad_data: AdvertisingData) -> None:
+            local_name = ad_data.get(
+                AdvertisingData.Type.COMPLETE_LOCAL_NAME
+            ) or ad_data.get(AdvertisingData.Type.SHORTENED_LOCAL_NAME)
+            if local_name == name:
+                peer_address.set_result(address)
 
         listener = None
         was_scanning = self.scanning
@@ -3958,13 +4384,13 @@ class Device(CompositeEventEmitter):
     async def setup_cig(
         self,
         cig_id: int,
-        cis_id: List[int],
-        sdu_interval: Tuple[int, int],
+        cis_id: Sequence[int],
+        sdu_interval: tuple[int, int],
         framing: int,
-        max_sdu: Tuple[int, int],
+        max_sdu: tuple[int, int],
         retransmission_number: int,
-        max_transport_latency: Tuple[int, int],
-    ) -> List[int]:
+        max_transport_latency: tuple[int, int],
+    ) -> list[int]:
         """Sends hci.HCI_LE_Set_CIG_Parameters_Command.
 
         Args:
@@ -4013,7 +4439,9 @@ class Device(CompositeEventEmitter):
 
     # [LE only]
     @experimental('Only for testing.')
-    async def create_cis(self, cis_acl_pairs: List[Tuple[int, int]]) -> List[CisLink]:
+    async def create_cis(
+        self, cis_acl_pairs: Sequence[tuple[int, int]]
+    ) -> list[CisLink]:
         for cis_handle, acl_handle in cis_acl_pairs:
             acl_connection = self.lookup_connection(acl_handle)
             assert acl_connection
@@ -4112,6 +4540,106 @@ class Device(CompositeEventEmitter):
             check_result=True,
         )
 
+    # [LE only]
+    @experimental('Only for testing.')
+    async def create_big(
+        self, advertising_set: AdvertisingSet, parameters: BigParameters
+    ) -> Big:
+        if (big_handle := self.next_big_handle()) is None:
+            raise core.OutOfResourcesError("All valid BIG handles already in use")
+
+        with closing(EventWatcher()) as watcher:
+            big = Big(
+                big_handle=big_handle,
+                parameters=parameters,
+                advertising_set=advertising_set,
+            )
+            self.bigs[big_handle] = big
+            established = asyncio.get_running_loop().create_future()
+            watcher.once(
+                big, big.Event.ESTABLISHMENT, lambda: established.set_result(None)
+            )
+            watcher.once(
+                big,
+                big.Event.ESTABLISHMENT_FAILURE,
+                lambda status: established.set_exception(hci.HCI_Error(status)),
+            )
+
+            try:
+                await self.send_command(
+                    hci.HCI_LE_Create_BIG_Command(
+                        big_handle=big_handle,
+                        advertising_handle=advertising_set.advertising_handle,
+                        num_bis=parameters.num_bis,
+                        sdu_interval=parameters.sdu_interval,
+                        max_sdu=parameters.max_sdu,
+                        max_transport_latency=parameters.max_transport_latency,
+                        rtn=parameters.rtn,
+                        phy=parameters.phy,
+                        packing=parameters.packing,
+                        framing=parameters.framing,
+                        encryption=1 if parameters.broadcast_code else 0,
+                        broadcast_code=parameters.broadcast_code or bytes(16),
+                    ),
+                    check_result=True,
+                )
+                await established
+            except hci.HCI_Error:
+                del self.bigs[big_handle]
+                raise
+
+        return big
+
+    # [LE only]
+    @experimental('Only for testing.')
+    async def create_big_sync(
+        self, pa_sync: PeriodicAdvertisingSync, parameters: BigSyncParameters
+    ) -> BigSync:
+        if (big_handle := self.next_big_handle()) is None:
+            raise core.OutOfResourcesError("All valid BIG handles already in use")
+
+        if (pa_sync_handle := pa_sync.sync_handle) is None:
+            raise core.InvalidStateError("PA Sync is not established")
+
+        with closing(EventWatcher()) as watcher:
+            big_sync = BigSync(
+                big_handle=big_handle,
+                parameters=parameters,
+                pa_sync=pa_sync,
+            )
+            self.big_syncs[big_handle] = big_sync
+            established = asyncio.get_running_loop().create_future()
+            watcher.once(
+                big_sync,
+                big_sync.Event.ESTABLISHMENT,
+                lambda: established.set_result(None),
+            )
+            watcher.once(
+                big_sync,
+                big_sync.Event.ESTABLISHMENT_FAILURE,
+                lambda status: established.set_exception(hci.HCI_Error(status)),
+            )
+
+            try:
+                await self.send_command(
+                    hci.HCI_LE_BIG_Create_Sync_Command(
+                        big_handle=big_handle,
+                        sync_handle=pa_sync_handle,
+                        encryption=1 if parameters.broadcast_code else 0,
+                        broadcast_code=parameters.broadcast_code or bytes(16),
+                        mse=parameters.mse,
+                        big_sync_timeout=parameters.big_sync_timeout,
+                        bis=parameters.bis,
+                    ),
+                    check_result=True,
+                )
+                await established
+            except hci.HCI_Error:
+                del self.big_syncs[big_handle]
+                raise
+
+        return big_sync
+
     async def get_remote_le_features(self, connection: Connection) -> hci.LeFeatureMask:
         """[LE Only] Reads remote LE supported features.
 
@@ -4144,6 +4672,213 @@ class Device(CompositeEventEmitter):
             )
             return await read_feature_future
 
+    @experimental('Only for testing.')
+    async def get_remote_cs_capabilities(
+        self, connection: Connection
+    ) -> ChannelSoundingCapabilities:
+        complete_future: asyncio.Future[ChannelSoundingCapabilities] = (
+            asyncio.get_running_loop().create_future()
+        )
+
+        with closing(EventWatcher()) as watcher:
+            watcher.once(
+                connection, 'channel_sounding_capabilities', complete_future.set_result
+            )
+            watcher.once(
+                connection,
+                'channel_sounding_capabilities_failure',
+                lambda status: complete_future.set_exception(hci.HCI_Error(status)),
+            )
+            await self.send_command(
+                hci.HCI_LE_CS_Read_Remote_Supported_Capabilities_Command(
+                    connection_handle=connection.handle
+                ),
+                check_result=True,
+            )
+            return await complete_future
+
+    @experimental('Only for testing.')
+    async def set_default_cs_settings(
+        self,
+        connection: Connection,
+        role_enable: int = (
+            hci.CsRoleMask.INITIATOR | hci.CsRoleMask.REFLECTOR
+        ),  # Both role
+        cs_sync_antenna_selection: int = 0xFF,  # No Preference
+        max_tx_power: int = 0x04,  # 4 dB
+    ) -> None:
+        await self.send_command(
+            hci.HCI_LE_CS_Set_Default_Settings_Command(
+                connection_handle=connection.handle,
+                role_enable=role_enable,
+                cs_sync_antenna_selection=cs_sync_antenna_selection,
+                max_tx_power=max_tx_power,
+            ),
+            check_result=True,
+        )
+
+    @experimental('Only for testing.')
+    async def create_cs_config(
+        self,
+        connection: Connection,
+        config_id: int | None = None,
+        create_context: int = 0x01,
+        main_mode_type: int = 0x02,
+        sub_mode_type: int = 0xFF,
+        min_main_mode_steps: int = 0x02,
+        max_main_mode_steps: int = 0x05,
+        main_mode_repetition: int = 0x00,
+        mode_0_steps: int = 0x03,
+        role: int = hci.CsRole.INITIATOR,
+        rtt_type: int = hci.RttType.AA_ONLY,
+        cs_sync_phy: int = hci.CsSyncPhy.LE_1M,
+        channel_map: bytes = b'\x54\x55\x55\x54\x55\x55\x55\x55\x55\x15',
+        channel_map_repetition: int = 0x01,
+        channel_selection_type: int = hci.HCI_LE_CS_Create_Config_Command.ChannelSelectionType.ALGO_3B,
+        ch3c_shape: int = hci.HCI_LE_CS_Create_Config_Command.Ch3cShape.HAT,
+        ch3c_jump: int = 0x03,
+    ) -> ChannelSoundingConfig:
+        complete_future: asyncio.Future[ChannelSoundingConfig] = (
+            asyncio.get_running_loop().create_future()
+        )
+        if config_id is None:
+            # Allocate an ID.
+            config_id = next(
+                (
+                    i
+                    for i in range(DEVICE_MIN_CS_CONFIG_ID, DEVICE_MAX_CS_CONFIG_ID + 1)
+                    if i not in connection.cs_configs
+                ),
+                None,
+            )
+        if config_id is None:
+            raise OutOfResourcesError("No available config ID on this connection!")
+
+        with closing(EventWatcher()) as watcher:
+            watcher.once(
+                connection, 'channel_sounding_config', complete_future.set_result
+            )
+            watcher.once(
+                connection,
+                'channel_sounding_config_failure',
+                lambda status: complete_future.set_exception(hci.HCI_Error(status)),
+            )
+            await self.send_command(
+                hci.HCI_LE_CS_Create_Config_Command(
+                    connection_handle=connection.handle,
+                    config_id=config_id,
+                    create_context=create_context,
+                    main_mode_type=main_mode_type,
+                    sub_mode_type=sub_mode_type,
+                    min_main_mode_steps=min_main_mode_steps,
+                    max_main_mode_steps=max_main_mode_steps,
+                    main_mode_repetition=main_mode_repetition,
+                    mode_0_steps=mode_0_steps,
+                    role=role,
+                    rtt_type=rtt_type,
+                    cs_sync_phy=cs_sync_phy,
+                    channel_map=channel_map,
+                    channel_map_repetition=channel_map_repetition,
+                    channel_selection_type=channel_selection_type,
+                    ch3c_shape=ch3c_shape,
+                    ch3c_jump=ch3c_jump,
+                    reserved=0x00,
+                ),
+                check_result=True,
+            )
+            return await complete_future
+
+    @experimental('Only for testing.')
+    async def enable_cs_security(self, connection: Connection) -> None:
+        complete_future: asyncio.Future[None] = (
+            asyncio.get_running_loop().create_future()
+        )
+        with closing(EventWatcher()) as watcher:
+
+            def on_event(event: hci.HCI_LE_CS_Security_Enable_Complete_Event) -> None:
+                if event.connection_handle != connection.handle:
+                    return
+                if event.status == hci.HCI_SUCCESS:
+                    complete_future.set_result(None)
+                else:
+                    complete_future.set_exception(hci.HCI_Error(event.status))
+
+            watcher.once(self.host, 'cs_security', on_event)
+            await self.send_command(
+                hci.HCI_LE_CS_Security_Enable_Command(
+                    connection_handle=connection.handle
+                ),
+                check_result=True,
+            )
+            return await complete_future
+
+    @experimental('Only for testing.')
+    async def set_cs_procedure_parameters(
+        self,
+        connection: Connection,
+        config: ChannelSoundingConfig,
+        tone_antenna_config_selection=0x00,
+        preferred_peer_antenna=0x00,
+        max_procedure_len=0x2710,  # 6.25s
+        min_procedure_interval=0x01,
+        max_procedure_interval=0xFF,
+        max_procedure_count=0x01,
+        min_subevent_len=0x0004E2,  # 1250us
+        max_subevent_len=0x1E8480,  # 2s
+        phy=hci.CsSyncPhy.LE_1M,
+        tx_power_delta=0x00,
+        snr_control_initiator=hci.CsSnr.NOT_APPLIED,
+        snr_control_reflector=hci.CsSnr.NOT_APPLIED,
+    ) -> None:
+        await self.send_command(
+            hci.HCI_LE_CS_Set_Procedure_Parameters_Command(
+                connection_handle=connection.handle,
+                config_id=config.config_id,
+                max_procedure_len=max_procedure_len,
+                min_procedure_interval=min_procedure_interval,
+                max_procedure_interval=max_procedure_interval,
+                max_procedure_count=max_procedure_count,
+                min_subevent_len=min_subevent_len,
+                max_subevent_len=max_subevent_len,
+                tone_antenna_config_selection=tone_antenna_config_selection,
+                phy=phy,
+                tx_power_delta=tx_power_delta,
+                preferred_peer_antenna=preferred_peer_antenna,
+                snr_control_initiator=snr_control_initiator,
+                snr_control_reflector=snr_control_reflector,
+            ),
+            check_result=True,
+        )
+
+    @experimental('Only for testing.')
+    async def enable_cs_procedure(
+        self,
+        connection: Connection,
+        config: ChannelSoundingConfig,
+        enabled: bool = True,
+    ) -> ChannelSoundingProcedure:
+        complete_future: asyncio.Future[ChannelSoundingProcedure] = (
+            asyncio.get_running_loop().create_future()
+        )
+        with closing(EventWatcher()) as watcher:
+            watcher.once(
+                connection, 'channel_sounding_procedure', complete_future.set_result
+            )
+            watcher.once(
+                connection,
+                'channel_sounding_procedure_failure',
+                lambda x: complete_future.set_exception(hci.HCI_Error(x)),
+            )
+            await self.send_command(
+                hci.HCI_LE_CS_Procedure_Enable_Command(
+                    connection_handle=connection.handle,
+                    config_id=config.config_id,
+                    enable=enabled,
+                ),
+                check_result=True,
+            )
+            return await complete_future
+
     @host_event_handler
     def on_flush(self):
         self.emit('flush')
@@ -4178,21 +4913,94 @@ class Device(CompositeEventEmitter):
     def add_services(self, services):
         self.gatt_server.add_services(services)
 
-    def add_default_services(self, generic_access_service=True):
+    def add_default_services(
+        self, add_gap_service: bool = True, add_gatt_service: bool = True
+    ) -> None:
         # Add a GAP Service if requested
-        if generic_access_service:
+        if add_gap_service:
             self.gatt_server.add_service(GenericAccessService(self.name))
+        if add_gatt_service:
+            self.gatt_service = gatt_service.GenericAttributeProfileService()
+            self.gatt_server.add_service(self.gatt_service)
+
+    async def notify_subscriber(
+        self,
+        connection: Connection,
+        attribute: Attribute,
+        value: Optional[Any] = None,
+        force: bool = False,
+    ) -> None:
+        """
+        Send a notification to an attribute subscriber.
 
-    async def notify_subscriber(self, connection, attribute, value=None, force=False):
+        Args:
+           connection:
+             The connection of the subscriber.
+           attribute:
+             The attribute whose value is notified.
+           value:
+             The value of the attribute (if None, the value is read from the attribute)
+            force:
+              If True, send a notification even if there is no subscriber.
+        """
         await self.gatt_server.notify_subscriber(connection, attribute, value, force)
 
-    async def notify_subscribers(self, attribute, value=None, force=False):
+    async def notify_subscribers(
+        self, attribute: Attribute, value=None, force=False
+    ) -> None:
+        """
+        Send a notification to all the subscribers of an attribute.
+
+        Args:
+           attribute:
+             The attribute whose value is notified.
+           value:
+             The value of the attribute (if None, the value is read from the attribute)
+            force:
+              If True, send a notification for every connection even if there is no
+              subscriber.
+        """
         await self.gatt_server.notify_subscribers(attribute, value, force)
 
-    async def indicate_subscriber(self, connection, attribute, value=None, force=False):
+    async def indicate_subscriber(
+        self,
+        connection: Connection,
+        attribute: Attribute,
+        value: Optional[Any] = None,
+        force: bool = False,
+    ):
+        """
+        Send an indication to an attribute subscriber.
+
+        This method returns when the response to the indication has been received.
+
+        Args:
+           connection:
+             The connection of the subscriber.
+           attribute:
+             The attribute whose value is indicated.
+           value:
+             The value of the attribute (if None, the value is read from the attribute)
+            force:
+              If True, send an indication even if there is no subscriber.
+        """
         await self.gatt_server.indicate_subscriber(connection, attribute, value, force)
 
-    async def indicate_subscribers(self, attribute, value=None, force=False):
+    async def indicate_subscribers(
+        self, attribute: Attribute, value: Optional[Any] = None, force: bool = False
+    ):
+        """
+        Send an indication to all the subscribers of an attribute.
+
+        Args:
+           attribute:
+             The attribute whose value is notified.
+           value:
+             The value of the attribute (if None, the value is read from the attribute)
+            force:
+              If True, send an indication for every connection even if there is no
+              subscriber.
+        """
         await self.gatt_server.indicate_subscribers(attribute, value, force)
 
     @host_event_handler
@@ -4233,6 +5041,112 @@ class Device(CompositeEventEmitter):
         )
         self.connecting_extended_advertising_sets[connection_handle] = advertising_set
 
+    @host_event_handler
+    def on_big_establishment(
+        self,
+        status: int,
+        big_handle: int,
+        bis_handles: list[int],
+        big_sync_delay: int,
+        transport_latency_big: int,
+        phy: int,
+        nse: int,
+        bn: int,
+        pto: int,
+        irc: int,
+        max_pdu: int,
+        iso_interval: int,
+    ) -> None:
+        if not (big := self.bigs.get(big_handle)):
+            logger.warning('BIG %d not found', big_handle)
+            return
+
+        if status != hci.HCI_SUCCESS:
+            del self.bigs[big_handle]
+            logger.debug('Unable to create BIG %d', big_handle)
+            big.state = Big.State.TERMINATED
+            big.emit(Big.Event.ESTABLISHMENT_FAILURE, status)
+            return
+
+        big.bis_links = [BisLink(handle=handle, big=big) for handle in bis_handles]
+        big.big_sync_delay = big_sync_delay
+        big.transport_latency_big = transport_latency_big
+        big.phy = phy
+        big.nse = nse
+        big.bn = bn
+        big.pto = pto
+        big.irc = irc
+        big.max_pdu = max_pdu
+        big.iso_interval = iso_interval
+        big.state = Big.State.ACTIVE
+
+        for bis_link in big.bis_links:
+            self.bis_links[bis_link.handle] = bis_link
+        big.emit(Big.Event.ESTABLISHMENT)
+
+    @host_event_handler
+    def on_big_termination(self, reason: int, big_handle: int) -> None:
+        if not (big := self.bigs.pop(big_handle, None)):
+            logger.warning('BIG %d not found', big_handle)
+            return
+
+        big.state = Big.State.TERMINATED
+        for bis_link in big.bis_links:
+            self.bis_links.pop(bis_link.handle, None)
+        big.emit(Big.Event.TERMINATION, reason)
+
+    @host_event_handler
+    def on_big_sync_establishment(
+        self,
+        status: int,
+        big_handle: int,
+        transport_latency_big: int,
+        nse: int,
+        bn: int,
+        pto: int,
+        irc: int,
+        max_pdu: int,
+        iso_interval: int,
+        bis_handles: list[int],
+    ) -> None:
+        if not (big_sync := self.big_syncs.get(big_handle)):
+            logger.warning('BIG Sync %d not found', big_handle)
+            return
+
+        if status != hci.HCI_SUCCESS:
+            del self.big_syncs[big_handle]
+            logger.debug('Unable to create BIG Sync %d', big_handle)
+            big_sync.state = BigSync.State.TERMINATED
+            big_sync.emit(BigSync.Event.ESTABLISHMENT_FAILURE, status)
+            return
+
+        big_sync.transport_latency_big = transport_latency_big
+        big_sync.nse = nse
+        big_sync.bn = bn
+        big_sync.pto = pto
+        big_sync.irc = irc
+        big_sync.max_pdu = max_pdu
+        big_sync.iso_interval = iso_interval
+        big_sync.bis_links = [
+            BisLink(handle=handle, big=big_sync) for handle in bis_handles
+        ]
+        big_sync.state = BigSync.State.ACTIVE
+
+        for bis_link in big_sync.bis_links:
+            self.bis_links[bis_link.handle] = bis_link
+        big_sync.emit(BigSync.Event.ESTABLISHMENT)
+
+    @host_event_handler
+    def on_big_sync_lost(self, big_handle: int, reason: int) -> None:
+        if not (big_sync := self.big_syncs.pop(big_handle, None)):
+            logger.warning('BIG %d not found', big_handle)
+            return
+
+        for bis_link in big_sync.bis_links:
+            self.bis_links.pop(bis_link.handle, None)
+        big_sync.state = BigSync.State.TERMINATED
+        big_sync.emit(BigSync.Event.TERMINATION, reason)
+
     def _complete_le_extended_advertising_connection(
         self, connection: Connection, advertising_set: AdvertisingSet
     ) -> None:
@@ -4258,29 +5172,6 @@ class Device(CompositeEventEmitter):
                 lambda _: self.abort_on('flush', advertising_set.start()),
             )
 
-        self._emit_le_connection(connection)
-
-    def _emit_le_connection(self, connection: Connection) -> None:
-        # If supported, read which PHY we're connected with before
-        # notifying listeners of the new connection.
-        if self.host.supports_command(hci.HCI_LE_READ_PHY_COMMAND):
-
-            async def read_phy():
-                result = await self.send_command(
-                    hci.HCI_LE_Read_PHY_Command(connection_handle=connection.handle),
-                    check_result=True,
-                )
-                connection.phy = ConnectionPHY(
-                    result.return_parameters.tx_phy, result.return_parameters.rx_phy
-                )
-                # Emit an event to notify listeners of the new connection
-                self.emit('connection', connection)
-
-            # Do so asynchronously to not block the current event handler
-            connection.abort_on('disconnection', read_phy())
-
-            return
-
         self.emit('connection', connection)
 
     @host_event_handler
@@ -4379,7 +5270,6 @@ class Device(CompositeEventEmitter):
             peer_resolvable_address,
             role,
             connection_parameters,
-            ConnectionPHY(hci.HCI_LE_1M_PHY, hci.HCI_LE_1M_PHY),
         )
         self.connections[connection_handle] = connection
 
@@ -4395,7 +5285,7 @@ class Device(CompositeEventEmitter):
 
         if role == hci.HCI_CENTRAL_ROLE or not self.supports_le_extended_advertising:
             # We can emit now, we have all the info we need
-            self._emit_le_connection(connection)
+            self.emit('connection', connection)
             return
 
         if role == hci.HCI_PERIPHERAL_ROLE and self.supports_le_extended_advertising:
@@ -4879,6 +5769,8 @@ class Device(CompositeEventEmitter):
     def on_iso_packet(self, handle: int, packet: hci.HCI_IsoDataPacket) -> None:
         if (cis_link := self.cis_links.get(handle)) and cis_link.sink:
             cis_link.sink(packet)
+        elif (bis_link := self.bis_links.get(handle)) and bis_link.sink:
+            bis_link.sink(packet)
 
     @host_event_handler
     @with_connection_from_handle
@@ -4947,14 +5839,13 @@ class Device(CompositeEventEmitter):
 
     @host_event_handler
     @with_connection_from_handle
-    def on_connection_phy_update(self, connection, connection_phy):
+    def on_connection_phy_update(self, connection, phy):
         logger.debug(
             f'*** Connection PHY Update: [0x{connection.handle:04X}] '
             f'{connection.peer_address} as {connection.role_name}, '
-            f'{connection_phy}'
+            f'{phy}'
         )
-        connection.phy = connection_phy
-        connection.emit('connection_phy_update')
+        connection.emit('connection_phy_update', phy)
 
     @host_event_handler
     @with_connection_from_handle
@@ -4994,6 +5885,106 @@ class Device(CompositeEventEmitter):
         )
         connection.emit('connection_data_length_change')
 
+    @host_event_handler
+    def on_cs_remote_supported_capabilities(
+        self, event: hci.HCI_LE_CS_Read_Remote_Supported_Capabilities_Complete_Event
+    ):
+        if not (connection := self.lookup_connection(event.connection_handle)):
+            return
+
+        if event.status != hci.HCI_SUCCESS:
+            connection.emit('channel_sounding_capabilities_failure', event.status)
+            return
+
+        capabilities = ChannelSoundingCapabilities(
+            num_config_supported=event.num_config_supported,
+            max_consecutive_procedures_supported=event.max_consecutive_procedures_supported,
+            num_antennas_supported=event.num_antennas_supported,
+            max_antenna_paths_supported=event.max_antenna_paths_supported,
+            roles_supported=event.roles_supported,
+            modes_supported=event.modes_supported,
+            rtt_capability=event.rtt_capability,
+            rtt_aa_only_n=event.rtt_aa_only_n,
+            rtt_sounding_n=event.rtt_sounding_n,
+            rtt_random_payload_n=event.rtt_random_payload_n,
+            nadm_sounding_capability=event.nadm_sounding_capability,
+            nadm_random_capability=event.nadm_random_capability,
+            cs_sync_phys_supported=event.cs_sync_phys_supported,
+            subfeatures_supported=event.subfeatures_supported,
+            t_ip1_times_supported=event.t_ip1_times_supported,
+            t_ip2_times_supported=event.t_ip2_times_supported,
+            t_fcs_times_supported=event.t_fcs_times_supported,
+            t_pm_times_supported=event.t_pm_times_supported,
+            t_sw_time_supported=event.t_sw_time_supported,
+            tx_snr_capability=event.tx_snr_capability,
+        )
+        connection.emit('channel_sounding_capabilities', capabilities)
+
+    @host_event_handler
+    def on_cs_config(self, event: hci.HCI_LE_CS_Config_Complete_Event):
+        if not (connection := self.lookup_connection(event.connection_handle)):
+            return
+
+        if event.status != hci.HCI_SUCCESS:
+            connection.emit('channel_sounding_config_failure', event.status)
+            return
+        if event.action == hci.HCI_LE_CS_Config_Complete_Event.Action.CREATED:
+            config = ChannelSoundingConfig(
+                config_id=event.config_id,
+                main_mode_type=event.main_mode_type,
+                sub_mode_type=event.sub_mode_type,
+                min_main_mode_steps=event.min_main_mode_steps,
+                max_main_mode_steps=event.max_main_mode_steps,
+                main_mode_repetition=event.main_mode_repetition,
+                mode_0_steps=event.mode_0_steps,
+                role=event.role,
+                rtt_type=event.rtt_type,
+                cs_sync_phy=event.cs_sync_phy,
+                channel_map=event.channel_map,
+                channel_map_repetition=event.channel_map_repetition,
+                channel_selection_type=event.channel_selection_type,
+                ch3c_shape=event.ch3c_shape,
+                ch3c_jump=event.ch3c_jump,
+                reserved=event.reserved,
+                t_ip1_time=event.t_ip1_time,
+                t_ip2_time=event.t_ip2_time,
+                t_fcs_time=event.t_fcs_time,
+                t_pm_time=event.t_pm_time,
+            )
+            connection.cs_configs[event.config_id] = config
+            connection.emit('channel_sounding_config', config)
+        elif event.action == hci.HCI_LE_CS_Config_Complete_Event.Action.REMOVED:
+            try:
+                config = connection.cs_configs.pop(event.config_id)
+                connection.emit('channel_sounding_config_removed', config.config_id)
+            except KeyError:
+                logger.error('Removing unknown config %d', event.config_id)
+
+    @host_event_handler
+    def on_cs_procedure(self, event: hci.HCI_LE_CS_Procedure_Enable_Complete_Event):
+        if not (connection := self.lookup_connection(event.connection_handle)):
+            return
+
+        if event.status != hci.HCI_SUCCESS:
+            connection.emit('channel_sounding_procedure_failure', event.status)
+            return
+
+        procedure = ChannelSoundingProcedure(
+            config_id=event.config_id,
+            state=event.state,
+            tone_antenna_config_selection=event.tone_antenna_config_selection,
+            selected_tx_power=event.selected_tx_power,
+            subevent_len=event.subevent_len,
+            subevents_per_event=event.subevents_per_event,
+            subevent_interval=event.subevent_interval,
+            event_interval=event.event_interval,
+            procedure_interval=event.procedure_interval,
+            procedure_count=event.procedure_count,
+            max_procedure_len=event.max_procedure_len,
+        )
+        connection.cs_procedures[procedure.config_id] = procedure
+        connection.emit('channel_sounding_procedure', procedure)
+
     # [Classic only]
     @host_event_handler
     @with_connection_from_address
@@ -5051,14 +6042,14 @@ class Device(CompositeEventEmitter):
         if att_pdu.op_code & 1:
             if connection.gatt_client is None:
                 logger.warning(
-                    color('no GATT client for connection 0x{connection_handle:04X}')
+                    'No GATT client for connection 0x%04X', connection.handle
                 )
                 return
             connection.gatt_client.on_gatt_pdu(att_pdu)
         else:
             if connection.gatt_server is None:
                 logger.warning(
-                    color('no GATT server for connection 0x{connection_handle:04X}')
+                    'No GATT server for connection 0x%04X', connection.handle
                 )
                 return
             connection.gatt_server.on_gatt_pdu(connection, att_pdu)