bumble 0.0.218__py3-none-any.whl → 0.0.220__py3-none-any.whl

bumble/link.py

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import asyncio
 
@@ -20,16 +21,7 @@ import asyncio
 import logging
 from typing import Optional
 
-from bumble import controller, core
-from bumble.hci import (
-    HCI_CONNECTION_ACCEPT_TIMEOUT_ERROR,
-    HCI_PAGE_TIMEOUT_ERROR,
-    HCI_SUCCESS,
-    HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
-    Address,
-    HCI_Connection_Complete_Event,
-    Role,
-)
+from bumble import controller, core, hci, lmp
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -40,13 +32,6 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 # Utils
 # -----------------------------------------------------------------------------
-def parse_parameters(params_str):
-    result = {}
-    for param_str in params_str.split(','):
-        if '=' in param_str:
-            key, value = param_str.split('=')
-            result[key] = value
-    return result
 
 
 # -----------------------------------------------------------------------------
@@ -69,21 +54,21 @@ class LocalLink:
     # Common utils
     ############################################################
 
-    def add_controller(self, controller):
+    def add_controller(self, controller: controller.Controller):
         logger.debug(f'new controller: {controller}')
         self.controllers.add(controller)
 
-    def remove_controller(self, controller):
+    def remove_controller(self, controller: controller.Controller):
         self.controllers.remove(controller)
 
-    def find_controller(self, address):
+    def find_controller(self, address: hci.Address) -> controller.Controller | None:
         for controller in self.controllers:
             if controller.random_address == address:
                 return controller
         return None
 
     def find_classic_controller(
-        self, address: Address
+        self, address: hci.Address
     ) -> Optional[controller.Controller]:
         for controller in self.controllers:
             if controller.public_address == address:
@@ -100,13 +85,19 @@ class LocalLink:
     def on_address_changed(self, controller):
         pass
 
-    def send_advertising_data(self, sender_address, data):
+    def send_advertising_data(self, sender_address: hci.Address, data: bytes):
         # Send the advertising data to all controllers, except the sender
         for controller in self.controllers:
             if controller.random_address != sender_address:
                 controller.on_link_advertising_data(sender_address, data)
 
-    def send_acl_data(self, sender_controller, destination_address, transport, data):
+    def send_acl_data(
+        self,
+        sender_controller: controller.Controller,
+        destination_address: hci.Address,
+        transport: core.PhysicalTransport,
+        data: bytes,
+    ):
         # Send the data to the first controller with a matching address
         if transport == core.PhysicalTransport.LE:
             destination_controller = self.find_controller(destination_address)
@@ -118,9 +109,13 @@ class LocalLink:
             raise ValueError("unsupported transport type")
 
         if destination_controller is not None:
-            destination_controller.on_link_acl_data(source_address, transport, data)
+            asyncio.get_running_loop().call_soon(
+                lambda: destination_controller.on_link_acl_data(
+                    source_address, transport, data
+                )
+            )
 
-    def on_connection_complete(self):
+    def on_connection_complete(self) -> None:
         # Check that we expect this call
         if not self.pending_connection:
             logger.warning('on_connection_complete with no pending connection')
@@ -139,17 +134,21 @@ class LocalLink:
             le_create_connection_command.peer_address
         ):
             central_controller.on_link_peripheral_connection_complete(
-                le_create_connection_command, HCI_SUCCESS
+                le_create_connection_command, hci.HCI_SUCCESS
             )
             peripheral_controller.on_link_central_connected(central_address)
             return
 
         # No peripheral found
         central_controller.on_link_peripheral_connection_complete(
-            le_create_connection_command, HCI_CONNECTION_ACCEPT_TIMEOUT_ERROR
+            le_create_connection_command, hci.HCI_CONNECTION_ACCEPT_TIMEOUT_ERROR
         )
 
