bscontroller 0.1.0__py3-none-any.whl

bscontroller/__init__.py

@@ -0,0 +1,57 @@
+# Copyright 2026 Xiaomi Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Standalone Bluetooth LE radio Controller and synchronized runtime."""
+
+from importlib import import_module
+from importlib.metadata import PackageNotFoundError, version
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from . import hci as hci
+    from .config import ControllerConfig as ControllerConfig
+    from .radio.base import Phy as Phy
+    from .radio.base import Radio as Radio
+    from .radio.base import Received as Received
+    from .runtime.event_loop import RadioEventLoop as RadioEventLoop
+    from .runtime.session import BabbleSimSession as RadioSession
+    from .runtime.worker import RadioControllerWorker as RadioController
+
+# Importing a protocol module must not construct the HCI/runtime dependency tree.
+# Keep the public convenience exports, loading their implementation when requested.
+_EXPORTS = {
+    'hci': ('.hci', None),
+    'ControllerConfig': ('.config', 'ControllerConfig'),
+    'Phy': ('.radio.base', 'Phy'),
+    'Radio': ('.radio.base', 'Radio'),
+    'Received': ('.radio.base', 'Received'),
+    'RadioEventLoop': ('.runtime.event_loop', 'RadioEventLoop'),
+    'RadioSession': ('.runtime.session', 'BabbleSimSession'),
+    'RadioController': ('.runtime.worker', 'RadioControllerWorker'),
+}
+
+
+def __getattr__(name: str):
+    if name not in _EXPORTS:
+        raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+    module, attribute = _EXPORTS[name]
+    imported = import_module(module, __name__)
+    value = getattr(imported, attribute) if attribute else imported
+    globals()[name] = value
+    return value
+
+
+try:
+    __version__ = version('bscontroller')
+except PackageNotFoundError:
+    __version__ = '0+unknown'
+
+__all__ = [
+    'Phy',
+    'Radio',
+    'RadioController',
+    'RadioEventLoop',
+    'RadioSession',
+    'Received',
+    'hci',
+]

bscontroller/__main__.py

@@ -0,0 +1,6 @@
+# Copyright 2026 Xiaomi Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .cli import main
+
+main()

bscontroller/address.py

