From c119a70d5b0569fbb2ac6af0f2d0c5e319f92791 Mon Sep 17 00:00:00 2001 From: Daniel Hammer Date: Wed, 3 Jun 2026 18:05:17 +0200 Subject: [PATCH] feat: Intel BT firmware download, A2dp & Bluetooth audio progress --- a2dp.c | 3816 +++++++++++++++++ avdtp.h | 314 ++ kernel/src/Api/Audio.hpp | 27 +- kernel/src/Api/BuildNo.hpp | 2 +- kernel/src/Drivers/USB/Bluetooth/A2dp.cpp | 534 ++- kernel/src/Drivers/USB/Bluetooth/A2dp.hpp | 9 + .../src/Drivers/USB/Bluetooth/Bluetooth.cpp | 163 +- .../src/Drivers/USB/Bluetooth/Bluetooth.hpp | 6 + kernel/src/Drivers/USB/Bluetooth/Hci.cpp | 624 ++- kernel/src/Drivers/USB/Bluetooth/Hci.hpp | 85 +- .../Drivers/USB/Bluetooth/IntelFirmware.cpp | 470 ++ .../Drivers/USB/Bluetooth/IntelFirmware.hpp | 27 + kernel/src/Drivers/USB/Bluetooth/L2cap.cpp | 133 +- kernel/src/Drivers/USB/Bluetooth/L2cap.hpp | 23 + kernel/src/Drivers/USB/Bluetooth/Sbc.cpp | 323 +- kernel/src/Drivers/USB/Bluetooth/Sbc.hpp | 7 + kernel/src/Drivers/USB/Xhci.cpp | 133 +- kernel/src/Drivers/USB/Xhci.hpp | 10 + kernel/src/Main.cpp | 6 + programs/GNUmakefile | 13 +- .../data/firmware/intel/ibt-1040-0041.ddc | Bin 0 -> 9 bytes .../data/firmware/intel/ibt-1040-0041.sfi | Bin 0 -> 720988 bytes 22 files changed, 6452 insertions(+), 273 deletions(-) create mode 100644 a2dp.c create mode 100644 avdtp.h create mode 100644 kernel/src/Drivers/USB/Bluetooth/IntelFirmware.cpp create mode 100644 kernel/src/Drivers/USB/Bluetooth/IntelFirmware.hpp create mode 100644 programs/data/firmware/intel/ibt-1040-0041.ddc create mode 100644 programs/data/firmware/intel/ibt-1040-0041.sfi diff --git a/a2dp.c b/a2dp.c new file mode 100644 index 0000000..c7e0fc7 --- /dev/null +++ b/a2dp.c @@ -0,0 +1,3816 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2006-2010 Nokia Corporation + * Copyright (C) 2004-2010 Marcel Holtmann + * Copyright (C) 2011 BMW Car IT GmbH. All rights reserved. + * + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE + +#include +#include +#include +#include + +#include +#include + +#include "bluetooth/bluetooth.h" +#include "bluetooth/sdp.h" +#include "bluetooth/sdp_lib.h" +#include "bluetooth/uuid.h" + +#include "gdbus/gdbus.h" + +#include "src/btd.h" +#include "src/plugin.h" +#include "src/adapter.h" +#include "src/device.h" +#include "src/dbus-common.h" +#include "src/error.h" +#include "src/profile.h" +#include "src/service.h" +#include "src/log.h" +#include "src/sdpd.h" +#include "src/textfile.h" +#include "src/shared/queue.h" +#include "src/shared/timeout.h" +#include "src/shared/util.h" + +#include "btio/btio.h" + +#include "avdtp.h" +#include "sink.h" +#include "source.h" +#include "a2dp.h" +#include "a2dp-codecs.h" +#include "media.h" + +/* The duration that streams without users are allowed to stay in + * STREAMING state. */ +#define SUSPEND_TIMEOUT 5 + +#define AVDTP_PSM 25 + +#define MEDIA_ENDPOINT_INTERFACE "org.bluez.MediaEndpoint1" + +struct a2dp_stream { + struct avdtp *session; + struct avdtp_stream *stream; + unsigned int suspend_timer; + gboolean locked; + gboolean suspending; + gboolean starting; +}; + +struct a2dp_sep { + struct a2dp_server *server; + struct a2dp_endpoint *endpoint; + uint8_t type; + uint8_t codec; + struct avdtp_local_sep *lsep; + struct queue *streams; + gboolean delay_reporting; + void *user_data; + GDestroyNotify destroy; +}; + +struct a2dp_setup_cb { + struct a2dp_setup *setup; + a2dp_discover_cb_t discover_cb; + a2dp_select_cb_t select_cb; + a2dp_config_cb_t config_cb; + a2dp_stream_cb_t resume_cb; + a2dp_stream_cb_t suspend_cb; + guint source_id; + void *user_data; + unsigned int id; +}; + +struct a2dp_setup { + struct a2dp_channel *chan; + struct avdtp *session; + struct queue *eps; + struct a2dp_sep *sep; + struct a2dp_remote_sep *rsep; + struct avdtp_stream *stream; + struct avdtp_error *err; + avdtp_set_configuration_cb setconf_cb; + GSList *seps; + GSList *caps; + gboolean reconfigure; + gboolean start; + GSList *cb; + GIOChannel *io; + guint id; + int ref; +}; + +struct a2dp_server { + struct btd_adapter *adapter; + GSList *sinks; + GSList *sources; + uint32_t source_record_id; + uint32_t sink_record_id; + gboolean sink_enabled; + gboolean source_enabled; + uint64_t seid_pool; + GIOChannel *io; + struct queue *seps; + struct queue *channels; +}; + +struct a2dp_remote_sep { + struct a2dp_channel *chan; + char *path; + struct avdtp_remote_sep *sep; + bool from_cache; +}; + +struct a2dp_last_used { + struct a2dp_sep *lsep; + struct a2dp_remote_sep *rsep; +}; + +struct a2dp_channel { + struct a2dp_server *server; + struct btd_device *device; + GIOChannel *io; + guint io_id; + unsigned int state_id; + unsigned int auth_id; + struct avdtp *session; + struct queue *seps; + struct a2dp_last_used *last_used; +}; + +static GSList *servers = NULL; +static GSList *setups = NULL; +static unsigned int cb_id = 0; + +struct a2dp_error { + const char *error_name; + uint8_t error_code; +}; + +#define A2DP_ERROR_PREFIX ERROR_INTERFACE ".A2DP." + +static struct a2dp_error config_errors[] = { + {"InvalidCodecType", A2DP_INVALID_CODEC_TYPE}, + {"NotSupportedCodecType", A2DP_NOT_SUPPORTED_CODEC_TYPE}, + {"InvalidSamplingFrequency", A2DP_INVALID_SAMPLING_FREQUENCY}, + {"NotSupportedSamplingFrequency", + A2DP_NOT_SUPPORTED_SAMPLING_FREQUENCY}, + {"InvalidChannelMode", A2DP_INVALID_CHANNEL_MODE}, + {"NotSupportedChannelMode", A2DP_NOT_SUPPORTED_CHANNEL_MODE}, + {"InvalidSubbands", A2DP_INVALID_SUBBANDS}, + {"NotSupportedSubbands", A2DP_NOT_SUPPORTED_SUBBANDS}, + {"InvalidAllocationMethod", A2DP_INVALID_ALLOCATION_METHOD}, + {"NotSupportedAllocationMethod", A2DP_NOT_SUPPORTED_ALLOCATION_METHOD}, + {"InvalidMinimumBitpoolValue", + A2DP_INVALID_MINIMUM_BITPOOL_VALUE}, + {"NotSupportedMinimumBitpoolValue", + A2DP_NOT_SUPPORTED_MINIMUM_BITPOOL_VALUE}, + {"InvalidMaximumBitpoolValue", A2DP_INVALID_MAXIMUM_BITPOOL_VALUE}, + {"NotSupportedMaximumBitpoolValue", + A2DP_NOT_SUPPORTED_MAXIMUM_BITPOOL_VALUE}, + {"InvalidLayer", A2DP_INVALID_LAYER}, + {"NotSupportedLayer", A2DP_NOT_SUPPORTED_LAYER}, + {"NotSupportedCRC", A2DP_NOT_SUPPORTED_CRC}, + {"NotSupportedMPF", A2DP_NOT_SUPPORTED_MPF}, + {"NotSupportedVBR", A2DP_NOT_SUPPORTED_VBR}, + {"InvalidBitRate", A2DP_INVALID_BIT_RATE}, + {"NotSupportedBitRate", A2DP_NOT_SUPPORTED_BIT_RATE}, + {"InvalidObjectType", A2DP_INVALID_OBJECT_TYPE}, + {"NotSupportedObjectType", A2DP_NOT_SUPPORTED_OBJECT_TYPE}, + {"InvalidChannels", A2DP_INVALID_CHANNELS}, + {"NotSupportedChannels", A2DP_NOT_SUPPORTED_CHANNELS}, + {"InvalidVersion", A2DP_INVALID_VERSION}, + {"NotSupportedVersion", A2DP_NOT_SUPPORTED_VERSION}, + {"NotSupportedMaximumSUL", A2DP_NOT_SUPPORTED_MAXIMUM_SUL}, + {"InvalidBlockLength", A2DP_INVALID_BLOCK_LENGTH}, + {"InvalidCPType", A2DP_INVALID_CP_TYPE}, + {"InvalidCPFormat", A2DP_INVALID_CP_FORMAT}, + {"InvalidCodecParameter", A2DP_INVALID_CODEC_PARAMETER}, + {"NotSupportedCodecParameter", A2DP_NOT_SUPPORTED_CODEC_PARAMETER}, + {"InvalidDRC", A2DP_INVALID_DRC}, + {"NotSupportedDRC", A2DP_NOT_SUPPORTED_DRC} +}; + +uint8_t a2dp_parse_config_error(const char *error_name) +{ + size_t prefix_length; + size_t i; + + prefix_length = strlen(A2DP_ERROR_PREFIX); + if (strncmp(A2DP_ERROR_PREFIX, error_name, prefix_length)) + return AVDTP_UNSUPPORTED_CONFIGURATION; + + error_name += prefix_length; + for (i = 0; i < ARRAY_SIZE(config_errors); i++) { + if (strcmp(config_errors[i].error_name, error_name) == 0) + return config_errors[i].error_code; + } + + return AVDTP_UNSUPPORTED_CONFIGURATION; +} + +static struct a2dp_setup *setup_ref(struct a2dp_setup *setup) +{ + setup->ref++; + + DBG("%p: ref=%d", setup, setup->ref); + + return setup; +} + +static bool match_by_session(const void *data, const void *user_data) +{ + const struct a2dp_channel *chan = data; + const struct avdtp *session = user_data; + + return chan->session == session; +} + +static struct a2dp_channel *find_channel(struct avdtp *session) +{ + GSList *l; + + for (l = servers; l; l = g_slist_next(l)) { + struct a2dp_server *server = l->data; + struct a2dp_channel *chan; + + chan = queue_find(server->channels, match_by_session, session); + if (chan) + return chan; + } + + return NULL; +} + +static struct a2dp_setup *setup_new(struct avdtp *session) +{ + struct a2dp_setup *setup; + struct a2dp_channel *chan; + + chan = find_channel(session); + if (!chan) + return NULL; + + setup = g_new0(struct a2dp_setup, 1); + setup->session = avdtp_ref(session); + setup->chan = find_channel(session); + setups = g_slist_append(setups, setup); + + return setup; +} + +static void setup_free(struct a2dp_setup *s) +{ + DBG("%p", s); + + if (s->io) { + g_io_channel_shutdown(s->io, TRUE, NULL); + g_io_channel_unref(s->io); + } + + if (s->id) + g_source_remove(s->id); + + queue_destroy(s->eps, NULL); + + setups = g_slist_remove(setups, s); + if (s->session) + avdtp_unref(s->session); + g_slist_free_full(s->cb, g_free); + g_slist_free_full(s->caps, g_free); + g_free(s->err); + g_free(s); +} + +static void setup_unref(struct a2dp_setup *setup) +{ + setup->ref--; + + DBG("%p: ref=%d", setup, setup->ref); + + if (setup->ref > 0) + return; + + setup_free(setup); +} + +static struct a2dp_setup_cb *setup_cb_new(struct a2dp_setup *setup) +{ + struct a2dp_setup_cb *cb; + + cb = g_new0(struct a2dp_setup_cb, 1); + cb->setup = setup; + cb->id = ++cb_id; + + return cb; +} + +static struct a2dp_setup_cb *setup_cb_add(struct a2dp_setup *setup) +{ + struct a2dp_setup_cb *cb; + + cb = setup_cb_new(setup); + + setup->cb = g_slist_append(setup->cb, cb); + return cb; +} + +static void setup_cb_free(struct a2dp_setup_cb *cb) +{ + struct a2dp_setup *setup = cb->setup; + + if (cb->source_id) + g_source_remove(cb->source_id); + + setup->cb = g_slist_remove(setup->cb, cb); + setup_unref(cb->setup); + g_free(cb); +} + +static void setup_error_set(struct a2dp_setup *setup, struct avdtp_error *err) +{ + if (!err) { + g_free(setup->err); + setup->err = NULL; + } else { + if (!setup->err) + setup->err = g_new0(struct avdtp_error, 1); + memcpy(setup->err, err, sizeof(struct avdtp_error)); + } +} + +static void setup_error_init(struct a2dp_setup *setup, uint8_t type, int id) +{ + struct avdtp_error err; + + avdtp_error_init(&err, type, id); + setup_error_set(setup, &err); +} + +static void finalize_setup_errno(struct a2dp_setup *s, int err, + GSourceFunc cb1, ...) +{ + GSourceFunc finalize; + va_list args; + + if (err < 0) + setup_error_init(s, AVDTP_ERRNO, -err); + + va_start(args, cb1); + finalize = cb1; + setup_ref(s); + while (finalize != NULL) { + finalize(s); + finalize = va_arg(args, GSourceFunc); + } + setup_unref(s); + va_end(args); +} + +static int error_to_errno(struct avdtp_error *err) +{ + int perr; + + if (!err) + return 0; + + if (avdtp_error_category(err) != AVDTP_ERRNO) + return -EIO; + + perr = avdtp_error_posix_errno(err); + switch (perr) { + case EHOSTDOWN: + case ECONNABORTED: + case EBADE: + case ECONNREFUSED: + return -perr; + default: + /* An unexpected error has occurred setup may be attempted + * again. + */ + return -EAGAIN; + } +} + +static gboolean finalize_config(gpointer data) +{ + struct a2dp_setup *s = data; + GSList *l; + struct avdtp_stream *stream = s->err ? NULL : s->stream; + + for (l = s->cb; l != NULL; ) { + struct a2dp_setup_cb *cb = l->data; + + l = l->next; + + if (!cb->config_cb) + continue; + + cb->config_cb(s->session, s->sep, stream, + error_to_errno(s->err), cb->user_data); + setup_cb_free(cb); + } + + return FALSE; +} + +static gboolean finalize_resume(gpointer data) +{ + struct a2dp_setup *s = data; + GSList *l; + + for (l = s->cb; l != NULL; ) { + struct a2dp_setup_cb *cb = l->data; + + l = l->next; + + if (!cb->resume_cb) + continue; + + cb->resume_cb(s->session, error_to_errno(s->err), + cb->user_data); + setup_cb_free(cb); + } + + return FALSE; +} + +static gboolean finalize_suspend(gpointer data) +{ + struct a2dp_setup *s = data; + GSList *l; + + for (l = s->cb; l != NULL; ) { + struct a2dp_setup_cb *cb = l->data; + + l = l->next; + + if (!cb->suspend_cb) + continue; + + cb->suspend_cb(s->session, error_to_errno(s->err), + cb->user_data); + setup_cb_free(cb); + } + + return FALSE; +} + +static void finalize_select(struct a2dp_setup *s) +{ + GSList *l; + + for (l = s->cb; l != NULL; ) { + struct a2dp_setup_cb *cb = l->data; + + l = l->next; + + if (!cb->select_cb) + continue; + + cb->select_cb(s->session, s->sep, s->caps, + error_to_errno(s->err), cb->user_data); + setup_cb_free(cb); + } +} + +static void finalize_discover(struct a2dp_setup *s) +{ + GSList *l; + + for (l = s->cb; l != NULL; ) { + struct a2dp_setup_cb *cb = l->data; + + l = l->next; + + if (!cb->discover_cb) + continue; + + cb->discover_cb(s->session, s->seps, error_to_errno(s->err), + cb->user_data); + setup_cb_free(cb); + } +} + +static gboolean finalize_all(gpointer data) +{ + struct a2dp_setup *s = data; + struct avdtp_stream *stream = s->err ? NULL : s->stream; + GSList *l; + + for (l = s->cb; l != NULL; ) { + struct a2dp_setup_cb *cb = l->data; + + l = l->next; + + if (cb->discover_cb) { + cb->discover_cb(s->session, s->seps, + error_to_errno(s->err), cb->user_data); + } else if (cb->select_cb) { + cb->select_cb(s->session, s->sep, s->caps, + error_to_errno(s->err), cb->user_data); + } else if (cb->suspend_cb) { + cb->suspend_cb(s->session, + error_to_errno(s->err), cb->user_data); + } else if (cb->resume_cb) { + cb->resume_cb(s->session, + error_to_errno(s->err), cb->user_data); + } else if (cb->config_cb) { + cb->config_cb(s->session, s->sep, stream, + error_to_errno(s->err), cb->user_data); + } else + warn("setup_cb doesn't have any callback function"); + + setup_cb_free(cb); + } + + return FALSE; +} + +static struct a2dp_setup *find_setup_by_session(struct avdtp *session) +{ + GSList *l; + + for (l = setups; l != NULL; l = l->next) { + struct a2dp_setup *setup = l->data; + + if (setup->session == session) + return setup; + } + + return NULL; +} + +static struct a2dp_setup *a2dp_setup_get(struct avdtp *session) +{ + struct a2dp_setup *setup; + + setup = find_setup_by_session(session); + if (!setup) { + setup = setup_new(session); + if (!setup) + return NULL; + } + + return setup_ref(setup); +} + +static struct a2dp_setup *find_setup_by_stream(struct avdtp_stream *stream) +{ + GSList *l; + + for (l = setups; l != NULL; l = l->next) { + struct a2dp_setup *setup = l->data; + + if (setup->stream == stream) + return setup; + } + + return NULL; +} + +static bool match_stream_session(const void *data, const void *user_data) +{ + const struct a2dp_stream *stream = data; + const struct avdtp *session = user_data; + + return stream->session == session; +} + +static struct a2dp_stream *a2dp_stream_new(struct a2dp_sep *sep, + struct avdtp *session) +{ + struct a2dp_stream *stream; + + if (!sep->streams) + sep->streams = queue_new(); + + stream = new0(struct a2dp_stream, 1); + stream->session = avdtp_ref(session); + queue_push_tail(sep->streams, stream); + + return stream; +} + +static struct a2dp_stream *a2dp_stream_get(struct a2dp_sep *sep, + struct avdtp *session) +{ + struct a2dp_stream *stream; + + DBG("sep %p session %p", sep, session); + + stream = queue_find(sep->streams, match_stream_session, session); + if (stream) + return stream; + + return a2dp_stream_new(sep, session); +} + +static void a2dp_stream_starting(struct a2dp_sep *sep, struct avdtp *session) +{ + struct a2dp_stream *stream; + + stream = a2dp_stream_get(sep, session); + if (!stream) + return; + + stream->starting = TRUE; +} + +static void a2dp_stream_free(void *data) +{ + struct a2dp_stream *stream = data; + + if (stream->suspend_timer) { + timeout_remove(stream->suspend_timer); + stream->suspend_timer = 0; + } + + avdtp_unref(stream->session); + free(stream); +} + +static bool match_stream(const void *data, const void *user_data) +{ + const struct a2dp_stream *astream = data; + const struct avdtp_stream *stream = user_data; + + return astream->stream == stream; +} + +static void a2dp_stream_destroy(struct a2dp_sep *sep, + struct avdtp_stream *stream) +{ + struct a2dp_stream *astream; + + DBG("sep %p stream %p", sep, stream); + + astream = queue_remove_if(sep->streams, match_stream, stream); + if (astream) + a2dp_stream_free(astream); +} + +static void stream_state_changed(struct avdtp_stream *stream, + avdtp_state_t old_state, + avdtp_state_t new_state, + struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *sep = user_data; + struct a2dp_stream *a2dp_stream; + struct btd_device *dev = NULL; + + if (new_state == AVDTP_STATE_OPEN) { + struct a2dp_setup *setup; + int err; + + setup = find_setup_by_stream(stream); + if (!setup || !setup->start || setup->err) + return; + + setup->start = FALSE; + + err = avdtp_start(setup->session, stream); + if (err < 0 && err != -EINPROGRESS) { + error("avdtp_start: %s (%d)", strerror(-err), -err); + finalize_setup_errno(setup, err, finalize_resume, + NULL); + return; + } + + a2dp_stream_starting(sep, setup->session); + + return; + } + + if (new_state != AVDTP_STATE_IDLE) + return; + + a2dp_stream = queue_find(sep->streams, match_stream, stream); + if (a2dp_stream) { + dev = avdtp_get_device(a2dp_stream->session); + a2dp_stream_destroy(sep, stream); + } + + if (sep->endpoint && sep->endpoint->clear_configuration) + sep->endpoint->clear_configuration(sep, dev, sep->user_data); +} + +static gboolean auto_config(gpointer data) +{ + struct a2dp_setup *setup = data; + struct btd_device *dev = NULL; + struct btd_service *service; + struct a2dp_stream *stream; + + dev = avdtp_get_device(setup->session); + + if (setup->sep->type == AVDTP_SEP_TYPE_SOURCE) + service = btd_device_get_service(dev, A2DP_SINK_UUID); + else + service = btd_device_get_service(dev, A2DP_SOURCE_UUID); + + if (service == NULL) { + error("Unable to find btd service"); + return FALSE; + } + + /* Check if configuration was aborted */ + stream = queue_find(setup->sep->streams, match_stream, setup->stream); + if (!stream) + return FALSE; + + if (setup->err != NULL) + goto done; + + avdtp_stream_add_cb(setup->session, setup->stream, + stream_state_changed, setup->sep); + + if (setup->sep->type == AVDTP_SEP_TYPE_SOURCE) { + sink_new_stream(service, setup->session, setup->stream); + } else { + source_new_stream(service, setup->session, setup->stream); + } + +done: + if (setup->setconf_cb) + setup->setconf_cb(setup->session, setup->stream, setup->err); + + finalize_config(setup); + + setup_error_set(setup, NULL); + + setup_unref(setup); + + return FALSE; +} + +static void endpoint_setconf_cb(struct a2dp_setup *setup, uint8_t error_code) +{ + if (error_code != 0) + setup_error_init(setup, AVDTP_MEDIA_CODEC, error_code); + + auto_config(setup); + setup_unref(setup); +} + +static gboolean endpoint_match_codec_ind(struct avdtp *session, + struct avdtp_media_codec_capability *codec, + void *user_data) +{ + struct a2dp_sep *sep = user_data; + a2dp_vendor_codec_t *remote_codec; + a2dp_vendor_codec_t *local_codec; + uint8_t *capabilities; + size_t length; + + if (codec->media_codec_type != A2DP_CODEC_VENDOR) + return TRUE; + + if (sep->endpoint == NULL) + return FALSE; + + length = sep->endpoint->get_capabilities(sep, &capabilities, + sep->user_data); + if (length < sizeof(a2dp_vendor_codec_t)) + return FALSE; + + local_codec = (a2dp_vendor_codec_t *) capabilities; + remote_codec = (a2dp_vendor_codec_t *) codec->data; + + if (A2DP_GET_VENDOR_ID(*remote_codec) != + A2DP_GET_VENDOR_ID(*local_codec)) + return FALSE; + + if (A2DP_GET_CODEC_ID(*remote_codec) != A2DP_GET_CODEC_ID(*local_codec)) + return FALSE; + + DBG("vendor 0x%08x codec 0x%04x", A2DP_GET_VENDOR_ID(*remote_codec), + A2DP_GET_CODEC_ID(*remote_codec)); + return TRUE; +} + +static void reverse_discover(struct avdtp *session, GSList *seps, int err, + void *user_data) +{ + DBG("err %d", err); +} + +static gboolean endpoint_setconf_ind(struct avdtp *session, + struct avdtp_local_sep *sep, + struct avdtp_stream *stream, + GSList *caps, + avdtp_set_configuration_cb cb, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + struct a2dp_stream *a2dp_stream; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Set_Configuration_Ind", sep); + else + DBG("Source %p: Set_Configuration_Ind", sep); + + a2dp_stream = a2dp_stream_get(a2dp_sep, session); + if (!a2dp_stream) + return FALSE; + + setup = a2dp_setup_get(session); + if (!setup) + return FALSE; + + a2dp_stream->stream = stream; + setup->sep = a2dp_sep; + setup->stream = stream; + setup->setconf_cb = cb; + + for (; caps != NULL; caps = g_slist_next(caps)) { + struct avdtp_service_capability *cap = caps->data; + struct avdtp_media_codec_capability *codec; + gboolean ret; + + if (cap->category == AVDTP_DELAY_REPORTING && + !a2dp_sep->delay_reporting) { + setup_error_init(setup, AVDTP_DELAY_REPORTING, + AVDTP_UNSUPPORTED_CONFIGURATION); + goto done; + } + + if (cap->category != AVDTP_MEDIA_CODEC) + continue; + + codec = (struct avdtp_media_codec_capability *) cap->data; + + if (codec->media_codec_type != a2dp_sep->codec) { + setup_error_init(setup, AVDTP_MEDIA_CODEC, + AVDTP_UNSUPPORTED_CONFIGURATION); + goto done; + } + + ret = a2dp_sep->endpoint->set_configuration(a2dp_sep, + codec->data, + cap->length - sizeof(*codec), + setup_ref(setup), + endpoint_setconf_cb, + a2dp_sep->user_data); + if (ret == 0) { + /* Attempt to reverse discover if there are no remote + * SEPs. + */ + if (queue_isempty(setup->chan->seps)) + a2dp_discover(session, reverse_discover, NULL); + return TRUE; + } + + setup_error_init(setup, AVDTP_MEDIA_CODEC, + AVDTP_UNSUPPORTED_CONFIGURATION); + setup_unref(setup); + break; + } + +done: + g_idle_add(auto_config, setup); + return TRUE; +} + +static gboolean endpoint_getcap_ind(struct avdtp *session, + struct avdtp_local_sep *sep, + gboolean get_all, GSList **caps, + uint8_t *err, void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct avdtp_service_capability *media_transport, *media_codec; + struct avdtp_media_codec_capability *codec_caps; + uint8_t *capabilities; + size_t length; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Get_Capability_Ind", sep); + else + DBG("Source %p: Get_Capability_Ind", sep); + + *caps = NULL; + + media_transport = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT, + NULL, 0); + + *caps = g_slist_append(*caps, media_transport); + + length = a2dp_sep->endpoint->get_capabilities(a2dp_sep, &capabilities, + a2dp_sep->user_data); + + codec_caps = g_malloc0(sizeof(*codec_caps) + length); + codec_caps->media_type = AVDTP_MEDIA_TYPE_AUDIO; + codec_caps->media_codec_type = a2dp_sep->codec; + memcpy(codec_caps->data, capabilities, length); + + media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, codec_caps, + sizeof(*codec_caps) + length); + + *caps = g_slist_append(*caps, media_codec); + g_free(codec_caps); + + if (get_all) { + struct avdtp_service_capability *delay_reporting; + delay_reporting = avdtp_service_cap_new(AVDTP_DELAY_REPORTING, + NULL, 0); + *caps = g_slist_append(*caps, delay_reporting); + } + + return TRUE; +} + +static void endpoint_open_cb(struct a2dp_setup *setup, uint8_t error_code) +{ + int err = error_to_errno(setup->err); + + if (error_code != 0) { + setup->stream = NULL; + finalize_setup_errno(setup, -EPERM, finalize_config, NULL); + goto done; + } + + if (err == 0) + err = avdtp_open(setup->session, setup->stream); + + if (err == 0) + goto done; + + error("avdtp_open %s (%d)", strerror(-err), -err); + setup->stream = NULL; + finalize_setup_errno(setup, err, finalize_config, NULL); +done: + setup_unref(setup); +} + +static bool match_remote_sep(const void *data, const void *user_data) +{ + const struct a2dp_remote_sep *sep = data; + const struct avdtp_remote_sep *rsep = user_data; + + return sep->sep == rsep; +} + +static void store_remote_sep(void *data, void *user_data) +{ + struct a2dp_remote_sep *sep = data; + GKeyFile *key_file = user_data; + char seid[4], value[256]; + struct avdtp_service_capability *service = avdtp_get_codec(sep->sep); + struct avdtp_media_codec_capability *codec; + unsigned int i; + ssize_t offset; + + if (!service) + return; + + codec = (void *) service->data; + + sprintf(seid, "%02hhx", avdtp_get_seid(sep->sep)); + + offset = sprintf(value, "%02hhx:%02hhx:%02hhx:", + avdtp_get_type(sep->sep), codec->media_codec_type, + avdtp_get_delay_reporting(sep->sep)); + + for (i = 0; i < service->length - sizeof(*codec); i++) + offset += sprintf(value + offset, "%02hhx", codec->data[i]); + + g_key_file_set_string(key_file, "Endpoints", seid, value); +} + +static void store_remote_seps(struct a2dp_channel *chan) +{ + struct btd_device *device = chan->device; + char filename[PATH_MAX]; + char dst_addr[18]; + GKeyFile *key_file; + GError *gerr = NULL; + char *data; + gsize length = 0; + + ba2str(device_get_address(device), dst_addr); + + create_filename(filename, PATH_MAX, "/%s/cache/%s", + btd_adapter_get_storage_dir(device_get_adapter(device)), + dst_addr); + + key_file = g_key_file_new(); + if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) { + error("Unable to load key file from %s: (%s)", filename, + gerr->message); + g_clear_error(&gerr); + } + + data = g_key_file_get_string(key_file, "Endpoints", "LastUsed", + NULL); + + /* Remove current endpoints since it might have changed */ + g_key_file_remove_group(key_file, "Endpoints", NULL); + + queue_foreach(chan->seps, store_remote_sep, key_file); + + if (data) { + g_key_file_set_string(key_file, "Endpoints", "LastUsed", + data); + g_free(data); + } + + data = g_key_file_to_data(key_file, &length, NULL); + if (!g_file_set_contents(filename, data, length, &gerr)) { + error("Unable set contents for %s: (%s)", filename, + gerr->message); + g_error_free(gerr); + } + + g_free(data); + g_key_file_free(key_file); +} + +static void invalidate_remote_cache(struct a2dp_setup *setup, + struct avdtp_error *err) +{ + if (err->category == AVDTP_ERRNO) + return; + + /* Attempt to unregister Remote SEP if configuration fails and it was + * loaded from cache. + */ + if (setup->rsep && setup->rsep->from_cache) { + warn("Invalidating Remote SEP from cache"); + avdtp_unregister_remote_sep(setup->session, setup->rsep->sep); + /* Update cache */ + store_remote_seps(setup->chan); + /* Set error to -EAGAIN so the likes of policy plugin can + * reattempt to connect. + */ + setup_error_init(setup, AVDTP_ERRNO, -EAGAIN); + } +} + +static void setconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, + struct avdtp_error *err, void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + struct a2dp_stream *a2dp_stream; + struct btd_device *dev; + struct btd_service *service; + int ret; + + dev = avdtp_get_device(session); + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) { + DBG("Sink %p: Set_Configuration_Cfm", sep); + service = btd_device_get_service(dev, A2DP_SOURCE_UUID); + } else { + DBG("Source %p: Set_Configuration_Cfm", sep); + service = btd_device_get_service(dev, A2DP_SINK_UUID); + } + + if (service == NULL) { + error("Unable to find btd service"); + return; + } + + setup = find_setup_by_session(session); + + if (err) { + if (setup) { + setup_ref(setup); + setup_error_set(setup, err); + invalidate_remote_cache(setup, err); + finalize_config(setup); + setup_error_set(setup, NULL); + setup_unref(setup); + } + + return; + } + + avdtp_stream_add_cb(session, stream, stream_state_changed, a2dp_sep); + + a2dp_stream = a2dp_stream_get(a2dp_sep, session); + if (a2dp_stream) + a2dp_stream->stream = stream; + + if (!setup) + return; + + /* Notify D-Bus interface of the new stream */ + if (a2dp_sep->type == AVDTP_SEP_TYPE_SOURCE) { + sink_new_stream(service, session, setup->stream); + } else { + source_new_stream(service, session, setup->stream); + } + + /* Notify Endpoint */ + if (a2dp_sep->endpoint) { + struct avdtp_service_capability *service; + struct avdtp_media_codec_capability *codec; + int err; + + service = avdtp_stream_get_codec(stream); + codec = (struct avdtp_media_codec_capability *) service->data; + + err = a2dp_sep->endpoint->set_configuration(a2dp_sep, + codec->data, service->length - + sizeof(*codec), + setup_ref(setup), + endpoint_open_cb, + a2dp_sep->user_data); + if (err == 0) + return; + + setup->stream = NULL; + finalize_setup_errno(setup, -EPERM, finalize_config, NULL); + setup_unref(setup); + return; + } + + ret = avdtp_open(session, stream); + if (ret < 0) { + error("avdtp_open %s (%d)", strerror(-ret), -ret); + setup->stream = NULL; + finalize_setup_errno(setup, ret, finalize_config, NULL); + } +} + +static gboolean getconf_ind(struct avdtp *session, struct avdtp_local_sep *sep, + uint8_t *err, void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Get_Configuration_Ind", sep); + else + DBG("Source %p: Get_Configuration_Ind", sep); + return TRUE; +} + +static void getconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Set_Configuration_Cfm", sep); + else + DBG("Source %p: Set_Configuration_Cfm", sep); +} + +static void store_last_used(struct a2dp_channel *chan, uint8_t lseid, + uint8_t rseid) +{ + GKeyFile *key_file; + GError *gerr = NULL; + char filename[PATH_MAX]; + char dst_addr[18]; + char value[6]; + char *data; + size_t len = 0; + + ba2str(device_get_address(chan->device), dst_addr); + + create_filename(filename, PATH_MAX, "/%s/cache/%s", + btd_adapter_get_storage_dir(device_get_adapter(chan->device)), + dst_addr); + + key_file = g_key_file_new(); + if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) { + error("Unable to load key file from %s: (%s)", filename, + gerr->message); + g_clear_error(&gerr); + } + + sprintf(value, "%02hhx:%02hhx", lseid, rseid); + + g_key_file_set_string(key_file, "Endpoints", "LastUsed", value); + + data = g_key_file_to_data(key_file, &len, NULL); + if (!g_file_set_contents(filename, data, len, &gerr)) { + error("Unable set contents for %s: (%s)", filename, + gerr->message); + g_error_free(gerr); + } + + g_free(data); + g_key_file_free(key_file); +} + +static void add_last_used(struct a2dp_channel *chan, struct a2dp_sep *lsep, + struct a2dp_remote_sep *rsep) +{ + if (!chan->last_used) + chan->last_used = new0(struct a2dp_last_used, 1); + + chan->last_used->lsep = lsep; + chan->last_used->rsep = rsep; +} + +static void update_last_used(struct a2dp_channel *chan, struct a2dp_sep *lsep, + struct avdtp_stream *stream) +{ + struct avdtp_remote_sep *rsep; + struct a2dp_remote_sep *sep; + + rsep = avdtp_stream_get_remote_sep(stream); + sep = queue_find(chan->seps, match_remote_sep, rsep); + if (!sep) { + error("Unable to find remote SEP"); + return; + } + + /* Check if already stored then skip */ + if (chan->last_used && (chan->last_used->lsep == lsep && + chan->last_used->rsep == sep)) + return; + + add_last_used(chan, lsep, sep); + + store_last_used(chan, avdtp_sep_get_seid(lsep->lsep), + avdtp_get_seid(rsep)); +} + +static gboolean open_ind(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Open_Ind", sep); + else + DBG("Source %p: Open_Ind", sep); + + setup = a2dp_setup_get(session); + if (!setup) + return FALSE; + + setup->stream = stream; + + if (!err && setup->chan) + update_last_used(setup->chan, a2dp_sep, stream); + + if (setup->reconfigure) + setup->reconfigure = FALSE; + + finalize_config(setup); + + return TRUE; +} + +static void open_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Open_Cfm", sep); + else + DBG("Source %p: Open_Cfm", sep); + + setup = find_setup_by_session(session); + if (!setup) + return; + + if (setup->reconfigure) + setup->reconfigure = FALSE; + + if (err) { + setup->stream = NULL; + setup_error_set(setup, err); + if (setup->start) + finalize_resume(setup); + } else if (setup->chan) + update_last_used(setup->chan, a2dp_sep, stream); + + finalize_config(setup); + + return; +} + +static bool suspend_timeout(struct a2dp_stream *stream) +{ + if (avdtp_suspend(stream->session, stream->stream) == 0) + stream->suspending = TRUE; + + stream->suspend_timer = 0; + + return FALSE; +} + +static gboolean start_ind(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_stream *a2dp_stream; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Start_Ind", sep); + else + DBG("Source %p: Start_Ind", sep); + + a2dp_stream = queue_find(a2dp_sep->streams, match_stream, stream); + if (!a2dp_stream) + return FALSE; + + if (!a2dp_stream->locked) + a2dp_stream->suspend_timer = timeout_add_seconds( + SUSPEND_TIMEOUT, + (timeout_func_t) suspend_timeout, + a2dp_stream, NULL); + + if (!a2dp_stream->starting) + return TRUE; + + a2dp_stream->starting = FALSE; + + setup = find_setup_by_session(session); + if (setup) + finalize_resume(setup); + + return TRUE; +} + +static void start_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_stream *a2dp_stream; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Start_Cfm", sep); + else + DBG("Source %p: Start_Cfm", sep); + + a2dp_stream = queue_find(a2dp_sep->streams, match_stream, stream); + if (!a2dp_stream) + return; + + a2dp_stream->starting = FALSE; + + setup = find_setup_by_session(session); + if (!setup) + return; + + if (err) { + setup->stream = NULL; + setup_error_set(setup, err); + } + + finalize_resume(setup); +} + +static gboolean suspend_ind(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_stream *a2dp_stream; + struct a2dp_setup *setup; + gboolean start; + int start_err; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Suspend_Ind", sep); + else + DBG("Source %p: Suspend_Ind", sep); + + a2dp_stream = queue_find(a2dp_sep->streams, match_stream, stream); + if (!a2dp_stream) + return FALSE; + + if (a2dp_stream->suspend_timer) { + timeout_remove(a2dp_stream->suspend_timer); + a2dp_stream->suspend_timer = 0; + } + + if (!a2dp_stream->suspending) + return TRUE; + + a2dp_stream->suspending = FALSE; + + setup = find_setup_by_session(session); + if (!setup) + return TRUE; + + start = setup->start; + setup->start = FALSE; + + finalize_suspend(setup); + + if (!start) + return TRUE; + + start_err = avdtp_start(session, a2dp_stream->stream); + if (start_err < 0 && start_err != -EINPROGRESS) { + error("avdtp_start: %s (%d)", strerror(-start_err), + -start_err); + finalize_setup_errno(setup, start_err, finalize_resume, NULL); + } + + return TRUE; +} + +static void suspend_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_stream *a2dp_stream; + struct a2dp_setup *setup; + gboolean start; + int start_err; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Suspend_Cfm", sep); + else + DBG("Source %p: Suspend_Cfm", sep); + + a2dp_stream = queue_find(a2dp_sep->streams, match_stream, stream); + if (!a2dp_stream) + return; + + a2dp_stream->suspending = FALSE; + + setup = find_setup_by_session(session); + if (!setup) + return; + + start = setup->start; + setup->start = FALSE; + + if (err) { + setup->stream = NULL; + setup_error_set(setup, err); + } + + finalize_suspend(setup); + + if (!start) + return; + + if (err) { + finalize_resume(setup); + return; + } + + start_err = avdtp_start(session, a2dp_stream->stream); + if (start_err < 0 && start_err != -EINPROGRESS) { + error("avdtp_start: %s (%d)", strerror(-start_err), -start_err); + finalize_setup_errno(setup, start_err, finalize_suspend, NULL); + } +} + +static gboolean close_ind(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Close_Ind", sep); + else + DBG("Source %p: Close_Ind", sep); + + setup = find_setup_by_session(session); + if (!setup) + return TRUE; + + finalize_setup_errno(setup, -ECONNRESET, finalize_suspend, + finalize_resume, NULL); + + return TRUE; +} + +static struct a2dp_remote_sep *find_remote_sep(struct a2dp_channel *chan, + struct a2dp_sep *sep) +{ + struct avdtp_remote_sep *rsep; + + if (!chan || !sep) + return NULL; + + rsep = avdtp_find_remote_sep(chan->session, sep->lsep); + + return queue_find(chan->seps, match_remote_sep, rsep); +} + +static gboolean a2dp_reconfigure(gpointer data) +{ + struct a2dp_setup *setup = data; + struct a2dp_sep *sep = setup->sep; + int posix_err; + struct avdtp_media_codec_capability *rsep_codec; + struct avdtp_service_capability *cap; + + setup->id = 0; + + if (setup->err) { + posix_err = error_to_errno(setup->err); + goto failed; + } + + if (!sep->lsep) { + error("no valid local SEP"); + posix_err = -EINVAL; + goto failed; + } + + if (setup->rsep) { + cap = avdtp_get_codec(setup->rsep->sep); + rsep_codec = (struct avdtp_media_codec_capability *) cap->data; + /* Check that codec really match after closing */ + if (sep->codec != rsep_codec->media_codec_type) + setup->rsep = NULL; + } + + if (!setup->rsep) + setup->rsep = find_remote_sep(setup->chan, sep); + + if (!setup->rsep) { + error("unable to find remote SEP"); + posix_err = -EINVAL; + goto failed; + } + + posix_err = avdtp_set_configuration(setup->session, setup->rsep->sep, + sep->lsep, + setup->caps, + &setup->stream); + if (posix_err < 0) { + error("avdtp_set_configuration: %s", strerror(-posix_err)); + goto failed; + } + + return FALSE; + +failed: + finalize_setup_errno(setup, posix_err, finalize_config, NULL); + return FALSE; +} + +static bool setup_reconfigure(struct a2dp_setup *setup) +{ + if (!setup->reconfigure || setup->id) + return false; + + DBG("%p", setup); + + setup->id = g_idle_add(a2dp_reconfigure, setup); + + setup->reconfigure = FALSE; + + return true; +} + +static struct a2dp_remote_sep *get_remote_sep(struct a2dp_channel *chan, + struct avdtp_stream *stream) +{ + struct avdtp_remote_sep *rsep; + + rsep = avdtp_stream_get_remote_sep(stream); + + return queue_find(chan->seps, match_remote_sep, rsep); +} + +static void close_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Close_Cfm", sep); + else + DBG("Source %p: Close_Cfm", sep); + + setup = find_setup_by_session(session); + if (!setup) + return; + + if (err) { + setup->stream = NULL; + setup_error_set(setup, err); + finalize_config(setup); + return; + } + + if (!setup->rsep) + setup->rsep = get_remote_sep(setup->chan, stream); + + setup_reconfigure(setup); +} + +static void abort_ind(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Abort_Ind", sep); + else + DBG("Source %p: Abort_Ind", sep); + + a2dp_stream_destroy(a2dp_sep, stream); + + setup = find_setup_by_session(session); + if (!setup) + return; + + finalize_setup_errno(setup, -ECONNRESET, finalize_suspend, + finalize_resume, + finalize_config, NULL); + + return; +} + +static void abort_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: Abort_Cfm", sep); + else + DBG("Source %p: Abort_Cfm", sep); + + setup = find_setup_by_session(session); + if (!setup) + return; + + if (setup_reconfigure(setup)) + return; + + setup_unref(setup); +} + +static gboolean reconf_ind(struct avdtp *session, struct avdtp_local_sep *sep, + uint8_t *err, void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: ReConfigure_Ind", sep); + else + DBG("Source %p: ReConfigure_Ind", sep); + + return TRUE; +} + +static gboolean endpoint_delayreport_ind(struct avdtp *session, + struct avdtp_local_sep *sep, + uint8_t rseid, uint16_t delay, + uint8_t *err, void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: DelayReport_Ind", sep); + else + DBG("Source %p: DelayReport_Ind", sep); + + if (a2dp_sep->endpoint == NULL || + a2dp_sep->endpoint->set_delay == NULL) + return FALSE; + + a2dp_sep->endpoint->set_delay(a2dp_sep, delay, a2dp_sep->user_data); + + return TRUE; +} + +static void reconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + struct a2dp_setup *setup; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: ReConfigure_Cfm", sep); + else + DBG("Source %p: ReConfigure_Cfm", sep); + + setup = find_setup_by_session(session); + if (!setup) + return; + + if (err) { + setup->stream = NULL; + setup_error_set(setup, err); + } + + finalize_config(setup); +} + +static void delay_report_cfm(struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, + struct avdtp_error *err, void *user_data) +{ + struct a2dp_sep *a2dp_sep = user_data; + + if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) + DBG("Sink %p: DelayReport_Cfm", sep); + else + DBG("Source %p: DelayReport_Cfm", sep); +} + +static struct avdtp_sep_cfm cfm = { + .set_configuration = setconf_cfm, + .get_configuration = getconf_cfm, + .open = open_cfm, + .start = start_cfm, + .suspend = suspend_cfm, + .close = close_cfm, + .abort = abort_cfm, + .reconfigure = reconf_cfm, + .delay_report = delay_report_cfm, +}; + +static struct avdtp_sep_ind endpoint_ind = { + .match_codec = endpoint_match_codec_ind, + .get_capability = endpoint_getcap_ind, + .set_configuration = endpoint_setconf_ind, + .get_configuration = getconf_ind, + .open = open_ind, + .start = start_ind, + .suspend = suspend_ind, + .close = close_ind, + .abort = abort_ind, + .reconfigure = reconf_ind, + .delayreport = endpoint_delayreport_ind, +}; + +static sdp_record_t *a2dp_record(uint8_t type) +{ + sdp_list_t *svclass_id, *pfseq, *apseq, *root; + uuid_t root_uuid, l2cap_uuid, avdtp_uuid, a2dp_uuid; + sdp_profile_desc_t profile[1]; + sdp_list_t *aproto, *proto[2]; + sdp_record_t *record; + sdp_data_t *psm, *version, *features; + uint16_t lp = AVDTP_UUID; + uint16_t a2dp_ver = 0x0104, avdtp_ver = 0x0103, feat = 0x000f; + + record = sdp_record_alloc(); + if (!record) + return NULL; + + sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); + root = sdp_list_append(0, &root_uuid); + sdp_set_browse_groups(record, root); + + if (type == AVDTP_SEP_TYPE_SOURCE) + sdp_uuid16_create(&a2dp_uuid, AUDIO_SOURCE_SVCLASS_ID); + else + sdp_uuid16_create(&a2dp_uuid, AUDIO_SINK_SVCLASS_ID); + svclass_id = sdp_list_append(0, &a2dp_uuid); + sdp_set_service_classes(record, svclass_id); + + sdp_uuid16_create(&profile[0].uuid, ADVANCED_AUDIO_PROFILE_ID); + profile[0].version = a2dp_ver; + pfseq = sdp_list_append(0, &profile[0]); + sdp_set_profile_descs(record, pfseq); + + sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); + proto[0] = sdp_list_append(0, &l2cap_uuid); + psm = sdp_data_alloc(SDP_UINT16, &lp); + proto[0] = sdp_list_append(proto[0], psm); + apseq = sdp_list_append(0, proto[0]); + + sdp_uuid16_create(&avdtp_uuid, AVDTP_UUID); + proto[1] = sdp_list_append(0, &avdtp_uuid); + version = sdp_data_alloc(SDP_UINT16, &avdtp_ver); + proto[1] = sdp_list_append(proto[1], version); + apseq = sdp_list_append(apseq, proto[1]); + + aproto = sdp_list_append(0, apseq); + sdp_set_access_protos(record, aproto); + + features = sdp_data_alloc(SDP_UINT16, &feat); + sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features); + + if (type == AVDTP_SEP_TYPE_SOURCE) + sdp_set_info_attr(record, "Audio Source", 0, 0); + else + sdp_set_info_attr(record, "Audio Sink", 0, 0); + + free(psm); + free(version); + sdp_list_free(proto[0], 0); + sdp_list_free(proto[1], 0); + sdp_list_free(apseq, 0); + sdp_list_free(pfseq, 0); + sdp_list_free(aproto, 0); + sdp_list_free(root, 0); + sdp_list_free(svclass_id, 0); + + return record; +} + +static struct a2dp_server *find_server(GSList *list, struct btd_adapter *a) +{ + + for (; list; list = list->next) { + struct a2dp_server *server = list->data; + + if (server->adapter == a) + return server; + } + + return NULL; +} + +static void remote_sep_free(void *data) +{ + struct a2dp_remote_sep *sep = data; + + avdtp_remote_sep_set_destroy(sep->sep, NULL, NULL); + + free(sep->path); + free(sep); +} + +static void remove_remote_sep(void *data) +{ + struct a2dp_remote_sep *sep = data; + + if (!sep->path) { + remote_sep_free(sep); + return; + } + + g_dbus_unregister_interface(btd_get_dbus_connection(), sep->path, + MEDIA_ENDPOINT_INTERFACE); +} + +static void channel_free(void *data) +{ + struct a2dp_channel *chan = data; + struct a2dp_setup *setup; + + if (chan->auth_id > 0) + btd_cancel_authorization(chan->auth_id); + + if (chan->io_id > 0) + g_source_remove(chan->io_id); + + if (chan->io) { + g_io_channel_shutdown(chan->io, TRUE, NULL); + g_io_channel_unref(chan->io); + } + + avdtp_remove_state_cb(chan->state_id); + + queue_destroy(chan->seps, remove_remote_sep); + free(chan->last_used); + + setup = find_setup_by_session(chan->session); + if (setup) { + setup->chan = NULL; + setup_ref(setup); + /* Finalize pending commands before we NULL setup->session */ + finalize_setup_errno(setup, -ENOTCONN, finalize_all, NULL); + avdtp_unref(setup->session); + setup->session = NULL; + setup_unref(setup); + } + + g_free(chan); +} + +static void channel_remove(struct a2dp_channel *chan) +{ + struct a2dp_server *server = chan->server; + + DBG("chan %p", chan); + + queue_remove(server->channels, chan); + + channel_free(chan); +} + +static gboolean disconnect_cb(GIOChannel *io, GIOCondition cond, gpointer data) +{ + struct a2dp_channel *chan = data; + + DBG("chan %p", chan); + + chan->io_id = 0; + + channel_remove(chan); + + return FALSE; +} + +static void caps_add_codec(GSList **l, uint8_t codec, uint8_t *caps, + size_t size) +{ + struct avdtp_service_capability *media_transport, *media_codec; + struct avdtp_media_codec_capability *cap; + + media_transport = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT, + NULL, 0); + + *l = g_slist_append(*l, media_transport); + + cap = g_malloc0(sizeof(*cap) + size); + cap->media_type = AVDTP_MEDIA_TYPE_AUDIO; + cap->media_codec_type = codec; + memcpy(cap->data, caps, size); + + media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, cap, + sizeof(*cap) + size); + + *l = g_slist_append(*l, media_codec); + g_free(cap); +} + +struct client { + const char *sender; + const char *path; +}; + +static int match_client(const void *data, const void *user_data) +{ + struct a2dp_sep *sep = (void *) data; + const struct a2dp_endpoint *endpoint = sep->endpoint; + const struct client *client = user_data; + + if (strcmp(client->sender, endpoint->get_name(sep, sep->user_data))) + return -1; + + return strcmp(client->path, endpoint->get_path(sep, sep->user_data)); +} + +static struct a2dp_sep *find_sep(struct a2dp_server *server, uint8_t type, + const char *sender, const char *path) +{ + GSList *l; + struct client client = { sender, path }; + + l = type == AVDTP_SEP_TYPE_SINK ? server->sources : server->sinks; + + l = g_slist_find_custom(l, &client, match_client); + if (l) + return l->data; + + return NULL; +} + +static int parse_properties(DBusMessageIter *props, uint8_t **caps, int *size) +{ + while (dbus_message_iter_get_arg_type(props) == DBUS_TYPE_DICT_ENTRY) { + const char *key; + DBusMessageIter value, entry; + int var; + + dbus_message_iter_recurse(props, &entry); + dbus_message_iter_get_basic(&entry, &key); + + dbus_message_iter_next(&entry); + dbus_message_iter_recurse(&entry, &value); + + var = dbus_message_iter_get_arg_type(&value); + if (strcasecmp(key, "Capabilities") == 0) { + DBusMessageIter array; + + if (var != DBUS_TYPE_ARRAY) + return -EINVAL; + + dbus_message_iter_recurse(&value, &array); + dbus_message_iter_get_fixed_array(&array, caps, size); + return 0; + } + + dbus_message_iter_next(props); + } + + return -EINVAL; +} + +static void reconfig_cb(struct avdtp *session, struct a2dp_sep *sep, + struct avdtp_stream *stream, int err, void *user_data) +{ + DBusMessage *msg = user_data; + + if (err) + g_dbus_send_message(btd_get_dbus_connection(), + btd_error_failed(msg, strerror(-err))); + else + g_dbus_send_reply(btd_get_dbus_connection(), msg, + DBUS_TYPE_INVALID); + + dbus_message_unref(msg); +} + +static int a2dp_reconfig(struct a2dp_channel *chan, const char *sender, + struct a2dp_sep *lsep, struct a2dp_remote_sep *rsep, + uint8_t *caps, int size, void *user_data) +{ + struct a2dp_setup *setup; + struct a2dp_stream *stream; + struct a2dp_setup_cb *cb_data; + GSList *l; + int err; + + if (!chan->session) + return -ENOTCONN; + + setup = a2dp_setup_get(chan->session); + if (!setup) + return -ENOMEM; + + cb_data = setup_cb_add(setup); + cb_data->config_cb = reconfig_cb; + cb_data->user_data = user_data; + + setup->sep = lsep; + setup->rsep = rsep; + + g_slist_free_full(setup->caps, g_free); + setup->caps = NULL; + + caps_add_codec(&setup->caps, setup->sep->codec, caps, size); + + l = avdtp_get_type(rsep->sep) == AVDTP_SEP_TYPE_SINK ? + chan->server->sources : + chan->server->sinks; + + /* Check for existing stream and close it */ + for (; l; l = g_slist_next(l)) { + struct a2dp_sep *tmp = l->data; + + /* Attempt to reconfigure if a stream already exists */ + stream = queue_find(tmp->streams, match_stream_session, + chan->session); + if (stream) { + /* Only allow switching sep from the same sender */ + if (strcmp(sender, tmp->endpoint->get_name(tmp, + tmp->user_data))) { + err = -EPERM; + goto fail; + } + + /* Check if stream is for the channel */ + if (!avdtp_has_stream(chan->session, stream->stream)) + continue; + + err = avdtp_close(chan->session, stream->stream, FALSE); + if (err < 0) { + err = avdtp_abort(chan->session, + stream->stream); + if (err < 0) { + error("avdtp_abort: %s", + strerror(-err)); + goto fail; + } + } + + setup->reconfigure = TRUE; + + return 0; + } + } + + err = avdtp_set_configuration(setup->session, setup->rsep->sep, + lsep->lsep, + setup->caps, + &setup->stream); + if (err < 0) { + error("avdtp_set_configuration: %s", strerror(-err)); + goto fail; + } + + return 0; + +fail: + setup_cb_free(cb_data); + return err; +} + +static DBusMessage *set_configuration(DBusConnection *conn, DBusMessage *msg, + void *data) +{ + struct a2dp_remote_sep *rsep = data; + struct a2dp_channel *chan = rsep->chan; + struct a2dp_sep *lsep = NULL; + struct avdtp_service_capability *service; + struct avdtp_media_codec_capability *codec; + DBusMessageIter args, props; + const char *sender, *path; + uint8_t *caps; + int err, size = 0; + + sender = dbus_message_get_sender(msg); + + dbus_message_iter_init(msg, &args); + + dbus_message_iter_get_basic(&args, &path); + dbus_message_iter_next(&args); + + lsep = find_sep(chan->server, avdtp_get_type(rsep->sep), sender, path); + if (!lsep) + return btd_error_invalid_args(msg); + + service = avdtp_get_codec(rsep->sep); + codec = (struct avdtp_media_codec_capability *) service->data; + + /* Check if codec really matches */ + if (!endpoint_match_codec_ind(chan->session, codec, lsep)) + return btd_error_invalid_args(msg); + + dbus_message_iter_recurse(&args, &props); + if (dbus_message_iter_get_arg_type(&props) != DBUS_TYPE_DICT_ENTRY) + return btd_error_invalid_args(msg); + + if (parse_properties(&props, &caps, &size) < 0) + return btd_error_invalid_args(msg); + + err = a2dp_reconfig(chan, sender, lsep, rsep, caps, size, + dbus_message_ref(msg)); + if (err < 0) { + dbus_message_unref(msg); + return btd_error_failed(msg, strerror(-err)); + } + + return NULL; +} + +static const GDBusMethodTable sep_methods[] = { + { GDBUS_ASYNC_METHOD("SetConfiguration", + GDBUS_ARGS({ "endpoint", "o" }, + { "properties", "a{sv}" } ), + NULL, set_configuration) }, + { }, +}; + +static gboolean get_uuid(const GDBusPropertyTable *property, + DBusMessageIter *iter, void *data) +{ + struct a2dp_remote_sep *sep = data; + const char *uuid; + + switch (avdtp_get_type(sep->sep)) { + case AVDTP_SEP_TYPE_SOURCE: + uuid = A2DP_SOURCE_UUID; + break; + case AVDTP_SEP_TYPE_SINK: + uuid = A2DP_SINK_UUID; + break; + default: + uuid = ""; + } + + dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid); + + return TRUE; +} + +static gboolean get_codec(const GDBusPropertyTable *property, + DBusMessageIter *iter, void *data) +{ + struct a2dp_remote_sep *sep = data; + struct avdtp_service_capability *cap = avdtp_get_codec(sep->sep); + struct avdtp_media_codec_capability *codec = (void *) cap->data; + + dbus_message_iter_append_basic(iter, DBUS_TYPE_BYTE, + &codec->media_codec_type); + + return TRUE; +} + +static gboolean get_capabilities(const GDBusPropertyTable *property, + DBusMessageIter *iter, void *data) +{ + struct a2dp_remote_sep *sep = data; + struct avdtp_service_capability *service = avdtp_get_codec(sep->sep); + struct avdtp_media_codec_capability *codec = (void *) service->data; + uint8_t *caps = codec->data; + DBusMessageIter array; + + dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, + DBUS_TYPE_BYTE_AS_STRING, &array); + + dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &caps, + service->length - sizeof(*codec)); + + dbus_message_iter_close_container(iter, &array); + + return TRUE; +} + +static gboolean get_device(const GDBusPropertyTable *property, + DBusMessageIter *iter, void *data) +{ + struct a2dp_remote_sep *sep = data; + const char *path; + + path = device_get_path(sep->chan->device); + + dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path); + + return TRUE; +} + +static gboolean get_delay_reporting(const GDBusPropertyTable *property, + DBusMessageIter *iter, void *data) +{ + struct a2dp_remote_sep *sep = data; + dbus_bool_t delay_report; + + delay_report = avdtp_get_delay_reporting(sep->sep); + + dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &delay_report); + + return TRUE; +} + +static const GDBusPropertyTable sep_properties[] = { + { "UUID", "s", get_uuid, NULL, NULL }, + { "Codec", "y", get_codec, NULL, NULL }, + { "Capabilities", "ay", get_capabilities, NULL, NULL }, + { "Device", "o", get_device, NULL, NULL }, + { "DelayReporting", "b", get_delay_reporting, NULL, NULL }, + { } +}; + +static void remote_sep_destroy(void *user_data) +{ + struct a2dp_remote_sep *sep = user_data; + + if (queue_remove(sep->chan->seps, sep)) + remove_remote_sep(sep); +} + +static struct a2dp_remote_sep *register_remote_sep(void *data, void *user_data) +{ + struct avdtp_remote_sep *rsep = data; + struct a2dp_channel *chan = user_data; + struct a2dp_remote_sep *sep; + + sep = queue_find(chan->seps, match_remote_sep, rsep); + if (sep) + return sep; + + if (!avdtp_get_codec(rsep)) { + error("Unable to get remote sep codec"); + return NULL; + } + + sep = new0(struct a2dp_remote_sep, 1); + sep->chan = chan; + sep->sep = rsep; + + if (asprintf(&sep->path, "%s/sep%d", + device_get_path(chan->device), + avdtp_get_seid(rsep)) < 0) { + error("Could not allocate path for remote sep %s/sep%d", + device_get_path(chan->device), + avdtp_get_seid(rsep)); + sep->path = NULL; + goto done; + } + + if (g_dbus_register_interface(btd_get_dbus_connection(), + sep->path, MEDIA_ENDPOINT_INTERFACE, + sep_methods, NULL, sep_properties, + sep, remote_sep_free) == FALSE) { + error("Could not register remote sep %s", sep->path); + free(sep->path); + free(sep); + return NULL; + } + + DBG("Found remote SEP: %s", sep->path); + + avdtp_remote_sep_set_destroy(rsep, sep, remote_sep_destroy); + +done: + queue_push_tail(chan->seps, sep); + + return sep; +} + +static bool match_seid(const void *data, const void *user_data) +{ + const struct a2dp_remote_sep *sep = data; + const uint8_t *seid = user_data; + + return avdtp_get_seid(sep->sep) == *seid; +} + +static int match_sep(const void *data, const void *user_data) +{ + struct a2dp_sep *sep = (void *) data; + const uint8_t *seid = user_data; + + return *seid - avdtp_sep_get_seid(sep->lsep); +} + +static struct a2dp_sep *find_sep_by_seid(struct a2dp_server *server, + uint8_t seid) +{ + GSList *l; + + l = g_slist_find_custom(server->sources, &seid, match_sep); + if (l) + return l->data; + + l = g_slist_find_custom(server->sinks, &seid, match_sep); + if (l) + return l->data; + + return NULL; +} + +static void load_remote_sep(struct a2dp_channel *chan, GKeyFile *key_file, + char **seids) +{ + struct a2dp_sep *lsep; + struct a2dp_remote_sep *sep; + struct avdtp_remote_sep *rsep; + uint8_t lseid, rseid; + char *value; + bool update = false; + + if (!seids) + return; + + for (; *seids; seids++) { + uint8_t type; + uint8_t codec; + uint8_t delay_reporting; + GSList *l = NULL; + char caps[256]; + uint8_t data[128]; + int i, size; + + if (sscanf(*seids, "%02hhx", &rseid) != 1) + continue; + + value = g_key_file_get_string(key_file, "Endpoints", *seids, + NULL); + if (!value) + continue; + + /* Try loading with delay_reporting first */ + if (sscanf(value, "%02hhx:%02hhx:%02hhx:%s", &type, &codec, + &delay_reporting, caps) != 4) { + /* Try old format */ + if (sscanf(value, "%02hhx:%02hhx:%s", &type, &codec, + caps) != 3) { + warn("Unable to load Endpoint: seid %u", rseid); + g_free(value); + continue; + } + delay_reporting = false; + } + + for (i = 0, size = strlen(caps); i < size; i += 2) { + uint8_t *tmp = data + i / 2; + + if (sscanf(caps + i, "%02hhx", tmp) != 1) { + warn("Unable to load Endpoint: seid %u", rseid); + break; + } + } + + g_free(value); + + if (i != size) + continue; + + caps_add_codec(&l, codec, data, size / 2); + + rsep = avdtp_register_remote_sep(chan->session, rseid, type, l, + delay_reporting); + if (!rsep) { + warn("Unable to register Endpoint: seid %u", rseid); + continue; + } + + sep = register_remote_sep(rsep, chan); + if (!sep) { + avdtp_unregister_remote_sep(chan->session, rsep); + update = true; + continue; + } + + sep->from_cache = true; + } + + /* Update cache */ + if (update) + store_remote_seps(chan); + + value = g_key_file_get_string(key_file, "Endpoints", "LastUsed", NULL); + if (!value) + return; + + if (sscanf(value, "%02hhx:%02hhx", &lseid, &rseid) != 2) { + warn("Unable to load LastUsed"); + g_free(value); + return; + } + + g_free(value); + + lsep = find_sep_by_seid(chan->server, lseid); + if (!lsep) { + warn("Unable to load LastUsed: lseid %u not found", lseid); + return; + } + + sep = queue_find(chan->seps, match_seid, &rseid); + if (!sep) { + warn("Unable to load LastUsed: rseid %u not found", rseid); + return; + } + + DBG("LastUsed: lseid %u rseid %u", lseid, rseid); + + add_last_used(chan, lsep, sep); +} + +static void load_remote_seps(struct a2dp_channel *chan) +{ + struct btd_device *device = chan->device; + char filename[PATH_MAX]; + char dst_addr[18]; + char **keys; + GKeyFile *key_file; + GError *gerr = NULL; + + ba2str(device_get_address(device), dst_addr); + + create_filename(filename, PATH_MAX, "/%s/cache/%s", + btd_adapter_get_storage_dir(device_get_adapter(device)), + dst_addr); + + key_file = g_key_file_new(); + if (!g_key_file_load_from_file(key_file, filename, 0, &gerr)) { + error("Unable to load key file from %s: (%s)", filename, + gerr->message); + g_error_free(gerr); + } + keys = g_key_file_get_keys(key_file, "Endpoints", NULL, NULL); + + load_remote_sep(chan, key_file, keys); + + g_strfreev(keys); + g_key_file_free(key_file); +} + +static void avdtp_state_cb(struct btd_device *dev, struct avdtp *session, + avdtp_session_state_t old_state, + avdtp_session_state_t new_state, + void *user_data) +{ + struct a2dp_channel *chan = user_data; + + switch (new_state) { + case AVDTP_SESSION_STATE_DISCONNECTED: + if (chan->session == session) + channel_remove(chan); + break; + case AVDTP_SESSION_STATE_CONNECTING: + break; + case AVDTP_SESSION_STATE_CONNECTED: + if (!chan->session) + chan->session = session; + load_remote_seps(chan); + break; + } +} + +static struct a2dp_channel *channel_new(struct a2dp_server *server, + struct btd_device *device, + GIOChannel *io) +{ + struct a2dp_channel *chan; + + chan = g_new0(struct a2dp_channel, 1); + chan->server = server; + chan->device = device; + chan->seps = queue_new(); + chan->state_id = avdtp_add_state_cb(device, avdtp_state_cb, chan); + + if (!queue_push_tail(server->channels, chan)) { + g_free(chan); + return NULL; + } + + if (!io) + return chan; + + chan->io = g_io_channel_ref(io); + chan->io_id = g_io_add_watch(io, G_IO_ERR | G_IO_HUP | G_IO_NVAL, + (GIOFunc) disconnect_cb, chan); + + return chan; +} + +static bool match_by_device(const void *data, const void *user_data) +{ + const struct a2dp_channel *chan = data; + const struct btd_device *device = user_data; + + return chan->device == device; +} + +struct avdtp *a2dp_avdtp_get(struct btd_device *device) +{ + struct a2dp_server *server; + struct a2dp_channel *chan; + + server = find_server(servers, device_get_adapter(device)); + if (server == NULL) + return NULL; + + chan = queue_find(server->channels, match_by_device, device); + if (!chan) { + chan = channel_new(server, device, NULL); + if (!chan) + return NULL; + } + + if (chan->session) + return avdtp_ref(chan->session); + + /* Check if there is any SEP available */ + if (!queue_isempty(server->seps)) + goto found; + + DBG("Unable to find any available SEP"); + + return NULL; + +found: + chan->session = avdtp_new(chan->io, device, server->seps); + if (!chan->session) { + channel_remove(chan); + return NULL; + } + + return avdtp_ref(chan->session); +} + +static void connect_cb(GIOChannel *io, GError *err, gpointer user_data) +{ + struct a2dp_channel *chan = user_data; + + if (err) { + error("%s", err->message); + goto fail; + } + + if (!chan->session) { + chan->session = avdtp_new(chan->io, chan->device, + chan->server->seps); + if (!chan->session) { + error("Unable to create AVDTP session"); + goto fail; + } + } + + g_io_channel_unref(chan->io); + chan->io = NULL; + + g_source_remove(chan->io_id); + chan->io_id = 0; + + return; + +fail: + channel_remove(chan); +} + +static void auth_cb(DBusError *derr, void *user_data) +{ + struct a2dp_channel *chan = user_data; + GError *err = NULL; + + chan->auth_id = 0; + + if (derr && dbus_error_is_set(derr)) { + error("Access denied: %s", derr->message); + goto fail; + } + + if (!bt_io_accept(chan->io, connect_cb, chan, NULL, &err)) { + error("bt_io_accept: %s", err->message); + g_error_free(err); + goto fail; + } + + return; + +fail: + channel_remove(chan); +} + +static void transport_cb(GIOChannel *io, GError *err, gpointer user_data) +{ + struct a2dp_setup *setup = user_data; + uint16_t omtu, imtu; + + if (!g_slist_find(setups, setup)) { + warn("bt_io_accept: setup %p no longer valid", setup); + g_io_channel_shutdown(io, TRUE, NULL); + return; + } + + if (err) { + error("%s", err->message); + goto drop; + } + + bt_io_get(io, &err, BT_IO_OPT_OMTU, &omtu, BT_IO_OPT_IMTU, &imtu, + BT_IO_OPT_INVALID); + if (err) { + error("%s", err->message); + g_error_free(err); + goto drop; + } + + if (!avdtp_stream_set_transport(setup->stream, + g_io_channel_unix_get_fd(io), + imtu, omtu)) + goto drop; + + g_io_channel_set_close_on_unref(io, FALSE); + + g_io_channel_unref(setup->io); + setup->io = NULL; + + setup_unref(setup); + + return; + +drop: + setup_unref(setup); + g_io_channel_shutdown(io, TRUE, NULL); + +} +static void confirm_cb(GIOChannel *io, gpointer data) +{ + struct a2dp_server *server = data; + struct a2dp_channel *chan; + char address[18]; + bdaddr_t src, dst; + GError *err = NULL; + struct btd_device *device; + + bt_io_get(io, &err, + BT_IO_OPT_SOURCE_BDADDR, &src, + BT_IO_OPT_DEST_BDADDR, &dst, + BT_IO_OPT_DEST, address, + BT_IO_OPT_INVALID); + if (err) { + error("%s", err->message); + g_error_free(err); + goto drop; + } + + DBG("AVDTP: incoming connect from %s", address); + + device = btd_adapter_find_device(adapter_find(&src), &dst, + BDADDR_BREDR); + if (!device) + goto drop; + + chan = queue_find(server->channels, match_by_device, device); + if (chan) { + struct a2dp_setup *setup; + + setup = find_setup_by_session(chan->session); + if (!setup || !setup->stream) + goto drop; + + if (setup->io || avdtp_stream_get_transport(setup->stream, + NULL, NULL, NULL, NULL)) { + error("transport channel already exists"); + goto drop; + } + + if (!bt_io_accept(io, transport_cb, setup, NULL, &err)) { + error("bt_io_accept: %s", err->message); + g_error_free(err); + goto drop; + } + + /* + * Reference the channel so it can be shutdown properly + * stopping bt_io_accept from calling the callback with invalid + * setup pointer. + */ + setup->io = g_io_channel_ref(io); + + return; + } + + chan = channel_new(server, device, io); + if (!chan) + goto drop; + + chan->auth_id = btd_request_authorization(&src, &dst, + ADVANCED_AUDIO_UUID, + auth_cb, chan); + if (chan->auth_id == 0 && !chan->session) + channel_remove(chan); + + return; + +drop: + g_io_channel_shutdown(io, TRUE, NULL); +} + +static bool a2dp_server_listen(struct a2dp_server *server) +{ + GError *err = NULL; + BtIOMode mode; + + if (server->io) + return true; + + mode = btd_opts.avdtp.session_mode; + + server->io = bt_io_listen(NULL, confirm_cb, server, NULL, &err, + BT_IO_OPT_SOURCE_BDADDR, + btd_adapter_get_address(server->adapter), + BT_IO_OPT_PSM, AVDTP_PSM, + BT_IO_OPT_MODE, mode, + BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM, + BT_IO_OPT_CENTRAL, true, + /* Set Input MTU to 0 for auto-tune attempt */ + BT_IO_OPT_IMTU, 0, + BT_IO_OPT_INVALID); + if (server->io) + return true; + + error("%s", err->message); + g_error_free(err); + + return false; +} + +static struct a2dp_server *a2dp_server_register(struct btd_adapter *adapter) +{ + struct a2dp_server *server; + + server = g_new0(struct a2dp_server, 1); + + server->adapter = btd_adapter_ref(adapter); + server->seps = queue_new(); + server->channels = queue_new(); + + servers = g_slist_append(servers, server); + + return server; +} + +static void a2dp_unregister_sep(struct a2dp_sep *sep) +{ + struct a2dp_server *server = sep->server; + + if (sep->destroy) { + sep->destroy(sep->user_data); + sep->endpoint = NULL; + } + + avdtp_unregister_sep(server->seps, &server->seid_pool, sep->lsep); + + queue_destroy(sep->streams, a2dp_stream_free); + g_free(sep); + + if (!queue_isempty(server->seps)) + return; + + if (server->io) { + g_io_channel_shutdown(server->io, TRUE, NULL); + g_io_channel_unref(server->io); + server->io = NULL; + } +} + +static void a2dp_server_unregister(struct a2dp_server *server) +{ + servers = g_slist_remove(servers, server); + queue_destroy(server->channels, channel_free); + queue_destroy(server->seps, NULL); + + if (server->io) { + g_io_channel_shutdown(server->io, TRUE, NULL); + g_io_channel_unref(server->io); + } + + btd_adapter_unref(server->adapter); + g_free(server); +} + +struct a2dp_sep *a2dp_add_sep(struct btd_adapter *adapter, uint8_t type, + uint8_t codec, gboolean delay_reporting, + struct a2dp_endpoint *endpoint, + void *user_data, GDestroyNotify destroy, + int *err) +{ + struct a2dp_server *server; + struct a2dp_sep *sep; + GSList **l; + uint32_t *record_id; + sdp_record_t *record; + + server = find_server(servers, adapter); + if (server == NULL) { + if (err) + *err = -EPROTONOSUPPORT; + return NULL; + } + + if (type == AVDTP_SEP_TYPE_SINK && !server->sink_enabled) { + if (err) + *err = -EPROTONOSUPPORT; + return NULL; + } + + if (type == AVDTP_SEP_TYPE_SOURCE && !server->source_enabled) { + if (err) + *err = -EPROTONOSUPPORT; + return NULL; + } + + sep = g_new0(struct a2dp_sep, 1); + + sep->lsep = avdtp_register_sep(server->seps, &server->seid_pool, type, + AVDTP_MEDIA_TYPE_AUDIO, codec, + delay_reporting, &endpoint_ind, + &cfm, sep); + + if (sep->lsep == NULL) { + g_free(sep); + if (err) + *err = -EINVAL; + return NULL; + } + + sep->server = server; + sep->endpoint = endpoint; + sep->codec = codec; + sep->type = type; + sep->delay_reporting = delay_reporting; + + if (type == AVDTP_SEP_TYPE_SOURCE) { + l = &server->sources; + record_id = &server->source_record_id; + } else { + l = &server->sinks; + record_id = &server->sink_record_id; + } + + if (*record_id != 0) + goto add; + + record = a2dp_record(type); + if (!record) { + error("Unable to allocate new service record"); + a2dp_unregister_sep(sep); + if (err) + *err = -EINVAL; + return NULL; + } + + if (adapter_service_add(server->adapter, record) < 0) { + error("Unable to register A2DP service record"); + sdp_record_free(record); + a2dp_unregister_sep(sep); + if (err) + *err = -EINVAL; + return NULL; + } + + if (!a2dp_server_listen(server)) { + sdp_record_free(record); + a2dp_unregister_sep(sep); + if (err) + *err = -EINVAL; + return NULL; + } + + *record_id = record->handle; + +add: + *l = g_slist_append(*l, sep); + + sep->user_data = user_data; + sep->destroy = destroy; + + if (err) + *err = 0; + return sep; +} + +static bool match_locked(const void *data, const void *user_data) +{ + const struct a2dp_stream *stream = data; + + return stream->locked; +} + +void a2dp_remove_sep(struct a2dp_sep *sep) +{ + struct a2dp_server *server = sep->server; + + if (sep->type == AVDTP_SEP_TYPE_SOURCE) { + if (g_slist_find(server->sources, sep) == NULL) + return; + server->sources = g_slist_remove(server->sources, sep); + if (server->sources == NULL && server->source_record_id) { + adapter_service_remove(server->adapter, + server->source_record_id); + server->source_record_id = 0; + } + } else { + if (g_slist_find(server->sinks, sep) == NULL) + return; + server->sinks = g_slist_remove(server->sinks, sep); + if (server->sinks == NULL && server->sink_record_id) { + adapter_service_remove(server->adapter, + server->sink_record_id); + server->sink_record_id = 0; + } + } + + if (queue_find(sep->streams, match_locked, NULL)) + return; + + a2dp_unregister_sep(sep); +} + +static void select_cb(struct a2dp_setup *setup, void *ret, int size) +{ + struct avdtp_service_capability *service; + struct avdtp_media_codec_capability *codec; + int err; + + if (setup->err) + goto done; + + if (size >= 0) { + caps_add_codec(&setup->caps, setup->sep->codec, ret, size); + goto done; + } + + setup->sep = queue_pop_head(setup->eps); + if (!setup->sep) { + error("Unable to select a valid configuration"); + goto done; + } + + setup->rsep = find_remote_sep(setup->chan, setup->sep); + service = avdtp_get_codec(setup->rsep->sep); + codec = (struct avdtp_media_codec_capability *) service->data; + + err = setup->sep->endpoint->select_configuration(setup->sep, + codec->data, + service->length - sizeof(*codec), + setup, + select_cb, setup->sep->user_data); + if (err == 0) + return; + +done: + finalize_select(setup); + setup_unref(setup); +} + +static struct queue *a2dp_find_eps(struct avdtp *session, GSList *list, + const char *sender) +{ + struct a2dp_channel *chan = find_channel(session); + struct queue *seps = NULL; + + for (; list; list = list->next) { + struct a2dp_sep *sep = list->data; + struct avdtp_remote_sep *rsep; + + /* Use sender's endpoint if available */ + if (sender) { + const char *name; + + if (sep->endpoint == NULL) + continue; + + name = sep->endpoint->get_name(sep, sep->user_data); + if (g_strcmp0(sender, name) != 0) + continue; + } + + rsep = avdtp_find_remote_sep(session, sep->lsep); + if (!rsep) + continue; + + if (!seps) + seps = queue_new(); + + /* Prepend last used so it is preferred over others */ + if (chan->last_used && (chan->last_used->lsep == sep && + chan->last_used->rsep->sep == rsep)) + queue_push_head(seps, sep); + else + queue_push_tail(seps, sep); + } + + return seps; +} + +static struct queue *a2dp_select_eps(struct avdtp *session, uint8_t type, + const char *sender) +{ + struct a2dp_server *server; + struct queue *seps; + GSList *l; + + server = find_server(servers, avdtp_get_adapter(session)); + if (!server) + return NULL; + + l = type == AVDTP_SEP_TYPE_SINK ? server->sources : server->sinks; + + /* Check sender's seps first */ + seps = a2dp_find_eps(session, l, sender); + if (seps != NULL) + return seps; + + return a2dp_find_eps(session, l, NULL); +} + +static void foreach_register_remote_sep(void *data, void *user_data) +{ + register_remote_sep(data, user_data); +} + +static void discover_cb(struct avdtp *session, GSList *seps, + struct avdtp_error *err, void *user_data) +{ + struct a2dp_setup *setup = user_data; + uint16_t version = avdtp_get_version(session); + + DBG("version 0x%04x err %p", version, err); + + setup->seps = seps; + if (err) + setup_error_set(setup, err); + + if (!err) { + g_slist_foreach(seps, foreach_register_remote_sep, setup->chan); + + /* Only store version has been initialized as features like + * Delay Reporting may not be queried if the version in + * unknown. + */ + if (version) + store_remote_seps(setup->chan); + } + + finalize_discover(setup); +} + +unsigned int a2dp_discover(struct avdtp *session, a2dp_discover_cb_t cb, + void *user_data) +{ + struct a2dp_setup *setup; + struct a2dp_setup_cb *cb_data; + + setup = a2dp_setup_get(session); + if (!setup) + return 0; + + /* Don't add cb since avdtp_discover can end up disconnecting the + * session causing the cb to be freed. + */ + cb_data = setup_cb_new(setup); + cb_data->discover_cb = cb; + cb_data->user_data = user_data; + + if (avdtp_discover(session, discover_cb, setup) == 0) { + setup->cb = g_slist_append(setup->cb, cb_data); + return cb_data->id; + } + + setup_cb_free(cb_data); + return 0; +} + +unsigned int a2dp_select_capabilities(struct avdtp *session, + uint8_t type, const char *sender, + a2dp_select_cb_t cb, + void *user_data) +{ + struct a2dp_setup *setup; + struct a2dp_setup_cb *cb_data; + struct queue *eps; + struct avdtp_service_capability *service; + struct avdtp_media_codec_capability *codec; + int err; + + eps = a2dp_select_eps(session, type, sender); + if (!eps) { + error("Unable to select SEP"); + return 0; + } + + setup = a2dp_setup_get(session); + if (!setup) + return 0; + + cb_data = setup_cb_add(setup); + cb_data->select_cb = cb; + cb_data->user_data = user_data; + + setup->eps = eps; + setup->sep = queue_pop_head(eps); + setup->rsep = find_remote_sep(setup->chan, setup->sep); + + if (setup->rsep == NULL) { + error("Could not find remote sep"); + goto fail; + } + + service = avdtp_get_codec(setup->rsep->sep); + codec = (struct avdtp_media_codec_capability *) service->data; + + err = setup->sep->endpoint->select_configuration(setup->sep, + codec->data, + service->length - + sizeof(*codec), + setup_ref(setup), + select_cb, + setup->sep->user_data); + if (err == 0) + return cb_data->id; + + setup_unref(setup); + +fail: + setup_cb_free(cb_data); + return 0; + +} + +unsigned int a2dp_config(struct avdtp *session, struct a2dp_sep *sep, + a2dp_config_cb_t cb, GSList *caps, + void *user_data) +{ + struct a2dp_setup_cb *cb_data; + GSList *l; + struct a2dp_server *server; + struct a2dp_setup *setup; + struct a2dp_stream *stream; + struct avdtp_service_capability *cap; + struct avdtp_media_codec_capability *codec_cap = NULL; + int posix_err; + + server = find_server(servers, avdtp_get_adapter(session)); + if (!server) + return 0; + + for (l = caps; l != NULL; l = l->next) { + cap = l->data; + + if (cap->category != AVDTP_MEDIA_CODEC) + continue; + + codec_cap = (void *) cap->data; + break; + } + + if (!codec_cap) + return 0; + + if (sep->codec != codec_cap->media_codec_type) + return 0; + + DBG("a2dp_config: selected SEP %p", sep->lsep); + + setup = a2dp_setup_get(session); + if (!setup) + return 0; + + cb_data = setup_cb_add(setup); + cb_data->config_cb = cb; + cb_data->user_data = user_data; + + stream = queue_find(sep->streams, match_stream_session, session); + + setup->sep = sep; + setup->stream = stream ? stream->stream : NULL; + + /* Copy given caps if they are different than current caps */ + if (setup->caps != caps) { + g_slist_free_full(setup->caps, g_free); + setup->caps = g_slist_copy(caps); + } + + switch (avdtp_stream_get_state(setup->stream)) { + case AVDTP_STATE_IDLE: + if (sep->type == AVDTP_SEP_TYPE_SOURCE) + l = server->sources; + else + l = server->sinks; + + for (; l != NULL; l = l->next) { + struct a2dp_sep *tmp = l->data; + + stream = queue_find(tmp->streams, match_stream_session, + session); + if (!stream) + continue; + + if (avdtp_has_stream(session, stream->stream)) + break; + } + + if (l != NULL) { + if (stream->locked) + goto failed; + setup->reconfigure = TRUE; + if (avdtp_close(session, stream->stream, FALSE) < 0) { + error("avdtp_close failed"); + goto failed; + } + break; + } + + setup->rsep = find_remote_sep(setup->chan, sep); + if (setup->rsep == NULL) { + error("No matching ACP and INT SEPs found"); + goto failed; + } + + posix_err = avdtp_set_configuration(session, setup->rsep->sep, + sep->lsep, caps, + &setup->stream); + if (posix_err < 0) { + error("avdtp_set_configuration: %s", + strerror(-posix_err)); + goto failed; + } + break; + case AVDTP_STATE_OPEN: + case AVDTP_STATE_STREAMING: + if (avdtp_stream_has_capabilities(setup->stream, caps)) { + DBG("Configuration match: resuming"); + cb_data->source_id = g_idle_add(finalize_config, + setup); + } else if (!setup->reconfigure) { + setup->reconfigure = TRUE; + if (avdtp_close(session, setup->stream, FALSE) < 0) { + error("avdtp_close failed"); + goto failed; + } + } + break; + case AVDTP_STATE_CONFIGURED: + case AVDTP_STATE_CLOSING: + case AVDTP_STATE_ABORTING: + default: + error("SEP in bad state for requesting a new stream"); + goto failed; + } + + return cb_data->id; + +failed: + setup_cb_free(cb_data); + return 0; +} + +unsigned int a2dp_resume(struct avdtp *session, struct a2dp_sep *sep, + a2dp_stream_cb_t cb, void *user_data) +{ + struct a2dp_setup_cb *cb_data; + struct a2dp_setup *setup; + struct a2dp_stream *stream; + + setup = a2dp_setup_get(session); + if (!setup) + return 0; + + cb_data = setup_cb_add(setup); + cb_data->resume_cb = cb; + cb_data->user_data = user_data; + + if (setup->reconfigure) + goto failed; + + stream = queue_find(sep->streams, match_stream_session, session); + + setup->sep = sep; + setup->stream = stream ? stream->stream : NULL; + + switch (avdtp_stream_get_state(setup->stream)) { + case AVDTP_STATE_IDLE: + goto failed; + case AVDTP_STATE_CONFIGURED: + setup->start = TRUE; + break; + case AVDTP_STATE_OPEN: + if (avdtp_start(session, setup->stream) < 0) { + error("avdtp_start failed"); + goto failed; + } + stream->starting = TRUE; + break; + case AVDTP_STATE_STREAMING: + if (!stream->suspending && stream->suspend_timer) { + timeout_remove(stream->suspend_timer); + stream->suspend_timer = 0; + } + if (stream->suspending) + setup->start = TRUE; + else + cb_data->source_id = g_idle_add(finalize_resume, + setup); + break; + case AVDTP_STATE_CLOSING: + case AVDTP_STATE_ABORTING: + default: + error("SEP in bad state for resume"); + goto failed; + } + + return cb_data->id; + +failed: + setup_cb_free(cb_data); + return 0; +} + +unsigned int a2dp_suspend(struct avdtp *session, struct a2dp_sep *sep, + a2dp_stream_cb_t cb, void *user_data) +{ + struct a2dp_setup_cb *cb_data; + struct a2dp_setup *setup; + struct a2dp_stream *stream; + + setup = a2dp_setup_get(session); + if (!setup) + return 0; + + cb_data = setup_cb_add(setup); + cb_data->suspend_cb = cb; + cb_data->user_data = user_data; + + if (setup->reconfigure) + goto failed; + + stream = queue_find(sep->streams, match_stream_session, session); + + setup->sep = sep; + setup->stream = stream ? stream->stream : NULL; + + switch (avdtp_stream_get_state(setup->stream)) { + case AVDTP_STATE_IDLE: + error("a2dp_suspend: no stream to suspend"); + goto failed; + break; + case AVDTP_STATE_OPEN: + cb_data->source_id = g_idle_add(finalize_suspend, setup); + break; + case AVDTP_STATE_STREAMING: + if (avdtp_suspend(session, setup->stream) < 0) { + error("avdtp_suspend failed"); + goto failed; + } + stream->suspending = TRUE; + break; + case AVDTP_STATE_CONFIGURED: + case AVDTP_STATE_CLOSING: + case AVDTP_STATE_ABORTING: + default: + error("SEP in bad state for suspend"); + goto failed; + } + + return cb_data->id; + +failed: + setup_cb_free(cb_data); + return 0; +} + +gboolean a2dp_cancel(unsigned int id) +{ + GSList *ls; + + for (ls = setups; ls != NULL; ls = g_slist_next(ls)) { + struct a2dp_setup *setup = ls->data; + GSList *l; + for (l = setup->cb; l != NULL; l = g_slist_next(l)) { + struct a2dp_setup_cb *cb = l->data; + + if (cb->id != id) + continue; + + setup_ref(setup); + setup_cb_free(cb); + + if (!setup->cb) { + DBG("aborting setup %p", setup); + if (!avdtp_abort(setup->session, setup->stream)) + return TRUE; + } + + setup_unref(setup); + return TRUE; + } + } + + return FALSE; +} + +gboolean a2dp_sep_lock(struct a2dp_sep *sep, struct avdtp *session) +{ + struct a2dp_stream *stream; + + stream = queue_find(sep->streams, match_stream_session, session); + if (!stream || stream->locked) + return FALSE; + + DBG("stream %p locked", sep->lsep); + stream->locked = TRUE; + + return TRUE; +} + +gboolean a2dp_sep_unlock(struct a2dp_sep *sep, struct avdtp *session) +{ + struct a2dp_server *server = sep->server; + struct a2dp_stream *stream; + avdtp_state_t state; + GSList *l; + + stream = queue_find(sep->streams, match_stream_session, session); + if (!stream) + return FALSE; + + state = avdtp_stream_get_state(stream->stream); + + stream->locked = FALSE; + + DBG("stream %p unlocked", stream); + + if (sep->type == AVDTP_SEP_TYPE_SOURCE) + l = server->sources; + else + l = server->sinks; + + /* Unregister sep if it was removed */ + if (g_slist_find(l, sep) == NULL) { + a2dp_unregister_sep(sep); + return TRUE; + } + + if (!stream->stream || state == AVDTP_STATE_IDLE) + return TRUE; + + switch (state) { + case AVDTP_STATE_OPEN: + /* Set timer here */ + break; + case AVDTP_STATE_STREAMING: + if (avdtp_suspend(session, stream->stream) == 0) + stream->suspending = TRUE; + break; + case AVDTP_STATE_IDLE: + case AVDTP_STATE_CONFIGURED: + case AVDTP_STATE_CLOSING: + case AVDTP_STATE_ABORTING: + default: + break; + } + + return TRUE; +} + +struct avdtp_stream *a2dp_sep_get_stream(struct a2dp_sep *sep, + struct avdtp *session) +{ + struct a2dp_stream *stream; + + stream = queue_find(sep->streams, match_stream_session, session); + if (stream) + return stream->stream; + + return NULL; +} + +struct btd_device *a2dp_setup_get_device(struct a2dp_setup *setup) +{ + if (setup->session == NULL) + return NULL; + + return avdtp_get_device(setup->session); +} + +const char *a2dp_setup_remote_path(struct a2dp_setup *setup) +{ + if (setup->rsep) { + return setup->rsep->path; + } + + return NULL; +} + +static int a2dp_source_probe(struct btd_service *service) +{ + struct btd_device *dev = btd_service_get_device(service); + + DBG("path %s", device_get_path(dev)); + + source_init(service); + + return 0; +} + +static void a2dp_source_remove(struct btd_service *service) +{ + source_unregister(service); +} + +static int a2dp_sink_probe(struct btd_service *service) +{ + struct btd_device *dev = btd_service_get_device(service); + + DBG("path %s", device_get_path(dev)); + + return sink_init(service); +} + +static void a2dp_sink_remove(struct btd_service *service) +{ + sink_unregister(service); +} + +static int a2dp_source_connect(struct btd_service *service) +{ + struct btd_device *dev = btd_service_get_device(service); + struct btd_adapter *adapter = device_get_adapter(dev); + struct a2dp_server *server; + const char *path = device_get_path(dev); + + DBG("path %s", path); + + server = find_server(servers, adapter); + if (!server || !server->sink_enabled) { + DBG("Unexpected error: cannot find server"); + return -EPROTONOSUPPORT; + } + + /* Return protocol not available if no record/endpoint exists */ + if (server->sink_record_id == 0) + return -ENOPROTOOPT; + + return source_connect(service); +} + +static int a2dp_source_disconnect(struct btd_service *service) +{ + struct btd_device *dev = btd_service_get_device(service); + const char *path = device_get_path(dev); + + DBG("path %s", path); + + return source_disconnect(service); +} + +static int a2dp_sink_connect(struct btd_service *service) +{ + struct btd_device *dev = btd_service_get_device(service); + struct btd_adapter *adapter = device_get_adapter(dev); + struct a2dp_server *server; + const char *path = device_get_path(dev); + + DBG("path %s", path); + + server = find_server(servers, adapter); + if (!server || !server->source_enabled) { + DBG("Unexpected error: cannot find server"); + return -EPROTONOSUPPORT; + } + + /* Return protocol not available if no record/endpoint exists */ + if (server->source_record_id == 0) + return -ENOPROTOOPT; + + return sink_connect(service); +} + +static int a2dp_sink_disconnect(struct btd_service *service) +{ + struct btd_device *dev = btd_service_get_device(service); + const char *path = device_get_path(dev); + + DBG("path %s", path); + + return sink_disconnect(service); +} + +static int a2dp_source_server_probe(struct btd_profile *p, + struct btd_adapter *adapter) +{ + struct a2dp_server *server; + + DBG("path %s", adapter_get_path(adapter)); + + server = find_server(servers, adapter); + if (server != NULL) + goto done; + + server = a2dp_server_register(adapter); + if (server == NULL) + return -EPROTONOSUPPORT; + +done: + server->source_enabled = TRUE; + + return 0; +} + +static void a2dp_source_server_remove(struct btd_profile *p, + struct btd_adapter *adapter) +{ + struct a2dp_server *server; + + DBG("path %s", adapter_get_path(adapter)); + + server = find_server(servers, adapter); + if (!server) + return; + + g_slist_free_full(server->sources, + (GDestroyNotify) a2dp_unregister_sep); + + if (server->source_record_id) { + adapter_service_remove(server->adapter, + server->source_record_id); + server->source_record_id = 0; + } + + if (server->sink_record_id) + return; + + a2dp_server_unregister(server); +} + +static int a2dp_sink_server_probe(struct btd_profile *p, + struct btd_adapter *adapter) +{ + struct a2dp_server *server; + + DBG("path %s", adapter_get_path(adapter)); + + server = find_server(servers, adapter); + if (server != NULL) + goto done; + + server = a2dp_server_register(adapter); + if (server == NULL) + return -EPROTONOSUPPORT; + +done: + server->sink_enabled = TRUE; + + return 0; +} + +static void a2dp_sink_server_remove(struct btd_profile *p, + struct btd_adapter *adapter) +{ + struct a2dp_server *server; + + DBG("path %s", adapter_get_path(adapter)); + + server = find_server(servers, adapter); + if (!server) + return; + + g_slist_free_full(server->sinks, (GDestroyNotify) a2dp_unregister_sep); + + if (server->sink_record_id) { + adapter_service_remove(server->adapter, server->sink_record_id); + server->sink_record_id = 0; + } + + if (server->source_record_id) + return; + + a2dp_server_unregister(server); +} + +static int media_server_probe(struct btd_adapter *adapter) +{ + DBG("path %s", adapter_get_path(adapter)); + + return media_register(adapter); +} + +static void media_server_remove(struct btd_adapter *adapter) +{ + DBG("path %s", adapter_get_path(adapter)); + + media_unregister(adapter); +} + +static struct btd_profile a2dp_source_profile = { + .name = "a2dp-source", + .priority = BTD_PROFILE_PRIORITY_MEDIUM, + .bearer = BTD_PROFILE_BEARER_BREDR, + .remote_uuid = A2DP_SOURCE_UUID, + + .device_probe = a2dp_source_probe, + .device_remove = a2dp_source_remove, + + .auto_connect = true, + .connect = a2dp_source_connect, + .disconnect = a2dp_source_disconnect, + + .adapter_probe = a2dp_sink_server_probe, + .adapter_remove = a2dp_sink_server_remove, + + /* Connect source after sink, to prefer sink when conflicting */ + .after_services = BTD_PROFILE_UUID_CB(NULL, A2DP_SINK_UUID), +}; + +static struct btd_profile a2dp_sink_profile = { + .name = "a2dp-sink", + .priority = BTD_PROFILE_PRIORITY_MEDIUM, + .bearer = BTD_PROFILE_BEARER_BREDR, + .remote_uuid = A2DP_SINK_UUID, + .device_probe = a2dp_sink_probe, + .device_remove = a2dp_sink_remove, + + .auto_connect = true, + .connect = a2dp_sink_connect, + .disconnect = a2dp_sink_disconnect, + + .adapter_probe = a2dp_source_server_probe, + .adapter_remove = a2dp_source_server_remove, +}; + +static struct btd_adapter_driver media_driver = { + .name = "media", + .probe = media_server_probe, + .remove = media_server_remove, +}; + +static int a2dp_init(void) +{ + btd_register_adapter_driver(&media_driver); + btd_profile_register(&a2dp_source_profile); + btd_profile_register(&a2dp_sink_profile); + + return 0; +} + +static void a2dp_exit(void) +{ + btd_unregister_adapter_driver(&media_driver); + btd_profile_unregister(&a2dp_source_profile); + btd_profile_unregister(&a2dp_sink_profile); +} + +BLUETOOTH_PLUGIN_DEFINE(a2dp, VERSION, BLUETOOTH_PLUGIN_PRIORITY_DEFAULT, + a2dp_init, a2dp_exit) diff --git a/avdtp.h b/avdtp.h new file mode 100644 index 0000000..10c8f49 --- /dev/null +++ b/avdtp.h @@ -0,0 +1,314 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2006-2010 Nokia Corporation + * Copyright (C) 2004-2010 Marcel Holtmann + * + * + */ + +typedef enum { + AVDTP_SESSION_STATE_DISCONNECTED, + AVDTP_SESSION_STATE_CONNECTING, + AVDTP_SESSION_STATE_CONNECTED +} avdtp_session_state_t; + +struct avdtp; +struct avdtp_server; +struct avdtp_stream; +struct avdtp_local_sep; +struct avdtp_remote_sep; +struct avdtp_error { + uint8_t category; + union { + uint8_t error_code; + int posix_errno; + } err; +}; + +/* SEP capability categories */ +#define AVDTP_MEDIA_TRANSPORT 0x01 +#define AVDTP_REPORTING 0x02 +#define AVDTP_RECOVERY 0x03 +#define AVDTP_CONTENT_PROTECTION 0x04 +#define AVDTP_HEADER_COMPRESSION 0x05 +#define AVDTP_MULTIPLEXING 0x06 +#define AVDTP_MEDIA_CODEC 0x07 +#define AVDTP_DELAY_REPORTING 0x08 +#define AVDTP_ERRNO 0xff + +/* AVDTP error definitions */ +#define AVDTP_BAD_HEADER_FORMAT 0x01 +#define AVDTP_BAD_LENGTH 0x11 +#define AVDTP_BAD_ACP_SEID 0x12 +#define AVDTP_SEP_IN_USE 0x13 +#define AVDTP_SEP_NOT_IN_USE 0x14 +#define AVDTP_BAD_SERV_CATEGORY 0x17 +#define AVDTP_BAD_PAYLOAD_FORMAT 0x18 +#define AVDTP_NOT_SUPPORTED_COMMAND 0x19 +#define AVDTP_INVALID_CAPABILITIES 0x1A +#define AVDTP_BAD_RECOVERY_TYPE 0x22 +#define AVDTP_BAD_MEDIA_TRANSPORT_FORMAT 0x23 +#define AVDTP_BAD_RECOVERY_FORMAT 0x25 +#define AVDTP_BAD_ROHC_FORMAT 0x26 +#define AVDTP_BAD_CP_FORMAT 0x27 +#define AVDTP_BAD_MULTIPLEXING_FORMAT 0x28 +#define AVDTP_UNSUPPORTED_CONFIGURATION 0x29 +#define AVDTP_BAD_STATE 0x31 + +/* SEP types definitions */ +#define AVDTP_SEP_TYPE_SOURCE 0x00 +#define AVDTP_SEP_TYPE_SINK 0x01 + +/* Media types definitions */ +#define AVDTP_MEDIA_TYPE_AUDIO 0x00 +#define AVDTP_MEDIA_TYPE_VIDEO 0x01 +#define AVDTP_MEDIA_TYPE_MULTIMEDIA 0x02 + +typedef enum { + AVDTP_STATE_IDLE, + AVDTP_STATE_CONFIGURED, + AVDTP_STATE_OPEN, + AVDTP_STATE_STREAMING, + AVDTP_STATE_CLOSING, + AVDTP_STATE_ABORTING, +} avdtp_state_t; + +struct avdtp_service_capability { + uint8_t category; + uint8_t length; + uint8_t data[0]; +} __attribute__ ((packed)); + +#if __BYTE_ORDER == __LITTLE_ENDIAN + +struct avdtp_media_codec_capability { + uint8_t rfa0:4; + uint8_t media_type:4; + uint8_t media_codec_type; + uint8_t data[0]; +} __attribute__ ((packed)); + +#elif __BYTE_ORDER == __BIG_ENDIAN + +struct avdtp_media_codec_capability { + uint8_t media_type:4; + uint8_t rfa0:4; + uint8_t media_codec_type; + uint8_t data[0]; +} __attribute__ ((packed)); + +#else +#error "Unknown byte order" +#endif + +typedef void (*avdtp_session_state_cb) (struct btd_device *dev, + struct avdtp *session, + avdtp_session_state_t old_state, + avdtp_session_state_t new_state, + void *user_data); + +typedef void (*avdtp_stream_state_cb) (struct avdtp_stream *stream, + avdtp_state_t old_state, + avdtp_state_t new_state, + struct avdtp_error *err, + void *user_data); + +typedef void (*avdtp_set_configuration_cb) (struct avdtp *session, + struct avdtp_stream *stream, + struct avdtp_error *err); + +/* Callbacks for when a reply is received to a command that we sent */ +struct avdtp_sep_cfm { + void (*set_configuration) (struct avdtp *session, + struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + struct avdtp_error *err, + void *user_data); + void (*get_configuration) (struct avdtp *session, + struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + struct avdtp_error *err, + void *user_data); + void (*open) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data); + void (*start) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, struct avdtp_error *err, + void *user_data); + void (*suspend) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + struct avdtp_error *err, void *user_data); + void (*close) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + struct avdtp_error *err, void *user_data); + void (*abort) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + struct avdtp_error *err, void *user_data); + void (*reconfigure) (struct avdtp *session, + struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + struct avdtp_error *err, void *user_data); + void (*delay_report) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + struct avdtp_error *err, void *user_data); +}; + +/* Callbacks for indicating when we received a new command. The return value + * indicates whether the command should be rejected or accepted */ +struct avdtp_sep_ind { + gboolean (*match_codec) (struct avdtp *session, + struct avdtp_media_codec_capability *codec, + void *user_data); + gboolean (*get_capability) (struct avdtp *session, + struct avdtp_local_sep *sep, + gboolean get_all, + GSList **caps, uint8_t *err, + void *user_data); + gboolean (*set_configuration) (struct avdtp *session, + struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, + GSList *caps, + avdtp_set_configuration_cb cb, + void *user_data); + gboolean (*get_configuration) (struct avdtp *session, + struct avdtp_local_sep *lsep, + uint8_t *err, void *user_data); + gboolean (*open) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data); + gboolean (*start) (struct avdtp *session, struct avdtp_local_sep *lsep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data); + gboolean (*suspend) (struct avdtp *session, + struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data); + gboolean (*close) (struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data); + void (*abort) (struct avdtp *session, struct avdtp_local_sep *sep, + struct avdtp_stream *stream, uint8_t *err, + void *user_data); + gboolean (*reconfigure) (struct avdtp *session, + struct avdtp_local_sep *lsep, + uint8_t *err, void *user_data); + gboolean (*delayreport) (struct avdtp *session, + struct avdtp_local_sep *lsep, + uint8_t rseid, uint16_t delay, + uint8_t *err, void *user_data); +}; + +typedef void (*avdtp_discover_cb_t) (struct avdtp *session, GSList *seps, + struct avdtp_error *err, void *user_data); + +void avdtp_unref(struct avdtp *session); +struct avdtp *avdtp_ref(struct avdtp *session); + +struct avdtp_service_capability *avdtp_service_cap_new(uint8_t category, + void *data, int size); + +struct avdtp_remote_sep *avdtp_register_remote_sep(struct avdtp *session, + uint8_t seid, + uint8_t type, + GSList *caps, + bool delay_reporting); +int avdtp_unregister_remote_sep(struct avdtp *session, + struct avdtp_remote_sep *rsep); + +typedef void (*avdtp_remote_sep_destroy_t)(void *user_data); + +void avdtp_remote_sep_set_destroy(struct avdtp_remote_sep *sep, void *user_data, + avdtp_remote_sep_destroy_t destroy); + +uint8_t avdtp_get_seid(struct avdtp_remote_sep *sep); + +uint8_t avdtp_get_type(struct avdtp_remote_sep *sep); + +struct avdtp_service_capability *avdtp_get_codec(struct avdtp_remote_sep *sep); + +bool avdtp_get_delay_reporting(struct avdtp_remote_sep *sep); + +int avdtp_discover(struct avdtp *session, avdtp_discover_cb_t cb, + void *user_data); + +gboolean avdtp_has_stream(struct avdtp *session, struct avdtp_stream *stream); + +unsigned int avdtp_stream_add_cb(struct avdtp *session, + struct avdtp_stream *stream, + avdtp_stream_state_cb cb, void *data); +gboolean avdtp_stream_remove_cb(struct avdtp *session, + struct avdtp_stream *stream, + unsigned int id); + +gboolean avdtp_stream_set_transport(struct avdtp_stream *stream, int fd, + size_t imtu, size_t omtu); +gboolean avdtp_stream_get_transport(struct avdtp_stream *stream, int *sock, + uint16_t *imtu, uint16_t *omtu, + GSList **caps); +struct avdtp_service_capability *avdtp_stream_get_codec( + struct avdtp_stream *stream); +gboolean avdtp_stream_has_capabilities(struct avdtp_stream *stream, + GSList *caps); +gboolean avdtp_stream_has_delay_reporting(struct avdtp_stream *stream); +struct avdtp_remote_sep *avdtp_stream_get_remote_sep( + struct avdtp_stream *stream); + +unsigned int avdtp_add_state_cb(struct btd_device *dev, + avdtp_session_state_cb cb, void *user_data); + +gboolean avdtp_remove_state_cb(unsigned int id); + +int avdtp_set_configuration(struct avdtp *session, + struct avdtp_remote_sep *rsep, + struct avdtp_local_sep *lsep, + GSList *caps, + struct avdtp_stream **stream); + +int avdtp_get_configuration(struct avdtp *session, + struct avdtp_stream *stream); + +int avdtp_open(struct avdtp *session, struct avdtp_stream *stream); +int avdtp_start(struct avdtp *session, struct avdtp_stream *stream); +int avdtp_suspend(struct avdtp *session, struct avdtp_stream *stream); +int avdtp_close(struct avdtp *session, struct avdtp_stream *stream, + gboolean immediate); +int avdtp_abort(struct avdtp *session, struct avdtp_stream *stream); +int avdtp_delay_report(struct avdtp *session, struct avdtp_stream *stream, + uint16_t delay); + +struct avdtp_local_sep *avdtp_register_sep(struct queue *lseps, + uint64_t *seid_pool, + uint8_t type, + uint8_t media_type, + uint8_t codec_type, + gboolean delay_reporting, + struct avdtp_sep_ind *ind, + struct avdtp_sep_cfm *cfm, + void *user_data); + +/* Find a matching pair of local and remote SEP ID's */ +struct avdtp_remote_sep *avdtp_find_remote_sep(struct avdtp *session, + struct avdtp_local_sep *lsep); + +int avdtp_unregister_sep(struct queue *lseps, uint64_t *seid_pool, + struct avdtp_local_sep *sep); + +avdtp_state_t avdtp_stream_get_state(struct avdtp_stream *stream); +uint8_t avdtp_sep_get_seid(struct avdtp_local_sep *sep); + +void avdtp_error_init(struct avdtp_error *err, uint8_t type, int id); +const char *avdtp_strerror(struct avdtp_error *err); +uint8_t avdtp_error_category(struct avdtp_error *err); +int avdtp_error_error_code(struct avdtp_error *err); +int avdtp_error_posix_errno(struct avdtp_error *err); + +struct btd_adapter *avdtp_get_adapter(struct avdtp *session); +struct btd_device *avdtp_get_device(struct avdtp *session); +struct avdtp_server *avdtp_get_server(struct avdtp_local_sep *lsep); + +struct avdtp *avdtp_new(GIOChannel *chan, struct btd_device *device, + struct queue *lseps); +uint16_t avdtp_get_version(struct avdtp *session); diff --git a/kernel/src/Api/Audio.hpp b/kernel/src/Api/Audio.hpp index 813973c..4ea9222 100644 --- a/kernel/src/Api/Audio.hpp +++ b/kernel/src/Api/Audio.hpp @@ -25,18 +25,10 @@ namespace Montauk { static constexpr int AUDIO_HANDLE_BT = 0x100; static int64_t Sys_AudioOpen(uint32_t sampleRate, uint8_t channels, uint8_t bitsPerSample) { - // HDA-backed mixer is the preferred output. The mixer keeps the HDA - // hardware stream open across virtual streams, so multiple apps can - // play simultaneously. - if (Drivers::Audio::IntelHda::IsInitialized()) { - auto* proc = Sched::GetCurrentProcessPtr(); - int pid = proc ? proc->pid : -1; - const char* name = proc ? proc->name : "?"; - return (int64_t)Drivers::Audio::Mixer::Open(sampleRate, channels, - bitsPerSample, pid, name); - } - - // Fallback: Bluetooth A2DP when no HDA controller is present. + // Auto-switch: when a Bluetooth A2DP sink is connected and its stream is + // set up (StartSource left it Configured/Open), route audio to the + // headphones -- like a phone does when you plug in BT. Falls back to + // the built-in speakers (HDA) when no BT sink is ready. if (Drivers::USB::Bluetooth::IsInitialized()) { auto state = Drivers::USB::Bluetooth::A2dp::GetState(); if (state == Drivers::USB::Bluetooth::A2dp::State::Open || @@ -48,6 +40,17 @@ namespace Montauk { } } + // HDA-backed mixer is the default output. The mixer keeps the HDA + // hardware stream open across virtual streams, so multiple apps can + // play simultaneously. + if (Drivers::Audio::IntelHda::IsInitialized()) { + auto* proc = Sched::GetCurrentProcessPtr(); + int pid = proc ? proc->pid : -1; + const char* name = proc ? proc->name : "?"; + return (int64_t)Drivers::Audio::Mixer::Open(sampleRate, channels, + bitsPerSample, pid, name); + } + return -1; } diff --git a/kernel/src/Api/BuildNo.hpp b/kernel/src/Api/BuildNo.hpp index 47643ad..f5b58a1 100644 --- a/kernel/src/Api/BuildNo.hpp +++ b/kernel/src/Api/BuildNo.hpp @@ -12,4 +12,4 @@ #pragma once -#define MONTAUK_BUILD_NUMBER 1 +#define MONTAUK_BUILD_NUMBER 48 diff --git a/kernel/src/Drivers/USB/Bluetooth/A2dp.cpp b/kernel/src/Drivers/USB/Bluetooth/A2dp.cpp index 8192b70..67a0e5e 100644 --- a/kernel/src/Drivers/USB/Bluetooth/A2dp.cpp +++ b/kernel/src/Drivers/USB/Bluetooth/A2dp.cpp @@ -70,10 +70,41 @@ namespace Drivers::USB::Bluetooth::A2dp { static uint8_t g_remoteSeid = 0; // Remote stream endpoint ID static uint8_t g_localSeid = 1; // Our local SEID + // Audio sink endpoints advertised by the remote (AVDTP Discover). A modern + // headset typically exposes several SEPs -- one per codec (SBC, AAC, aptX, + // ...). Each SEP carries exactly ONE media codec, so codec choice is + // endpoint choice. We must probe each with GetCapabilities and configure the + // one that offers SBC (the codec our encoder produces). The old code grabbed + // the FIRST audio sink and committed to it; on Bose that is the AAC endpoint, + // so the subsequent SBC SetConfiguration was rejected (cat=1 err=0x29, + // UNSUPPORTED_CONFIGURATION) and music never played. + static uint8_t g_sinkSeids[16] = {}; + static uint32_t g_numSinkSeids = 0; + + // The transaction label + signal id of the command we are currently waiting + // on a response for. ProcessAvdtp only accepts a response that matches both, + // so the headset's own AVDTP traffic (it opens channels and issues its own + // commands) cannot be mistaken for our reply and desync the handshake. + static uint8_t g_expectLabel = 0xFF; + static uint8_t g_expectSignal = 0xFF; + // SBC encoder static Sbc::SbcEncoder g_sbcEncoder = {}; static bool g_sbcInitialized = false; + // SBC capability negotiation. An A2DP source must SetConfiguration with a + // subset of what the sink advertised in GetCapabilities -- asserting a fixed + // config the sink didn't offer gets it rejected with UNSUPPORTED_CONFIGURATION + // (0x29), the observed Bose behaviour. We parse the sink's SBC capability and + // pick a supported config; g_cfgSbc is what we actually configured (used to + // set up the encoder so the frame headers match). + static uint8_t g_sinkSbcCaps[4] = {}; // advertised: [freq|mode][blk|sub|alloc][minBP][maxBP] + static bool g_haveSinkSbcCaps = false; + static bool g_sinkDelayReporting = false; // sink advertised Delay Reporting (cat 0x08) + static bool g_sinkContentProtection = false; // sink advertised Content Protection (cat 0x04) + static uint8_t g_sinkCpType[2] = {}; // advertised CP_TYPE (LSB,MSB); SCMS-T = {0x02,0x00} + static uint8_t g_cfgSbc[4] = {}; // the SBC octets we configured + // Media packet state static uint16_t g_seqNum = 0; static uint32_t g_timestamp = 0; @@ -86,6 +117,12 @@ namespace Drivers::USB::Bluetooth::A2dp { static uint8_t g_avdtpResponseBuf[128] = {}; static uint32_t g_avdtpResponseLen = 0; + // SDP (service discovery) state. Many A2DP sinks refuse to engage AVDTP + // until the source has queried their service record, so we do a minimal SDP + // ServiceSearchAttribute query for the AudioSink service first. + static uint16_t g_sdpCid = 0; + static volatile bool g_sdpRspReady = false; + // ========================================================================= // AVDTP signaling helpers // ========================================================================= @@ -94,7 +131,8 @@ namespace Drivers::USB::Bluetooth::A2dp { uint8_t buf[128] = {}; // AVDTP single packet header - buf[0] = (g_txLabel << 4) | (PKT_SINGLE << 2) | MSG_COMMAND; + uint8_t lbl = g_txLabel; + buf[0] = (lbl << 4) | (PKT_SINGLE << 2) | MSG_COMMAND; buf[1] = signalId; g_txLabel = (g_txLabel + 1) & 0x0F; @@ -102,6 +140,13 @@ namespace Drivers::USB::Bluetooth::A2dp { memcpy(&buf[2], payload, len); } + // Record what we're waiting for and discard any stale response, so only + // the matching reply satisfies WaitAvdtpResponse (see g_expectLabel). + g_expectLabel = lbl; + g_expectSignal = signalId; + g_avdtpResponseReady = false; + g_avdtpResponseLen = 0; + L2cap::SendData(g_sigCid, buf, 2 + len); } @@ -129,6 +174,7 @@ namespace Drivers::USB::Bluetooth::A2dp { while (Timekeeping::GetMilliseconds() - start < timeoutMs) { Xhci::PollEvents(); + Hci::DrainEvents(); // AVDTP responses arrive as ACL data if (g_avdtpResponseReady) return true; for (int j = 0; j < 100; j++) { asm volatile("" ::: "memory"); @@ -137,6 +183,14 @@ namespace Drivers::USB::Bluetooth::A2dp { return false; } + // WaitAvdtpResponse() returns true for ACCEPT *and* REJECT (the msgType is in + // the low 2 bits of byte 0). This distinguishes them so a rejected + // configuration is surfaced instead of silently treated as success. + static bool AvdtpAccepted() { + return g_avdtpResponseLen >= 1 && + (g_avdtpResponseBuf[0] & 0x03) == MSG_RESPONSE_ACCEPT; + } + // ========================================================================= // AVDTP signaling procedures // ========================================================================= @@ -148,67 +202,185 @@ namespace Drivers::USB::Bluetooth::A2dp { KernelLogStream(WARNING, "BT-A2DP") << "AVDTP Discover timeout"; return false; } + if (!AvdtpAccepted()) { + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP Discover rejected"; + return false; + } - // Parse discover response to find audio sink SEID - // Response format: each SEP is 2 bytes: - // Byte 0: SEID(6) | InUse(1) | Rsvd(1) - // Byte 1: MediaType(4) | SEPType(4) (SEPType: 0=Source, 1=Sink) + // Parse discover response to enumerate audio sink SEIDs. Each SEP is 2 + // bytes: + // Byte 0: ACP SEID (bits 7-2) | In Use (bit 1) | RFA (bit 0) + // Byte 1: Media Type (bits 7-4) | TSEP (bit 3) | RFA (bits 2-0) + // TSEP (the Stream End Point type) is BIT 3: 0=Source (SRC), 1=Sink (SNK) + // -- it is NOT the low nibble. The old `& 0x0F` read RFA bits too, so an + // audio sink (byte1 = 0x08: Audio<<4 | SNK<<3) computed 0x08 != 0x01 and + // was rejected -> "No audio sink SEP found", an earlier HW symptom. + // + // Collect EVERY usable audio sink (the remote exposes one per codec); + // StartSource then probes each for SBC rather than committing to the + // first, which on Bose is the AAC endpoint. + g_numSinkSeids = 0; if (g_avdtpResponseLen >= 4) { for (uint32_t i = 2; i + 1 < g_avdtpResponseLen; i += 2) { uint8_t seid = (g_avdtpResponseBuf[i] >> 2) & 0x3F; bool inUse = (g_avdtpResponseBuf[i] >> 1) & 1; uint8_t mediaType = (g_avdtpResponseBuf[i + 1] >> 4) & 0x0F; - uint8_t sepType = g_avdtpResponseBuf[i + 1] & 0x0F; + uint8_t sepType = (g_avdtpResponseBuf[i + 1] >> 3) & 0x01; // TSEP: 1=Sink if (mediaType == MEDIA_AUDIO && sepType == 0x01 && !inUse) { - g_remoteSeid = seid; - KernelLogStream(INFO, "BT-A2DP") << "Found audio sink SEID=" - << (uint64_t)seid; - return true; + if (g_numSinkSeids < (sizeof(g_sinkSeids) / sizeof(g_sinkSeids[0]))) { + g_sinkSeids[g_numSinkSeids++] = seid; + } } } } - KernelLogStream(WARNING, "BT-A2DP") << "No audio sink SEP found"; - return false; + if (g_numSinkSeids == 0) { + KernelLogStream(WARNING, "BT-A2DP") << "No audio sink SEP found"; + return false; + } + + KernelLogStream cl(INFO, "BT-A2DP"); + cl << "Found " << (uint64_t)g_numSinkSeids << " audio sink SEID(s):"; + for (uint32_t i = 0; i < g_numSinkSeids; i++) cl << " " << (uint64_t)g_sinkSeids[i]; + return true; } - static bool AvdtpGetCapabilities() { - uint8_t payload[1] = {(uint8_t)(g_remoteSeid << 2)}; + // Pick a single capability bit: the first preference (MSB of the list first) + // that the sink advertises in `avail`; fall back to the lowest set bit. + static uint8_t PickBit(uint8_t avail, const uint8_t* pref, int n) { + for (int i = 0; i < n; i++) if (avail & pref[i]) return pref[i]; + for (int b = 0; b < 8; b++) if (avail & (1u << b)) return (uint8_t)(1u << b); + return 0; + } + + static bool AvdtpGetCapabilities(uint8_t seid) { + // Clear the per-endpoint capability state up front, BEFORE any early + // return, so a probe that times out or is rejected leaves no stale SBC + // caps behind for the next endpoint in the probe loop or a later + // StartSource() reconnect/retry to misread. + g_haveSinkSbcCaps = false; + g_sinkDelayReporting = false; + g_sinkContentProtection = false; + g_sinkCpType[0] = g_sinkCpType[1] = 0; + g_sinkSbcCaps[0] = g_sinkSbcCaps[1] = g_sinkSbcCaps[2] = g_sinkSbcCaps[3] = 0; + + uint8_t payload[1] = {(uint8_t)(seid << 2)}; SendAvdtpCommand(AVDTP_GET_CAPABILITIES, payload, 1); - return WaitAvdtpResponse(); + if (!WaitAvdtpResponse()) { + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP GetCapabilities timeout (SEID=" + << (uint64_t)seid << ")"; + return false; + } + if (!AvdtpAccepted()) { + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP GetCapabilities rejected (SEID=" + << (uint64_t)seid << ")"; + return false; + } + + // Parse the advertised service capabilities so SetConfiguration offers + // only a subset the sink actually supports. Capabilities follow the + // AVDTP header (bytes 0-1): [category][LOSC][content...] repeated. + // (Capability state was already cleared at function entry.) + KernelLogStream cl(INFO, "BT-A2DP"); + cl << "GetCap SEID=" << (uint64_t)seid << " cats:" << base::hex; + uint32_t off = 2; + while (off + 2 <= g_avdtpResponseLen) { + uint8_t cat = g_avdtpResponseBuf[off]; + uint8_t losc = g_avdtpResponseBuf[off + 1]; + cl << " " << (uint64_t)cat << "/" << (uint64_t)losc; + if (off + 2 + (uint32_t)losc > g_avdtpResponseLen) break; + const uint8_t* content = &g_avdtpResponseBuf[off + 2]; + if (cat == 0x08) g_sinkDelayReporting = true; // Delay Reporting + if (cat == 0x04 && losc >= 2) { // Content Protection (e.g. SCMS-T) + g_sinkContentProtection = true; + g_sinkCpType[0] = content[0]; + g_sinkCpType[1] = content[1]; + cl << " [CP " << (uint64_t)content[0] << " " << (uint64_t)content[1] << "]"; + } + if (cat == CAT_MEDIA_CODEC && losc >= 6 && content[1] == CODEC_SBC) { + g_sinkSbcCaps[0] = content[2]; + g_sinkSbcCaps[1] = content[3]; + g_sinkSbcCaps[2] = content[4]; + g_sinkSbcCaps[3] = content[5]; + g_haveSinkSbcCaps = true; + cl << " [SBC " << (uint64_t)content[2] << " " << (uint64_t)content[3] + << " " << (uint64_t)content[4] << " " << (uint64_t)content[5] << "]"; + } + off += 2 + losc; + } + cl << base::dec; + return true; } static bool AvdtpSetConfiguration() { - // Set Configuration payload: - // ACP SEID (1 byte) | INT SEID (1 byte) | Service Capabilities... - uint8_t payload[12] = {}; - payload[0] = (g_remoteSeid << 2); // ACP SEID - payload[1] = (g_localSeid << 2); // INT SEID + // Choose an SBC configuration that is a SUBSET of the sink's advertised + // capabilities (each field exactly one bit). Asserting unsupported + // values gets UNSUPPORTED_CONFIGURATION (0x29). + uint8_t oct0, oct1, minBP, maxBP; + if (g_haveSinkSbcCaps) { + static const uint8_t freqPref[4] = {0x10, 0x20, 0x40, 0x80}; // 48,44.1,32,16 kHz + static const uint8_t modePref[4] = {0x01, 0x02, 0x04, 0x08}; // Joint,Stereo,Dual,Mono + static const uint8_t blkPref[4] = {0x10, 0x20, 0x40, 0x80}; // 16,12,8,4 blocks + static const uint8_t subPref[2] = {0x04, 0x08}; // 8,4 subbands + static const uint8_t allocPref[2] = {0x01, 0x02}; // Loudness,SNR + oct0 = PickBit(g_sinkSbcCaps[0] & 0xF0, freqPref, 4) + | PickBit(g_sinkSbcCaps[0] & 0x0F, modePref, 4); + oct1 = PickBit(g_sinkSbcCaps[1] & 0xF0, blkPref, 4) + | PickBit(g_sinkSbcCaps[1] & 0x0C, subPref, 2) + | PickBit(g_sinkSbcCaps[1] & 0x03, allocPref, 2); + minBP = g_sinkSbcCaps[2] < 2 ? 2 : g_sinkSbcCaps[2]; + maxBP = g_sinkSbcCaps[3] > 53 ? 53 : g_sinkSbcCaps[3]; // cap to our quality target + if (maxBP < minBP) maxBP = minBP; + } else { + oct0 = 0x11; oct1 = 0x15; minBP = 2; maxBP = 53; // mandatory SBC baseline + } + g_cfgSbc[0] = oct0; g_cfgSbc[1] = oct1; g_cfgSbc[2] = minBP; g_cfgSbc[3] = maxBP; - // Media Transport capability (no data) - payload[2] = CAT_MEDIA_TRANSPORT; // Category - payload[3] = 0; // Length + // Set Configuration: ACP SEID | INT SEID | Service Capabilities. + uint8_t payload[24] = {}; + int n = 0; + payload[n++] = (g_remoteSeid << 2); // ACP SEID + payload[n++] = (g_localSeid << 2); // INT SEID + payload[n++] = CAT_MEDIA_TRANSPORT; payload[n++] = 0; + payload[n++] = CAT_MEDIA_CODEC; payload[n++] = 6; + payload[n++] = (MEDIA_AUDIO << 4); // Media Type (audio) + payload[n++] = CODEC_SBC; // Codec Type (SBC) + payload[n++] = oct0; payload[n++] = oct1; payload[n++] = minBP; payload[n++] = maxBP; + // If the sink advertised Content Protection (cat 0x04), configure SCMS-T + // (CP_TYPE 0x0002). Bose QC sinks advertise it and gate the media + // transport channel on it: SetConfiguration is accepted without it, but + // the sink then never authorizes the transport L2CAP channel (it answers + // the transport CONN_REQ with a perpetual PENDING). CP_TYPE is 2 bytes, + // LSB first; SCMS-T carries no extra CP-type-specific data (LOSC=2). + if (g_sinkContentProtection) { + payload[n++] = 0x04; payload[n++] = 2; // Content Protection, LOSC=2 + payload[n++] = g_sinkCpType[0]; // CP_TYPE LSB (SCMS-T = 0x02) + payload[n++] = g_sinkCpType[1]; // CP_TYPE MSB (SCMS-T = 0x00) + } + // If the sink advertised Delay Reporting, configure it too -- some sinks + // reject SetConfiguration that omits a category they require. + if (g_sinkDelayReporting) { payload[n++] = 0x08; payload[n++] = 0; } - // Media Codec capability (SBC) - payload[4] = CAT_MEDIA_CODEC; // Category - payload[5] = 6; // Length - payload[6] = (MEDIA_AUDIO << 4); // Media Type - payload[7] = CODEC_SBC; // Codec Type - // SBC codec info (4 bytes) - // Sampling: 44.1kHz (bit 5), Channel mode: Joint Stereo (bit 0) - payload[8] = 0x21; // 44.1kHz | Joint Stereo - // Block length: 16 (bit 7), Subbands: 8 (bit 1), Alloc: Loudness (bit 0) - payload[9] = 0x83; // 16 blocks | 8 subbands | Loudness - payload[10] = 2; // Min bitpool - payload[11] = 53; // Max bitpool + KernelLogStream(INFO, "BT-A2DP") << "SetConfig SBC oct0=" << base::hex << (uint64_t)oct0 + << " oct1=" << (uint64_t)oct1 << base::dec << " bp=" << (uint64_t)minBP << ".." + << (uint64_t)maxBP << (g_sinkContentProtection ? " +scms-t" : "") + << (g_sinkDelayReporting ? " +delay" : ""); - SendAvdtpCommand(AVDTP_SET_CONFIGURATION, payload, 12); + SendAvdtpCommand(AVDTP_SET_CONFIGURATION, payload, (uint16_t)n); if (!WaitAvdtpResponse()) { KernelLogStream(WARNING, "BT-A2DP") << "AVDTP SetConfiguration timeout"; return false; } + if (!AvdtpAccepted()) { + // Reject payload: [failing service category][error code] + uint8_t cat = (g_avdtpResponseLen > 2) ? g_avdtpResponseBuf[2] : 0; + uint8_t err = (g_avdtpResponseLen > 3) ? g_avdtpResponseBuf[3] : 0; + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP SetConfiguration rejected (cat=" + << base::hex << (uint64_t)cat << " err=" << (uint64_t)err << base::dec << ")"; + return false; + } g_state = State::Configured; KernelLogStream(OK, "BT-A2DP") << "Stream configured"; @@ -223,6 +395,12 @@ namespace Drivers::USB::Bluetooth::A2dp { KernelLogStream(WARNING, "BT-A2DP") << "AVDTP Open timeout"; return false; } + if (!AvdtpAccepted()) { + uint8_t err = (g_avdtpResponseLen > 2) ? g_avdtpResponseBuf[2] : 0; + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP Open rejected (err=" + << base::hex << (uint64_t)err << base::dec << ")"; + return false; + } g_state = State::Open; KernelLogStream(OK, "BT-A2DP") << "Stream opened"; @@ -237,6 +415,12 @@ namespace Drivers::USB::Bluetooth::A2dp { KernelLogStream(WARNING, "BT-A2DP") << "AVDTP Start timeout"; return false; } + if (!AvdtpAccepted()) { + uint8_t err = (g_avdtpResponseLen > 2) ? g_avdtpResponseBuf[2] : 0; + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP Start rejected (err=" + << base::hex << (uint64_t)err << base::dec << ")"; + return false; + } g_state = State::Streaming; KernelLogStream(OK, "BT-A2DP") << "Streaming started"; @@ -248,26 +432,248 @@ namespace Drivers::USB::Bluetooth::A2dp { // ========================================================================= void OnChannelReady(uint16_t l2capCid) { + // Invoked from L2CAP inside the ACL receive path -- i.e. NESTED under + // Xhci::PollEvents. PollEvents is non-reentrant (re-entry guard), so we + // must NOT run the blocking AVDTP signaling chain here; a nested poll + // would stall and every WaitAvdtpResponse() would time out. Just record + // the channel; StartSource() drives the handshakes from top-level + // (process) context where polling is free to run. if (g_sigCid == 0) { - // First AVDTP channel is signaling g_sigCid = l2capCid; KernelLogStream(OK, "BT-A2DP") << "AVDTP signaling channel ready: CID=" << (uint64_t)l2capCid; - - // Auto-discover remote SEPs - g_state = State::Discovering; - if (AvdtpDiscover()) { - AvdtpGetCapabilities(); - AvdtpSetConfiguration(); - } } else if (g_mediaCid == 0) { - // Second AVDTP channel is media transport g_mediaCid = l2capCid; KernelLogStream(OK, "BT-A2DP") << "AVDTP media channel ready: CID=" << (uint64_t)l2capCid; } } + // ========================================================================= + // StartSource — drive the A2DP source role after the ACL link is up + // ========================================================================= + // Runs at top-level (process) context, NOT nested under PollEvents, so the + // blocking AVDTP handshakes are safe. Opens the AVDTP signaling channel, + // negotiates an SBC stream (Discover -> GetCapabilities -> SetConfiguration + // -> Open), then opens the media transport channel. Leaves the stream in + // the Open state; the first audio write (StartStream) issues AVDTP_START. + // Without this the headset has no media stream and terminates the link + // (HCI disconnect reason 0x13), which is the connect/disconnect flapping. + // Called by L2CAP when data arrives on the SDP channel (the query response). + void ProcessSdp(const uint8_t* data, uint16_t len) { + (void)data; + if (len > 0) g_sdpRspReady = true; + } + + // Minimal SDP: open PSM 0x0001, send a ServiceSearchAttributeRequest for the + // AudioSink service (UUID 0x110B), wait briefly for the response. Best + // effort -- the goal is to satisfy sinks that gate AVDTP on a prior SDP + // query. Returns true if the SDP channel configured (i.e. ACL data flows). + static bool DoSdpQuery(uint32_t timeoutMs) { + g_sdpCid = 0; + g_sdpRspReady = false; + + uint16_t cid = L2cap::Connect(L2cap::PSM_SDP); + if (!cid || !L2cap::WaitConfigured(cid, timeoutMs)) { + KernelLogStream(WARNING, "BT-A2DP") << "SDP channel setup failed (connRsp=" + << base::hex << (uint64_t)L2cap::LastConnRspResult() << base::dec << ")"; + Hci::DumpAclStats(); // did our CONN_REQ even go out / any reply arrive? + return false; + } + g_sdpCid = cid; + + // ServiceSearchAttributeRequest for AudioSink (0x110B), all attributes. + uint8_t pdu[20] = { + 0x06, // PDU ID: ServiceSearchAttributeRequest + 0x00, 0x01, // Transaction ID + 0x00, 0x0F, // Parameter length = 15 + 0x35, 0x03, // ServiceSearchPattern: DES, 3 bytes + 0x19, 0x11, 0x0B, // UUID16 0x110B (AudioSink) + 0xFF, 0xFF, // MaximumAttributeByteCount + 0x35, 0x05, // AttributeIDList: DES, 5 bytes + 0x0A, 0x00, 0x00, 0xFF, 0xFF, // UINT32 range 0x0000-0xFFFF + 0x00 // ContinuationState (none) + }; + L2cap::SendData(cid, pdu, sizeof(pdu)); + + uint64_t start = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - start < timeoutMs) { + Xhci::PollEvents(); + Hci::DrainEvents(); + if (g_sdpRspReady) { + KernelLogStream(OK, "BT-A2DP") << "SDP query answered"; + return true; + } + for (int j = 0; j < 100; j++) asm volatile("" ::: "memory"); + } + KernelLogStream(INFO, "BT-A2DP") << "SDP query sent, no response (continuing)"; + return true; // channel configured + query sent; proceed to AVDTP + } + + bool StartSource(uint32_t timeoutMs) { + constexpr int kMaxAttempts = 4; + + // Connection phase, retried. A sink commonly ignores the very first + // L2CAP CONN_REQ that lands right after Encryption Change (the build-39 + // HW symptom: connRsp stays 0xFFFF, the headset never answers). Re-dial + // up to kMaxAttempts. We retry ONLY when the remote ignored us + // (connRsp==0xFFFF -> our dialed channel has RemoteCid==0, so freeing it + // owes the peer no Disconnect); if it answered but config stalled + // (connRsp!=0xFFFF) we do NOT loop -- that's the config phase, surfaced + // by its own logs. We never reset the CID allocator, so each retry uses + // a fresh local CID and a late response for an old one cannot cross-wire. + for (int attempt = 0; attempt < kMaxAttempts; attempt++) { + g_sigCid = 0; + g_mediaCid = 0; + g_state = State::Idle; + g_txLabel = 1; + g_avdtpResponseReady = false; + + // SDP service query: best effort, FIRST attempt only -- some sinks + // gate AVDTP on a prior SDP query; repeating it on retries only burns + // a channel slot and 2s with no benefit. + if (attempt == 0) DoSdpQuery(2000); + + // AVDTP signaling channel (PSM 0x0019). Dial out, then wait for a + // channel to become ready in EITHER direction (OnChannelReady sets + // g_sigCid for ours, or one the headset opened to us). + uint16_t sig = L2cap::Connect(L2cap::PSM_AVDTP); + KernelLogStream(INFO, "BT-A2DP") << "AVDTP signaling: attempt " + << (uint64_t)(attempt + 1) << "/" << (uint64_t)kMaxAttempts + << " dialed cid=" << base::hex << (uint64_t)sig << base::dec + << " (acl=" << (uint64_t)L2cap::GetAclHandle() << "), waiting..."; + + uint64_t sigStart = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - sigStart < timeoutMs) { + Xhci::PollEvents(); + Hci::DrainEvents(); + if (g_sigCid != 0) break; + for (int j = 0; j < 100; j++) asm volatile("" ::: "memory"); + } + if (g_sigCid != 0) break; // signaling channel up -> proceed + + auto* ch = sig ? L2cap::GetChannel(sig) : nullptr; + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP signaling attempt " + << (uint64_t)(attempt + 1) << " TIMEOUT (remoteCid=" + << base::hex << (uint64_t)(ch ? ch->RemoteCid : 0) << base::dec + << " localCfg=" << (uint64_t)(ch ? ch->LocalConfigDone : 0) + << " remoteCfg=" << (uint64_t)(ch ? ch->RemoteConfigDone : 0) + << " connRsp=" << base::hex << (uint64_t)L2cap::LastConnRspResult() + << base::dec << " incomingReqs=" + << (uint64_t)L2cap::IncomingAvdtpReqCount() << ")"; + + // Retry only if the remote IGNORED our CONN_REQ entirely. If it + // answered (connRsp != 0xFFFF) the stall is in the config exchange, + // not the dial -- don't loop; let the config-phase logs speak. + if (L2cap::LastConnRspResult() != 0xFFFF) { + Hci::DumpAclStats(); + return false; + } + // Free our unanswered dialed channel so repeated retries don't leak + // the fixed channel table, then settle (draining events, so the RX + // ring keeps being serviced) before re-dialing. + if (sig) L2cap::FreeChannel(sig); + uint64_t st = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - st < 400) { + Xhci::PollEvents(); + Hci::DrainEvents(); + for (int j = 0; j < 200; j++) asm volatile("pause" ::: "memory"); + } + } + + if (g_sigCid == 0) { + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP signaling setup gave up after retries"; + Hci::DumpAclStats(); + return false; + } + KernelLogStream(OK, "BT-A2DP") << "AVDTP signaling channel ready, cid=" + << base::hex << (uint64_t)g_sigCid << base::dec; + + // 2. Negotiate the SBC stream (top-level: polling is free to run). + g_state = State::Discovering; + if (!AvdtpDiscover()) return false; + + // Probe each advertised audio sink and configure the first that offers + // SBC. Each SEP carries a single codec, so we cannot assume the first + // sink is SBC -- on Bose it is AAC, and configuring SBC against it is + // rejected (UNSUPPORTED_CONFIGURATION). SBC is mandatory for any A2DP + // sink, so a usable endpoint is always present once we look past the + // first. AvdtpGetCapabilities sets g_haveSinkSbcCaps when the probed + // SEID advertises SBC; we keep that endpoint's caps for SetConfiguration. + bool pickedSbc = false; + for (uint32_t i = 0; i < g_numSinkSeids; i++) { + if (!AvdtpGetCapabilities(g_sinkSeids[i])) continue; // skip endpoints that error + if (g_haveSinkSbcCaps) { + g_remoteSeid = g_sinkSeids[i]; + pickedSbc = true; + KernelLogStream(OK, "BT-A2DP") << "Selected SBC sink SEID=" + << (uint64_t)g_remoteSeid; + break; + } + KernelLogStream(INFO, "BT-A2DP") << "SEID=" << (uint64_t)g_sinkSeids[i] + << " is not SBC, trying next"; + } + if (!pickedSbc) { + KernelLogStream(WARNING, "BT-A2DP") << "No SBC-capable sink endpoint found"; + return false; + } + + if (!AvdtpSetConfiguration()) return false; // -> Configured + + // 3. Open the stream endpoint. + if (!AvdtpOpen()) return false; // -> Open + + // 4. Media transport channel: a SECOND PSM 0x0019 L2CAP channel the AVDTP + // initiator opens after AVDTP_OPEN. Dial ONCE, immediately (inside the + // sink's open-acceptor window), and HOLD that same channel while + // polling. A CONN_RSP result=1 (PENDING) is NON-FINAL: a conformant + // sink follows it with SUCCESS/REFUSED on the SAME channel, so we must + // NOT tear it down and re-dial -- doing so (build 47) only churned CIDs + // and abandoned the very connection the sink was authorizing, while a + // single held dial (build 44) already proved holding alone is harmless. + // Also accept an inbound transport channel (some sinks open it). + // NOTE: the real gate on Bose is Content Protection -- see + // AvdtpSetConfiguration's SCMS-T handling; without it the sink pends + // this channel forever (connRsp=1, remoteCid=0). + g_mediaCid = 0; + constexpr uint32_t kMediaWaitMs = 8000; + + uint16_t media = L2cap::Connect(L2cap::PSM_AVDTP); + KernelLogStream(INFO, "BT-A2DP") << "AVDTP media: dialed cid=" + << base::hex << (uint64_t)media << base::dec << ", holding channel..."; + + uint64_t mStart = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - mStart < kMediaWaitMs) { + Xhci::PollEvents(); + Hci::DrainEvents(); + auto* ch = media ? L2cap::GetChannel(media) : nullptr; + if (ch && ch->Configured) { g_mediaCid = media; break; } // PENDING->SUCCESS->configured + uint16_t other = L2cap::FindConfiguredAvdtpChannelExcept(g_sigCid); + if (other) { g_mediaCid = other; break; } // sink opened it inbound + for (int j = 0; j < 100; j++) asm volatile("" ::: "memory"); + } + + if (g_mediaCid == 0) { + // Do NOT FreeChannel here -- a late SUCCESS would then match no + // active channel. Leave it; the next connection's Initialize resets + // the table. Log the held channel's state for diagnosis. + auto* ch = media ? L2cap::GetChannel(media) : nullptr; + KernelLogStream(WARNING, "BT-A2DP") << "AVDTP media channel setup failed (remoteCid=" + << base::hex << (uint64_t)(ch ? ch->RemoteCid : 0) << base::dec + << " localCfg=" << (uint64_t)(ch ? ch->LocalConfigDone : 0) + << " remoteCfg=" << (uint64_t)(ch ? ch->RemoteConfigDone : 0) + << " connRsp=" << base::hex << (uint64_t)L2cap::LastConnRspResult() + << base::dec << " incomingReqs=" + << (uint64_t)L2cap::IncomingAvdtpReqCount() << ")"; + Hci::DumpAclStats(); + return false; + } + + KernelLogStream(OK, "BT-A2DP") << "A2DP source ready (signaling + media), cid=" + << base::hex << (uint64_t)g_mediaCid << base::dec << " state=Open"; + return true; + } + // ========================================================================= // ProcessAvdtp — handle AVDTP signaling packets // ========================================================================= @@ -281,10 +687,15 @@ namespace Drivers::USB::Bluetooth::A2dp { uint8_t signalId = data[1] & 0x3F; if (msgType == MSG_RESPONSE_ACCEPT || msgType == MSG_RESPONSE_REJECT) { - // This is a response to our command - memcpy(g_avdtpResponseBuf, data, len > sizeof(g_avdtpResponseBuf) ? sizeof(g_avdtpResponseBuf) : len); - g_avdtpResponseLen = len; - g_avdtpResponseReady = true; + // Only accept the response to the command we are actually waiting on + // (matching transaction label AND signal id). Otherwise the headset's + // own responses/duplicates could be read as ours and desync the chain. + if (txLabel == g_expectLabel && signalId == g_expectSignal) { + uint32_t cp = (len > sizeof(g_avdtpResponseBuf)) ? sizeof(g_avdtpResponseBuf) : len; + memcpy(g_avdtpResponseBuf, data, cp); + g_avdtpResponseLen = len; + g_avdtpResponseReady = true; + } return; } @@ -310,7 +721,7 @@ namespace Drivers::USB::Bluetooth::A2dp { rsp[4] = (MEDIA_AUDIO << 4); rsp[5] = CODEC_SBC; rsp[6] = 0x21; // 44.1kHz | Joint Stereo - rsp[7] = 0x83; // 16 blocks | 8 subbands | Loudness + rsp[7] = 0x15; // 16 blocks (b4) | 8 subbands (b2) | Loudness (b0) rsp[8] = 2; // Min bitpool rsp[9] = 53; // Max bitpool SendAvdtpResponse(txLabel, AVDTP_GET_CAPABILITIES, rsp, 10); @@ -375,6 +786,12 @@ namespace Drivers::USB::Bluetooth::A2dp { bool ConfigureStream(uint32_t sampleRate, uint8_t channels, uint8_t bitsPerSample) { Sbc::Init(&g_sbcEncoder, sampleRate, channels, bitsPerSample); + // Override with the SBC parameters actually negotiated in + // SetConfiguration so the encoded frame headers match what the sink + // agreed to (Init's defaults may differ from the negotiated subset). + if (g_cfgSbc[0] || g_cfgSbc[1]) { + Sbc::Configure(&g_sbcEncoder, g_cfgSbc[0], g_cfgSbc[1], g_cfgSbc[3]); + } g_sbcInitialized = true; g_seqNum = 0; g_timestamp = 0; @@ -429,6 +846,8 @@ namespace Drivers::USB::Bluetooth::A2dp { if (bytesPerFrame > sizeof(scaledPcm)) return -1; uint32_t consumed = 0; + uint16_t maxOut = Hci::AclMaxPackets(); + if (maxOut == 0) maxOut = 4; // controller ACL buffer credits while (consumed + bytesPerFrame <= pcmLen) { // Copy and scale by volume @@ -464,8 +883,23 @@ namespace Drivers::USB::Bluetooth::A2dp { uint32_t totalLen = 13 + encodedSize; + // Flow control + event pump. WriteAudio runs in syscall context, + // which otherwise never services the xHCI event ring -- so without + // this the controller's ACL credits (Number-Of-Completed-Packets) + // and the RX ring are never processed and the TX ring stalls/overruns + // (-> no audio). Wait for a controller buffer credit, send, then pump + // so the completion + credit are reaped before the next frame. + uint64_t t0 = Timekeeping::GetMilliseconds(); + while (Hci::AclPendingCount() >= maxOut + && Timekeeping::GetMilliseconds() - t0 < 100) { + Xhci::PollEvents(); + Hci::DrainEvents(); + } + // Send via L2CAP on media channel L2cap::SendData(g_mediaCid, mediaPkt, (uint16_t)totalLen); + Xhci::PollEvents(); + Hci::DrainEvents(); g_seqNum++; g_timestamp += samplesPerFrame; diff --git a/kernel/src/Drivers/USB/Bluetooth/A2dp.hpp b/kernel/src/Drivers/USB/Bluetooth/A2dp.hpp index 1b295df..93d7e6d 100644 --- a/kernel/src/Drivers/USB/Bluetooth/A2dp.hpp +++ b/kernel/src/Drivers/USB/Bluetooth/A2dp.hpp @@ -26,12 +26,21 @@ namespace Drivers::USB::Bluetooth::A2dp { // Public API // ========================================================================= + // Drive the A2DP source role after an ACL link is up: open the AVDTP + // signaling channel, negotiate an SBC stream, and open the media transport + // channel. Must be called from process context (it blocks on the AVDTP + // handshakes), NOT from an event/interrupt path. Leaves the stream Open. + bool StartSource(uint32_t timeoutMs = 5000); + // Called by L2CAP when an AVDTP channel becomes ready void OnChannelReady(uint16_t l2capCid); // Process an AVDTP signaling packet void ProcessAvdtp(const uint8_t* data, uint16_t len); + // Process an SDP response packet (on the SDP L2CAP channel) + void ProcessSdp(const uint8_t* data, uint16_t len); + // Configure a stream for the given PCM parameters bool ConfigureStream(uint32_t sampleRate, uint8_t channels, uint8_t bitsPerSample); diff --git a/kernel/src/Drivers/USB/Bluetooth/Bluetooth.cpp b/kernel/src/Drivers/USB/Bluetooth/Bluetooth.cpp index 8d8235a..a1e4aa0 100644 --- a/kernel/src/Drivers/USB/Bluetooth/Bluetooth.cpp +++ b/kernel/src/Drivers/USB/Bluetooth/Bluetooth.cpp @@ -7,8 +7,10 @@ #include "Bluetooth.hpp" #include "Hci.hpp" #include "A2dp.hpp" +#include "IntelFirmware.hpp" #include #include +#include #include #include #include @@ -26,6 +28,15 @@ namespace Drivers::USB::Bluetooth { static uint8_t g_slotId = 0; static uint8_t g_bdAddr[6] = {}; + // True when the USB transport is up but the firmware-dependent HCI init is + // still waiting for the ramdisk (drive 0) to be mounted. Set when an + // adapter enumerates during the boot port scan, which runs before the boot + // filesystems are mounted; cleared by ServiceDeferredInit() once VFS is up. + static bool g_initPending = false; + + // Forward declaration: firmware-dependent HCI bring-up, run once VFS is up. + static void CompleteInit(); + // Intel Bluetooth device IDs static bool IsIntelBt(uint16_t vid, uint16_t pid) { if (vid != 0x8087) return false; @@ -76,7 +87,9 @@ namespace Drivers::USB::Bluetooth { << " subver=" << (uint64_t)lver.LmpSubversion << base::dec; } - // Read Intel version to check firmware state + // Read legacy Intel version for diagnostics (TLV parts return this in + // a different layout; the authoritative state check happens inside the + // firmware download path below via the TLV version). Hci::IntelVersion ver = {}; if (!Hci::ReadIntelVersion(&ver)) { KernelLogStream(WARNING, "BT") << "Failed to read Intel BT version"; @@ -85,23 +98,24 @@ namespace Drivers::USB::Bluetooth { << " FW variant=" << base::hex << (uint64_t)ver.FwVariant << " FW rev=" << (uint64_t)ver.FwRevision << "." << (uint64_t)ver.FwBuildNum << base::dec; - - if (ver.FwVariant == 0x23) { - KernelLogStream(OK, "BT") << "Intel BT firmware already loaded (operational mode)"; - } else if (ver.FwVariant == 0x06) { - KernelLogStream(WARNING, "BT") << "Intel BT in bootloader mode, firmware not loaded"; - KernelLogStream(WARNING, "BT") << "Bluetooth will have limited functionality without firmware"; - } else if (!hciVersionOk) { - // Standard HCI commands failed AND Intel version is zeros/unknown - // -> controller is in bootloader mode, needs firmware download - KernelLogStream(WARNING, "BT") << "Intel BT in bootloader mode (FW not loaded by UEFI)"; - KernelLogStream(WARNING, "BT") << "Bluetooth requires firmware download for full functionality"; - } else { - KernelLogStream(INFO, "BT") << "Intel BT firmware variant: " - << base::hex << (uint64_t)ver.FwVariant; - } } + // Run the firmware download path. This reads the TLV version, and if + // the controller is in bootloader mode, loads the matching .sfi image + // from the ramdisk, secure-sends it, boots the operational firmware + // and applies DDC parameters. Returns true if the controller ends up + // operational (either already loaded, or freshly downloaded). + if (!DownloadIntelFirmware()) { + KernelLogStream(WARNING, "BT") + << "Intel BT firmware not loaded; limited functionality"; + // Standard init already issued an HCI Reset above. + return true; + } + + // The operational firmware just (re)booted. Give it a clean reset and + // re-enable the Intel vendor event mask before the generic HCI setup. + Hci::Reset(); + Hci::IntelSetEventMask(); return true; } @@ -137,10 +151,31 @@ namespace Drivers::USB::Bluetooth { // so it must be queued to receive them. Hci::StartEventPipe(); - // Intel-specific initialization (includes HCI Reset) + // The firmware download path reads the .sfi/.ddc images from the + // ramdisk (drive 0). Adapters present at boot enumerate during the + // xHCI port scan, which runs before the boot filesystems are mounted, + // so defer the firmware-dependent bring-up until VFS is available. + if (!Fs::Vfs::IsDriveRegistered(0)) { + g_initPending = true; + KernelLogStream(INFO, "BT") << "Transport up; deferring init until ramdisk is mounted"; + return; + } + + CompleteInit(); + } + + // ========================================================================= + // CompleteInit — firmware-dependent HCI bring-up (needs VFS/ramdisk) + // ========================================================================= + + static void CompleteInit() { + auto* dev = Xhci::GetDevice(g_slotId); + if (!dev) return; + + // Intel-specific initialization (firmware download + HCI Reset) bool didReset = false; if (IsIntelBt(dev->VendorId, dev->ProductId)) { - if (InitIntelBluetooth(slotId)) { + if (InitIntelBluetooth(g_slotId)) { didReset = true; // InitIntelBluetooth already sent HCI Reset } else { KernelLogStream(WARNING, "BT") << "Intel BT init failed, continuing with basic HCI"; @@ -164,6 +199,13 @@ namespace Drivers::USB::Bluetooth { << (uint64_t)g_bdAddr[1] << ":" << (uint64_t)g_bdAddr[0] << base::dec; } + // NOTE: an earlier build overrode the BD_ADDR via 0xFC31 to dodge a + // (since disproven) stale-bond theory. Removed: the BD_ADDR is an input + // to the SSP authentication confirmation, and if the override only + // changes the advertised address but not the address the firmware uses + // in the crypto, the two sides compute different confirmations and + // pairing fails (Simple Pairing Complete = 0x05). Use the real address. + // Read buffer size uint16_t aclLen = 0, aclNum = 0; uint8_t scoLen = 0; @@ -185,18 +227,40 @@ namespace Drivers::USB::Bluetooth { // Enable Simple Secure Pairing Hci::WriteSSPMode(1); - // Set event mask to receive relevant events - uint8_t eventMask[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0x00, 0x20}; + // Set event mask to receive relevant events. Octet 6 (events 0x31-0x38) + // MUST be enabled for Secure Simple Pairing: IO Capability Request + // (0x31, bit 48), IO Capability Response (0x32), User Confirmation + // Request (0x33), Simple Pairing Complete (0x36) all live there. It was + // 0x00 -> the controller started SSP but the IO-Capability Request event + // never reached us, so pairing always timed out with auth failure 0x05. + uint8_t eventMask[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xFF, 0x20}; Hci::SendCommand(Hci::OP_SET_EVENT_MASK, eventMask, 8); Hci::WaitCommandComplete(Hci::OP_SET_EVENT_MASK); // Enable inquiry + page scan (discoverable and connectable) Hci::WriteScanEnable(0x03); + // Load persisted bonds so previously-paired devices reconnect without + // re-pairing (VFS is up by the time CompleteInit runs). + Hci::LoadLinkKeys(); + g_initialized = true; KernelLogStream(OK, "BT") << "Bluetooth adapter initialized successfully"; } + // ========================================================================= + // ServiceDeferredInit — run boot-deferred bring-up once VFS is ready + // ========================================================================= + + void ServiceDeferredInit() { + if (!g_initPending || g_initialized) return; + if (!Fs::Vfs::IsDriveRegistered(0)) return; // ramdisk still not mounted + + g_initPending = false; + KernelLogStream(INFO, "BT") << "Ramdisk mounted; completing Bluetooth init"; + CompleteInit(); + } + // ========================================================================= // Public queries // ========================================================================= @@ -255,6 +319,8 @@ namespace Drivers::USB::Bluetooth { int Connect(const uint8_t* bdAddr, uint32_t timeoutMs) { if (!g_initialized || !bdAddr) return -1; + Hci::ResetEventTrace(); // capture the pairing/SSP event sequence + if (!Hci::CreateConnection(bdAddr)) return -1; // Wait for Connection Complete event @@ -271,7 +337,61 @@ namespace Drivers::USB::Bluetooth { for (int j = 0; j < 6; j++) { if (conn->BdAddr[j] != bdAddr[j]) { match = false; break; } } - if (match) return 0; + if (match) { + // The headset (in pairing mode) drives Secure Simple + // Pairing itself right after the ACL link comes up. Let + // authentication + encryption finish BEFORE opening any + // L2CAP/AVDTP channels: doing A2DP on a not-yet- + // authenticated link races with the pairing handshake and + // the headset drops us (reason 0x05). Drain events here + // so the IO-capability / user-confirm / link-key / encrypt + // events all get serviced. + // + // We are the initiator: request authentication so the + // controller starts Secure Simple Pairing (Link Key + // Request -> our negative reply -> IO Capability Request + // -> ... ). The headset does not start this on its own. + // NB this only works now that octet 6 of the event mask + // is enabled so the IO-Capability Request event actually + // reaches us; before that this produced 03 17 06 05. + Hci::AuthenticateLink(conn->Handle); + + uint64_t t0 = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - t0 < 5000) { + Xhci::PollEvents(); + Hci::DrainEvents(); + // Send queued pairing replies reliably (top-level, + // not nested under PollEvents). + Hci::ProcessPendingCommands(); + if (!conn->Active) break; // link dropped during pairing + if (conn->Encrypted) break; // authenticated + encrypted -> ready + for (int k = 0; k < 200; k++) asm volatile("pause" ::: "memory"); + } + + // Bring up the A2DP source stream (signaling + media + // channels, SBC negotiation) only once the link is + // secured. Without a media stream the headset also drops + // the link (reason 0x13), so this keeps it engaged too. + if (conn->Active) { + // Let the link settle after Encryption Change before + // dialing L2CAP: some sinks ignore a CONN_REQ that + // arrives the instant encryption completes. Drain + // (don't blind-sleep) so the ACL RX ring stays live. + uint64_t st = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - st < 300) { + Xhci::PollEvents(); + Hci::DrainEvents(); + for (int k = 0; k < 200; k++) asm volatile("pause" ::: "memory"); + } + A2dp::StartSource(); + } + // Persist any new link key now (process context), even if + // the link later dropped, so the disk write never stalls + // the nested pairing event handler. + Hci::FlushLinkKeys(); + Hci::DumpEventTrace(); // show the pairing/SSP sequence + return 0; + } } } @@ -280,6 +400,7 @@ namespace Drivers::USB::Bluetooth { } } + Hci::DumpEventTrace(); // show whatever events did arrive return -1; // Timeout } diff --git a/kernel/src/Drivers/USB/Bluetooth/Bluetooth.hpp b/kernel/src/Drivers/USB/Bluetooth/Bluetooth.hpp index 6804379..238113c 100644 --- a/kernel/src/Drivers/USB/Bluetooth/Bluetooth.hpp +++ b/kernel/src/Drivers/USB/Bluetooth/Bluetooth.hpp @@ -13,6 +13,12 @@ namespace Drivers::USB::Bluetooth { // Called by USB enumeration when a Bluetooth adapter is detected void RegisterAdapter(uint8_t slotId); + // Complete any firmware-dependent bring-up that was deferred because the + // adapter enumerated during the boot port scan, before the ramdisk (which + // holds the firmware images) was mounted. Safe to call unconditionally + // once the boot filesystems are up; a no-op if nothing is pending. + void ServiceDeferredInit(); + // Query adapter state bool IsInitialized(); uint8_t GetSlotId(); diff --git a/kernel/src/Drivers/USB/Bluetooth/Hci.cpp b/kernel/src/Drivers/USB/Bluetooth/Hci.cpp index f6b6596..a2e9c8c 100644 --- a/kernel/src/Drivers/USB/Bluetooth/Hci.cpp +++ b/kernel/src/Drivers/USB/Bluetooth/Hci.cpp @@ -6,6 +6,7 @@ #include "Hci.hpp" #include "L2cap.hpp" +#include #include #include #include @@ -31,14 +32,27 @@ namespace Drivers::USB::Bluetooth::Hci { static volatile uint32_t g_eventLen = 0; static volatile bool g_eventReady = false; - // ACL receive buffer - static uint8_t g_aclRxBuf[1024] = {}; - static volatile uint32_t g_aclRxLen = 0; - static volatile bool g_aclRxReady = false; + // ACL receive ring buffer. The bulk-IN callback (nested under PollEvents) + // only copies an incoming packet into a slot; DrainEvents() processes them + // at top level. A ring (not a single buffer) is required because the headset + // bursts many ACL packets at once -- the single buffer was overwriting and + // dropping the L2CAP Config Response, leaving our channel half-configured. + static constexpr int ACL_RX_SLOTS = 32; + static constexpr int ACL_RX_SLOT_SIZE = 1024; + static uint8_t g_aclRxRing[ACL_RX_SLOTS][ACL_RX_SLOT_SIZE] = {}; + static volatile uint16_t g_aclRxLens[ACL_RX_SLOTS] = {}; + static volatile uint8_t g_aclRxHead = 0; + static volatile uint8_t g_aclRxTail = 0; - // ACL transmit DMA buffer - static uint8_t* g_aclTxBuf = nullptr; - static uint64_t g_aclTxBufPhys = 0; + // ACL transmit DMA buffers (a ring, not one): SendAcl queues an async bulk + // OUT transfer, so two sends in quick succession (e.g. our Config Request + // then a Config Response, both fired while DrainEvents processes a burst) + // would have the second overwrite the first buffer before it is DMA'd to the + // wire -- corrupting the first packet. Rotate buffers to avoid that. + static constexpr int ACL_TX_SLOTS = 8; + static uint8_t* g_aclTxRing[ACL_TX_SLOTS] = {}; + static uint64_t g_aclTxRingPhys[ACL_TX_SLOTS] = {}; + static uint8_t g_aclTxSlot = 0; // HCI command DMA buffer (separate from ACL to avoid conflicts) static uint8_t* g_cmdDmaBuf = nullptr; @@ -52,11 +66,179 @@ namespace Drivers::USB::Bluetooth::Hci { static uint16_t g_aclMaxNum = 0; static volatile uint16_t g_aclPendingCount = 0; + // Diagnostic ACL data-path counters: TX submitted, TX completed (bulk OUT + // completion), RX received (bulk IN). Used to tell whether L2CAP signaling + // actually flows over ACL after encryption is enabled. + static volatile uint32_t g_aclTxCount = 0; + static volatile uint32_t g_aclTxDoneCount = 0; + static volatile uint32_t g_aclRxCount = 0; + // Incremented when an incoming ACL packet is dropped because the RX ring was + // full -- a nonzero value means a burst overran the ring (and could have + // dropped an L2CAP Config Response). Surfaced by DumpAclStats(). + static volatile uint32_t g_aclRxDropCount = 0; + // Inquiry results static InquiryDevice g_inquiryResults[MAX_INQUIRY_RESULTS] = {}; static volatile int g_inquiryResultCount = 0; static volatile bool g_inquiryActive = false; + // Set when the Intel "bootup" vendor event arrives after a firmware boot. + // Written from the USB transfer callback (ProcessEvent), polled by + // IntelBootFirmware, hence volatile. + static volatile bool g_intelBootup = false; + + // Latest Intel "secure send result" vendor event (0xFF sub-opcode 0x06). + // The bootloader uses this, not Command Complete, to report the outcome of + // secure-send (0xFC09) firmware download. Written from ProcessEvent. + static volatile bool g_secureResultValid = false; + static volatile uint8_t g_secureResult = 0; // 0 = success + static volatile uint8_t g_secureStatus = 0; // 0 = success + + // Firmware-download diagnostics. g_ssBytesSent / g_ssFragsSent accumulate + // the bytes / 0xFC09 fragments handed to the controller since the last + // ClearSecureSendResult(), so an async 0xFF/0x06 result or a fragment error + // can be pinned to an exact upload position. g_lastControlCC is the xHCI + // completion code of the most recent SendCommand() control transfer. + static volatile uint64_t g_ssBytesSent = 0; + static volatile uint32_t g_ssFragsSent = 0; + static volatile uint32_t g_lastControlCC = 0; + + // Lockless HCI-event trace for diagnosing the pairing/SSP sequence. + // ProcessEvent (which may run from the xHCI IRQ) only does an array write + // here -- no lock, no terminal I/O, so it cannot deadlock against g_termLock. + // DumpEventTrace() prints it from top-level (process) context. + static constexpr int EVT_TRACE_MAX = 48; + static volatile uint8_t g_evtTrace[EVT_TRACE_MAX] = {}; + static volatile uint8_t g_evtTraceCount = 0; + // Status byte of the last Simple Pairing Complete (0x36) / Auth Complete + // (0x06) / Disconnection (0x05) -- captured to find WHY pairing fails. + static volatile uint8_t g_lastSppStatus = 0xEE; + static volatile uint8_t g_lastAuthStatus = 0xEE; + static volatile uint8_t g_lastDiscReason = 0xEE; + + // Pending-command queue. Pairing replies (IO-cap / user-confirm / link-key) + // are triggered from event handlers running NESTED under PollEvents, where a + // command can only be fire-and-forget (the reentrancy guard makes a nested + // wait a no-op). Fire-and-forget proved unreliable for SSP -- the IO-cap + // value feeds the authentication confirmation, so a late/garbled reply makes + // the DHKey check fail (Simple Pairing Complete status 0x05). Instead the + // handlers ENQUEUE the reply here; ProcessPendingCommands() sends it later + // from top-level (process) context with a real, confirmed transfer. + struct PendingHciCmd { uint16_t opcode; uint8_t len; uint8_t params[16]; }; + static PendingHciCmd g_pending[16] = {}; + static volatile uint8_t g_pendingHead = 0; + static volatile uint8_t g_pendingTail = 0; + + static void EnqueueHciCmd(uint16_t opcode, const uint8_t* params, uint8_t len) { + uint8_t next = (uint8_t)((g_pendingHead + 1) & 15); + if (next == g_pendingTail) return; // full -> drop (should never happen) + if (len > 16) len = 16; + g_pending[g_pendingHead].opcode = opcode; + g_pending[g_pendingHead].len = len; + for (uint8_t i = 0; i < len; i++) g_pending[g_pendingHead].params[i] = params[i]; + g_pendingHead = next; + } + + // ========================================================================= + // Bonded-device link key store + // ========================================================================= + // Persisted to disk so a pairing survives reboots. Without it a once-paired + // device challenges us for the link key on reconnect, we have nothing to + // answer with, and authentication fails -> the remote drops the link with + // disconnect reason 0x05. On EVT_LINK_KEY_NOTIFICATION we cache the new key + // (RAM, marked dirty); FlushLinkKeys() writes it from process context so the + // disk I/O never blocks mid-pairing while nested under PollEvents. + static constexpr int MAX_BONDS = 8; + static constexpr uint32_t LINK_KEY_MAGIC = 0x314B5442; // 'BTK1' + + struct StoredLinkKey { + uint8_t addr[6]; + uint8_t key[16]; + bool valid; + }; + static StoredLinkKey g_bonds[MAX_BONDS] = {}; + static bool g_bondsDirty = false; + + static bool AddrEq(const uint8_t* a, const uint8_t* b) { + for (int i = 0; i < 6; i++) if (a[i] != b[i]) return false; + return true; + } + + static int FindBondIndex(const uint8_t* addr) { + for (int i = 0; i < MAX_BONDS; i++) { + if (g_bonds[i].valid && AddrEq(g_bonds[i].addr, addr)) return i; + } + return -1; + } + + static void StoreLinkKey(const uint8_t* addr, const uint8_t* key) { + int idx = FindBondIndex(addr); + if (idx < 0) { + for (int i = 0; i < MAX_BONDS; i++) { + if (!g_bonds[i].valid) { idx = i; break; } + } + if (idx < 0) idx = 0; // table full: recycle the first slot + } + memcpy(g_bonds[idx].addr, addr, 6); + memcpy(g_bonds[idx].key, key, 16); + g_bonds[idx].valid = true; + g_bondsDirty = true; // FlushLinkKeys() persists from safe context + } + + // On-disk layout: [magic u32][MAX_BONDS x { addr[6], key[16], valid[1] }]. + static constexpr uint64_t LINK_KEY_BLOB_SIZE = 4 + MAX_BONDS * 23; + + void LoadLinkKeys() { + Fs::Vfs::BackendFile f; + if (Fs::Vfs::OpenBackendFile("0:/os/btkeys.bin", f) < 0) return; // none stored yet + uint64_t size = Fs::Vfs::GetBackendFileSize(f); + if (size < LINK_KEY_BLOB_SIZE) { Fs::Vfs::CloseBackendFile(f); return; } + + uint8_t blob[LINK_KEY_BLOB_SIZE]; + Fs::Vfs::ReadBackendFile(f, blob, 0, LINK_KEY_BLOB_SIZE); + Fs::Vfs::CloseBackendFile(f); + + uint32_t magic = (uint32_t)blob[0] | ((uint32_t)blob[1] << 8) + | ((uint32_t)blob[2] << 16) | ((uint32_t)blob[3] << 24); + if (magic != LINK_KEY_MAGIC) return; + + int off = 4, n = 0; + for (int i = 0; i < MAX_BONDS; i++) { + memcpy(g_bonds[i].addr, &blob[off], 6); off += 6; + memcpy(g_bonds[i].key, &blob[off], 16); off += 16; + g_bonds[i].valid = blob[off++] != 0; + if (g_bonds[i].valid) n++; + } + g_bondsDirty = false; + KernelLogStream(INFO, "BT-HCI") << "Loaded " << (uint64_t)n << " bonded device key(s)"; + } + + void FlushLinkKeys() { + if (!g_bondsDirty) return; + + uint8_t blob[LINK_KEY_BLOB_SIZE] = {}; + blob[0] = (uint8_t)(LINK_KEY_MAGIC); + blob[1] = (uint8_t)(LINK_KEY_MAGIC >> 8); + blob[2] = (uint8_t)(LINK_KEY_MAGIC >> 16); + blob[3] = (uint8_t)(LINK_KEY_MAGIC >> 24); + int off = 4; + for (int i = 0; i < MAX_BONDS; i++) { + memcpy(&blob[off], g_bonds[i].addr, 6); off += 6; + memcpy(&blob[off], g_bonds[i].key, 16); off += 16; + blob[off++] = g_bonds[i].valid ? 1 : 0; + } + + Fs::Vfs::BackendFile f; + if (Fs::Vfs::CreateBackendFile("0:/os/btkeys.bin", f) < 0) { + KernelLogStream(WARNING, "BT-HCI") << "Could not open link key store for writing"; + return; + } + Fs::Vfs::WriteBackendFile(f, blob, 0, LINK_KEY_BLOB_SIZE); + Fs::Vfs::CloseBackendFile(f); + g_bondsDirty = false; + KernelLogStream(OK, "BT-HCI") << "Link key store persisted"; + } + // ========================================================================= // USB transfer callback // ========================================================================= @@ -93,18 +275,38 @@ namespace Drivers::USB::Bluetooth::Hci { // Re-queue interrupt transfer for next event Xhci::QueueInterruptTransfer(slotId); - } else if (epDci == bulkInDci && data && length > 0) { - // ACL data received on bulk IN - uint32_t copyLen = length; - if (copyLen > sizeof(g_aclRxBuf)) copyLen = sizeof(g_aclRxBuf); - memcpy(g_aclRxBuf, data, copyLen); - g_aclRxLen = copyLen; - g_aclRxReady = true; + } else if (epDci == bulkInDci) { + // ACL data received on bulk IN -> copy into the ring; processed by + // DrainEvents() at top level (do NOT process here, nested). + // Only enqueue a packet big enough to carry an L2CAP header (ACL + // header + L2CAP header = 8 bytes). Smaller completions are ZLP / + // re-arm artifacts and the firmware-phase bulk-IN runts (4-7 bytes, + // the old "rx flood") -- ProcessPacket would reject them anyway, and + // dropping them here keeps the ring + rx stats clean. We STILL + // re-arm on every completion below (the bulk IN must keep cycling to + // absorb the device's ~635 KB cc=4 glitch during firmware download). + if (data && length >= sizeof(AclHeader) + 4) { + g_aclRxCount++; + uint8_t next = (uint8_t)((g_aclRxHead + 1) % ACL_RX_SLOTS); + if (next != g_aclRxTail) { // ring not full + uint32_t copyLen = length; + if (copyLen > ACL_RX_SLOT_SIZE) copyLen = ACL_RX_SLOT_SIZE; + memcpy(g_aclRxRing[g_aclRxHead], data, copyLen); + g_aclRxLens[g_aclRxHead] = (uint16_t)copyLen; + g_aclRxHead = next; + } else { + g_aclRxDropCount++; // ring overran -> a packet was lost + } + } - // Re-queue bulk IN transfer - Xhci::QueueBulkInTransfer(slotId, nullptr, 0, dev->BulkInMaxPacket); + // Re-queue bulk IN transfer (only on a real success/short completion; + // the error path passes data==nullptr and is handled elsewhere). + if (data) { + Xhci::QueueBulkInTransfer(slotId, nullptr, 0, dev->BulkInMaxPacket); + } } else if (epDci == (dev->BulkOutEpNum ? (uint8_t)(dev->BulkOutEpNum * 2) : (uint8_t)0)) { // Bulk OUT completion — decrement pending count + g_aclTxDoneCount++; if (g_aclPendingCount > 0) g_aclPendingCount--; } } @@ -145,8 +347,10 @@ namespace Drivers::USB::Bluetooth::Hci { g_cmdDmaBuf = (uint8_t*)Memory::g_pfa->AllocateZeroed(); g_cmdDmaBufPhys = Memory::SubHHDM(g_cmdDmaBuf); - g_aclTxBuf = (uint8_t*)Memory::g_pfa->AllocateZeroed(); - g_aclTxBufPhys = Memory::SubHHDM(g_aclTxBuf); + for (int i = 0; i < ACL_TX_SLOTS; i++) { + g_aclTxRing[i] = (uint8_t*)Memory::g_pfa->AllocateZeroed(); + g_aclTxRingPhys[i] = Memory::SubHHDM(g_aclTxRing[i]); + } // NOTE: Do NOT queue interrupt IN or bulk IN transfers here. // The BT controller is not yet HCI-initialized and may misbehave. @@ -156,7 +360,16 @@ namespace Drivers::USB::Bluetooth::Hci { KernelLogStream(OK, "BT-HCI") << "HCI transport initialized on slot " << (uint64_t)slotId; } - // Start receiving HCI events and ACL data — call after HCI init sequence + // Start receiving HCI events and ACL data — call after HCI init sequence. + // Arms BOTH the interrupt IN (events) and the bulk IN (ACL). The bulk IN + // MUST stay armed across the firmware download: on this controller the device + // glitches a USB transaction error (cc=4) near ~635 KB of the upload, and an + // armed bulk IN ABSORBS it (a benign cc=4 on the bulk endpoint) so the + // interrupt-IN event pipe survives and the download completes. Deferring the + // bulk-IN arm (build 40) moved that cc=4 onto the interrupt IN and wedged the + // download at 635 KB -- reverted. The harmless firmware-phase bulk-IN runts + // (4-7 byte completions) are filtered at enqueue in TransferCallback so they + // never pollute the RX ring. void StartEventPipe() { if (!g_initialized) return; @@ -207,6 +420,8 @@ namespace Drivers::USB::Bluetooth::Hci { g_cmdDmaBuf, false); // dirIn = false (host to device) + g_lastControlCC = cc; + if (cc != Xhci::CC_SUCCESS) { KernelLogStream(WARNING, "BT-HCI") << "SendCommand failed, opcode=" << base::hex << (uint64_t)opcode << " cc=" << base::dec << (uint64_t)cc; @@ -222,6 +437,12 @@ namespace Drivers::USB::Bluetooth::Hci { bool WaitCommandComplete(uint16_t opcode, uint8_t* outParams, uint8_t maxLen, uint32_t timeoutMs) { + // Nested inside PollEvents (an event handler issued this command): we + // cannot wait -- a nested PollEvents is a no-op, so the Command Complete + // is reaped by the active PollEvents after we return. The command was + // already submitted (fire-and-forget); report success. + if (Xhci::InPollContext()) return true; + uint64_t start = Timekeeping::GetMilliseconds(); while (Timekeeping::GetMilliseconds() - start < timeoutMs) { @@ -275,6 +496,9 @@ namespace Drivers::USB::Bluetooth::Hci { // ========================================================================= bool WaitCommandStatus(uint16_t opcode, uint32_t timeoutMs) { + // See WaitCommandComplete: cannot wait when nested under PollEvents. + if (Xhci::InPollContext()) return true; + uint64_t start = Timekeeping::GetMilliseconds(); while (Timekeeping::GetMilliseconds() - start < timeoutMs) { @@ -311,25 +535,44 @@ namespace Drivers::USB::Bluetooth::Hci { // ========================================================================= bool SendAcl(uint16_t handle, uint16_t pbFlag, const uint8_t* data, uint16_t len) { - if (!g_initialized || !g_aclTxBuf) return false; + if (!g_initialized || !g_aclTxRing[0]) return false; if (len + sizeof(AclHeader) > 4096) return false; // Single page DMA buffer + // Use the next TX ring slot so a rapid second send can't overwrite this + // packet before its bulk OUT transfer DMAs it to the wire. + uint8_t* txBuf = g_aclTxRing[g_aclTxSlot]; + uint64_t txPhys = g_aclTxRingPhys[g_aclTxSlot]; + g_aclTxSlot = (uint8_t)((g_aclTxSlot + 1) % ACL_TX_SLOTS); + // Build ACL packet in DMA buffer - auto* hdr = (AclHeader*)g_aclTxBuf; + auto* hdr = (AclHeader*)txBuf; hdr->HandleFlags = (handle & 0x0FFF) | pbFlag; hdr->DataLength = len; if (data && len > 0) { - memcpy(g_aclTxBuf + sizeof(AclHeader), data, len); + memcpy(txBuf + sizeof(AclHeader), data, len); } uint32_t totalLen = sizeof(AclHeader) + len; g_aclPendingCount++; - Xhci::QueueBulkOutTransfer(g_slotId, g_aclTxBuf, g_aclTxBufPhys, totalLen); + g_aclTxCount++; + Xhci::QueueBulkOutTransfer(g_slotId, txBuf, txPhys, totalLen); return true; } + uint16_t AclPendingCount() { return g_aclPendingCount; } + uint16_t AclMaxPackets() { return g_aclMaxNum; } + + void DumpAclStats() { + KernelLogStream(INFO, "BT-HCI") << "ACL stats: tx=" << (uint64_t)g_aclTxCount + << " txDone=" << (uint64_t)g_aclTxDoneCount + << " rx=" << (uint64_t)g_aclRxCount + << " rxDrop=" << (uint64_t)g_aclRxDropCount + << " pending=" << (uint64_t)g_aclPendingCount + << " bufNum=" << (uint64_t)g_aclMaxNum; + } + // ========================================================================= // ProcessEvent — handle HCI events // ========================================================================= @@ -341,6 +584,17 @@ namespace Drivers::USB::Bluetooth::Hci { uint8_t evtParamLen = data[1]; const uint8_t* params = data + 2; + // Record into the lockless trace (safe from the IRQ path: array write + // only, no lock / no terminal I/O). DumpEventTrace() prints it later + // from top-level context. + if (evtCode != EVT_NUM_COMPLETED_PACKETS && g_evtTraceCount < EVT_TRACE_MAX) { + g_evtTrace[g_evtTraceCount++] = evtCode; + } + // status byte = params[0] for these (Disconnection: status,handle,reason) + if (evtCode == EVT_SIMPLE_PAIRING_COMPLETE && evtParamLen >= 1) g_lastSppStatus = params[0]; + if (evtCode == EVT_AUTH_COMPLETE && evtParamLen >= 1) g_lastAuthStatus = params[0]; + if (evtCode == EVT_DISCONNECTION_COMPLETE && evtParamLen >= 4) g_lastDiscReason = params[3]; + switch (evtCode) { case EVT_CONNECTION_COMPLETE: { if (evtParamLen >= 11) { @@ -430,18 +684,68 @@ namespace Drivers::USB::Bluetooth::Hci { memcpy(reply, ¶ms[0], 6); // BD_ADDR reply[6] = 0x03; // IO Capability: NoInputNoOutput reply[7] = 0x00; // OOB data not present - reply[8] = 0x00; // Authentication requirements: MITM not required - SendCommand(OP_IO_CAPABILITY_REPLY, reply, 9); - WaitCommandComplete(OP_IO_CAPABILITY_REPLY, nullptr, 0, 1000); + reply[8] = 0x04; // Auth req: MITM not required, General Bonding + // (0x04, not 0x00 "No Bonding") so a + // persistent link key is created -> the bond + // survives reboots via the link-key store. + // Queue for reliable top-level delivery (see EnqueueHciCmd): + // the IO-cap value feeds the SSP confirmation, so it must be + // sent intact, not fire-and-forget. + EnqueueHciCmd(OP_IO_CAPABILITY_REPLY, reply, 9); } break; } case EVT_USER_CONFIRM_REQUEST: { if (evtParamLen >= 6) { - // Auto-confirm - SendCommand(OP_USER_CONFIRM_REPLY, ¶ms[0], 6); - WaitCommandComplete(OP_USER_CONFIRM_REPLY, nullptr, 0, 1000); + // Auto-confirm (Just Works). Queue for reliable top-level + // delivery -- a late confirm makes pairing fail (spp=0x05). + EnqueueHciCmd(OP_USER_CONFIRM_REPLY, ¶ms[0], 6); + } + break; + } + + case EVT_LINK_KEY_REQUEST: { + if (evtParamLen >= 6) { + int idx = FindBondIndex(¶ms[0]); + if (idx >= 0) { + // We remember this device: hand back the stored key so + // authentication succeeds without re-pairing. + uint8_t reply[22]; + memcpy(reply, ¶ms[0], 6); + memcpy(&reply[6], g_bonds[idx].key, 16); + EnqueueHciCmd(OP_LINK_KEY_REQ_REPLY, reply, 22); + } else { + // Unknown device: tell the controller we have no key so + // the remote falls back to fresh Secure Simple Pairing + // (Just Works) instead of failing auth (reason 0x05). + EnqueueHciCmd(OP_LINK_KEY_REQ_NEG_REPLY, ¶ms[0], 6); + } + } + break; + } + + case EVT_LINK_KEY_NOTIFICATION: { + // Pairing produced a new link key: BD_ADDR[6] + key[16] + type[1]. + // Cache it now (fast); FlushLinkKeys() persists it to disk from + // process context so the disk write never stalls this nested + // event handler mid-pairing. + if (evtParamLen >= 22) { + StoreLinkKey(¶ms[0], ¶ms[6]); + KernelLogStream(INFO, "BT-HCI") << "Link key notification (new bond cached)"; + } + break; + } + + case EVT_AUTH_COMPLETE: { + // Authentication succeeded -> turn on encryption. The link must + // be encrypted before A2DP; without this the headset finishes + // pairing, waits for encryption that never comes, and drops us + // (reason 0x05). Set Connection Encryption = handle(2) + 0x01. + // Queue for reliable top-level delivery. + if (evtParamLen >= 3 && params[0] == 0) { + uint8_t enc[3] = { params[1], params[2], 0x01 }; + EnqueueHciCmd(OP_SET_CONN_ENCRYPT, enc, 3); } break; } @@ -542,6 +846,31 @@ namespace Drivers::USB::Bluetooth::Hci { break; } + case EVT_VENDOR_SPECIFIC: { + // Intel vendor events carry a sub-opcode in the first byte. + // 0x02 = "bootup" (operational firmware booted after 0xFC01) + // 0x06 = "secure send result": result(1) opcode(2) status(1) + uint8_t sub = (evtParamLen >= 1) ? params[0] : 0xFF; + if (sub == 0x02) { + g_intelBootup = true; + } else if (sub == 0x06 && evtParamLen >= 5) { + g_secureResult = params[1]; + g_secureStatus = params[4]; + g_secureResultValid = true; + // A healthy bootloader stays silent until the final + // fragment, so the byte/frag position here pins exactly + // where it reacted -- and a non-zero result/status mid + // upload is the signature of an active rejection. + bool err = (params[1] != 0) || (params[4] != 0); + KernelLogStream(err ? ERROR : INFO, "BT-HCI") << "secure-send result=" + << base::hex << (uint64_t)params[1] << " status=" + << (uint64_t)params[4] << base::dec + << " @ byte " << g_ssBytesSent + << " frag " << (uint64_t)g_ssFragsSent; + } + break; + } + default: break; } @@ -658,6 +987,195 @@ namespace Drivers::USB::Bluetooth::Hci { return true; } + // ========================================================================= + // Intel firmware download primitives + // ========================================================================= + + int ReadIntelVersionTlv(uint8_t* outBuf, int maxLen) { + if (!outBuf || maxLen <= 0) return -1; + + uint8_t param = 0xFF; + if (!SendCommand(OP_INTEL_READ_VERSION, ¶m, 1)) return -1; + + // Wait for the matching Command Complete and copy the *actually + // received* return parameters. The TLV version response can exceed a + // single interrupt packet; WaitCommandComplete trusts the event's + // declared length, so we read g_eventBuf/g_eventLen directly to avoid + // copying past what the controller delivered. + uint64_t start = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - start < 2000) { + Xhci::PollEvents(); + + if (g_eventReady) { + g_eventReady = false; + if (g_eventLen >= 5 && g_eventBuf[0] == EVT_COMMAND_COMPLETE) { + uint16_t op = (uint16_t)g_eventBuf[3] | ((uint16_t)g_eventBuf[4] << 8); + if (op == OP_INTEL_READ_VERSION) { + // Return params begin at byte 5 (status, then TLVs). + int avail = (int)g_eventLen - 5; + if (avail < 0) avail = 0; + int n = (avail < maxLen) ? avail : maxLen; + memcpy(outBuf, &g_eventBuf[5], n); + return n; + } + } + } + + for (int j = 0; j < 100; j++) asm volatile("" ::: "memory"); + } + + KernelLogStream(WARNING, "BT-HCI") << "ReadIntelVersionTlv timeout"; + return -1; + } + + void ClearSecureSendResult() { + g_secureResultValid = false; + g_ssBytesSent = 0; + g_ssFragsSent = 0; + } + + bool PeekSecureSendResult(uint8_t* outResult, uint8_t* outStatus) { + if (!g_secureResultValid) return false; + if (outResult) *outResult = g_secureResult; + if (outStatus) *outStatus = g_secureStatus; + return true; + } + + void ResetEventTrace() { + g_evtTraceCount = 0; + g_lastSppStatus = 0xEE; + g_lastAuthStatus = 0xEE; + g_lastDiscReason = 0xEE; + } + + void DumpEventTrace() { + // Top-level only (acquires g_termLock). Shows the HCI-event sequence so + // a stalled pairing/SSP flow is visible, e.g. whether an IO Capability + // Request (0x31) / User Confirm (0x33) arrive after a link-key reply, or + // the link just goes 0x03 (connect) -> 0x17 (link-key req) -> 0x05 + // (disconnect/auth-fail) with no pairing in between. + KernelLogStream s(INFO, "BT-HCI"); + s << "event trace:"; + uint8_t n = g_evtTraceCount; + if (n > EVT_TRACE_MAX) n = EVT_TRACE_MAX; + for (uint8_t i = 0; i < n; i++) { + s << " " << base::hex << (uint64_t)g_evtTrace[i] << base::dec; + } + s << " | spp=" << base::hex << (uint64_t)g_lastSppStatus + << " auth=" << (uint64_t)g_lastAuthStatus + << " disc=" << (uint64_t)g_lastDiscReason << base::dec; + } + + void ProcessPendingCommands() { + // Top-level only: drains queued pairing replies with real, confirmed + // control transfers. Must NOT be called from inside PollEvents. + if (Xhci::InPollContext()) return; + while (g_pendingTail != g_pendingHead) { + PendingHciCmd c = g_pending[g_pendingTail]; + g_pendingTail = (uint8_t)((g_pendingTail + 1) & 15); + SendCommand(c.opcode, c.params, c.len); + // Set Connection Encryption returns Command Status (not Complete), + // so wait on that instead of burning a 1s timeout that delays A2DP. + if (c.opcode == OP_SET_CONN_ENCRYPT) { + WaitCommandStatus(c.opcode, 1000); + } else { + WaitCommandComplete(c.opcode, nullptr, 0, 1000); + } + } + } + + bool WaitSecureSendResult(uint32_t timeoutMs, uint8_t* outResult, uint8_t* outStatus) { + uint64_t start = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - start < timeoutMs) { + Xhci::PollEvents(); + if (g_secureResultValid) { + if (outResult) *outResult = g_secureResult; + if (outStatus) *outStatus = g_secureStatus; + return true; + } + for (int j = 0; j < 100; j++) asm volatile("" ::: "memory"); + } + return false; + } + + bool IntelSecureSend(uint8_t fragmentType, const uint8_t* data, uint32_t len) { + uint32_t off = 0; + while (len > 0) { + uint8_t frag = (len > 252) ? 252 : (uint8_t)len; + + // Fragment: [type][up to 252 data bytes] + uint8_t buf[253]; + buf[0] = fragmentType; + memcpy(&buf[1], data + off, frag); + + // The Intel bootloader does NOT return a Command Complete for + // 0xFC09 (Linux's btusb injects a fake one). Pacing comes from the + // synchronous USB transfer in SendCommand; the download outcome is + // reported asynchronously via the 0xFF/0x06 secure-send result + // event. So: send, drain events, and move on -- do not block per + // fragment waiting for a reply that never arrives. + if (!SendCommand(OP_INTEL_SECURE_SEND, buf, (uint8_t)(frag + 1))) { + KernelLogStream(ERROR, "BT-HCI") << "Secure send transport error: type=" + << base::hex << (uint64_t)fragmentType << " cc=" << (uint64_t)g_lastControlCC + << base::dec << " at frag #" << (uint64_t)g_ssFragsSent + << " byte " << g_ssBytesSent; + return false; + } + Xhci::PollEvents(); + + g_ssBytesSent += frag; + g_ssFragsSent++; + + len -= frag; + off += frag; + } + return true; + } + + bool IntelBootFirmware(uint32_t bootAddr, uint32_t timeoutMs) { + g_intelBootup = false; + + // intel_reset: reset_type=0x00, patch_enable=0x01, ddc_reload=0x00, + // boot_option=0x01 (boot at specified address), boot_param (LE32). + uint8_t params[8] = { + 0x00, 0x01, 0x00, 0x01, + (uint8_t)(bootAddr & 0xFF), + (uint8_t)((bootAddr >> 8) & 0xFF), + (uint8_t)((bootAddr >> 16) & 0xFF), + (uint8_t)((bootAddr >> 24) & 0xFF), + }; + + // Fire and forget: the controller reboots into operational firmware + // and signals readiness via the Intel bootup vendor event rather than + // a Command Complete for 0xFC01. + if (!SendCommand(OP_INTEL_RESET, params, sizeof(params))) return false; + + uint64_t start = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - start < timeoutMs) { + Xhci::PollEvents(); + if (g_intelBootup) return true; + for (int j = 0; j < 100; j++) asm volatile("" ::: "memory"); + } + + KernelLogStream(ERROR, "BT-HCI") << "Timed out waiting for Intel bootup event"; + return false; + } + + bool IntelWriteDdcRecord(const uint8_t* record, uint8_t recordLen) { + if (!record || recordLen == 0) return false; + if (!SendCommand(OP_INTEL_DDC_CONFIG_WRITE, record, recordLen)) return false; + uint8_t st[4] = {}; + if (!WaitCommandComplete(OP_INTEL_DDC_CONFIG_WRITE, st, sizeof(st), 2000)) return false; + return st[0] == 0; + } + + bool IntelSetEventMask() { + // Enables the Intel vendor events used during/after firmware load. + uint8_t mask[8] = { 0x87, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + if (!SendCommand(OP_INTEL_SET_EVENT_MASK, mask, sizeof(mask))) return false; + return WaitCommandComplete(OP_INTEL_SET_EVENT_MASK, nullptr, 0, 2000); + } + bool WriteLocalName(const char* name) { uint8_t params[248] = {}; int i = 0; @@ -695,6 +1213,24 @@ namespace Drivers::USB::Bluetooth::Hci { return WaitCommandStatus(OP_ACCEPT_CONN_REQ); } + bool AuthenticateLink(uint16_t handle) { + // Request authentication on an established ACL link. As the connection + // initiator we must drive this: a bonded headset will not start pairing + // on its own for a device it believes it already knows, so the link just + // sits unauthenticated until it drops (reason 0x05). This kicks off the + // flow -- the controller raises a Link Key Request (we answer with a + // stored key, or negatively to force fresh Secure Simple Pairing). + uint8_t params[2] = { (uint8_t)(handle & 0xFF), (uint8_t)(handle >> 8) }; + if (!SendCommand(OP_AUTH_REQUESTED, params, 2)) return false; + return WaitCommandStatus(OP_AUTH_REQUESTED, 2000); + } + + bool SetBdAddr(const uint8_t* addr) { + // Intel 0xFC31: 6-byte BD_ADDR, little-endian (same order as ReadBdAddr). + if (!SendCommand(OP_INTEL_WRITE_BD_ADDR, addr, 6)) return false; + return WaitCommandComplete(OP_INTEL_WRITE_BD_ADDR, nullptr, 0, 2000); + } + bool Disconnect(uint16_t handle, uint8_t reason) { uint8_t params[3] = { (uint8_t)(handle & 0xFF), @@ -786,12 +1322,32 @@ namespace Drivers::USB::Bluetooth::Hci { g_eventReady = false; } - // Drain ACL data - if (g_aclRxReady) { - g_aclRxReady = false; - if (g_aclRxLen > 0) { - ProcessAcl(g_aclRxBuf, g_aclRxLen); + // Drain all queued ACL packets (process the whole ring, not just one, + // so a burst is never left unhandled). + while (g_aclRxTail != g_aclRxHead) { + uint8_t slot = g_aclRxTail; + uint16_t pl = g_aclRxLens[slot]; + + // Diagnostic (top-level, safe to log -- not the IRQ path): trace the + // first few ACL packets so the rx flood / missing Config Response is + // identifiable in ONE boot. Layout: ACL header(4) + L2CAP header(4), + // so the L2CAP CID is at bytes 6-7; on the signaling channel (CID 1) + // byte 8 is the command code (0x03 CONN_RSP, 0x04 CONFIG_REQ, + // 0x05 CONFIG_RSP). A flood of len==maxpacket junk CIDs vs real + // cid=0001 code=05 packets tells the two failure modes apart. + static uint32_t s_rxTraced = 0; + if (s_rxTraced < 24 && pl >= 8) { + const uint8_t* d = g_aclRxRing[slot]; + uint16_t cid = (uint16_t)d[6] | ((uint16_t)d[7] << 8); + uint8_t code = (pl >= 9) ? d[8] : 0; + KernelLogStream(INFO, "BT-HCI") << "rx[" << (uint64_t)s_rxTraced + << "] len=" << (uint64_t)pl << " cid=" << base::hex << (uint64_t)cid + << " code=" << (uint64_t)code << base::dec; + s_rxTraced++; } + + ProcessAcl(g_aclRxRing[slot], pl); + g_aclRxTail = (uint8_t)((g_aclRxTail + 1) % ACL_RX_SLOTS); } } diff --git a/kernel/src/Drivers/USB/Bluetooth/Hci.hpp b/kernel/src/Drivers/USB/Bluetooth/Hci.hpp index 47e4e2b..009e4eb 100644 --- a/kernel/src/Drivers/USB/Bluetooth/Hci.hpp +++ b/kernel/src/Drivers/USB/Bluetooth/Hci.hpp @@ -30,6 +30,8 @@ namespace Drivers::USB::Bluetooth::Hci { constexpr uint16_t OP_DISCONNECT = 0x0406; constexpr uint16_t OP_ACCEPT_CONN_REQ = 0x0409; constexpr uint16_t OP_REJECT_CONN_REQ = 0x040A; + constexpr uint16_t OP_LINK_KEY_REQ_REPLY = 0x040B; + constexpr uint16_t OP_LINK_KEY_REQ_NEG_REPLY = 0x040C; constexpr uint16_t OP_AUTH_REQUESTED = 0x0411; constexpr uint16_t OP_SET_CONN_ENCRYPT = 0x0413; constexpr uint16_t OP_IO_CAPABILITY_REPLY = 0x042B; @@ -63,6 +65,8 @@ namespace Drivers::USB::Bluetooth::Hci { constexpr uint16_t OP_INTEL_RESET = 0xFC01; constexpr uint16_t OP_INTEL_SET_EVENT_MASK = 0xFC52; constexpr uint16_t OP_INTEL_DDC_CONFIG_WRITE = 0xFC8B; + constexpr uint16_t OP_INTEL_SECURE_SEND = 0xFC09; + constexpr uint16_t OP_INTEL_WRITE_BD_ADDR = 0xFC31; // set adapter BD_ADDR // ========================================================================= // HCI event codes @@ -75,6 +79,8 @@ namespace Drivers::USB::Bluetooth::Hci { constexpr uint8_t EVT_DISCONNECTION_COMPLETE = 0x05; constexpr uint8_t EVT_AUTH_COMPLETE = 0x06; constexpr uint8_t EVT_ENCRYPT_CHANGE = 0x08; + constexpr uint8_t EVT_LINK_KEY_REQUEST = 0x17; + constexpr uint8_t EVT_LINK_KEY_NOTIFICATION = 0x18; constexpr uint8_t EVT_COMMAND_COMPLETE = 0x0E; constexpr uint8_t EVT_COMMAND_STATUS = 0x0F; constexpr uint8_t EVT_NUM_COMPLETED_PACKETS = 0x13; @@ -163,7 +169,10 @@ namespace Drivers::USB::Bluetooth::Hci { // Initialize HCI transport over USB for the given slot void Initialize(uint8_t slotId); - // Start receiving HCI events and ACL data (call after HCI init sequence) + // Start receiving HCI events and ACL data (call after HCI init sequence). + // Arms both the interrupt IN and the bulk IN; the bulk IN must stay armed + // through the firmware download (it absorbs the device's ~635 KB cc=4 glitch + // and keeps the event pipe alive -- see the definition). void StartEventPipe(); // Send an HCI command via USB control transfer (EP0) @@ -212,6 +221,53 @@ namespace Drivers::USB::Bluetooth::Hci { // Read Intel-specific version info bool ReadIntelVersion(IntelVersion* ver); + // ========================================================================= + // Intel firmware download primitives (bootloader mode) + // ========================================================================= + + // Read the Intel version response in TLV format (0xFC05 with parameter + // 0xFF). Copies the raw return parameters (byte 0 = status, followed by + // the TLV stream) into outBuf, bounded by the number of bytes actually + // received from the controller. Returns that length, or -1 on failure. + int ReadIntelVersionTlv(uint8_t* outBuf, int maxLen); + + // Intel "Secure Send" (0xFC09): pushes one logical fragment to the + // bootloader, split into <=252-byte chunks each prefixed with the + // fragment type (0x00 CSS init, 0x01 firmware data, 0x02 signature, + // 0x03 public key). The bootloader does not Command-Complete these; pacing + // is by USB transfer completion and the result arrives asynchronously as a + // 0xFF/0x06 secure-send result event (see WaitSecureSendResult). + bool IntelSecureSend(uint8_t fragmentType, const uint8_t* data, uint32_t len); + + // Reset / await the Intel "secure send result" vendor event (0xFF/0x06). + // Call ClearSecureSendResult() before a download phase, then + // WaitSecureSendResult() to read the outcome (result/status, 0 = success). + void ClearSecureSendResult(); + bool WaitSecureSendResult(uint32_t timeoutMs, uint8_t* outResult, uint8_t* outStatus); + + // Bonded-device link key persistence (so pairings survive reboots). + // LoadLinkKeys(): read the on-disk store once VFS is up. + // FlushLinkKeys(): write the store to disk if it changed -- call from + // process context (NOT an event handler), since it does blocking disk I/O. + void LoadLinkKeys(); + void FlushLinkKeys(); + + // Non-blocking peek at the most recent 0xFF/0x06 secure-send result without + // consuming it. Returns true if one has arrived since the last + // ClearSecureSendResult(). The payload loop uses this to catch a mid-stream + // rejection -- a healthy bootloader stays silent until the final fragment. + bool PeekSecureSendResult(uint8_t* outResult, uint8_t* outStatus); + + // Reset the controller into operational firmware at bootAddr (0xFC01) and + // wait for the Intel "bootup" vendor event. Returns true once booted. + bool IntelBootFirmware(uint32_t bootAddr, uint32_t timeoutMs = 5000); + + // Apply one DDC parameter record (record[0] = payload length) via 0xFC8B. + bool IntelWriteDdcRecord(const uint8_t* record, uint8_t recordLen); + + // Configure the Intel vendor event mask (0xFC52). + bool IntelSetEventMask(); + // Set local name bool WriteLocalName(const char* name); @@ -227,6 +283,33 @@ namespace Drivers::USB::Bluetooth::Hci { // Accept an incoming connection bool AcceptConnection(const uint8_t* bdAddr, uint8_t role); + // Request authentication on an ACL link (we are the connection initiator). + // Drives Link Key Request -> pairing; needed for bonded-device reconnects. + bool AuthenticateLink(uint16_t handle); + + // Set the adapter's BD_ADDR (Intel vendor command 0xFC31). Used to dodge a + // remote that holds a stale, un-clearable bond to our real address. + bool SetBdAddr(const uint8_t* addr); + + // Lockless HCI-event trace (diagnostic). Reset before a connection attempt, + // dump afterwards from top-level to see the pairing/SSP event sequence. + void ResetEventTrace(); + void DumpEventTrace(); + + // Send any queued pairing replies (IO-cap / user-confirm / link-key) with + // real confirmed transfers. Call from top-level (e.g. the connect loop), + // NOT from an event handler -- event handlers only enqueue. + void ProcessPendingCommands(); + + // Diagnostic: print ACL data-path counters (tx / txDone / rx / pending). + void DumpAclStats(); + + // ACL TX flow control: outstanding (un-acked) ACL packets, and the + // controller's ACL buffer count (Number-Of-Completed-Packets credits). The + // media writer throttles on these so it never overruns the controller. + uint16_t AclPendingCount(); + uint16_t AclMaxPackets(); + // Disconnect a connection bool Disconnect(uint16_t handle, uint8_t reason); diff --git a/kernel/src/Drivers/USB/Bluetooth/IntelFirmware.cpp b/kernel/src/Drivers/USB/Bluetooth/IntelFirmware.cpp new file mode 100644 index 0000000..aa0c44f --- /dev/null +++ b/kernel/src/Drivers/USB/Bluetooth/IntelFirmware.cpp @@ -0,0 +1,470 @@ +/* + * IntelFirmware.cpp + * Intel Bluetooth bootloader firmware download path + * + * Ports the btintel "TLV" bootloader sequence: read the version, derive the + * ibt--.sfi / .ddc file names, secure-send the signed RSA/ECDSA + * header and command-buffer payload, boot the operational image and apply + * the DDC parameters. The .sfi/.ddc files are staged on the ramdisk at + * 0:/os/firmware/intel/ by the userspace build. + * + * Copyright (c) 2026 Daniel Hammer +*/ + +#include "IntelFirmware.hpp" +#include "Hci.hpp" +#include +#include +#include +#include +#include +#include + +using namespace Kt; + +namespace Drivers::USB::Bluetooth { + + // ========================================================================= + // .sfi / TLV format constants (from drivers/bluetooth/btintel.{c,h}) + // ========================================================================= + + // CSS secure-boot header layout. + static constexpr uint32_t RSA_HEADER_LEN = 644; // RSA header + key + sig + static constexpr uint32_t ECDSA_HEADER_LEN = 320; // follows the RSA header + static constexpr uint32_t ECDSA_OFFSET = 644; + static constexpr uint32_t CSS_HEADER_OFFSET = 8; // version field offset + + static constexpr uint32_t RSA_HEADER_VER = 0x00010000; + static constexpr uint32_t HYBRID_HEADER_VER = 0x00069700; + static constexpr uint32_t ECDSA_HEADER_VER = 0x00020000; + + // The operational image embeds its reset/boot address in a final + // CMD_WRITE_BOOT_PARAMS HCI command. + static constexpr uint16_t CMD_WRITE_BOOT_PARAMS = 0xFC0E; + + // Image type (INTEL_TLV_IMAGE_TYPE value): 0x01 bootloader, 0x02 + // intermediate loader, 0x03 operational. + static constexpr uint8_t IMG_BOOTLOADER = 0x01; + static constexpr uint8_t IMG_OPERATIONAL = 0x03; + + // Version TLV type ids (enum INTEL_TLV_* starts at 0x10). + static constexpr uint8_t TLV_CNVI_TOP = 0x10; + static constexpr uint8_t TLV_CNVR_TOP = 0x11; + static constexpr uint8_t TLV_CNVI_BT = 0x12; + static constexpr uint8_t TLV_IMAGE_TYPE = 0x1C; + static constexpr uint8_t TLV_MIN_FW = 0x2D; + static constexpr uint8_t TLV_SBE_TYPE = 0x2F; + + // ========================================================================= + // Helpers + // ========================================================================= + + static uint32_t Rd32(const uint8_t* p) { + return (uint32_t)p[0] | ((uint32_t)p[1] << 8) + | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24); + } + + struct IntelTlvVersion { + uint32_t CnviTop = 0; + uint32_t CnvrTop = 0; + uint32_t CnviBt = 0; + uint8_t ImgType = 0; + uint8_t SbeType = 0xFF; // 0x00 RSA, 0x01 ECDSA, 0xFF unknown + bool SbeValid = false; + bool Valid = false; + }; + + static void ParseTlv(const uint8_t* buf, int len, IntelTlvVersion* v) { + int i = 0; + while (i + 2 <= len) { + uint8_t type = buf[i]; + uint8_t l = buf[i + 1]; + if (i + 2 + l > len) break; + const uint8_t* val = &buf[i + 2]; + + switch (type) { + case TLV_CNVI_TOP: if (l >= 4) v->CnviTop = Rd32(val); break; + case TLV_CNVR_TOP: if (l >= 4) v->CnvrTop = Rd32(val); break; + case TLV_CNVI_BT: if (l >= 4) v->CnviBt = Rd32(val); break; + case TLV_IMAGE_TYPE: if (l >= 1) v->ImgType = val[0]; break; + case TLV_SBE_TYPE: if (l >= 1) { v->SbeType = val[0]; v->SbeValid = true; } break; + default: break; + } + i += 2 + l; + } + // CNVI top is always present on a real TLV response. + v->Valid = (v->CnviTop != 0); + } + + // ibt-- packing: __swab16(((top & 0xfff) << 4) | ((top >> 24) & 0xf)) + static uint16_t CnvxPack(uint32_t top) { + uint16_t t = (uint16_t)(top & 0x0FFF); + uint8_t s = (uint8_t)((top >> 24) & 0x0F); + uint16_t packed = (uint16_t)((t << 4) | s); + return (uint16_t)((packed >> 8) | (packed << 8)); // __swab16 + } + + static uint8_t HwVariant(uint32_t cnviBt) { + return (uint8_t)((cnviBt >> 16) & 0x3F); + } + + static char HexDigit(uint8_t n) { + return (char)(n < 10 ? ('0' + n) : ('a' + n - 10)); + } + + // Build "0:/os/firmware/intel/ibt--." into out (>= 48 bytes). + static void BuildFwPath(char* out, uint16_t cnvi, uint16_t cnvr, const char* ext) { + const char* prefix = "0:/os/firmware/intel/ibt-"; + char* p = out; + while (*prefix) *p++ = *prefix++; + for (int sh = 12; sh >= 0; sh -= 4) *p++ = HexDigit((cnvi >> sh) & 0xF); + *p++ = '-'; + for (int sh = 12; sh >= 0; sh -= 4) *p++ = HexDigit((cnvr >> sh) & 0xF); + *p++ = '.'; + while (*ext) *p++ = *ext++; + *p = '\0'; + } + + // ========================================================================= + // Secure-boot header transmission + // ========================================================================= + + // Try one secure-boot header type. Layout: + // RSA : CSS 128 @0, pkey 256 @128, sig 256 @388 + // ECDSA: CSS 128 @644, pkey 96 @772, sig 96 @868 (after the RSA hdr) + // + // The CSS init fragment is sent and checked FIRST: a non-zero secure-send + // result (0xFF/0x06) means the controller's secure-boot engine rejected + // this header type, so we bail before blasting the ~200-512 byte key and + // signature -- sending those after a rejected CSS wedges EP0 and (since + // this runs on the boot path) freezes the kernel. Returns true only if the + // full header is accepted (or the controller stays silent, in which case + // the payload + bootup event remain the final gate). + static bool TryHeader(const uint8_t* fw, bool ecdsa) { + const uint32_t cssOff = ecdsa ? 644 : 0; + const uint32_t pkeyOff = ecdsa ? 644 + 128 : 128; + const uint32_t pkeyLen = ecdsa ? 96 : 256; + const uint32_t sigOff = ecdsa ? 644 + 224 : 388; + const uint32_t sigLen = ecdsa ? 96 : 256; + const char* name = ecdsa ? "ECDSA" : "RSA"; + + KernelLogStream(INFO, "BT-FW") << "Trying " << name << " secure-boot header"; + + uint8_t result = 0, status = 0; + + // 1. CSS header init -- check the result before committing key/sig. + Hci::ClearSecureSendResult(); + if (!Hci::IntelSecureSend(0x00, fw + cssOff, 128)) return false; + if (Hci::WaitSecureSendResult(1500, &result, &status) && (result || status)) { + KernelLogStream(WARNING, "BT-FW") << name << " CSS rejected (result=" + << base::hex << (uint64_t)result << " status=" << (uint64_t)status + << base::dec << ")"; + return false; + } + + // 2. Public key + signature. + Hci::ClearSecureSendResult(); + if (!Hci::IntelSecureSend(0x03, fw + pkeyOff, pkeyLen)) return false; + if (!Hci::IntelSecureSend(0x02, fw + sigOff, sigLen)) return false; + if (Hci::WaitSecureSendResult(2000, &result, &status) && (result || status)) { + KernelLogStream(WARNING, "BT-FW") << name << " header rejected (result=" + << base::hex << (uint64_t)result << " status=" << (uint64_t)status + << base::dec << ")"; + return false; + } + + KernelLogStream(OK, "BT-FW") << name << " secure-boot header accepted"; + return true; + } + + // Push the command-buffer payload starting at `offset`. Fragments are cut + // on HCI command boundaries and only flushed when 4-byte aligned, matching + // btintel_download_firmware_payload(). + static bool SendPayload(const uint8_t* fw, uint64_t size, uint64_t offset) { + uint64_t fwPtr = offset; + uint32_t fragLen = 0; + uint32_t sends = 0; + uint64_t start = Timekeeping::GetMilliseconds(); + + while (fwPtr < size) { + // Safety net: never let a stalled upload freeze the boot path. + if (Timekeeping::GetMilliseconds() - start > 30000) { + KernelLogStream(ERROR, "BT-FW") << "Payload upload stalled at " << fwPtr - offset + << "/" << (size - offset) << " bytes; aborting"; + return false; + } + uint64_t cmd = fwPtr + fragLen; + if (cmd + 3 > size) break; // truncated header + uint8_t plen = fw[cmd + 2]; + fragLen += 3 + plen; + if (fwPtr + fragLen > size) { + KernelLogStream(ERROR, "BT-FW") << "Firmware payload command overruns file"; + return false; + } + + if ((fragLen % 4) == 0) { + if (!Hci::IntelSecureSend(0x01, fw + fwPtr, fragLen)) { + KernelLogStream(ERROR, "BT-FW") << "Payload secure-send failed at offset " + << fwPtr; + return false; + } + fwPtr += fragLen; + fragLen = 0; + + // A healthy bootloader only emits an 0xFF/0x06 result on the + // final fragment. One arriving mid-stream with a non-zero + // result/status means it rejected what we just sent -- surface + // the exact offset instead of blasting the rest of the image + // into a wedged device (which then NAKs to a cc=4 on EP0). + uint8_t r = 0, s = 0; + if (Hci::PeekSecureSendResult(&r, &s) && (r || s)) { + KernelLogStream(ERROR, "BT-FW") << "Bootloader rejected payload at byte " + << (fwPtr - offset) << "/" << (size - offset) << " (result=" + << base::hex << (uint64_t)r << " status=" << (uint64_t)s + << base::dec << ")"; + return false; + } + + // Coarse progress so a slow/stalled upload is distinguishable + // from steady progress (one line per ~512 fragments). + if ((++sends % 512) == 0) { + KernelLogStream(INFO, "BT-FW") << " payload " << fwPtr - offset + << "/" << (size - offset) << " bytes (" << (uint64_t)sends << " frags)"; + } + } + } + return true; + } + + // Walk the command stream from the start of the image to recover the boot + // address embedded in the CMD_WRITE_BOOT_PARAMS command. + static bool FindBootAddress(const uint8_t* fw, uint64_t size, uint32_t* outAddr) { + uint64_t p = 0; + while (p + 3 <= size) { + uint16_t op = (uint16_t)fw[p] | ((uint16_t)fw[p + 1] << 8); + uint8_t plen = fw[p + 2]; + if (op == CMD_WRITE_BOOT_PARAMS) { + if (p + 3 + 4 > size) return false; + *outAddr = Rd32(&fw[p + 3]); + KernelLogStream(INFO, "BT-FW") << "Boot address: " << base::hex + << (uint64_t)*outAddr << base::dec + << " (fw build " << (uint64_t)fw[p + 7] << "-" + << (uint64_t)fw[p + 8] << "." << (uint64_t)fw[p + 9] << ")"; + return true; + } + p += 3 + plen; + } + return false; + } + + // ========================================================================= + // DDC parameter application (best effort) + // ========================================================================= + + static void ApplyDdc(uint16_t cnvi, uint16_t cnvr) { + char path[48]; + BuildFwPath(path, cnvi, cnvr, "ddc"); + + Fs::Vfs::BackendFile file; + if (Fs::Vfs::OpenBackendFile(path, file) < 0) { + KernelLogStream(INFO, "BT-FW") << "No DDC parameters (" << path << ")"; + return; + } + + uint64_t size = Fs::Vfs::GetBackendFileSize(file); + if (size == 0 || size > 4096) { + Fs::Vfs::CloseBackendFile(file); + return; + } + + uint8_t* ddc = (uint8_t*)Memory::g_heap->Request(size); + if (!ddc) { + Fs::Vfs::CloseBackendFile(file); + return; + } + Fs::Vfs::ReadBackendFile(file, ddc, 0, size); + Fs::Vfs::CloseBackendFile(file); + + // Each record is [len][len bytes of parameters]; the whole record is + // sent as the 0xFC8B payload. + uint64_t p = 0; + int applied = 0; + while (p < size) { + uint8_t total = (uint8_t)(ddc[p] + 1); + if (p + total > size) break; + if (Hci::IntelWriteDdcRecord(&ddc[p], total)) applied++; + p += total; + } + + Memory::g_heap->Free(ddc); + KernelLogStream(OK, "BT-FW") << "Applied " << (uint64_t)applied << " DDC record(s)"; + } + + // ========================================================================= + // Download orchestration + // ========================================================================= + + static bool DownloadImage(const uint8_t* fw, uint64_t size, + const IntelTlvVersion& ver, + uint16_t cnvi, uint16_t cnvr) { + if (size < RSA_HEADER_LEN + 16) { + KernelLogStream(ERROR, "BT-FW") << "Firmware image too small (" << size << " bytes)"; + return false; + } + + uint32_t cssVer = Rd32(&fw[CSS_HEADER_OFFSET]); + if (cssVer != RSA_HEADER_VER && cssVer != HYBRID_HEADER_VER) { + KernelLogStream(ERROR, "BT-FW") << "Invalid CSS header version: " + << base::hex << (uint64_t)cssVer << base::dec; + return false; + } + + uint32_t bootAddr = 0; + if (!FindBootAddress(fw, size, &bootAddr)) { + KernelLogStream(ERROR, "BT-FW") << "Could not locate boot address in firmware"; + return false; + } + + uint8_t hw = HwVariant(ver.CnviBt); + uint64_t payloadOffset; + bool headerOk = false; + + if (hw <= 0x14) { + // RSA-only parts: RSA header then command buffer. + headerOk = TryHeader(fw, false); + payloadOffset = RSA_HEADER_LEN; + } else { + // 0x17+ parts ship RSA(644) + ECDSA(320) headers; the command + // buffer follows both. sbe_type selects which header the part's + // secure-boot engine expects. + if (size < RSA_HEADER_LEN + ECDSA_HEADER_LEN || fw[ECDSA_OFFSET] != 0x06) { + KernelLogStream(ERROR, "BT-FW") << "Missing ECDSA header for hw variant " + << base::hex << (uint64_t)hw << base::dec; + return false; + } + payloadOffset = RSA_HEADER_LEN + ECDSA_HEADER_LEN; + + // Honor sbe_type if the version reply included it; otherwise (the + // common case here -- the reply is truncated to one USB packet so + // sbe_type is missing) try ECDSA first. These newer parts + // (AX210/AX211, hw_variant >= 0x17) use the ECDSA secure-boot + // engine, and TryHeader checks the CSS result before committing the + // key/signature, so a wrong guess fails cleanly instead of wedging. + bool order[2]; + int n; + if (ver.SbeValid && ver.SbeType == 0x00) { order[0] = false; n = 1; } // RSA + else if (ver.SbeValid && ver.SbeType == 0x01) { order[0] = true; n = 1; } // ECDSA + else { order[0] = true; order[1] = false; n = 2; } // ECDSA, then RSA + + for (int k = 0; k < n && !headerOk; k++) { + headerOk = TryHeader(fw, order[k]); + } + } + + if (!headerOk) { + KernelLogStream(ERROR, "BT-FW") << "Secure-boot header rejected"; + return false; + } + + KernelLogStream(INFO, "BT-FW") << "Downloading firmware payload (" + << (size - payloadOffset) << " bytes)"; + Hci::ClearSecureSendResult(); // discard header-era result + if (!SendPayload(fw, size, payloadOffset)) { + KernelLogStream(ERROR, "BT-FW") << "Firmware payload download failed"; + return false; + } + + // The bootloader signals download completion with a final 0xFF/0x06 + // secure-send result. Wait for it (and check it) before booting. + uint8_t r = 0, s = 0; + if (Hci::WaitSecureSendResult(5000, &r, &s)) { + if (r != 0 || s != 0) { + KernelLogStream(ERROR, "BT-FW") << "Firmware download failed (result=" + << base::hex << (uint64_t)r << " status=" << (uint64_t)s + << base::dec << ")"; + return false; + } + KernelLogStream(OK, "BT-FW") << "Firmware download complete"; + } else { + KernelLogStream(INFO, "BT-FW") << "No download-complete event; booting anyway"; + } + + KernelLogStream(INFO, "BT-FW") << "Booting operational firmware"; + if (!Hci::IntelBootFirmware(bootAddr)) return false; + + KernelLogStream(OK, "BT-FW") << "Operational firmware booted"; + + // DDC parameters are applied against the now-running firmware. + ApplyDdc(cnvi, cnvr); + return true; + } + + bool DownloadIntelFirmware() { + // 1. Read the TLV version to learn the SKU and current image type. + uint8_t raw[256]; + int rawLen = Hci::ReadIntelVersionTlv(raw, sizeof(raw)); + if (rawLen < 1 || raw[0] != 0) { + KernelLogStream(WARNING, "BT-FW") << "Could not read Intel TLV version"; + return false; + } + + IntelTlvVersion ver; + ParseTlv(raw + 1, rawLen - 1, &ver); + if (!ver.Valid) { + KernelLogStream(WARNING, "BT-FW") << "Unrecognized Intel version response"; + return false; + } + + uint16_t cnvi = CnvxPack(ver.CnviTop); + uint16_t cnvr = CnvxPack(ver.CnvrTop); + + KernelLogStream(INFO, "BT-FW") << "Intel CNVi=" << base::hex << (uint64_t)cnvi + << " CNVr=" << (uint64_t)cnvr << " hw_variant=" << (uint64_t)HwVariant(ver.CnviBt) + << " img_type=" << (uint64_t)ver.ImgType << base::dec; + + // Diagnostic: how much of the TLV version response we actually received + // (a value near 60 means the controller's reply was truncated to one + // interrupt packet), and whether sbe_type made it through. + KernelLogStream(INFO, "BT-FW") << "TLV bytes=" << (uint64_t)rawLen + << " sbe_valid=" << (uint64_t)(ver.SbeValid ? 1 : 0) + << " sbe_type=" << base::hex << (uint64_t)ver.SbeType << base::dec; + + // 2. If the operational image is already running, nothing to do. + if (ver.ImgType == IMG_OPERATIONAL) { + KernelLogStream(OK, "BT-FW") << "Operational firmware already loaded"; + return true; + } + if (ver.ImgType != IMG_BOOTLOADER) { + KernelLogStream(WARNING, "BT-FW") << "Unexpected image type, attempting download anyway"; + } + + // 3. Load the .sfi image from the ramdisk. + char sfiPath[48]; + BuildFwPath(sfiPath, cnvi, cnvr, "sfi"); + KernelLogStream(INFO, "BT-FW") << "Loading firmware: " << sfiPath; + + Fs::Vfs::BackendFile file; + if (Fs::Vfs::OpenBackendFile(sfiPath, file) < 0) { + KernelLogStream(ERROR, "BT-FW") << "Firmware not found: " << sfiPath; + KernelLogStream(WARNING, "BT-FW") << "Bluetooth stays in bootloader mode (no firmware)"; + return false; + } + + uint64_t size = Fs::Vfs::GetBackendFileSize(file); + uint8_t* fw = (uint8_t*)Memory::g_heap->Request(size); + if (!fw) { + KernelLogStream(ERROR, "BT-FW") << "Failed to allocate " << size << " bytes for firmware"; + Fs::Vfs::CloseBackendFile(file); + return false; + } + Fs::Vfs::ReadBackendFile(file, fw, 0, size); + Fs::Vfs::CloseBackendFile(file); + asm volatile("" ::: "memory"); + + // 4. Run the secure download + boot sequence. + bool ok = DownloadImage(fw, size, ver, cnvi, cnvr); + Memory::g_heap->Free(fw); + return ok; + } + +} diff --git a/kernel/src/Drivers/USB/Bluetooth/IntelFirmware.hpp b/kernel/src/Drivers/USB/Bluetooth/IntelFirmware.hpp new file mode 100644 index 0000000..39e0c87 --- /dev/null +++ b/kernel/src/Drivers/USB/Bluetooth/IntelFirmware.hpp @@ -0,0 +1,27 @@ +/* + * IntelFirmware.hpp + * Intel Bluetooth bootloader firmware download path + * Copyright (c) 2026 Daniel Hammer +*/ + +#pragma once +#include + +namespace Drivers::USB::Bluetooth { + + // Drive the Intel bootloader firmware download sequence for the currently + // registered adapter: + // 1. Read the TLV version and decide whether a download is required. + // 2. Derive the firmware/DDC file names (ibt--.{sfi,ddc}) + // and load them from 0:/os/firmware/intel/. + // 3. Secure-send the signed header + command-buffer payload (0xFC09). + // 4. Boot the operational firmware (0xFC01) and wait for the bootup + // event, then apply DDC parameters (0xFC8B). + // + // Returns true if the controller is operational afterwards (either it was + // already running firmware, or the download completed). Returns false if + // the controller is in bootloader mode and the download could not be + // completed (e.g. firmware file missing). + bool DownloadIntelFirmware(); + +} diff --git a/kernel/src/Drivers/USB/Bluetooth/L2cap.cpp b/kernel/src/Drivers/USB/Bluetooth/L2cap.cpp index 8596e4a..414d12f 100644 --- a/kernel/src/Drivers/USB/Bluetooth/L2cap.cpp +++ b/kernel/src/Drivers/USB/Bluetooth/L2cap.cpp @@ -25,6 +25,15 @@ namespace Drivers::USB::Bluetooth::L2cap { static bool g_initialized = false; static uint8_t g_sigIdentifier = 1; + // Diagnostic: result of the most recent L2CAP Connection Response we got for + // an outgoing connection (0=success, 1=pending, 2=PSM-unsupported, + // 3=security-block, 4=no-resources). 0xFFFF = none received yet. + static volatile uint16_t g_lastConnRspResult = 0xFFFF; + + // Diagnostic: how many incoming AVDTP connection requests the remote has + // made (tells us whether the headset wants to initiate the audio channel). + static volatile uint16_t g_incomingAvdtpReqs = 0; + // Channel table static ChannelInfo g_channels[MAX_CHANNELS] = {}; static uint16_t g_nextCid = CID_DYNAMIC_START; @@ -116,14 +125,24 @@ namespace Drivers::USB::Bluetooth::L2cap { if (l2len + sizeof(L2capHeader) > len) return; if (cid == CID_SIGNALING) { - // L2CAP signaling channel - if (l2len < sizeof(SignalHeader)) return; + // L2CAP signaling channel. One packet may carry MULTIPLE commands + // back to back -- a headset commonly bundles its Config Response + // (to our request) with its own Config Request in a single packet. + // Loop over all of them, or we'd handle one and silently drop the + // rest (which left our channel half-configured: localCfg=0). + uint16_t sOff = 0; + while (sOff + sizeof(SignalHeader) <= l2len) { + auto* sig = (const SignalHeader*)(payload + sOff); + const uint8_t* sigPayload = payload + sOff + sizeof(SignalHeader); + uint16_t sigPayloadLen = sig->Length; + // Clamp (don't bail) so a length that doesn't exactly match the + // packet never skips this command -- the cases bounds-check their + // own reads. Advancing by the clamped length ends the loop after + // the last real command. + uint16_t avail = (uint16_t)(l2len - sOff - sizeof(SignalHeader)); + if (sigPayloadLen > avail) sigPayloadLen = avail; - auto* sig = (const SignalHeader*)payload; - const uint8_t* sigPayload = payload + sizeof(SignalHeader); - uint16_t sigPayloadLen = sig->Length; - - switch (sig->Code) { + switch (sig->Code) { case SIG_CONN_REQ: { if (sigPayloadLen >= 4) { uint16_t psm = (uint16_t)sigPayload[0] | ((uint16_t)sigPayload[1] << 8); @@ -134,6 +153,7 @@ namespace Drivers::USB::Bluetooth::L2cap { // Accept connections for AVDTP if (psm == PSM_AVDTP || psm == PSM_SDP) { + if (psm == PSM_AVDTP) g_incomingAvdtpReqs++; auto* ch = AllocChannel(psm); if (ch) { ch->RemoteCid = srcCid; @@ -147,6 +167,17 @@ namespace Drivers::USB::Bluetooth::L2cap { rsp[4] = 0; rsp[5] = 0; // Result: success rsp[6] = 0; rsp[7] = 0; // Status: no info SendSignal(SIG_CONN_RSP, sig->Identifier, rsp, 8); + + // As the acceptor we must ALSO send our own + // Configuration Request -- otherwise our side + // never reaches LocalConfigDone and the channel + // never becomes Configured (OnChannelReady never + // fires). Address the remote's CID. + uint8_t cfgReq[4] = {}; + cfgReq[0] = (uint8_t)(srcCid & 0xFF); + cfgReq[1] = (uint8_t)(srcCid >> 8); + cfgReq[2] = 0; cfgReq[3] = 0; // Flags + SendSignal(SIG_CONFIG_REQ, g_sigIdentifier++, cfgReq, 4); } } else { // Reject: PSM not supported @@ -167,9 +198,15 @@ namespace Drivers::USB::Bluetooth::L2cap { uint16_t dstCid = (uint16_t)sigPayload[0] | ((uint16_t)sigPayload[1] << 8); uint16_t srcCid = (uint16_t)sigPayload[2] | ((uint16_t)sigPayload[3] << 8); uint16_t result = (uint16_t)sigPayload[4] | ((uint16_t)sigPayload[5] << 8); + // Status (bytes 6-7) explains a PENDING (result=1): 0=no + // info, 1=authentication pending, 2=authorization pending. + uint16_t status = (sigPayloadLen >= 8) + ? ((uint16_t)sigPayload[6] | ((uint16_t)sigPayload[7] << 8)) : 0; + g_lastConnRspResult = result; KernelLogStream(INFO, "BT-L2CAP") << "Connection Response: dstCID=" - << base::hex << (uint64_t)dstCid << " result=" << (uint64_t)result; + << base::hex << (uint64_t)dstCid << " result=" << (uint64_t)result + << " status=" << (uint64_t)status << base::dec; if (result == CONN_SUCCESS) { // Find our channel by srcCid (which is our local CID) @@ -239,12 +276,29 @@ namespace Drivers::USB::Bluetooth::L2cap { case SIG_CONFIG_RSP: { if (sigPayloadLen >= 6) { + // The Config Response's first field is the "Source CID". + // In a RECEIVED Config Response it echoes back OUR local + // channel endpoint (the device that sent the Config + // Request -- us), NOT the remote's CID -- exactly like the + // SIG_CONN_RSP handler above matches srcCid to LocalCid. + // Matching RemoteCid here was THE bug that pinned every + // AVDTP channel at localCfg=0: a success Config Response + // arrived but matched no channel, so LocalConfigDone never + // got set and the channel never became Configured. uint16_t srcCid = (uint16_t)sigPayload[0] | ((uint16_t)sigPayload[1] << 8); uint16_t result = (uint16_t)sigPayload[4] | ((uint16_t)sigPayload[5] << 8); + if (result != CFG_SUCCESS) { + KernelLogStream(WARNING, "BT-L2CAP") << "Config Response result=" + << base::hex << (uint64_t)result << base::dec + << " (our config rejected)"; + } + if (result == CFG_SUCCESS) { + bool matched = false; for (int i = 0; i < MAX_CHANNELS; i++) { - if (g_channels[i].Active && g_channels[i].RemoteCid == srcCid) { + if (g_channels[i].Active && g_channels[i].LocalCid == srcCid) { + matched = true; g_channels[i].LocalConfigDone = true; if (g_channels[i].LocalConfigDone && g_channels[i].RemoteConfigDone) { g_channels[i].Configured = true; @@ -258,6 +312,11 @@ namespace Drivers::USB::Bluetooth::L2cap { break; } } + if (!matched) { + KernelLogStream(WARNING, "BT-L2CAP") + << "Config Response (success) for unknown CID=" + << base::hex << (uint64_t)srcCid << base::dec; + } } } break; @@ -312,6 +371,8 @@ namespace Drivers::USB::Bluetooth::L2cap { default: break; + } + sOff += sizeof(SignalHeader) + sigPayloadLen; } } else { // Data on a dynamic channel @@ -319,6 +380,8 @@ namespace Drivers::USB::Bluetooth::L2cap { if (g_channels[i].Active && g_channels[i].LocalCid == cid) { if (g_channels[i].Psm == PSM_AVDTP) { A2dp::ProcessAvdtp(payload, l2len); + } else if (g_channels[i].Psm == PSM_SDP) { + A2dp::ProcessSdp(payload, l2len); } break; } @@ -333,6 +396,8 @@ namespace Drivers::USB::Bluetooth::L2cap { uint16_t Connect(uint16_t psm) { if (!g_initialized) return 0; + g_lastConnRspResult = 0xFFFF; // reset diagnostic for this attempt + auto* ch = AllocChannel(psm); if (!ch) return 0; @@ -356,6 +421,7 @@ namespace Drivers::USB::Bluetooth::L2cap { while (Timekeeping::GetMilliseconds() - start < timeoutMs) { Xhci::PollEvents(); + Hci::DrainEvents(); // process incoming ACL (the Connection Response!) auto* ch = GetChannel(localCid); if (ch && ch->Configured) return true; @@ -406,6 +472,36 @@ namespace Drivers::USB::Bluetooth::L2cap { return nullptr; } + bool FreeChannel(uint16_t localCid) { + // Reclaim a channel slot from a failed/abandoned dial during A2DP + // bring-up retries. Two cases: + // - RemoteCid == 0: the remote never acknowledged our CONN_REQ (ignored, + // or answered only with a stuck PENDING that never completed), so its + // side was never created and no Disconnect is owed -- just free it. + // - RemoteCid != 0: a CONN_RSP success arrived (the peer allocated its + // CID) but the channel never finished configuring, so the peer holds a + // half-open channel. Send it a Disconnect Request before freeing, or + // BOTH our slot leaks (the old RemoteCid==0-only guard left it Active) + // AND the peer keeps a dangling channel. + // We deliberately do NOT reset g_nextCid, so a late response for this + // (now freed) CID matches nothing rather than cross-wiring the retry. + for (int i = 0; i < MAX_CHANNELS; i++) { + if (g_channels[i].Active && g_channels[i].LocalCid == localCid) { + if (g_channels[i].RemoteCid != 0) { + uint8_t req[4] = {}; + req[0] = (uint8_t)(g_channels[i].RemoteCid & 0xFF); + req[1] = (uint8_t)(g_channels[i].RemoteCid >> 8); + req[2] = (uint8_t)(g_channels[i].LocalCid & 0xFF); + req[3] = (uint8_t)(g_channels[i].LocalCid >> 8); + SendSignal(SIG_DISCONN_REQ, g_sigIdentifier++, req, 4); + } + g_channels[i].Active = false; + return true; + } + } + return false; + } + ChannelInfo* FindChannelByPsm(uint16_t psm) { for (int i = 0; i < MAX_CHANNELS; i++) { if (g_channels[i].Active && g_channels[i].Psm == psm) { @@ -415,8 +511,27 @@ namespace Drivers::USB::Bluetooth::L2cap { return nullptr; } + uint16_t FindConfiguredAvdtpChannelExcept(uint16_t exceptCid) { + for (int i = 0; i < MAX_CHANNELS; i++) { + if (g_channels[i].Active && g_channels[i].Configured + && g_channels[i].Psm == PSM_AVDTP + && g_channels[i].LocalCid != exceptCid) { + return g_channels[i].LocalCid; + } + } + return 0; + } + uint16_t GetAclHandle() { return g_aclHandle; } + uint16_t LastConnRspResult() { + return g_lastConnRspResult; + } + + uint16_t IncomingAvdtpReqCount() { + return g_incomingAvdtpReqs; + } + } diff --git a/kernel/src/Drivers/USB/Bluetooth/L2cap.hpp b/kernel/src/Drivers/USB/Bluetooth/L2cap.hpp index f1c414c..465b72c 100644 --- a/kernel/src/Drivers/USB/Bluetooth/L2cap.hpp +++ b/kernel/src/Drivers/USB/Bluetooth/L2cap.hpp @@ -105,7 +105,30 @@ namespace Drivers::USB::Bluetooth::L2cap { // Find channel by PSM ChannelInfo* FindChannelByPsm(uint16_t psm); + // Find a CONFIGURED AVDTP channel whose LocalCid != exceptCid, returning its + // LocalCid (0 if none). Used to locate the AVDTP media transport channel -- + // the second configured PSM-0x19 channel -- regardless of which side opened + // it (we dial it after AVDTP_OPEN, but some sinks open it inbound instead). + uint16_t FindConfiguredAvdtpChannelExcept(uint16_t exceptCid); + + // Reclaim a dialed channel during A2DP bring-up retries so a failed connect + // doesn't leak the fixed-size channel table. If the peer had acknowledged + // the channel (RemoteCid != 0) a Disconnect Request is sent first; an + // unanswered dial (RemoteCid == 0) owes nothing. Does NOT reset the CID + // allocator (a late response for the freed CID then matches nothing). + // Returns true if a matching active channel was found and freed. + bool FreeChannel(uint16_t localCid); + // Get the ACL handle uint16_t GetAclHandle(); + // Diagnostic: result code of the most recent outgoing L2CAP Connection + // Response (0xFFFF if none yet). 0=success, 1=pending, 2=PSM-unsupported, + // 3=security-block, 4=no-resources. + uint16_t LastConnRspResult(); + + // Diagnostic: number of incoming AVDTP connection requests seen (whether the + // remote wants to initiate the audio channel itself). + uint16_t IncomingAvdtpReqCount(); + } diff --git a/kernel/src/Drivers/USB/Bluetooth/Sbc.cpp b/kernel/src/Drivers/USB/Bluetooth/Sbc.cpp index be79ceb..5680784 100644 --- a/kernel/src/Drivers/USB/Bluetooth/Sbc.cpp +++ b/kernel/src/Drivers/USB/Bluetooth/Sbc.cpp @@ -106,6 +106,34 @@ namespace Drivers::USB::Bluetooth::Sbc { enc->FrameSize = (headerBits + dataBits + 7) / 8; } + void Configure(SbcEncoder* enc, uint8_t octet0, uint8_t octet1, uint8_t bitpool) { + // octet0: SamplingFreq[7:4] | ChannelMode[3:0] + if (octet0 & 0x80) enc->Frequency = FREQ_16000; + else if (octet0 & 0x40) enc->Frequency = FREQ_32000; + else if (octet0 & 0x20) enc->Frequency = FREQ_44100; + else enc->Frequency = FREQ_48000; // b4 (48k) or default + + if (octet0 & 0x08) { enc->ChannelMode = MODE_MONO; enc->Channels = 1; } + else if (octet0 & 0x04) { enc->ChannelMode = MODE_DUAL_CHANNEL; enc->Channels = 2; } + else if (octet0 & 0x02) { enc->ChannelMode = MODE_STEREO; enc->Channels = 2; } + else { enc->ChannelMode = MODE_JOINT_STEREO; enc->Channels = 2; } // b0 + + // octet1: BlockLength[7:4] | Subbands[3:2] | Alloc[1:0] + if (octet1 & 0x80) enc->Blocks = 4; + else if (octet1 & 0x40) enc->Blocks = 8; + else if (octet1 & 0x20) enc->Blocks = 12; + else enc->Blocks = 16; // b4 (16) or default + enc->Subbands = (octet1 & 0x08) ? 4 : 8; // b3=4, else 8 + enc->AllocMethod = (octet1 & 0x02) ? ALLOC_SNR : ALLOC_LOUDNESS; // b1=SNR, else Loudness + if (bitpool) enc->Bitpool = bitpool; + + enc->SamplesPerFrame = enc->Blocks * enc->Subbands; + uint32_t headerBits = 32 + (4 * enc->Subbands * enc->Channels); + if (enc->ChannelMode == MODE_JOINT_STEREO) headerBits += enc->Subbands; + uint32_t dataBits = enc->Blocks * enc->Bitpool; + enc->FrameSize = (headerBits + dataBits + 7) / 8; + } + // ========================================================================= // Analysis filter bank (8 subbands) // ========================================================================= @@ -149,12 +177,13 @@ namespace Drivers::USB::Bluetooth::Sbc { // Bit allocation (Loudness method) // ========================================================================= - static void BitAllocation(SbcEncoder* enc, - int32_t sb_samples[SBC_BLOCKS][SBC_SUBBANDS], - int ch, - int32_t scale_factors[SBC_SUBBANDS], - uint8_t bits[SBC_SUBBANDS]) { - // Compute scale factors + // Compute the 4-bit scale factor for each subband of one channel: the number + // of bits needed to represent the largest-magnitude subband sample. Must be + // run on the FINAL sb_samples (after any joint-stereo transform), because the + // decoder re-derives the bit allocation from these transmitted scale factors. + static void ComputeScaleFactors(SbcEncoder* enc, + int32_t sb_samples[SBC_BLOCKS][SBC_SUBBANDS], + int32_t scale_factors[SBC_SUBBANDS]) { for (int sb = 0; sb < enc->Subbands; sb++) { int32_t maxVal = 0; for (int blk = 0; blk < enc->Blocks; blk++) { @@ -162,95 +191,120 @@ namespace Drivers::USB::Bluetooth::Sbc { if (val < 0) val = -val; if (val > maxVal) maxVal = val; } - - // Find scale factor (highest bit position) - scale_factors[sb] = 0; - int32_t tmp = maxVal; - while (tmp > 0) { - scale_factors[sb]++; - tmp >>= 1; - } + int32_t sf = 0, tmp = maxVal; + while (tmp > 0) { sf++; tmp >>= 1; } + scale_factors[sb] = sf; } + } - // Loudness offset table for 8 subbands (from SBC spec) - static const int8_t loudness_offset_8[4][8] = { - {-2, 0, 0, 0, 0, 0, 0, 1}, // 16kHz - {-3, 0, 0, 0, 0, 0, 1, 2}, // 32kHz - {-4, 0, 0, 0, 0, 0, 1, 2}, // 44.1kHz - {-4, 0, 0, 0, 0, 0, 1, 2}, // 48kHz - }; + // Loudness offset table for 8 subbands (SBC spec), indexed by sampling freq. + static const int8_t g_loudnessOffset8[4][8] = { + {-2, 0, 0, 0, 0, 0, 0, 1}, // 16kHz + {-3, 0, 0, 0, 0, 0, 1, 2}, // 32kHz + {-4, 0, 0, 0, 0, 0, 1, 2}, // 44.1kHz + {-4, 0, 0, 0, 0, 0, 1, 2}, // 48kHz + }; - // Compute bitneed - int32_t bitneed[SBC_SUBBANDS]; - for (int sb = 0; sb < enc->Subbands; sb++) { - if (enc->AllocMethod == ALLOC_LOUDNESS) { - bitneed[sb] = scale_factors[sb] - loudness_offset_8[enc->Frequency][sb]; - } else { - bitneed[sb] = scale_factors[sb]; - } - } + // ========================================================================= + // Bit allocation -- canonical A2DP / BlueZ algorithm + // ========================================================================= + // The per-subband bit widths are NOT transmitted; the decoder re-derives + // them from the scale factors + bitpool + allocation method using exactly + // this algorithm, so the encoder must reproduce it bit-for-bit or the + // sample bitstream desyncs into noise. For STEREO/JOINT the two channels + // share one bitpool (scope = both channels); for MONO each channel is + // independent. (The old hand-rolled version over-allocated and overran the + // frame buffer.) + static void AllocateScope(SbcEncoder* enc, + int32_t bitneed[SBC_CHANNELS][SBC_SUBBANDS], + uint8_t bits[SBC_CHANNELS][SBC_SUBBANDS], + int c0, int c1) { + int sub = enc->Subbands; - // Bit allocation loop - int32_t bitcount = 0; - int32_t slicecount = 0; - int32_t bitslice = (int32_t)(scale_factors[0] > 0 ? scale_factors[0] : 1); + int maxBitneed = 0; + for (int c = c0; c < c1; c++) + for (int sb = 0; sb < sub; sb++) + if (bitneed[c][sb] > maxBitneed) maxBitneed = bitneed[c][sb]; - // Find max bitneed - for (int sb = 0; sb < enc->Subbands; sb++) { - if (bitneed[sb] > bitslice) bitslice = bitneed[sb]; - } - bitslice++; - - // Iterative allocation - for (int sb = 0; sb < enc->Subbands; sb++) bits[sb] = 0; - - while (true) { + int bitcount = 0, slicecount = 0, bitslice = maxBitneed + 1; + do { bitslice--; - bitcount = 0; + bitcount += slicecount; slicecount = 0; - for (int sb = 0; sb < enc->Subbands; sb++) { - if (bitneed[sb] >= bitslice + 1 && bitneed[sb] < bitslice + 16) { - if (bitneed[sb] == bitslice + 1) { - bitcount += 2; + for (int c = c0; c < c1; c++) { + for (int sb = 0; sb < sub; sb++) { + if (bitneed[c][sb] > bitslice + 1 && bitneed[c][sb] < bitslice + 16) slicecount++; + else if (bitneed[c][sb] == bitslice + 1) + slicecount += 2; + } + } + } while (bitcount + slicecount < enc->Bitpool); + + if (bitcount + slicecount == enc->Bitpool) { + bitcount += slicecount; + bitslice--; + } + + for (int c = c0; c < c1; c++) { + for (int sb = 0; sb < sub; sb++) { + if (bitneed[c][sb] < bitslice + 2) { + bits[c][sb] = 0; + } else { + int b = bitneed[c][sb] - bitslice; + bits[c][sb] = (uint8_t)(b > 16 ? 16 : b); + } + } + } + + // Distribute leftover bits in spec order (subband-major, channel-minor). + int twoCh = (c1 - c0 == 2) ? 1 : 0; + int c = c0, sb = 0; + while (bitcount < enc->Bitpool && sb < sub) { + if (bits[c][sb] >= 2 && bits[c][sb] < 16) { + bits[c][sb]++; + bitcount++; + } else if (bitneed[c][sb] == bitslice + 1 && enc->Bitpool > bitcount + 1) { + bits[c][sb] = 2; + bitcount += 2; + } + if (twoCh) { if (c == c0) c = c0 + 1; else { c = c0; sb++; } } + else sb++; + } + c = c0; sb = 0; + while (bitcount < enc->Bitpool && sb < sub) { + if (bits[c][sb] < 16) { bits[c][sb]++; bitcount++; } + if (twoCh) { if (c == c0) c = c0 + 1; else { c = c0; sb++; } } + else sb++; + } + } + + static void BitAllocation(SbcEncoder* enc, + int32_t scale_factors[SBC_CHANNELS][SBC_SUBBANDS], + uint8_t bits[SBC_CHANNELS][SBC_SUBBANDS]) { + int sub = enc->Subbands; + int32_t bitneed[SBC_CHANNELS][SBC_SUBBANDS]; + + for (int c = 0; c < enc->Channels; c++) { + for (int sb = 0; sb < sub; sb++) { + if (enc->AllocMethod == ALLOC_LOUDNESS) { + if (scale_factors[c][sb] == 0) { + bitneed[c][sb] = -5; } else { - bitcount++; - slicecount++; - } - } - } - if (bitcount + slicecount >= enc->Bitpool) break; - if (bitslice <= -16) break; - - for (int sb = 0; sb < enc->Subbands; sb++) { - if (bitneed[sb] >= bitslice + 1 && bitneed[sb] < bitslice + 16) { - if (bitneed[sb] == bitslice + 1) { - bits[sb] = 2; - } else if (bits[sb] < 16) { - bits[sb]++; + int loud = scale_factors[c][sb] - g_loudnessOffset8[enc->Frequency][sb]; + bitneed[c][sb] = (loud > 0) ? (loud / 2) : loud; } + } else { + bitneed[c][sb] = scale_factors[c][sb]; } } } - // Distribute remaining bits - int32_t remaining = enc->Bitpool - bitcount; - for (int sb = 0; sb < enc->Subbands && remaining > 0; sb++) { - if (bits[sb] >= 2 && bits[sb] < 16) { - bits[sb]++; - remaining--; - } else if (bitneed[sb] == bitslice && bits[sb] == 0) { - bits[sb] = 2; - remaining -= 2; - if (remaining < 0) { bits[sb] = 0; break; } - } - } - - for (int sb = 0; sb < enc->Subbands && remaining > 0; sb++) { - if (bits[sb] < 16) { - bits[sb]++; - remaining--; - } + bool shared = (enc->ChannelMode == MODE_STEREO || enc->ChannelMode == MODE_JOINT_STEREO); + if (shared && enc->Channels == 2) { + AllocateScope(enc, bitneed, bits, 0, 2); + } else { + for (int c = 0; c < enc->Channels; c++) AllocateScope(enc, bitneed, bits, c, c + 1); } } @@ -280,38 +334,34 @@ namespace Drivers::USB::Bluetooth::Sbc { uint32_t Encode(SbcEncoder* enc, const int16_t* pcm, uint8_t* out) { int32_t sb_samples[SBC_CHANNELS][SBC_BLOCKS][SBC_SUBBANDS]; - int32_t scale_factors[SBC_CHANNELS][SBC_SUBBANDS]; - uint8_t bits[SBC_CHANNELS][SBC_SUBBANDS]; + int32_t scale_factors[SBC_CHANNELS][SBC_SUBBANDS] = {}; + uint8_t bits[SBC_CHANNELS][SBC_SUBBANDS] = {}; - // Clear output memset(out, 0, enc->FrameSize); - // Analysis filter for each channel + // 1. Analysis filterbank per channel. for (int ch = 0; ch < enc->Channels; ch++) { AnalysisFilter(enc, pcm, ch, sb_samples[ch]); - BitAllocation(enc, sb_samples[ch], ch, scale_factors[ch], bits[ch]); } - // Joint stereo processing + // 2. Joint-stereo decision + mid/side transform, applied BEFORE scale + // factors and bit allocation: the decoder re-derives the bit widths + // from the transmitted scale factors, which must reflect the FINAL + // (post-transform) samples, or the sample bitstream desyncs. uint8_t joint = 0; if (enc->ChannelMode == MODE_JOINT_STEREO) { for (int sb = 0; sb < enc->Subbands - 1; sb++) { - // Simple heuristic: use joint coding if it saves bits - int32_t maxMid = 0, maxSide = 0; + int32_t maxMid = 0, maxSide = 0, maxOrig = 0; for (int blk = 0; blk < enc->Blocks; blk++) { - int32_t mid = (sb_samples[0][blk][sb] + sb_samples[1][blk][sb]) / 2; - int32_t side = (sb_samples[0][blk][sb] - sb_samples[1][blk][sb]) / 2; + int32_t l = sb_samples[0][blk][sb], r = sb_samples[1][blk][sb]; + int32_t mid = (l + r) / 2, side = (l - r) / 2; if (mid < 0) mid = -mid; if (side < 0) side = -side; + int32_t al = l < 0 ? -l : l, ar = r < 0 ? -r : r; if (mid > maxMid) maxMid = mid; if (side > maxSide) maxSide = side; - } - int32_t maxOrig = 0; - for (int blk = 0; blk < enc->Blocks; blk++) { - int32_t v0 = sb_samples[0][blk][sb]; if (v0 < 0) v0 = -v0; - int32_t v1 = sb_samples[1][blk][sb]; if (v1 < 0) v1 = -v1; - if (v0 > maxOrig) maxOrig = v0; - if (v1 > maxOrig) maxOrig = v1; + if (al > maxOrig) maxOrig = al; + if (ar > maxOrig) maxOrig = ar; } if (maxMid + maxSide < maxOrig) { joint |= (1 << (enc->Subbands - 1 - sb)); @@ -321,84 +371,85 @@ namespace Drivers::USB::Bluetooth::Sbc { sb_samples[0][blk][sb] = (l + r) / 2; sb_samples[1][blk][sb] = (l - r) / 2; } - // Recalculate scale factors for joint channels - for (int ch = 0; ch < 2; ch++) { - int32_t maxVal = 0; - for (int blk = 0; blk < enc->Blocks; blk++) { - int32_t val = sb_samples[ch][blk][sb]; - if (val < 0) val = -val; - if (val > maxVal) maxVal = val; - } - scale_factors[ch][sb] = 0; - int32_t tmp = maxVal; - while (tmp > 0) { scale_factors[ch][sb]++; tmp >>= 1; } - } } } } - // Pack SBC frame header - out[0] = 0x9C; // Sync word - out[1] = (enc->Frequency << 6) | ((enc->Blocks == 4 ? 0 : enc->Blocks == 8 ? 1 : enc->Blocks == 12 ? 2 : 3) << 4) - | (enc->ChannelMode << 2) | (enc->AllocMethod << 1) | (enc->Subbands == 8 ? 1 : 0); + // 3. Scale factors from the final subband samples. + for (int ch = 0; ch < enc->Channels; ch++) { + ComputeScaleFactors(enc, sb_samples[ch], scale_factors[ch]); + } + + // 4. Bit allocation (canonical; decoder re-derives the same widths). + BitAllocation(enc, scale_factors, bits); + + // 5a. Frame header. In the FRAME HEADER allocation_method is 0=Loudness, + // 1=SNR -- the OPPOSITE polarity of the codec-capability bit. Since + // ALLOC_LOUDNESS==1 internally, emit (Loudness ? 0 : 1). + out[0] = 0x9C; + uint8_t blkCode = (enc->Blocks == 4 ? 0 : enc->Blocks == 8 ? 1 : enc->Blocks == 12 ? 2 : 3); + out[1] = (uint8_t)((enc->Frequency << 6) | (blkCode << 4) + | (enc->ChannelMode << 2) + | ((enc->AllocMethod == ALLOC_LOUDNESS ? 0u : 1u) << 1) + | (enc->Subbands == 8 ? 1u : 0u)); out[2] = enc->Bitpool; + // out[3] = CRC, filled after the join + scale-factor bits are packed. - // CRC (computed over header bytes 1-2 and scale factors) - // Will be filled after scale factors are packed + BitWriter bw = {out, 32}; // packing starts at byte 4 (after 4-byte header) - BitWriter bw = {out, 32}; // Start after 4-byte header - - // Joint stereo flags + // 5b. Join flags (joint stereo only). if (enc->ChannelMode == MODE_JOINT_STEREO) { WriteBits(&bw, joint, enc->Subbands); } - // Pack scale factors (4 bits each) + // 5c. Scale factors, 4 bits each (ch0 all subbands, then ch1). for (int ch = 0; ch < enc->Channels; ch++) { for (int sb = 0; sb < enc->Subbands; sb++) { - uint32_t sf = scale_factors[ch][sb]; + uint32_t sf = (uint32_t)scale_factors[ch][sb]; if (sf > 15) sf = 15; WriteBits(&bw, sf, 4); } } - // Compute CRC (over bytes 1, 2, and scale factor bits) - uint32_t crcBits = 16 + (enc->Channels * enc->Subbands * 4); - if (enc->ChannelMode == MODE_JOINT_STEREO) crcBits += enc->Subbands; - out[3] = SbcCrc8(&out[1], (crcBits + 7) / 8, crcBits % 8 ? crcBits % 8 : 8); + // 5d. CRC-8 over the LOGICAL stream: byte1, byte2, then the join + + // scale-factor bits. Those bits physically start at out[4] (out[3] + // is the CRC slot itself), so build a contiguous buffer that SKIPS + // out[3]. Computing over &out[1] as one span (the old bug) folds the + // zero CRC byte into the CRC and a compliant sink drops every frame. + uint32_t sfBits = (enc->ChannelMode == MODE_JOINT_STEREO ? (uint32_t)enc->Subbands : 0u) + + (uint32_t)enc->Channels * enc->Subbands * 4; + uint32_t sfBytes = (sfBits + 7) / 8; + uint8_t crcbuf[2 + (SBC_CHANNELS * SBC_SUBBANDS * 4 + SBC_SUBBANDS + 7) / 8]; + crcbuf[0] = out[1]; + crcbuf[1] = out[2]; + for (uint32_t i = 0; i < sfBytes; i++) crcbuf[2 + i] = out[4 + i]; + uint32_t crcTotalBits = 16 + sfBits; + out[3] = SbcCrc8(crcbuf, 2 + sfBytes, (crcTotalBits % 8) ? (crcTotalBits % 8) : 8); - // Pack audio samples + // 5e. Quantize + pack audio samples (block-major, then channel, subband). for (int blk = 0; blk < enc->Blocks; blk++) { for (int ch = 0; ch < enc->Channels; ch++) { for (int sb = 0; sb < enc->Subbands; sb++) { if (bits[ch][sb] == 0) continue; - int32_t sf = scale_factors[ch][sb]; int32_t sample = sb_samples[ch][blk][sb]; - - // Quantize: levels = (1 << bits) - 1 uint32_t levels = (1u << bits[ch][sb]) - 1; int32_t quantized; - if (sf > 0) { - // Normalize and quantize int32_t maxRange = (1 << sf); quantized = (int32_t)(((int64_t)(sample + maxRange) * levels) / (2 * maxRange)); } else { quantized = levels / 2; } - if (quantized < 0) quantized = 0; if (quantized > (int32_t)levels) quantized = (int32_t)levels; - WriteBits(&bw, (uint32_t)quantized, bits[ch][sb]); } } } - // Pad to byte boundary - uint32_t totalBytes = (bw.BitPos + 7) / 8; - return totalBytes > enc->FrameSize ? enc->FrameSize : totalBytes; + // SBC frames are fixed-size for a given configuration. + return enc->FrameSize; } // ========================================================================= diff --git a/kernel/src/Drivers/USB/Bluetooth/Sbc.hpp b/kernel/src/Drivers/USB/Bluetooth/Sbc.hpp index d88dd60..9a1c611 100644 --- a/kernel/src/Drivers/USB/Bluetooth/Sbc.hpp +++ b/kernel/src/Drivers/USB/Bluetooth/Sbc.hpp @@ -75,6 +75,13 @@ namespace Drivers::USB::Bluetooth::Sbc { // Initialize encoder with given parameters void Init(SbcEncoder* enc, uint32_t sampleRate, uint8_t channels, uint8_t bitsPerSample); + // Override the encoder's SBC parameters from the negotiated AVDTP capability + // octets (octet0 = SamplingFreq[7:4]|ChannelMode[3:0], octet1 = + // BlockLength[7:4]|Subbands[3:2]|Alloc[1:0]) + the chosen bitpool, so the + // emitted frame headers match exactly what the sink agreed to. Call after + // Init. + void Configure(SbcEncoder* enc, uint8_t octet0, uint8_t octet1, uint8_t bitpool); + // Encode one SBC frame from PCM data // pcm: interleaved 16-bit signed PCM, length = blocks * subbands * channels // out: output buffer for SBC frame diff --git a/kernel/src/Drivers/USB/Xhci.cpp b/kernel/src/Drivers/USB/Xhci.cpp index 0d6820f..2850162 100644 --- a/kernel/src/Drivers/USB/Xhci.cpp +++ b/kernel/src/Drivers/USB/Xhci.cpp @@ -107,6 +107,13 @@ namespace Drivers::USB::Xhci { // Per-device info static UsbDeviceInfo g_devices[MAX_SLOTS + 1] = {}; + // True while PollEvents() is draining the event ring. Submitters that are + // reached from inside an event callback (e.g. an HCI reply sent from a + // Bluetooth event handler) see this and must NOT wait for completion -- + // PollEvents is non-reentrant, so the wait would never observe the + // completion. Used by InPollContext() / ControlTransfer(). + static volatile bool g_pollActive = false; + // Interrupt transfer data buffers (per slot) static uint8_t* g_interruptDataBuf[MAX_SLOTS + 1] = {}; static uint64_t g_interruptDataBufPhys[MAX_SLOTS + 1] = {}; @@ -366,12 +373,40 @@ namespace Drivers::USB::Xhci { return true; } + // True when the caller is running inside PollEvents() (e.g. an HCI reply + // sent from a Bluetooth event handler). Such callers must fire-and-forget, + // not wait, since a nested PollEvents is a no-op. + bool InPollContext() { + return g_pollActive; + } + // ------------------------------------------------------------------------- // PollEvents - process event ring // ------------------------------------------------------------------------- void PollEvents() { - while (true) { + // PollEvents runs both from the synchronous poll loops (ControlTransfer, + // SendCommand, firmware download) and from the xHCI MSI handler. On a + // single core the IRQ can preempt a poll loop mid-drain; if both advance + // g_evtRingDequeue / g_evtRingCCS the ring tracking desyncs and the + // cycle-bit check can start matching stale entries forever -> the boot + // freezes (observed wedging the Bluetooth firmware download at ~635 KB, + // where the dying device floods the event ring). Guard against re-entry: + // the interrupt is already acked (IMAN.IP cleared in HandleInterrupt) and + // the active poll loop drains these events itself. g_pollActive is also + // read by InPollContext() so command submitters (ControlTransfer) can + // tell they are nested and must fire-and-forget instead of waiting. + if (g_pollActive) return; + g_pollActive = true; + + // Bound the work per call so a flooding/wedged device can never spin + // here forever; the outer wall-clock timeouts then fire instead of + // freezing. 4x the ring size is far above any legitimate burst. + constexpr uint32_t MAX_EVENTS_PER_CALL = EVT_RING_SIZE * 4; + uint32_t processed = 0, portEvts = 0, xferEvts = 0; + uint32_t lastType = 0, lastSlot = 0, lastEp = 0, lastCC = 0; + + while (processed < MAX_EVENTS_PER_CALL) { TRB& evt = g_evtRing[g_evtRingDequeue]; // Check if the cycle bit matches our expected cycle state @@ -381,6 +416,7 @@ namespace Drivers::USB::Xhci { } uint32_t trbType = (evt.Control & TRB_TYPE_MASK) >> TRB_TYPE_SHIFT; + lastType = trbType; switch (trbType) { case TRB_COMMAND_COMPLETION: { @@ -393,6 +429,7 @@ namespace Drivers::USB::Xhci { } case TRB_PORT_STATUS_CHANGE: { + portEvts++; uint32_t portId = (evt.Parameter0 >> 24) & 0xFF; uint32_t portsc = ReadOp(OP_PORTSC_BASE + (portId - 1) * OP_PORTSC_STRIDE); // Clear change bits (write-1-to-clear) @@ -412,6 +449,8 @@ namespace Drivers::USB::Xhci { uint32_t slotId = (evt.Control >> 24) & 0xFF; uint32_t epDci = (evt.Control >> 16) & 0x1F; uint32_t residual = evt.Status & 0x00FFFFFF; + xferEvts++; + lastSlot = slotId; lastEp = epDci; lastCC = completionCode; if (epDci == 1) { // EP0 (DCI 1) - control transfer completion @@ -437,9 +476,18 @@ namespace Drivers::USB::Xhci { uint8_t intDci = dev.InterruptEpNum ? (dev.InterruptEpNum * 2 + 1) : 0; if (epDci == bulkInDci && g_transferCallbacks[slotId]) { - // Bulk IN — dispatch via registered callback - uint16_t len = dev.BulkInMaxPacket; - if (residual < len) len = dev.BulkInMaxPacket - (uint16_t)residual; + // Bulk IN — dispatch via registered callback. + // len = actually-transferred bytes (requested - + // residual). A 0-byte / ZLP completion has + // residual == requested, so len MUST be 0: the old + // code left len at the full max-packet and handed + // the callback a slice of STALE DMA buffer, which + // the BT driver then counted as a bogus ACL packet + // (the constant rx flood) and pushed into its RX + // ring, crowding out the real Config Response. + uint32_t reqLen = dev.BulkInMaxPacket; + uint16_t len = (residual < reqLen) + ? (uint16_t)(reqLen - residual) : 0; g_transferCallbacks[slotId](slotId, epDci, g_bulkInDataBuf[slotId], len, completionCode); } else if (epDci == bulkOutDci && g_transferCallbacks[slotId]) { @@ -495,6 +543,7 @@ namespace Drivers::USB::Xhci { g_evtRingDequeue = 0; g_evtRingCCS = !g_evtRingCCS; } + processed++; } // Update ERDP to tell the controller we have processed events @@ -504,6 +553,20 @@ namespace Drivers::USB::Xhci { WriteRt(IR0_ERDP, (uint32_t)(erdp & 0xFFFFFFFF)); WriteRt(IR0_ERDP + 4, (uint32_t)(erdp >> 32)); + // A full batch means the ring is being flooded -- surface the dominant + // event source (rate-limited) so a wedge is diagnosable, not silent. + if (processed >= MAX_EVENTS_PER_CALL) { + static uint32_t stormLogs = 0; + if (stormLogs < 8) { + stormLogs++; + KernelLogStream(WARNING, "xHCI") << "Event storm: " << (uint64_t)processed + << "/call (port=" << (uint64_t)portEvts << " xfer=" << (uint64_t)xferEvts + << " lastType=" << (uint64_t)lastType << " slot=" << (uint64_t)lastSlot + << " ep=" << (uint64_t)lastEp << " cc=" << (uint64_t)lastCC << ")"; + } + } + + g_pollActive = false; } // ------------------------------------------------------------------------- @@ -559,8 +622,11 @@ namespace Drivers::USB::Xhci { g_cmdCompleted = false; WriteDoorbell(0, 0); - // Poll until command completes (with timeout) - for (uint32_t i = 0; i < 100000; i++) { + // Poll until command completes. Wall-clock bounded so a storm/wedge + // can't stretch this into a multi-second freeze; normal commands + // complete in well under a millisecond. + uint64_t cmdStart = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - cmdStart < 2000) { PollEvents(); if (g_cmdCompleted) { return g_cmdCompletionCode; @@ -654,8 +720,22 @@ namespace Drivers::USB::Xhci { g_xferCompleted = false; WriteDoorbell(slotId, 1); - // Poll until transfer completes - for (uint32_t i = 0; i < 100000; i++) { + // If we are nested inside PollEvents (e.g. an HCI reply sent from a + // Bluetooth event handler), we cannot wait for completion here: the + // reentrancy guard makes a nested PollEvents a no-op, so the completion + // would never be observed and the timeout+recovery path would corrupt + // the EP0 ring. The transfer is submitted (doorbell rung); let the + // active PollEvents reap its completion. Fire-and-forget. + if (g_pollActive) { + return CC_SUCCESS; + } + + // Poll until transfer completes. Wall-clock bounded (not iteration + // bounded) so a wedged device fails in ~2s and reports its cc, instead + // of the per-iteration cost ballooning under an event storm into a + // multi-second freeze with no output. + uint64_t xferStart = Timekeeping::GetMilliseconds(); + while (Timekeeping::GetMilliseconds() - xferStart < 2000) { PollEvents(); if (g_xferCompleted) { return g_xferCompletionCode; @@ -730,6 +810,43 @@ namespace Drivers::USB::Xhci { WriteDoorbell(slotId, target); } + // ------------------------------------------------------------------------- + // ResetInterruptEndpoint - clear a halted interrupt IN endpoint and re-arm + // ------------------------------------------------------------------------- + // A USB transaction error (cc=4) halts the endpoint; the host must issue + // Reset Endpoint + Set TR Dequeue before it will accept transfers again. + // Used by the Bluetooth firmware-download path, where a glitch on the event + // pipe near the end of a large upload otherwise kills event reception for + // good (no Command Complete / bootup events). + void ResetInterruptEndpoint(uint8_t slotId) { + if (slotId == 0 || slotId > MAX_SLOTS || !g_devices[slotId].Active) return; + UsbDeviceInfo& dev = g_devices[slotId]; + if (dev.InterruptEpNum == 0 || !dev.InterruptRing) return; + + uint8_t dci = dev.InterruptEpNum * 2 + 1; + + TRB resetTrb = {}; + resetTrb.Control = (TRB_RESET_ENDPOINT << TRB_TYPE_SHIFT) + | ((uint32_t)slotId << 24) + | ((uint32_t)dci << 16); + SendCommand(resetTrb); + + uint64_t newDeq = dev.InterruptRingPhys + + (uint64_t)dev.InterruptRingEnqueue * sizeof(TRB); + if (dev.InterruptRingCCS) newDeq |= 1; // DCS bit + + TRB deqTrb = {}; + deqTrb.Parameter0 = (uint32_t)(newDeq & 0xFFFFFFFF); + deqTrb.Parameter1 = (uint32_t)(newDeq >> 32); + deqTrb.Control = (TRB_SET_TR_DEQUEUE << TRB_TYPE_SHIFT) + | ((uint32_t)slotId << 24) + | ((uint32_t)dci << 16); + SendCommand(deqTrb); + + // Re-arm reception. + QueueInterruptTransfer(slotId); + } + // ------------------------------------------------------------------------- // QueueBulkInTransfer // ------------------------------------------------------------------------- diff --git a/kernel/src/Drivers/USB/Xhci.hpp b/kernel/src/Drivers/USB/Xhci.hpp index c01824f..740bcee 100644 --- a/kernel/src/Drivers/USB/Xhci.hpp +++ b/kernel/src/Drivers/USB/Xhci.hpp @@ -315,6 +315,16 @@ namespace Drivers::USB::Xhci { // Queue an interrupt IN transfer on a device's interrupt endpoint void QueueInterruptTransfer(uint8_t slotId); + // Clear a halted interrupt IN endpoint (Reset Endpoint + Set TR Dequeue) + // and re-arm reception. Needed after a USB transaction error on the event + // pipe (e.g. during Bluetooth firmware download). + void ResetInterruptEndpoint(uint8_t slotId); + + // True while PollEvents() is draining the event ring. A command submitter + // reached from inside an event callback must fire-and-forget (not wait), + // since a nested PollEvents() is a no-op. + bool InPollContext(); + // Queue a bulk transfer on a device's bulk IN or OUT endpoint void QueueBulkInTransfer(uint8_t slotId, uint8_t* data, uint64_t dataPhys, uint32_t length); void QueueBulkOutTransfer(uint8_t slotId, uint8_t* data, uint64_t dataPhys, uint32_t length); diff --git a/kernel/src/Main.cpp b/kernel/src/Main.cpp index 58c2211..ae39931 100644 --- a/kernel/src/Main.cpp +++ b/kernel/src/Main.cpp @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -178,6 +179,11 @@ extern "C" void kmain() { Fs::InitializeBootFilesystems(module_request.response); + // A Bluetooth adapter present at boot enumerates during the xHCI port scan, + // before the ramdisk is mounted. Now that drive 0 is up, finish any + // firmware-dependent bring-up that was deferred (loads ibt-*.sfi/.ddc). + Drivers::USB::Bluetooth::ServiceDeferredInit(); + Hal::LoadTSS(); Montauk::InitializeSyscalls(); diff --git a/programs/GNUmakefile b/programs/GNUmakefile index 63ab3b4..d288690 100644 --- a/programs/GNUmakefile +++ b/programs/GNUmakefile @@ -78,6 +78,12 @@ WWWDST := $(patsubst $(WWWDIR)/%,$(BINDIR)/www/%,$(WWWSRC)) # CA certificate bundle. CA_CERTS := $(BINDIR)/os/certs/ca-certificates.crt +# Device firmware blobs (e.g. Intel Bluetooth ibt-*.sfi/.ddc) bundled into +# bin/os/firmware/ so the kernel can load them from the ramdisk at runtime. +FWDIR := data/firmware +FWSRC := $(shell find $(FWDIR) -type f 2>/dev/null) +FWDST := $(patsubst $(FWDIR)/%,$(BINDIR)/os/firmware/%,$(FWSRC)) + # System config TOML files bundled into bin/config/. CONFIGDIR := data/config CONFIGSRC := $(wildcard $(CONFIGDIR)/*.toml) @@ -85,7 +91,7 @@ CONFIGDST := $(patsubst $(CONFIGDIR)/%,$(BINDIR)/config/%,$(CONFIGSRC)) .PHONY: all clean 2048 doom fetch wiki wikipedia weather imageviewer fontpreview spreadsheet wordprocessor pdfviewer disks devexplorer installer audio music video bluetooth network terminal klog procmgr calculator login desktop shell rpgdemo paint tcc lua screenshot texteditor mandelbrot printers timezone printd printctl dialogs icons fonts configs bearssl libc tls libjpeg libjpegwrite install-apps libloader libs libhello test_dialogs test_dl crashpad -all: bearssl libc libjpeg libjpegwrite tls libloader libs libhello $(TARGETS) fetch wiki wikipedia weather imageviewer fontpreview spreadsheet wordprocessor pdfviewer disks devexplorer installer audio music video bluetooth network terminal klog procmgr calculator 2048 doom rpgdemo paint tcc lua screenshot texteditor mandelbrot printers timezone printd printctl dialogs login desktop shell icons fonts install-apps test_dialogs test_dl crashpad $(MANDST) $(WWWDST) $(CA_CERTS) $(CONFIGDST) +all: bearssl libc libjpeg libjpegwrite tls libloader libs libhello $(TARGETS) fetch wiki wikipedia weather imageviewer fontpreview spreadsheet wordprocessor pdfviewer disks devexplorer installer audio music video bluetooth network terminal klog procmgr calculator 2048 doom rpgdemo paint tcc lua screenshot texteditor mandelbrot printers timezone printd printctl dialogs login desktop shell icons fonts install-apps test_dialogs test_dl crashpad $(MANDST) $(WWWDST) $(CA_CERTS) $(CONFIGDST) $(FWDST) # Build BearSSL static library (cross-compiled for freestanding x86_64). BEARSSL_INCLUDES := -isystem $(shell cd .. && pwd)/kernel/freestnd-c-hdrs/x86_64/include -isystem $(abspath include/libc) @@ -328,6 +334,11 @@ $(CA_CERTS): data/ca-certificates.crt mkdir -p $(BINDIR)/os/certs cp $< $@ +# Copy device firmware blobs into bin/os/firmware/ (preserving subdirs). +$(BINDIR)/os/firmware/%: $(FWDIR)/% + mkdir -p $(dir $@) + cp $< $@ + # Copy system config files into bin/config/. $(BINDIR)/config/%: $(CONFIGDIR)/% mkdir -p $(BINDIR)/config diff --git a/programs/data/firmware/intel/ibt-1040-0041.ddc b/programs/data/firmware/intel/ibt-1040-0041.ddc new file mode 100644 index 0000000000000000000000000000000000000000..6e067796ed5e452f5914f576e750263123672c02 GIT binary patch literal 9 QcmZS9V3c6dWMpOl00O)Kb^rhX literal 0 HcmV?d00001 diff --git a/programs/data/firmware/intel/ibt-1040-0041.sfi b/programs/data/firmware/intel/ibt-1040-0041.sfi new file mode 100644 index 0000000000000000000000000000000000000000..6de49e177ea69616665daf6c1f654d119057c942 GIT binary patch literal 720988 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
XX=-_x>;3QTmmiFjx%Ay}N6M<(^*42jH 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

HV#F&Q?_Z))gWx!*Go8b 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%0AHI(>U7yVL1*99OrU@6`W-Nn*V+yQt( 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%0AAu{O(GD^~v>scXAlx-FFZ4_}!^) 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 N+v63Yx{Aa2e*i30ifRA= literal 0 HcmV?d00001