Skip to contentSkip to conversation

shared/asha: Cancel callbacks before resetting the device

RFC PATCH New Kyle Pepper 1 participant 2 messages Oct 15 Bluetooth drivers

lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/2 shared/asha: Cancel callbacks before resetting the device

Track and cancel the pending ACP request before releasing stream state. Detach state callbacks before invoking an owner that may remove the device. Send STOP when canceling a START that is already queued.

Detach set membership before clearing its identity, retain replacement members and clear notification registration on reset.

Fixes 8e4bece63ce9 ("src/shared: Add initial implementation for an ASHA profile")
Fixes f44d3e08e9a1 ("shared/asha: Add support for other side update")
Assisted-by OpenCode:gpt-6.1-sol

---
First of two new patches. Apply on BlueZ dd9d5ba1fa4f with the already-sent STATUS v2 and STOP changes, in that order. These prerequisites are not resent:
https://lore.kernel.org/linux-bluetooth/[email protected]/
https://lore.kernel.org/linux-bluetooth/[email protected]/

This patch handles pending ACP request/callback ownership, cancellation and set/notification reset. Patch 2 uses these lifecycle operations to gate ASHA startup and stop acquired streams after incompatible completed intervals.

The prerequisite alone passes its ASHA sanitizer fixtures. The combined standalone source passes 38/38 strict-maintainer ASan/UBSan and 38/38 ordinary LTO unit binaries. The full strict-maintainer plus LTO combination retains documented baseline GATT/monitor errors; it is not claimed passing.

The Arch integration was built in a clean chroot and is reported working on hardware. That trial also includes other existing runtime fixes; it is not isolated attribution or coverage of every cancellation/teardown interleaving. No remote CI, severity assessment or proof of all surrounding lifetimes is claimed.

 src/shared/asha.c         |  63 +++++++++++-------
 src/shared/asha.h         |   1 +
 unit/test-asha-interval.c | 137 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 177 insertions(+), 24 deletions(-)
src/shared/asha.c +39 -24
index f73bbce1d5..e6862e8423 100644
@@ -106,10 +106,10 @@ static void update_asha_set(struct bt_asha *asha, bool connected)
 			return;
 		}
 