@@ -0,0 +1,204 @@
+# Copyright 2021-2025 Google LLC
+# Copyright 2026 Xiaomi Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Bluetooth device addresses (Core 6.3, Vol 6, Part B, 1.3).
+
+Address type tags are also encoded at the HCI service boundary.
+"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar, Self
+
+from bscontroller.errors import InvalidArgumentError
+from bscontroller.serialization import SpecableEnum
+
+
+class OwnAddressType(SpecableEnum):
+    """Own-address selection (Core Vol 4, Part E, 7.8.5/10/12/53/64/66)."""
+
+    PUBLIC = 0x00
+    RANDOM = 0x01
+    RESOLVABLE_OR_PUBLIC = 0x02
+    RESOLVABLE_OR_RANDOM = 0x03
+
+    @property
+    def uses_random_fallback(self) -> bool:
+        return self in (self.RANDOM, self.RESOLVABLE_OR_RANDOM)
+
+    @property
+    def uses_resolvable_address(self) -> bool:
+        return self in (self.RESOLVABLE_OR_PUBLIC, self.RESOLVABLE_OR_RANDOM)
+
+
+class PrivacyMode(SpecableEnum):
+    """Peer identity acceptance policy (Core Vol 6, Part B, 4.7)."""
+
+    NETWORK_PRIVACY_MODE = 0x00
+    DEVICE_PRIVACY_MODE = 0x01
+
+
+# Vol 6, Part B, 1.3.2.2: an RPA contains a 24-bit hash and 24-bit prand.
+RPA_HASH_SIZE = 3
+RPA_PRAND_SIZE = 3
+RPA_PRAND_RANDOM_BITS = 22
+RPA_PRAND_TYPE_TAG = 0b01
+RANDOM_ADDRESS_TYPE_SHIFT = 6
+# Vol 6, Part B, 1.3.2, Table 1.2: address[47:46] = 0b11 marks a static address.
+STATIC_ADDRESS_TYPE_TAG = 0b11
+RPA_PRAND_RESOLVABLE_MASK = RPA_PRAND_TYPE_TAG << RPA_PRAND_RANDOM_BITS
+IRK_SIZE = 16
+
+
+class AddressType(SpecableEnum):
+    PUBLIC_DEVICE = 0x00
+    RANDOM_DEVICE = 0x01
+    PUBLIC_IDENTITY = 0x02
+    RANDOM_IDENTITY = 0x03
+    # (Directed Only) Address is RPA, but controller cannot resolve.
+    UNABLE_TO_RESOLVE = 0xFE
+    # (Extended Only) No address.
+    ANONYMOUS = 0xFF
+
+
+class Address:
+    '''
+    Bluetooth Address (see Bluetooth spec Vol 6, Part B - 1.3 DEVICE ADDRESS)
+    NOTE: the address bytes are stored in little-endian byte order here, so
+    address[0] is the LSB of the address, address[5] is the MSB.
+    '''
+
+    PUBLIC_DEVICE_ADDRESS = AddressType.PUBLIC_DEVICE
+    RANDOM_DEVICE_ADDRESS = AddressType.RANDOM_DEVICE
+    PUBLIC_IDENTITY_ADDRESS = AddressType.PUBLIC_IDENTITY
+    RANDOM_IDENTITY_ADDRESS = AddressType.RANDOM_IDENTITY
+
+    # Type declarations
+    NIL: ClassVar[Address]
+    ANY: ClassVar[Address]
+    ANY_RANDOM: ClassVar[Address]
+
+    # pylint: disable-next=unnecessary-lambda
+    ADDRESS_TYPE_SPEC = {'size': 1, 'mapper': lambda x: Address.address_type_name(x)}
+
+    @classmethod
+    def address_type_name(cls: type[Self], address_type: int) -> str:
+        return AddressType(address_type).name
+
+    @classmethod
+    def parse_address(cls: type[Self], data: bytes, offset: int) -> tuple[int, Self]:
+        # Fix the type to a default value. This is used for parsing type-less Classic
+        # addresses
+        return cls.parse_address_with_type(data, offset, Address.PUBLIC_DEVICE_ADDRESS)
+
+    @classmethod
+    def parse_random_address(
+        cls: type[Self], data: bytes, offset: int
+    ) -> tuple[int, Self]:
+        return cls.parse_address_with_type(data, offset, Address.RANDOM_DEVICE_ADDRESS)
+
+    @classmethod
+    def parse_address_with_type(
+        cls: type[Self], data: bytes, offset: int, address_type: AddressType
+    ) -> tuple[int, Self]:
+        return offset + 6, cls(data[offset : offset + 6], address_type)
+
+    @classmethod
+    def parse_address_preceded_by_type(
+        cls: type[Self], data: bytes, offset: int
+    ) -> tuple[int, Self]:
+        address_type = AddressType(data[offset - 1])
+        return cls.parse_address_with_type(data, offset, address_type)
+
+    def __init__(
+        self,
+        address: bytes | str,
+        address_type: AddressType = RANDOM_DEVICE_ADDRESS,
+    ) -> None:
+        '''
+        Initialize an instance. `address` may be a byte array in little-endian
+        format, or a hex string in big-endian format (with optional ':'
+        separators between the bytes).
+        If the address is a string suffixed with '/P', `address_type` is ignored and
+        the type is set to PUBLIC_DEVICE_ADDRESS.
+        '''
+        if isinstance(address, bytes):
+            self.address_bytes = address
+        else:
+            # Check if there's a '/P' type specifier
+            if address.endswith('P'):
+                address_type = Address.PUBLIC_DEVICE_ADDRESS
+                address = address[:-2]
+
+            if len(address) == 12 + 5:
+                # Form with ':' separators
+                address = address.replace(':', '')
+
+            self.address_bytes = bytes(reversed(bytes.fromhex(address)))
+
+        if len(self.address_bytes) != 6:
+            raise InvalidArgumentError('invalid address length')
+
+        self.address_type = address_type
+
+    @property
+    def is_public(self) -> bool:
+        return self.address_type in (
+            self.PUBLIC_DEVICE_ADDRESS,
+            self.PUBLIC_IDENTITY_ADDRESS,
+        )
+
+    @property
+    def is_random(self) -> bool:
+        return not self.is_public
+
+    @property
+    def is_resolvable(self) -> bool:
+        return self.address_type == self.RANDOM_DEVICE_ADDRESS and (
+            self.address_bytes[-1] >> RANDOM_ADDRESS_TYPE_SHIFT == RPA_PRAND_TYPE_TAG
+        )
+
+    @property
+    def is_static(self) -> bool:
+        return self.address_type == self.RANDOM_DEVICE_ADDRESS and (
+            self.address_bytes[-1] >> RANDOM_ADDRESS_TYPE_SHIFT
+            == STATIC_ADDRESS_TYPE_TAG
+        )
+
+    def to_string(self, with_type_qualifier: bool = True) -> str:
+        '''
+        String representation of the address, MSB first, with an optional type
+        qualifier.
+        '''
+        result = ':'.join([f'{x:02X}' for x in reversed(self.address_bytes)])
+        if not with_type_qualifier or not self.is_public:
+            return result
+        return result + '/P'
+
+    def __bytes__(self) -> bytes:
+        return self.address_bytes
+
+    def __hash__(self) -> int:
+        return hash(self.address_bytes)
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, Address)
+            and self.address_bytes == other.address_bytes
+            and self.is_public == other.is_public
+        )
+
+    def __str__(self) -> str:
+        return self.to_string()
+
+    def __repr__(self) -> str:
+        return (
+            f'Address({self.to_string(False)}/'
+            f'{self.address_type_name(self.address_type)})'
+        )
+
+
+Address.NIL = Address(b"\xff" * 6, Address.PUBLIC_DEVICE_ADDRESS)
+Address.ANY = Address(bytes(6), Address.PUBLIC_DEVICE_ADDRESS)
+Address.ANY_RANDOM = Address(bytes(6), Address.RANDOM_DEVICE_ADDRESS)