-    def connect(self, central_address, le_create_connection_command):
+    def connect(
+        self,
+        central_address: hci.Address,
+        le_create_connection_command: hci.HCI_LE_Create_Connection_Command,
+    ):
         logger.debug(
             f'$$$ CONNECTION {central_address} -> '
             f'{le_create_connection_command.peer_address}'
@@ -158,7 +157,10 @@ class LocalLink:
         asyncio.get_running_loop().call_soon(self.on_connection_complete)
 
     def on_disconnection_complete(
-        self, initiating_address, target_address, disconnect_command
+        self,
+        initiating_address: hci.Address,
+        target_address: hci.Address,
+        disconnect_command: hci.HCI_Disconnect_Command,
     ):
         # Find the controller that initiated the disconnection
         if not (initiating_controller := self.find_controller(initiating_address)):
@@ -172,20 +174,32 @@ class LocalLink:
             )
 
         initiating_controller.on_link_disconnection_complete(
-            disconnect_command, HCI_SUCCESS
+            disconnect_command, hci.HCI_SUCCESS
         )
 
-    def disconnect(self, initiating_address, target_address, disconnect_command):
+    def disconnect(
+        self,
+        initiating_address: hci.Address,
+        target_address: hci.Address,
+        disconnect_command: hci.HCI_Disconnect_Command,
+    ):
         logger.debug(
             f'$$$ DISCONNECTION {initiating_address} -> '
             f'{target_address}: reason = {disconnect_command.reason}'
         )
-        args = [initiating_address, target_address, disconnect_command]
-        asyncio.get_running_loop().call_soon(self.on_disconnection_complete, *args)
+        asyncio.get_running_loop().call_soon(
+            lambda: self.on_disconnection_complete(
+                initiating_address, target_address, disconnect_command
+            )
+        )
 
-    # pylint: disable=too-many-arguments
     def on_connection_encrypted(
-        self, central_address, peripheral_address, rand, ediv, ltk
+        self,
+        central_address: hci.Address,
+        peripheral_address: hci.Address,
+        rand: bytes,
+        ediv: int,
+        ltk: bytes,
     ):
         logger.debug(f'*** ENCRYPTION {central_address} -> {peripheral_address}')
 
@@ -198,7 +212,7 @@ class LocalLink:
     def create_cis(
         self,
         central_controller: controller.Controller,
-        peripheral_address: Address,
+        peripheral_address: hci.Address,
         cig_id: int,
         cis_id: int,
     ) -> None:
@@ -216,7 +230,7 @@ class LocalLink:
     def accept_cis(
         self,
         peripheral_controller: controller.Controller,
-        central_address: Address,
+        central_address: hci.Address,
         cig_id: int,
         cis_id: int,
     ) -> None:
@@ -224,17 +238,16 @@ class LocalLink:
             f'$$$ CIS Accept {peripheral_controller.random_address} -> {central_address}'
         )
         if central_controller := self.find_controller(central_address):
-            asyncio.get_running_loop().call_soon(
-                central_controller.on_link_cis_established, cig_id, cis_id
-            )
-            asyncio.get_running_loop().call_soon(
+            loop = asyncio.get_running_loop()
+            loop.call_soon(central_controller.on_link_cis_established, cig_id, cis_id)
+            loop.call_soon(
                 peripheral_controller.on_link_cis_established, cig_id, cis_id
             )
 
     def disconnect_cis(
         self,
         initiator_controller: controller.Controller,
-        peer_address: Address,
+        peer_address: hci.Address,
         cig_id: int,
         cis_id: int,
     ) -> None:
@@ -242,138 +255,28 @@ class LocalLink:
             f'$$$ CIS Disconnect {initiator_controller.random_address} -> {peer_address}'
         )
         if peer_controller := self.find_controller(peer_address):