-		if (asha->right_side && set->right) {
+		if (asha->right_side && set->right == asha) {
 			set->right = NULL;
 			DBG("Right side unregistered for ASHA set");
-		} else if (!asha->right_side && set->left) {
+		} else if (!asha->right_side && set->left == asha) {
 			set->left = NULL;
 			DBG("Left side unregistered for ASHA set");
 		}
@@ -163,9 +163,13 @@ struct bt_asha *bt_asha_new(void)
 
 void bt_asha_reset(struct bt_asha *asha)
 {
+	bt_asha_state_reset(asha);
+	update_asha_set(asha, false);
+
 	if (asha->status_notify_id) {
 		bt_gatt_client_unregister_notify(asha->client,
 						asha->status_notify_id);
+		asha->status_notify_id = 0;
 	}
 
 	gatt_db_unref(asha->db);
@@ -174,19 +178,20 @@ void bt_asha_reset(struct bt_asha *asha)
 	bt_gatt_client_unref(asha->client);
 	asha->client = NULL;
 
-	bt_asha_state_reset(asha);
-
 	asha->psm = 0;
 	memset(asha->hisyncid, 0, sizeof(asha->hisyncid));
 
 	asha->attach_cb = NULL;
 	asha->attach_cb_data = NULL;
-
-	update_asha_set(asha, false);
 }
 
 void bt_asha_state_reset(struct bt_asha *asha)
 {
+	if (asha->acp_id) {
+		bt_gatt_client_cancel(asha->client, asha->acp_id);
+		asha->acp_id = 0;
+	}
+
 	asha->state = ASHA_STOPPED;
 
 	asha->state_cb = NULL;
@@ -195,33 +200,40 @@ void bt_asha_state_reset(struct bt_asha *asha)
 
 void bt_asha_free(struct bt_asha *asha)
 {
-	update_asha_set(asha, false);
-	gatt_db_unref(asha->db);
-	bt_gatt_client_unref(asha->client);
+	bt_asha_reset(asha);
 	free(asha);
 }
 
 static void asha_acp_sent(bool success, uint8_t err, void *user_data)
 {
 	struct bt_asha *asha = user_data;
+	bt_asha_cb_t callback = asha->state_cb;
+	void *data = asha->state_cb_data;
+
+	asha->acp_id = 0;
 
 	if (success) {
 		DBG("AudioControlPoint command successfully sent");
 	} else {
 		error("Failed to send AudioControlPoint command: %d", err);
 
-		if (asha->state_cb)
-			asha->state_cb(-1, asha->state_cb_data);
-
 		bt_asha_state_reset(asha);
+
+		if (callback)
+			callback(-1, data);
 	}
 }
 
 static int asha_send_acp(struct bt_asha *asha, uint8_t *cmd,
 		unsigned int len, bt_asha_cb_t cb, void *user_data)
 {
-	if (!bt_gatt_client_write_value(asha->client, asha->acp_handle, cmd,
-				len, asha_acp_sent, asha, NULL)) {
+	if (asha->acp_id)
+		bt_gatt_client_cancel(asha->client, asha->acp_id);
+
+	asha->acp_id = bt_gatt_client_write_value(asha->client,
+				asha->acp_handle, cmd, len, asha_acp_sent,
+				asha, NULL);
+	if (!asha->acp_id) {
 		error("Error writing ACP command");
 		return -1;
 	}
@@ -307,18 +319,17 @@ unsigned int bt_asha_stop(struct bt_asha *asha)
 	};
 	int ret;
 
-	if (asha->state != ASHA_STARTED)
+	if (asha->state == ASHA_STOPPED)
 		return 0;
 
-	asha->state = ASHA_STOPPED;
+	/* Cancel a pending START before queuing STOP on the same ATT link. */
+	bt_asha_state_reset(asha);
 
 	/* State is reset below without waiting for an ATT response. */
 	ret = asha_send_acp_without_response(asha, acp_stop_cmd,
 			sizeof(acp_stop_cmd));
 	asha_set_send_status(asha, false);
 
-	/* We reset our state without waiting for a response */
-	bt_asha_state_reset(asha);
 	DBG("ASHA stop done");
 
 	return ret;
@@ -468,10 +479,17 @@ static void audio_status_notify(uint16_t value_handle, const uint8_t *value,
 					uint16_t length, void *user_data)
 {
 	struct bt_asha *asha = user_data;
-	uint8_t status = *value;
+	uint8_t status;
 	/* Back these up to survive the reset paths */
 	bt_asha_cb_t state_cb = asha->state_cb;
-	bt_asha_cb_t state_cb_data = asha->state_cb_data;
+	void *state_cb_data = asha->state_cb_data;
+
+	if (length != 1)
+		return;
+
+	status = value[0];
+	asha->state_cb = NULL;
+	asha->state_cb_data = NULL;
 
 	DBG("ASHA status %u", status);
 
@@ -487,11 +505,8 @@ static void audio_status_notify(uint16_t value_handle, const uint8_t *value,
 		}
 	}
 
-	if (state_cb) {
+	if (state_cb)
 		state_cb(status, state_cb_data);
-		asha->state_cb = NULL;
-		asha->state_cb_data = NULL;
-	}
 }
 
 static void handle_characteristic(struct gatt_db_attribute *attr,
src/shared/asha.h +1 -0
index e6b2e7a0d2..cbacb5ddff 100644
@@ -31,6 +31,7 @@ struct bt_asha {
 	uint16_t acp_handle;
 	uint16_t volume_handle;
 	unsigned int status_notify_id;
+	unsigned int acp_id;
 
 	uint16_t psm;
 	bool right_side;
unit/test-asha-interval.c +137 -0

161 lines not on this page · raw message

base-commit: dd9d5ba1fa4f682b082b1275a8c38523d95a58fd
prerequisite-patch-id: ddf57fe789414af62220e755ca04c36ec8d46260
prerequisite-patch-id: 612e58f161bb31025d30aabe6a68809255e314ba

#1 lore raw

RFC PATCH 2/2 asha: Gate streaming on the observed connection interval

Wait for a completed 20 ms interval and queued STATUS before sending G.722 START. Bound acquisition through AudioStatusPoint and cancel pending CoC, timer and ACP work before releasing its owner.

Report later completed intervals and close an acquired stream if its interval becomes incompatible. Defer transport teardown outside HCI iteration and unregister its callback when the transport is destroyed.

Fixes c26389c466a0 ("profiles/audio: Add an ASHA plugin")
Assisted-by OpenCode:gpt-6.1-sol

---
Second of two new patches; requires patch 1 and the already-sent STATUS v2 and STOP prerequisites. It does not replace or resend either prerequisite.

Observe a completed 20 ms interval and queue STATUS before START. Bound setup through AudioStatusPoint and cancel pending acquisition on stop/reset/removal. On an incompatible completed interval after acquisition, report STATUS and defer STOP, CoC closure and transport-owner removal outside the HCI stream iteration. A failed update proposal does not invalidate a last observed working interval.

Coverage includes 21 startup, seven pending-CoC and 12 acquired-stream scenarios. Combined standalone source: 38/38 strict ASan/UBSan and 38/38 ordinary LTO unit binaries. Actual BtIO watch fixture: 500 cycles; extracted transport closure
functions: 1,000 mocked-owner cycles. No Valgrind or remote-CI pass is claimed.

The combined Arch port passes 44/44 package tests and is reported working on hardware; specific N7, paired-device and incompatible-update hardware coverage was not supplied. Standalone source is submitted here, not package integration.

Unknown/missed initial intervals are not reconstructed from requested values:
setup waits for an observation and may time out, including after daemon restart. Incompatible acquired timing closes the audio stream; seamless renegotiation or uninterrupted playback is not guaranteed. No forced ACL disconnect or new kernel ABI is added. A valid disjoint peer request can remain legal in Linux.

Companion Linux soft-preference RFC v2 and independent BlueZ interval tests:
https://lore.kernel.org/linux-bluetooth/[email protected]/
https://lore.kernel.org/linux-bluetooth/[email protected]/
Archive rendering of these links has not been independently verified.

 profiles/audio/asha.c      | 333 +++++++++++++++++---
 profiles/audio/asha.h      |   2 +
 profiles/audio/transport.c |  20 +-
 unit/test-asha-conn.c      | 603 +++++++++++++++++++++++++++++++++++--
 4 files changed, 904 insertions(+), 54 deletions(-)
profiles/audio/asha.c +298 -35
index 6596ff3633..310022ff4c 100644
@@ -55,6 +55,8 @@
 #define ASHA_MIN_MTU 163
 /* The default of 672 does not work */
 #define ASHA_CONNECTION_MTU 512
+#define ASHA_STREAM_INTERVAL 0x0010
+#define ASHA_START_TIMEOUT 10
 
 /* HCI connection handles occupy 0x0000 through 0x0eff. Zero is unknown. */
 #define ASHA_NUM_HANDLES 0x0f00
@@ -68,15 +70,34 @@ struct asha_adapter {
 static struct queue *asha_adapters;
 static struct queue *asha_streams;
 
+struct asha_start_wait {
+	bt_asha_cb_t callback;
+	void *user_data;
+	unsigned int source_id;
+	int error;
+	bool connected;
+	bool sent;
+};
+
+struct connect_data {
+	struct bt_asha_device *asha_dev;
+};
+
 struct bt_asha_device {
 	struct bt_asha *asha;
 	struct btd_device *device;
 	struct media_transport *transport;
 
 	GIOChannel *io;
+	struct connect_data *connect_data;
 	uint16_t imtu, omtu;
 
 	unsigned int resume_id;
+	struct asha_start_wait *start_wait;
+	unsigned int close_id;
+	int close_error;
+	bt_asha_cb_t closed_cb;
+	void *closed_data;
 };
 
 static bool match_adapter(const void *data, const void *user_data)
@@ -113,20 +134,25 @@ static bool asha_get_handle(struct bt_asha_device *asha_dev, uint16_t *handle)
 	return true;
 }
 
-static void asha_notify_interval(struct bt_asha_device *asha_dev,
+static bool asha_notify_interval(struct bt_asha_device *asha_dev,
 					uint16_t handle, uint16_t interval)
 {
 	/* Only announce an interval observed on this connection. */
 	if (!interval)
-		return;
+		return false;
 
 	DBG("ASHA connection h%u interval %u", handle, interval);
 
-	if (!bt_asha_set_connection_interval(asha_dev->asha, interval))
+	if (!bt_asha_set_connection_interval(asha_dev->asha, interval)) {
 		DBG("Could not send ASHA connection interval notification");
+		return false;
+	}
+
+	return true;
 }
 
-static void asha_send_interval(struct bt_asha_device *asha_dev)
+static bool asha_send_interval(struct bt_asha_device *asha_dev,
+						uint16_t *interval)
 {
 	struct asha_adapter *data;
 	uint16_t handle;
@@ -134,39 +160,234 @@ static void asha_send_interval(struct bt_asha_device *asha_dev)
 	data = queue_find(asha_adapters, match_adapter,
 					device_get_adapter(asha_dev->device));
 	if (!data || !asha_get_handle(asha_dev, &handle))
+		return false;
+
+	if (interval)
+		*interval = data->intervals[handle];
+
+	return asha_notify_interval(asha_dev, handle, data->intervals[handle]);
+}
+
+static void asha_start_wait_cancel(struct bt_asha_device *asha_dev)
+{
+	struct asha_start_wait *wait = asha_dev->start_wait;
+
+	if (!wait)
+		return;
+
+	asha_dev->start_wait = NULL;
+
+	if (wait->source_id)
+		g_source_remove(wait->source_id);
+
+	g_free(wait);
+}
+
+static void asha_cancel_connect(struct bt_asha_device *asha_dev)
+{
+	if (!asha_dev->connect_data)
+		return;
+
+	asha_dev->connect_data->asha_dev = NULL;
+	asha_dev->connect_data = NULL;
+}
+
+static gboolean asha_start_wait_error(gpointer user_data)
+{
+	struct bt_asha_device *asha_dev = user_data;
+	struct asha_start_wait *wait = asha_dev->start_wait;
+	bt_asha_cb_t callback = wait->callback;
+	void *data = wait->user_data;
+	int err = wait->error;
+
+	wait->source_id = 0;
+	bt_asha_device_stop(asha_dev);
+
+	/* The owner callback may remove the device. */
+	if (callback)
+		callback(err, data);
+
+	return G_SOURCE_REMOVE;
+}
+
+static gboolean asha_start_wait_timeout(gpointer user_data)
+{
+	struct bt_asha_device *asha_dev = user_data;
+
+	asha_dev->start_wait->error = -ETIMEDOUT;
+	return asha_start_wait_error(asha_dev);
+}
+
+static void asha_start_wait_fail(struct bt_asha_device *asha_dev, int err)
+{
+	struct asha_start_wait *wait = asha_dev->start_wait;
+
+	if (!wait || wait->error)
+		return;
+
+	if (wait->source_id)
+		g_source_remove(wait->source_id);
+
+	wait->error = err;
+	/* Do not call the owner from inside the HCI stream iteration. */
+	wait->source_id = g_idle_add(asha_start_wait_error, asha_dev);
+}
+
+static void asha_start_complete(int status, void *user_data)
+{
+	struct bt_asha_device *asha_dev = user_data;
+	struct asha_start_wait *wait = asha_dev->start_wait;
+	bt_asha_cb_t callback;
+	void *data;
+
+	if (!wait || wait->error)
 		return;
 
-	asha_notify_interval(asha_dev, handle, data->intervals[handle]);
+	if (status) {
+		asha_start_wait_fail(asha_dev, -EIO);
+		return;
+	}
+
+	callback = wait->callback;
+	data = wait->user_data;
+	asha_start_wait_cancel(asha_dev);
+
+	if (callback)
+		callback(0, data);
+}
+
+static void asha_start_wait_try(struct bt_asha_device *asha_dev)
+{
+	struct asha_start_wait *wait = asha_dev->start_wait;
+	uint16_t interval = 0;
+	bool notified;
+
+	if (!wait || wait->error || !wait->connected || wait->sent)
+		return;
+
+	notified = asha_send_interval(asha_dev, &interval);
+	if (!interval)
+		return;
+
+	if (!notified) {
+		asha_start_wait_fail(asha_dev, -EIO);
+		return;
+	}
+
+	if (interval != ASHA_STREAM_INTERVAL)
+		return;
+
+	wait->sent = true;
+
+	if (bt_asha_start(asha_dev->asha, asha_start_complete, asha_dev))
+		asha_start_wait_fail(asha_dev, -EIO);
+}
+
+static void asha_start_wait_begin(struct bt_asha_device *asha_dev,
+					bt_asha_cb_t callback, void *user_data)
+{
+	struct asha_start_wait *wait;
+
+	wait = g_new0(struct asha_start_wait, 1);
+	wait->callback = callback;
+	wait->user_data = user_data;
+	asha_dev->start_wait = wait;
+	wait->source_id = g_timeout_add_seconds(ASHA_START_TIMEOUT,
+					asha_start_wait_timeout, asha_dev);
+}
+
+static void asha_stream_close_cancel(struct bt_asha_device *asha_dev)
+{
+	if (!asha_dev->close_id)
+		return;
+
+	g_source_remove(asha_dev->close_id);
+	asha_dev->close_id = 0;
+}
+
+static gboolean asha_stream_closed(gpointer user_data)
+{
+	struct bt_asha_device *asha_dev = user_data;
+	bt_asha_cb_t callback = asha_dev->closed_cb;
+	void *data = asha_dev->closed_data;
+	int err = asha_dev->close_error;
+
+	asha_dev->close_id = 0;
+	bt_asha_device_stop(asha_dev);
+
+	if (callback)
+		callback(err, data);
+
+	return G_SOURCE_REMOVE;
+}
+
+static void asha_stream_fail(struct bt_asha_device *asha_dev, int err)
+{
+	if (asha_dev->close_id || asha_dev->asha->state != ASHA_STARTED)
+		return;
+
+	asha_dev->close_error = err;
+	/* Transport teardown must not run inside the HCI stream iteration. */
+	asha_dev->close_id = g_idle_add(asha_stream_closed, asha_dev);
 }
 
 struct interval_update {
 	struct asha_adapter *adapter;
 	uint16_t handle;
+	int error;
 };
 
 static void asha_update_stream(void *data, void *user_data)
 {
 	struct bt_asha_device *asha_dev = data;
 	struct interval_update *update = user_data;
-	uint16_t handle;
+	uint16_t handle, interval;
+	bool notified;
 
 	if (device_get_adapter(asha_dev->device) != update->adapter->adapter ||
 			!asha_get_handle(asha_dev, &handle) ||
 			handle != update->handle)
 		return;
 
-	asha_notify_interval(asha_dev, handle,
-					update->adapter->intervals[handle]);
+	if (update->error) {
+		asha_start_wait_fail(asha_dev, update->error);
+
+		if (update->error == -ENOTCONN)
+			asha_stream_fail(asha_dev, update->error);
+
+		return;
+	}
+
+	interval = update->adapter->intervals[handle];
+
+	/* An update can race the START response or AudioStatus notification. */
+	if (asha_dev->start_wait && asha_dev->start_wait->sent &&
+					interval != ASHA_STREAM_INTERVAL) {
+		asha_start_wait_fail(asha_dev, -ERANGE);
+		return;
+	}
+
+	if (asha_dev->start_wait) {
+		asha_start_wait_try(asha_dev);
+		return;
+	}
+
+	notified = asha_notify_interval(asha_dev, handle, interval);
+
+	if (interval != ASHA_STREAM_INTERVAL)
+		asha_stream_fail(asha_dev, -ERANGE);
+	else if (!notified)
+		asha_stream_fail(asha_dev, -EIO);
 }
 
 static void asha_conn_update(const void *param, uint8_t size, void *user_data)
 {
 	const struct bt_hci_evt_le_conn_update_complete *ev = param;
 	struct asha_adapter *data = user_data;
-	struct interval_update update;
+	struct interval_update update = { 0 };
 	uint16_t handle;
 
-	if (size != sizeof(*ev) || ev->status)
+	if (size != sizeof(*ev))
 		return;
 
 	handle = get_le16(&ev->handle);
@@ -174,7 +395,10 @@ static void asha_conn_update(const void *param, uint8_t size, void *user_data)
 	if (handle >= ASHA_NUM_HANDLES)
 		return;
 
-	data->intervals[handle] = get_le16(&ev->interval);
+	if (!ev->status)
+		data->intervals[handle] = get_le16(&ev->interval);
+	else
+		update.error = -EIO;
 	update.adapter = data;
 	update.handle = handle;
 	queue_foreach(asha_streams, asha_update_stream, &update);
@@ -216,6 +440,7 @@ static void asha_disconn_complete(const void *param, uint8_t size,
 {
 	const struct bt_hci_evt_disconnect_complete *ev = param;
 	struct asha_adapter *data = user_data;
+	struct interval_update update = { .adapter = data, .error = -ENOTCONN };
 	uint16_t handle;
 
 	if (size != sizeof(*ev) || ev->status)
@@ -223,8 +448,12 @@ static void asha_disconn_complete(const void *param, uint8_t size,
 
 	handle = get_le16(&ev->handle);
 
-	if (handle < ASHA_NUM_HANDLES)
-		data->intervals[handle] = 0;
+	if (handle >= ASHA_NUM_HANDLES)
+		return;
+
+	data->intervals[handle] = 0;
+	update.handle = handle;
+	queue_foreach(asha_streams, asha_update_stream, &update);
 }
 
 static int asha_adapter_probe(struct btd_profile *profile,
@@ -263,6 +492,17 @@ fail:
 	return -EIO;
 }
 
+static void asha_adapter_cancel_stream(void *data, void *user_data)
+{
+	struct bt_asha_device *asha_dev = data;
+
+	if (device_get_adapter(asha_dev->device) != user_data)
+		return;
+
+	asha_start_wait_fail(asha_dev, -ENODEV);
+	asha_stream_fail(asha_dev, -ENODEV);
+}
+
 static void asha_adapter_remove(struct btd_profile *profile,
 						struct btd_adapter *adapter)
 {
@@ -273,6 +513,7 @@ static void asha_adapter_remove(struct btd_profile *profile,
 	if (!data)
 		return;
 
+	queue_foreach(asha_streams, asha_adapter_cancel_stream, adapter);
 	bt_hci_unref(data->hci);
 	free(data);
 
@@ -297,20 +538,20 @@ static char *make_endpoint_path(struct bt_asha_device *asha_dev)
 	return path;
 }
 
-struct connect_data {
-	struct bt_asha_device *asha_dev;
-	bt_asha_cb_t cb;
-	void *cb_user_data;
-};
-
 static void connect_cb(GIOChannel *io, GError *err, gpointer user_data)
 {
 	struct connect_data *conn_data = user_data;
 	struct bt_asha_device *asha_dev = conn_data->asha_dev;
 	GError *gerr = NULL;
 
+	if (!asha_dev)
+		return;
+
+	asha_dev->connect_data = NULL;
+
 	if (err) {
 		error("%s", err->message);
+		asha_start_wait_fail(asha_dev, -EIO);
 		return;
 	}
 
@@ -325,12 +566,8 @@ static void connect_cb(GIOChannel *io, GError *err, gpointer user_data)
 		g_error_free(gerr);
 	}
 
-	asha_dev->io = io;
-
-	asha_send_interval(asha_dev);
-
-	bt_asha_start(asha_dev->asha, conn_data->cb,
-					conn_data->cb_user_data);
+	asha_dev->start_wait->connected = true;
+	asha_start_wait_try(asha_dev);
 }
 
 static int asha_connect_socket(struct bt_asha_device *asha_dev,
@@ -340,21 +577,22 @@ static int asha_connect_socket(struct bt_asha_device *asha_dev,
 	const bdaddr_t *src_addr;
 	struct connect_data *conn_data;
 
-	if (asha_dev->asha->state != ASHA_STOPPED) {
+	if (asha_dev->io || asha_dev->start_wait ||
+					asha_dev->asha->state != ASHA_STOPPED) {
 		error("ASHA device connect failed. Bad state %d",
 							asha_dev->asha->state);
-		return 0;
+		return -EBUSY;
 	}
 
 	conn_data = g_new0(struct connect_data, 1);
 	conn_data->asha_dev = asha_dev;
-	conn_data->cb = cb;
-	conn_data->cb_user_data = user_data;
+	asha_dev->connect_data = conn_data;
+	asha_start_wait_begin(asha_dev, cb, user_data);
 
 	src_addr = btd_adapter_get_address(
 			device_get_adapter(asha_dev->device));
 
-	if (!bt_io_connect(connect_cb, conn_data,
+	asha_dev->io = bt_io_connect(connect_cb, conn_data,
 				g_free, &gerr,
 				BT_IO_OPT_MODE, BT_IO_MODE_LE_FLOWCTL,
 				BT_IO_OPT_SOURCE_TYPE, BDADDR_LE_PUBLIC,
@@ -365,9 +603,13 @@ static int asha_connect_socket(struct bt_asha_device *asha_dev,
 				BT_IO_OPT_PSM, asha_dev->asha->psm,
 				BT_IO_OPT_OMTU, ASHA_MIN_MTU,
 				BT_IO_OPT_IMTU, ASHA_CONNECTION_MTU,
-				BT_IO_OPT_INVALID)) {
+				BT_IO_OPT_INVALID);
+	if (!asha_dev->io) {
 		error("Could not open L2CAP CoC socket: %s", gerr->message);
 		g_error_free(gerr);
+		asha_dev->connect_data = NULL;
+		g_free(conn_data);
+		asha_start_wait_cancel(asha_dev);
 		goto error;
 	}
 
@@ -393,13 +635,20 @@ unsigned int bt_asha_device_start(struct bt_asha_device *asha_dev,
 
 	if (ret < 0)
 		return 0;
-	else
-		return (++asha_dev->resume_id);
+
+	if (!++asha_dev->resume_id)
+		++asha_dev->resume_id;
+
+	return asha_dev->resume_id;
 }
 
 unsigned int bt_asha_device_stop(struct bt_asha_device *asha_dev)
 {
+	asha_stream_close_cancel(asha_dev);
+	asha_start_wait_cancel(asha_dev);
+	asha_cancel_connect(asha_dev);
 	bt_asha_stop(asha_dev->asha);
+	bt_asha_state_reset(asha_dev->asha);
 
 	if (asha_dev->io) {
 		g_io_channel_shutdown(asha_dev->io, TRUE, NULL);
@@ -412,6 +661,10 @@ unsigned int bt_asha_device_stop(struct bt_asha_device *asha_dev)
 
 void bt_asha_device_state_reset(struct bt_asha_device *asha_dev)
 {
+	asha_stream_close_cancel(asha_dev);
+	asha_start_wait_cancel(asha_dev);
+	asha_cancel_connect(asha_dev);
+
 	if (asha_dev->io) {
 		g_io_channel_shutdown(asha_dev->io, TRUE, NULL);
 		g_io_channel_unref(asha_dev->io);
@@ -419,8 +672,6 @@ void bt_asha_device_state_reset(struct bt_asha_device *asha_dev)
 	};
 
 	bt_asha_state_reset(asha_dev->asha);
-
-	asha_dev->resume_id = 0;
 }
 
 unsigned int bt_asha_device_device_get_resume_id(
@@ -432,9 +683,19 @@ unsigned int bt_asha_device_device_get_resume_id(
 enum bt_asha_state_t bt_asha_device_get_state(
 					struct bt_asha_device *asha_dev)
 {
+	if (asha_dev->start_wait)
+		return ASHA_STARTING;
+
 	return asha_dev->asha->state;
 }
 
+void bt_asha_device_set_stream_closed_cb(struct bt_asha_device *asha_dev,
+					bt_asha_cb_t callback, void *user_data)
+{
+	asha_dev->closed_cb = callback;
+	asha_dev->closed_data = user_data;
+}
+
 uint16_t bt_asha_device_get_render_delay(struct bt_asha_device *asha_dev)
 {
 	return asha_dev->asha->render_delay;
@@ -598,6 +859,7 @@ static void asha_source_device_remove(struct btd_service *service)
 		return;
 	}
 
+	bt_asha_device_state_reset(asha_dev);
 	queue_remove(asha_streams, asha_dev);
 
 	if (queue_isempty(asha_streams)) {
@@ -723,6 +985,7 @@ static int asha_source_disconnect(struct btd_service *service)
 	}
 
 	asha_source_endpoint_unregister(asha_dev);
+	bt_asha_device_state_reset(asha_dev);
 	bt_asha_reset(asha_dev->asha);
 
 	btd_service_disconnecting_complete(service, 0);
profiles/audio/asha.h +2 -0
index 9ffd9d307d..6c3550dc81 100644
@@ -20,6 +20,8 @@ struct bt_asha_device;
 unsigned int bt_asha_device_start(struct bt_asha_device *asha_dev,
 					bt_asha_cb_t cb, void *user_data);
 unsigned int bt_asha_device_stop(struct bt_asha_device *asha_dev);
+void bt_asha_device_set_stream_closed_cb(struct bt_asha_device *asha_dev,
+					bt_asha_cb_t callback, void *user_data);
 
 void bt_asha_device_state_reset(struct bt_asha_device *asha_dev);
 unsigned int bt_asha_device_device_get_resume_id(
profiles/audio/transport.c +19 -1
index e001f73151..794303464a 100644
@@ -2658,11 +2658,29 @@ static int transport_asha_set_volume(struct media_transport *transport,
 	return bt_asha_device_set_volume(asha_dev, scaled_volume) ? 0 : -EIO;
 }
 
+static void asha_transport_closed(int status, void *user_data)
+{
+	struct media_transport *transport = user_data;
+
+	if (transport->owner)
+		media_transport_remove_owner(transport);
+	else
+		transport_set_state(transport, TRANSPORT_STATE_IDLE);
+}
+
 static void *transport_asha_init(struct media_transport *transport, void *data)
 {
+	bt_asha_device_set_stream_closed_cb(data, asha_transport_closed,
+								transport);
+
 	/* We just store the struct asha_device on the transport */
 	return data;
 }
+
+static void transport_asha_destroy(void *data)
+{
+	bt_asha_device_set_stream_closed_cb(data, NULL, NULL);
+}
 #endif /* HAVE_ASHA */
 
 #ifdef HAVE_HFP
@@ -2857,7 +2875,7 @@ static void transport_hfp_cancel(struct media_transport *transport, guint id)
 			transport_asha_resume, transport_asha_suspend, \
 			transport_asha_cancel, NULL, NULL, \
 			transport_asha_get_volume, transport_asha_set_volume, \
-			NULL, NULL, NULL, NULL)
+			NULL, NULL, transport_asha_destroy, NULL)
 
 #define HFP_OPS(_uuid) \
 	TRANSPORT_OPS(_uuid, transport_hfp_properties, NULL, NULL, \
unit/test-asha-conn.c +585 -18

729 lines not on this page · raw message