bscontroller/capabilities.py

@@ -0,0 +1,16 @@
+# Copyright 2026 Xiaomi Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Implementation capabilities fixed by this Controller (PHYs, codec limits).
+
+Values the specification lets an implementation choose, such as buffer and list
+sizes, are configurable through :class:`bscontroller.config.ControllerConfig`.
+"""
+
+CONTROLLER_SUPPORTED_PHY_MASK = 0b111
+
+CONTROLLER_PRIMARY_SCAN_PHY_MASK = 0b101
+
+
+# Maximum combined extended advertising data retained by this Controller.
+CONTROLLER_ADV_DATA_SIZE_MAX = 1650

bscontroller/cli.py

@@ -0,0 +1,123 @@
+# Copyright 2026 Xiaomi Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Independent native simulation and external-Host entry points."""
+
+import argparse
+import asyncio
+import logging
+import signal
+import uuid
+from contextlib import nullcontext
+from pathlib import Path
+
+from . import RadioController, RadioEventLoop, RadioSession, __version__
+from .config import ControllerConfig
+from .runtime import PhyProcess
+
+
+async def serve(args):
+    controller = RadioController(
+        args.name,
+        args.address,
+        hci_snoop_file=args.btsnoop_file,
+        hci_socket=args.hci_socket,
+        config=args.config,
+    )
+    async with RadioSession(
+        args.sim_id, [(args.dev_id, controller)], clock_dev_id=args.clock_id
+    ):
+        print(f'HCI listening on {args.hci_socket}', flush=True)
+        await controller.terminated
+
+
+async def run(args):
+    loop = asyncio.get_running_loop()
+    task = asyncio.current_task()
+    loop.add_signal_handler(signal.SIGTERM, task.cancel)
+    try:
+        await serve(args)
+    finally:
+        loop.remove_signal_handler(signal.SIGTERM)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='BSController Bluetooth LE Controller')
+    parser.add_argument('--version', action='version', version=__version__)
+    commands = parser.add_subparsers(dest='command', required=True)
+    commands.add_parser(
+        'config', help='print a JSON configuration with every default value'
+    )
+    for name, help_text in [('serve', 'serve H4 HCI over a Unix socket')]:
+        command = commands.add_parser(name, help=help_text)
+        command.add_argument(
+            '--bsim-dir',
+            type=Path,
+            help='BabbleSim build output (default: BSIM_OUT_PATH)',
+        )
+        command.add_argument('--sim-id', default=None)
+        command.add_argument('--log-dir', type=Path)
+    server = commands.choices['serve']
+    server.add_argument('--hci-socket', type=Path, required=True)
+    server.add_argument(
+        '--btsnoop-file',
+        type=Path,
+        help='write HCI BTSnoop using the Controller simulation clock',
+    )
+    server.add_argument('--address', default='F0:F1:F2:F3:F4:01')
+    server.add_argument(
+        '--join', action='store_true', help='join a PHY managed by the caller'
+    )
+    server.add_argument(
+        '--config',
+        type=Path,
+        help='JSON Controller configuration (see "bscontroller config")',
+    )
+    server.add_argument(
+        '--name',
+        default='controller',
+        help='select this entry under "controllers" in --config',
+    )
+    server.add_argument('--dev-id', type=int, default=0)
+    server.add_argument('--clock-id', type=int, default=1)
+    args = parser.parse_args()
+    if args.command == 'config':
+        print(ControllerConfig.template())
+        return
+    if args.command == 'serve':
+        if args.dev_id < 0 or args.clock_id < 0 or args.dev_id == args.clock_id:
+            parser.error(
+                'Controller and clock IDs must be distinct nonnegative integers'
+            )
+        if args.join and args.sim_id is None:
+            parser.error('--join requires --sim-id and matching PHY device identities')
+        if not args.join and (args.dev_id, args.clock_id) != (0, 1):
+            parser.error('managed PHY mode uses --dev-id 0 and --clock-id 1')
+    args.sim_id = args.sim_id or ('bscontroller_' + uuid.uuid4().hex[:12])
+    args.log_dir = args.log_dir or Path('/tmp') / args.sim_id
+    logging.basicConfig(level=logging.WARNING)
+    if args.config is not None and not args.config.is_file():
+        parser.error(f'configuration file not found: {args.config}')
+    try:
+        owner = (
+            nullcontext()
+            if args.command == 'serve' and args.join
+            else PhyProcess(
+                args.sim_id,
+                2,
+                directory=args.bsim_dir,
+                log_dir=args.log_dir,
+            )
+        )
+        with owner, asyncio.Runner(loop_factory=RadioEventLoop) as runner:
+            runner.run(run(args))
+    except asyncio.CancelledError:
+        return
+    except KeyboardInterrupt:
+        parser.exit(130)
+    except (ValueError, FileExistsError, RuntimeError, TimeoutError, OSError) as error:
+        parser.exit(1, f'bscontroller: {error}\n')
+
+
+if __name__ == '__main__':
+    main()