-            asyncio.get_running_loop().call_soon(
+            loop = asyncio.get_running_loop()
+            loop.call_soon(
                 initiator_controller.on_link_cis_disconnected, cig_id, cis_id
             )
-            asyncio.get_running_loop().call_soon(
-                peer_controller.on_link_cis_disconnected, cig_id, cis_id
-            )
+            loop.call_soon(peer_controller.on_link_cis_disconnected, cig_id, cis_id)
 
     ############################################################
     # Classic handlers
     ############################################################
 
-    def classic_connect(self, initiator_controller, responder_address):
-        logger.debug(
-            f'[Classic] {initiator_controller.public_address} connects to {responder_address}'
-        )
-        responder_controller = self.find_classic_controller(responder_address)
-        if responder_controller is None:
-            initiator_controller.on_classic_connection_complete(
-                responder_address, HCI_PAGE_TIMEOUT_ERROR
-            )
-            return
-        self.pending_classic_connection = (initiator_controller, responder_controller)
-
-        responder_controller.on_classic_connection_request(
-            initiator_controller.public_address,
-            HCI_Connection_Complete_Event.LinkType.ACL,
-        )
-
-    def classic_accept_connection(
-        self, responder_controller, initiator_address, responder_role
-    ):
-        logger.debug(
-            f'[Classic] {responder_controller.public_address} accepts to connect {initiator_address}'
-        )
-        initiator_controller = self.find_classic_controller(initiator_address)
-        if initiator_controller is None:
-            responder_controller.on_classic_connection_complete(
-                responder_controller.public_address, HCI_PAGE_TIMEOUT_ERROR
-            )
-            return
-
-        async def task():
-            if responder_role != Role.PERIPHERAL:
-                initiator_controller.on_classic_role_change(
-                    responder_controller.public_address, int(not (responder_role))
-                )
-            initiator_controller.on_classic_connection_complete(
-                responder_controller.public_address, HCI_SUCCESS
-            )
-
-        asyncio.create_task(task())
-        responder_controller.on_classic_role_change(
-            initiator_controller.public_address, responder_role
-        )
-        responder_controller.on_classic_connection_complete(
-            initiator_controller.public_address, HCI_SUCCESS
-        )
-        self.pending_classic_connection = None
-
-    def classic_disconnect(self, initiator_controller, responder_address, reason):
-        logger.debug(
-            f'[Classic] {initiator_controller.public_address} disconnects {responder_address}'
-        )
-        responder_controller = self.find_classic_controller(responder_address)
-
-        async def task():
-            initiator_controller.on_classic_disconnected(responder_address, reason)
-
-        asyncio.create_task(task())
-        responder_controller.on_classic_disconnected(
-            initiator_controller.public_address, reason
-        )
-
-    def classic_switch_role(
-        self, initiator_controller, responder_address, initiator_new_role
-    ):
-        responder_controller = self.find_classic_controller(responder_address)
-        if responder_controller is None:
-            return
-
-        async def task():
-            initiator_controller.on_classic_role_change(
-                responder_address, initiator_new_role
-            )
-
-        asyncio.create_task(task())
-        responder_controller.on_classic_role_change(
-            initiator_controller.public_address, int(not (initiator_new_role))
-        )
-
-    def classic_sco_connect(
-        self,
-        initiator_controller: controller.Controller,
-        responder_address: Address,
-        link_type: int,
-    ):
-        logger.debug(
-            f'[Classic] {initiator_controller.public_address} connects SCO to {responder_address}'
-        )
-        responder_controller = self.find_classic_controller(responder_address)
-        # Initiator controller should handle it.
-        assert responder_controller
-
-        responder_controller.on_classic_connection_request(
-            initiator_controller.public_address,
-            link_type,
-        )
-
-    def classic_accept_sco_connection(
+    def send_lmp_packet(
         self,
-        responder_controller: controller.Controller,
-        initiator_address: Address,
-        link_type: int,
+        sender_controller: controller.Controller,
+        receiver_address: hci.Address,
+        packet: lmp.Packet,
     ):
-        logger.debug(
-            f'[Classic] {responder_controller.public_address} accepts to connect SCO {initiator_address}'
-        )
-        initiator_controller = self.find_classic_controller(initiator_address)
-        if initiator_controller is None:
-            responder_controller.on_classic_sco_connection_complete(
-                responder_controller.public_address,
-                HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
-                link_type,
+        if not (receiver_controller := self.find_classic_controller(receiver_address)):
+            raise core.InvalidArgumentError(
+                f"Unable to find controller for address {receiver_address}"
             )
-            return
-
-        async def task():
-            initiator_controller.on_classic_sco_connection_complete(
-                responder_controller.public_address, HCI_SUCCESS, link_type
+        asyncio.get_running_loop().call_soon(
+            lambda: receiver_controller.on_lmp_packet(
+                sender_controller.public_address, packet
             )
-
-        asyncio.create_task(task())
-        responder_controller.on_classic_sco_connection_complete(
-            initiator_controller.public_address, HCI_SUCCESS, link_type
         )

bumble/lmp.py

@@ -0,0 +1,324 @@
+# Copyright 2021-2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass, field
+from typing import TypeVar
+
+from bumble import hci, utils
+
+
+class Opcode(utils.OpenIntEnum):
+    '''
+    See Bluetooth spec @ Vol 2, Part C - 5.1 PDU summary.
+
+    Follow the alphabetical order defined there.
+    '''
+
+    # fmt: off
+    LMP_ACCEPTED                    = 3
+    LMP_ACCEPTED_EXT                = 127 << 8 + 1
+    LMP_AU_RAND                     = 11
+    LMP_AUTO_RATE                   = 35
+    LMP_CHANNEL_CLASSIFICATION      = 127 << 8 + 17
+    LMP_CHANNEL_CLASSIFICATION_REQ  = 127 << 8 + 16
+    LMP_CLK_ADJ                     = 127 << 8 + 5
+    LMP_CLK_ADJ_ACK                 = 127 << 8 + 6
+    LMP_CLK_ADJ_REQ                 = 127 << 8 + 7
+    LMP_CLKOFFSET_REQ               = 5
+    LMP_CLKOFFSET_RES               = 6
+    LMP_COMB_KEY                    = 9
+    LMP_DECR_POWER_REQ              = 32
+    LMP_DETACH                      = 7
+    LMP_DHKEY_CHECK                 = 65
+    LMP_ENCAPSULATED_HEADER         = 61
+    LMP_ENCAPSULATED_PAYLOAD        = 62
+    LMP_ENCRYPTION_KEY_SIZE_MASK_REQ= 58
+    LMP_ENCRYPTION_KEY_SIZE_MASK_RES= 59
+    LMP_ENCRYPTION_KEY_SIZE_REQ     = 16
+    LMP_ENCRYPTION_MODE_REQ         = 15
+    LMP_ESCO_LINK_REQ               = 127 << 8 + 12
+    LMP_FEATURES_REQ                = 39
+    LMP_FEATURES_REQ_EXT            = 127 << 8 + 3
+    LMP_FEATURES_RES                = 40
+    LMP_FEATURES_RES_EXT            = 127 << 8 + 4
+    LMP_HOLD                        = 20
+    LMP_HOLD_REQ                    = 21
+    LMP_HOST_CONNECTION_REQ         = 51
+    LMP_IN_RAND                     = 8
+    LMP_INCR_POWER_REQ              = 31
+    LMP_IO_CAPABILITY_REQ           = 127 << 8 + 25
+    LMP_IO_CAPABILITY_RES           = 127 << 8 + 26
+    LMP_KEYPRESS_NOTIFICATION       = 127 << 8 + 30
+    LMP_MAX_POWER                   = 33
+    LMP_MAX_SLOT                    = 45
+    LMP_MAX_SLOT_REQ                = 46
+    LMP_MIN_POWER                   = 34
+    LMP_NAME_REQ                    = 1
+    LMP_NAME_RES                    = 2
+    LMP_NOT_ACCEPTED                = 4
+    LMP_NOT_ACCEPTED_EXT            = 127 << 8 + 2
+    LMP_NUMERIC_COMPARISON_FAILED   = 127 << 8 + 27
+    LMP_OOB_FAILED                  = 127 << 8 + 29
+    LMP_PACKET_TYPE_TABLE_REQ       = 127 << 8 + 11
+    LMP_PAGE_MODE_REQ               = 53
+    LMP_PAGE_SCAN_MODE_REQ          = 54
+    LMP_PASSKEY_FAILED              = 127 << 8 + 28
+    LMP_PAUSE_ENCRYPTION_AES_REQ    = 66
+    LMP_PAUSE_ENCRYPTION_REQ        = 127 << 8 + 23
+    LMP_PING_REQ                    = 127 << 8 + 33
+    LMP_PING_RES                    = 127 << 8 + 34
+    LMP_POWER_CONTROL_REQ           = 127 << 8 + 31
+    LMP_POWER_CONTROL_RES           = 127 << 8 + 32
+    LMP_PREFERRED_RATE              = 36
+    LMP_QUALITY_OF_SERVICE          = 41
+    LMP_QUALITY_OF_SERVICE_REQ      = 42
+    LMP_REMOVE_ESCO_LINK_REQ        = 127 << 8 + 13
+    LMP_REMOVE_SCO_LINK_REQ         = 44
+    LMP_RESUME_ENCRYPTION_REQ       = 127 << 8 + 24
+    LMP_SAM_DEFINE_MAP              = 127 << 8 + 36
+    LMP_SAM_SET_TYPE0               = 127 << 8 + 35
+    LMP_SAM_SWITCH                  = 127 << 8 + 37
+    LMP_SCO_LINK_REQ                = 43
+    LMP_SET_AFH                     = 60
+    LMP_SETUP_COMPLETE              = 49
+    LMP_SIMPLE_PAIRING_CONFIRM      = 63
+    LMP_SIMPLE_PAIRING_NUMBER       = 64
+    LMP_SLOT_OFFSET                 = 52
+    LMP_SNIFF_REQ                   = 23
+    LMP_SNIFF_SUBRATING_REQ         = 127 << 8 + 21
+    LMP_SNIFF_SUBRATING_RES         = 127 << 8 + 22
+    LMP_SRES                        = 12
+    LMP_START_ENCRYPTION_REQ        = 17
+    LMP_STOP_ENCRYPTION_REQ         = 18
+    LMP_SUPERVISION_TIMEOUT         = 55
+    LMP_SWITCH_REQ                  = 19
+    LMP_TEMP_KEY                    = 14
+    LMP_TEMP_RAND                   = 13
+    LMP_TEST_ACTIVATE               = 56
+    LMP_TEST_CONTROL                = 57
+    LMP_TIMING_ACCURACY_REQ         = 47
+    LMP_TIMING_ACCURACY_RES         = 48
+    LMP_UNIT_KEY                    = 10
+    LMP_UNSNIFF_REQ                 = 24
+    LMP_USE_SEMI_PERMANENT_KEY      = 50
+    LMP_VERSION_REQ                 = 37
+    LMP_VERSION_RES                 = 38
+    # fmt: on
+
+    @classmethod
+    def parse_from(cls, data: bytes, offset: int = 0) -> tuple[int, Opcode]:
+        opcode = data[offset]
+        if opcode in (124, 127):
+            opcode = struct.unpack('>H', data)[0]
+            return offset + 2, Opcode(opcode)
+        return offset + 1, Opcode(opcode)
+
+    def __bytes__(self) -> bytes:
+        if self.value >> 8:
+            return struct.pack('>H', self.value)
+        return bytes([self.value])
+
+    @classmethod
+    def type_metadata(cls):
+        return hci.metadata(
+            {
+                'serializer': bytes,
+                'parser': lambda data, offset: (Opcode.parse_from(data, offset)),
+            }
+        )
+
+
+class Packet:
+    '''
+    See Bluetooth spec @ Vol 2, Part C - 5.1 PDU summary
+    '''
+
+    subclasses: dict[int, type[Packet]] = {}
+    opcode: Opcode
+    fields: hci.Fields = ()
+    _payload: bytes = b''
+
+    _Packet = TypeVar("_Packet", bound="Packet")
+
+    @classmethod
+    def subclass(cls, subclass: type[_Packet]) -> type[_Packet]:
+        # Register a factory for this class
+        cls.subclasses[subclass.opcode] = subclass
+        subclass.fields = hci.HCI_Object.fields_from_dataclass(subclass)
+
+        return subclass
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> Packet:
+        offset, opcode = Opcode.parse_from(data)
+        if not (subclass := cls.subclasses.get(opcode)):
+            instance = Packet()
+            instance.opcode = opcode
+        else:
+            instance = subclass(
+                **hci.HCI_Object.dict_from_bytes(data, offset, subclass.fields)
+            )
+        instance.payload = data[offset:]
+        return instance
+
+    @property
+    def payload(self) -> bytes:
+        if self._payload is None:
+            self._payload = hci.HCI_Object.dict_to_bytes(self.__dict__, self.fields)
+        return self._payload
+
+    @payload.setter
+    def payload(self, value: bytes) -> None:
+        self._payload = value
+
+    def __bytes__(self) -> bytes:
+        return bytes(self.opcode) + self.payload
+
+
+@Packet.subclass
+@dataclass
+class LmpAccepted(Packet):
+    opcode = Opcode.LMP_ACCEPTED
+
+    response_opcode: Opcode = field(metadata=Opcode.type_metadata())
+
+
+@Packet.subclass
+@dataclass
+class LmpNotAccepted(Packet):
+    opcode = Opcode.LMP_NOT_ACCEPTED
+
+    response_opcode: Opcode = field(metadata=Opcode.type_metadata())
+    error_code: int = field(metadata=hci.metadata(1))
+
+
+@Packet.subclass
+@dataclass
+class LmpAcceptedExt(Packet):
+    opcode = Opcode.LMP_ACCEPTED_EXT
+
+    response_opcode: Opcode = field(metadata=Opcode.type_metadata())
+
+
+@Packet.subclass
+@dataclass
+class LmpNotAcceptedExt(Packet):
+    opcode = Opcode.LMP_NOT_ACCEPTED_EXT
+
+    response_opcode: Opcode = field(metadata=Opcode.type_metadata())
+    error_code: int = field(metadata=hci.metadata(1))
+
+
+@Packet.subclass
+@dataclass
+class LmpAuRand(Packet):
+    opcode = Opcode.LMP_AU_RAND
+
+    random_number: bytes = field(metadata=hci.metadata(16))
+
+
+@Packet.subclass
+@dataclass
+class LmpDetach(Packet):
+    opcode = Opcode.LMP_DETACH
+
+    error_code: int = field(metadata=hci.metadata(1))
+
+
+@Packet.subclass
+@dataclass
+class LmpEscoLinkReq(Packet):
+    opcode = Opcode.LMP_ESCO_LINK_REQ
+
+    esco_handle: int = field(metadata=hci.metadata(1))
+    esco_lt_addr: int = field(metadata=hci.metadata(1))
+    timing_control_flags: int = field(metadata=hci.metadata(1))
+    d_esco: int = field(metadata=hci.metadata(1))
+    t_esco: int = field(metadata=hci.metadata(1))
+    w_esco: int = field(metadata=hci.metadata(1))
+    esco_packet_type_c_to_p: int = field(metadata=hci.metadata(1))
+    esco_packet_type_p_to_c: int = field(metadata=hci.metadata(1))
+    packet_length_c_to_p: int = field(metadata=hci.metadata(2))
+    packet_length_p_to_c: int = field(metadata=hci.metadata(2))
+    air_mode: int = field(metadata=hci.metadata(1))
+    negotiation_state: int = field(metadata=hci.metadata(1))
+
+
+@Packet.subclass
+@dataclass
+class LmpHostConnectionReq(Packet):
+    opcode = Opcode.LMP_HOST_CONNECTION_REQ
+
+
+@Packet.subclass
+@dataclass
+class LmpRemoveEscoLinkReq(Packet):
+    opcode = Opcode.LMP_REMOVE_ESCO_LINK_REQ
+
+    esco_handle: int = field(metadata=hci.metadata(1))
+    error_code: int = field(metadata=hci.metadata(1))
+
+
+@Packet.subclass
+@dataclass
+class LmpRemoveScoLinkReq(Packet):
+    opcode = Opcode.LMP_REMOVE_SCO_LINK_REQ
+
+    sco_handle: int = field(metadata=hci.metadata(1))
+    error_code: int = field(metadata=hci.metadata(1))
+
+
+@Packet.subclass
+@dataclass
+class LmpScoLinkReq(Packet):
+    opcode = Opcode.LMP_SCO_LINK_REQ
+
+    sco_handle: int = field(metadata=hci.metadata(1))
+    timing_control_flags: int = field(metadata=hci.metadata(1))
+    d_sco: int = field(metadata=hci.metadata(1))
+    t_sco: int = field(metadata=hci.metadata(1))
+    sco_packet: int = field(metadata=hci.metadata(1))
+    air_mode: int = field(metadata=hci.metadata(1))
+
+
+@Packet.subclass
+@dataclass
+class LmpSwitchReq(Packet):
+    opcode = Opcode.LMP_SWITCH_REQ
+
+    switch_instant: int = field(metadata=hci.metadata(4), default=0)
+
+
+@Packet.subclass
+@dataclass
+class LmpNameReq(Packet):
+    opcode = Opcode.LMP_NAME_REQ
+
+    name_offset: int = field(metadata=hci.metadata(2))
+
+
+@Packet.subclass
+@dataclass
+class LmpNameRes(Packet):
+    opcode = Opcode.LMP_NAME_RES
+
+    name_offset: int = field(metadata=hci.metadata(2))
+    name_length: int = field(metadata=hci.metadata(3))
+    name_fregment: bytes = field(metadata=hci.metadata('*'))