bscontroller/colors.py

@@ -0,0 +1,82 @@
+# Adapted for the independent BSController package.
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+class ColorError(ValueError):
+    """Error raised when a color spec is invalid."""
+
+
+# ANSI color names. There is also a "default"
+COLORS = ('black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white')
+
+# ANSI style names
+STYLES = (
+    'none',
+    'bold',
+    'faint',
+    'italic',
+    'underline',
+    'blink',
+    'blink2',
+    'negative',
+    'concealed',
+    'crossed',
+)
+
+
+ColorSpec = str | int
+
+
+def _join(*values: ColorSpec) -> str:
+    return ';'.join(str(v) for v in values)
+
+
+def _color_code(spec: ColorSpec, base: int) -> str:
+    if isinstance(spec, str):
+        spec = spec.strip().lower()
+
+    if spec == 'default':
+        return _join(base + 9)
+    elif spec in COLORS:
+        return _join(base + COLORS.index(spec))
+    elif isinstance(spec, int) and 0 <= spec <= 255:
+        return _join(base + 8, 5, spec)
+    else:
+        raise ColorError(f'Invalid color spec "{spec}"')
+
+
+def color(
+    s: str,
+    fg: ColorSpec | None = None,
+    bg: ColorSpec | None = None,
+    style: str | None = None,
+) -> str:
+    codes: list[ColorSpec] = []
+
+    if fg:
+        codes.append(_color_code(fg, 30))
+    if bg:
+        codes.append(_color_code(bg, 40))
+    if style:
+        for style_part in style.split('+'):
+            if style_part in STYLES:
+                codes.append(STYLES.index(style_part))
+            else:
+                raise ColorError(f'Invalid style "{style_part}"')
+
+    if codes:
+        return f'\x1b[{_join(*codes)}m{s}\x1b[0m'
+    else:
+        return s

bscontroller/config.py

@@ -0,0 +1,180 @@
+# Copyright 2026 Xiaomi Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Controller-defined parameters within their Core specification ranges.
+
+Precedence: built-in defaults, ``defaults``, ``controllers.<name>``, keyword
+arguments. JSON keys are camelCase or snake_case. Invalid or unknown entries are
+skipped with a warning; direct construction with an invalid value raises.
+
+Example file::
+
+    {
+      "defaults": {"aclPacketCount": 16},
+      "controllers": {"hci0": {"maxConnections": 2}}
+    }
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass, field, fields, replace
+from os import PathLike
+from typing import Any, Union
+
+logger = logging.getLogger(__name__)
+
+
+def _option(default: int, low: int, high: int) -> Any:
+    """A field with its inclusive specification range."""
+    return field(default=default, metadata={'range': (low, high)})
+
+
+@dataclass(frozen=True)
+class ControllerConfig:
+    """Controller-defined values; comments cite Core Vol 4, Part E."""
+
+    # 7.4.1 Read Local Version Information. Default Core 6.1 includes
+    # decision filtering and the v2 randomized RPA timeout command.
+    hci_version: int = _option(0x0F, 0x06, 0x10)
+    hci_revision: int = _option(0, 0, 0xFFFF)
+    lmp_version: int = _option(0x0F, 0x06, 0x10)
+    lmp_subversion: int = _option(0, 0, 0xFFFF)
+    manufacturer: int = _option(0xFFFF, 0, 0xFFFF)
+    # 7.8.2 LE Read Buffer Size.
+    acl_packet_count: int = _option(8, 1, 0xFF)
+    acl_packet_length: int = _option(251, 0x1B, 0xFFFF)
+    # 7.8.46 LE Read Maximum Data Length.
+    max_tx_octets: int = _option(251, 0x1B, 0xFB)
+    max_tx_time: int = _option(17040, 0x148, 0x4290)
+    max_rx_octets: int = _option(251, 0x1B, 0xFB)
+    max_rx_time: int = _option(17040, 0x148, 0x4290)
+    # 7.8.58 / 7.8.57 advertising sets and data.
+    advertising_set_count: int = _option(16, 1, 0xF0)
+    max_advertising_data_length: int = _option(1650, 0x1F, 0x672)
+    # 7.8.14 / 7.8.73 list sizes.
+    filter_accept_list_size: int = _option(16, 1, 0xFF)
+    # 7.8.41 LE Read Resolving List Size.
+    resolving_list_size: int = _option(16, 1, 0xFF)
+    periodic_advertiser_list_size: int = _option(8, 1, 0xFF)
+    # Concurrency limits; 5.3.1 bounds them by the 0x0000-0x0EFF handle space.
+    max_connections: int = _option(64, 1, 0x0EFF)
+    max_periodic_syncs: int = _option(16, 1, 0x0EFF)
+
+    def __post_init__(self) -> None:
+        for item in fields(self):
+            value = getattr(self, item.name)
+            if not _valid(item.name, value):
+                low, high = RANGES[item.name]
+                raise ValueError(f'{item.name}={value!r} is outside {low}-{high}')
+
+    def merged(
+        self, values: dict[str, Any] | None, source: str = 'config'
+    ) -> ControllerConfig:
+        """Apply ``values``; invalid entries keep the current value."""
+        changes = {}
+        for key, value in (values or {}).items():
+            name = _NAMES.get(key) if isinstance(key, str) else None
+            if name is None:
+                logger.warning('%s: unknown Controller option %r ignored', source, key)
+            elif not _valid(name, value):
+                low, high = RANGES[name]
+                logger.warning(
+                    '%s: %s=%r is outside %d-%d; keeping %r',
+                    source,
+                    key,
+                    value,
+                    low,
+                    high,
+                    changes.get(name, getattr(self, name)),
+                )
+            else:
+                changes[name] = int(value)
+        return replace(self, **changes)
+
+    @classmethod
+    def from_mapping(
+        cls, document: Any, name: str | None = None, **overrides
+    ) -> ControllerConfig:
+        """Build a configuration from a ``{defaults, controllers}`` document."""
+        if document is None:
+            document = {}
+        elif not isinstance(document, dict):
+            logger.warning('Controller configuration must be a JSON object')
+            document = {}
+        for key in document.keys() - {'defaults', 'controllers'}:
+            logger.warning('unknown Controller configuration section %r', key)
+        config = cls().merged(_section(document, 'defaults'), 'defaults')
+        if name is not None:
+            entry = _section(_section(document, 'controllers'), name)
+            config = config.merged(entry, f'controllers.{name}')
+        return config.merged(overrides, 'arguments')
+
+    @classmethod
+    def load(
+        cls, path: str | PathLike[str], name: str | None = None, **overrides
+    ) -> ControllerConfig:
+        """Read a JSON file. A missing or unreadable file raises ``OSError``;
+        malformed JSON raises ``ValueError``.
+        """
+        with open(path, encoding='utf-8') as source:
+            document = json.load(source)
+        return cls.from_mapping(document, name, **overrides)
+
+    @classmethod
+    def resolve(cls, source: ConfigSource, name: str | None) -> ControllerConfig:
+        """The configuration for the Controller called ``name``.
+
+        A ``ControllerConfig`` is used as given. A ``{defaults, controllers}``
+        mapping, or the path of such a JSON file, applies ``defaults`` and then
+        the entry for ``name``. ``None`` gives the built-in defaults.
+        """
+        if source is None:
+            return cls()
+        if isinstance(source, ControllerConfig):
+            return source
+        if isinstance(source, Mapping):
+            return cls.from_mapping(dict(source), name)
+        return cls.load(source, name)
+
+    @classmethod
+    def template(cls) -> str:
+        """A complete JSON document with every default, for editing."""
+        defaults = {_camel(key): value for key, value in asdict(cls()).items()}
+        return json.dumps({'defaults': defaults, 'controllers': {}}, indent=2)
+
+
+ConfigSource = Union[ControllerConfig, Mapping[str, Any], str, PathLike[str], None]
+"""Anything ``ControllerConfig.resolve`` accepts."""
+
+RANGES: dict[str, tuple[int, int]] = {
+    item.name: item.metadata['range'] for item in fields(ControllerConfig)
+}
+
+
+def _valid(name: str, value: object) -> bool:
+    """Integers (including int enums) within range; bool and floats are not."""
+    low, high = RANGES[name]
+    return (
+        isinstance(value, int) and not isinstance(value, bool) and low <= value <= high
+    )
+
+
+def _camel(name: str) -> str:
+    head, *rest = name.split('_')
+    return head + ''.join(part.title() for part in rest)
+
+
+_NAMES = {name: name for name in RANGES} | {_camel(name): name for name in RANGES}
+
+
+def _section(document: dict, key: str) -> dict:
+    value = document.get(key)
+    if value is None:
+        return {}
+    if not isinstance(value, dict):
+        logger.warning('Controller configuration %r must be an object', key)
+        return {}
+    return value

bscontroller/crypto/__init__.py

@@ -0,0 +1,23 @@
+# Copyright 2021-2025 Google LLC
+# Copyright 2026 Xiaomi Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""AES-128 primitive used by the LE Controller.
+
+Core 6.3, Vol 4, Part E, 7.8.22 and Vol 6, Part E.
+"""
+
+from cryptography.hazmat.primitives import ciphers
+from cryptography.hazmat.primitives.ciphers import algorithms, modes
+
+
+def e(key: bytes, data: bytes) -> bytes:
+    '''
+    AES-128 ECB, expecting byte-swapped inputs and producing a byte-swapped output.
+
+    See Bluetooth spec Vol 3, Part H - 2.2.1 Security function e
+    '''
+
+    cipher = ciphers.Cipher(algorithms.AES(key[::-1]), modes.ECB())
+    encryptor = cipher.encryptor()
+    return encryptor.update(data[::-1])[::-1]