Bluetooth: BAP: Add control point cbs to BASS

For the control point operations, add/modify/
remove source, callbacks are added so that Application
can decide whether to accept/reject the control point
operations.

Signed-off-by: Nithin Ramesh Myliattil <[email protected]>

Author: niym-ot

include/zephyr/bluetooth/audio/bap.h

@@ -791,6 +791,52 @@ struct bt_bap_scan_delegator_cb {
 	 * @param is_scanning true if scanning started, false if scanning stopped.
 	 */
 	void (*scanning_state)(struct bt_conn *conn, bool is_scanning);
+	/**
+	 * @brief Add Source operation callback
+	 *
+	 * These callbacks notify the application when a request comes
+	 * in to add a source. The application can return 0 to
+	 * accept or any other value to reject the request.
+	 *
+	 * @param conn       Pointer to the connection that initiated the request,
+	 *                   or NULL if locally triggered.
+	 * @param recv_state Pointer to the requested receive state to be added.
+	 *
+	 * @return 0 in case of accept, or other value to reject.
+	 */
+	int (*add_source)(struct bt_conn *conn,
+			  const struct bt_bap_scan_delegator_recv_state *recv_state);
+
+	/**
+	 * @brief Modify Source operation callback
+	 *
+	 * These callbacks notify the application when a request comes
+	 * in to modify a source. The application can return 0 to
+	 * accept or any other value to reject the request.
+	 *
+	 * @param conn       Pointer to the connection that initiated the request,
+	 *                   or NULL if locally triggered.
+	 * @param recv_state Pointer to the requested receive state to be modified.
+	 *
+	 * @return 0 in case of accept, or other value to reject.
+	 */
+	int (*modify_source)(struct bt_conn *conn,
+			     const struct bt_bap_scan_delegator_recv_state *recv_state);
+
+	/**
+	 * @brief Remove Source operation callback
+	 *
+	 * These callbacks notify the application when a request comes
+	 * in to remove a source. The application can return 0 to
+	 * accept or any other value to reject the request.
+	 *
+	 * @param conn   Pointer to the connection that initiated the request,
+	 *               or NULL if locally triggered.
+	 * @param src_id The Source ID that is requested to be removed.
+	 *
+	 * @return 0 in case of accept, or other value to reject.
+	 */
+	int (*remove_source)(struct bt_conn *conn, uint8_t src_id);
 };
 
 /** Structure holding information of audio stream endpoint */

subsys/bluetooth/audio/bap_scan_delegator.c

@@ -743,6 +743,15 @@ static int scan_delegator_add_src(struct bt_conn *conn,
 			     subgroup->metadata_len);
 	}
 
+	if (scan_delegator_cbs != NULL && scan_delegator_cbs->add_source != NULL) {
+		err = scan_delegator_cbs->add_source(conn, state);
+		if (err != 0) {
+			LOG_DBG("add_source callback rejected: 0x%02x", err);
+			ret = BT_GATT_ERR(BT_ATT_ERR_WRITE_REQ_REJECTED);
+			goto unlock_return;
+		}
+	}
+
 	/* The active flag shall be set before any application callbacks, so that any calls for the
 	 * receive state can be processed
 	 */
@@ -970,6 +979,19 @@ static int scan_delegator_mod_src(struct bt_conn *conn,
 		}
 	}
 
+	if (scan_delegator_cbs != NULL && scan_delegator_cbs->modify_source != NULL) {
+		err = scan_delegator_cbs->modify_source(conn, state);
+		if (err != 0) {
+			LOG_DBG("Modify Source rejected with reason 0x%02x", err);
+			(void)memcpy(state, &backup_state, sizeof(backup_state));
+
+			err = k_mutex_unlock(&internal_state->mutex);
+			__ASSERT(err == 0, "Failed to unlock mutex: %d", err);
+
+			return BT_GATT_ERR(BT_ATT_ERR_WRITE_REQ_REJECTED);
+		}
+	}
+
 	/* Only send the sync request to upper layers if it is requested, and
 	 * we are not already synced to the device
 	 */
@@ -1006,22 +1028,17 @@ static int scan_delegator_mod_src(struct bt_conn *conn,
 	} else if (pa_sync == BT_BAP_BASS_PA_REQ_NO_SYNC &&
 		   (state->pa_sync_state == BT_BAP_PA_STATE_INFO_REQ ||
 		    state->pa_sync_state == BT_BAP_PA_STATE_SYNCED)) {
-		/* Unlock mutex to avoid potential deadlock on app callback */
-		err = k_mutex_unlock(&internal_state->mutex);
-		__ASSERT(err == 0, "Failed to unlock mutex: %d", err);
-
 		/* Terminate PA sync */
 		err = pa_sync_term_request(conn, &internal_state->state);
 
 		if (err != 0) {
 			LOG_DBG("PA sync term from %p was rejected with reason %d", (void *)conn,
 				err);
-
+			err = k_mutex_unlock(&internal_state->mutex);
+			__ASSERT(err == 0, "Failed to unlock mutex: %d", err);
 			return BT_GATT_ERR(BT_ATT_ERR_WRITE_REQ_REJECTED);
 		}
-
 		state_changed = true;
-		k_mutex_lock(&internal_state->mutex, K_FOREVER);
 	}
 
 	/* Store requested_bis_sync after everything has been validated */
@@ -1122,22 +1139,30 @@ static int scan_delegator_rem_src(struct bt_conn *conn,
 	state = &internal_state->state;
 
 	/* If conn == NULL then it's a local operation and we do not need to ask the application */
-	if (conn != NULL && (state->pa_sync_state == BT_BAP_PA_STATE_INFO_REQ ||
-			     state->pa_sync_state == BT_BAP_PA_STATE_SYNCED)) {
-		/* Unlock mutex to avoid potential deadlock on app callback */
-		err = k_mutex_unlock(&internal_state->mutex);
-		__ASSERT(err == 0, "Failed to unlock mutex: %d", err);
-
-		/* Terminate PA sync */
-		err = pa_sync_term_request(conn, &internal_state->state);
-		if (err != 0) {
-			LOG_DBG("PA sync term from %p was rejected with reason %d", (void *)conn,
-				err);
-
-			return BT_GATT_ERR(BT_ATT_ERR_WRITE_REQ_REJECTED);
+	if (conn != NULL) {
+
+		if (scan_delegator_cbs != NULL && scan_delegator_cbs->remove_source != NULL) {
+			err = scan_delegator_cbs->remove_source(conn, src_id);
+			if (err != 0) {
+				LOG_DBG("Remove Source rejected with reason 0x%02x", err);
+				err = k_mutex_unlock(&internal_state->mutex);
+				__ASSERT(err == 0, "Failed to unlock mutex: %d", err);
+				return BT_GATT_ERR(BT_ATT_ERR_WRITE_REQ_REJECTED);
+			}
 		}
 
-		k_mutex_lock(&internal_state->mutex, K_FOREVER);
+		if (state->pa_sync_state == BT_BAP_PA_STATE_INFO_REQ ||
+		    state->pa_sync_state == BT_BAP_PA_STATE_SYNCED) {
+			/* Terminate PA sync */
+			err = pa_sync_term_request(conn, &internal_state->state);
+			if (err != 0) {
+				LOG_DBG("PA sync term from %p was rejected with reason %d",
+					(void *)conn, err);
+				err = k_mutex_unlock(&internal_state->mutex);
+				__ASSERT(err == 0, "Failed to unlock mutex: %d", err);
+				return BT_GATT_ERR(BT_ATT_ERR_WRITE_REQ_REJECTED);
+			}
+		}
 	}
 
 	for (uint8_t i = 0U; i < state->num_subgroups; i++) {

tests/bsim/bluetooth/audio/src/bap_broadcast_assistant_test.c

@@ -51,6 +51,8 @@ CREATE_FLAG(flag_recv_state_updated_with_bis_sync);
 CREATE_FLAG(flag_recv_state_removed);
 CREATE_FLAG(flag_broadcast_code_requested);
 CREATE_FLAG(flag_incorrect_broadcast_code);
+CREATE_FLAG(flag_remove_source_cb_called);
+CREATE_FLAG(flag_remove_source_rejected);
 
 /* Broadcaster variables */
 static bt_addr_le_t g_broadcaster_addr;
@@ -256,8 +258,16 @@ static void bap_broadcast_assistant_broadcast_code_cb(struct bt_conn *conn, int
 
 static void bap_broadcast_assistant_rem_src_cb(struct bt_conn *conn, int err)
 {
+	SET_FLAG(flag_remove_source_cb_called);
+
 	if (err != 0) {
-		FAIL("BASS remove source failed (%d)\n", err);
+		if (err == BT_ATT_ERR_WRITE_REQ_REJECTED) {
+			SET_FLAG(flag_remove_source_rejected);
+			printk("Remove source rejected (expected): err=%d\n", err);
+			return;
+		}
+
+		FAIL("BASS remove source failed (err %d)\n", err);
 		return;
 	}
 
@@ -690,12 +700,23 @@ static void test_bass_remove_source(void)
 	printk("Removing source\n");
 	UNSET_FLAG(flag_cb_called);
 	UNSET_FLAG(flag_write_complete);
+	UNSET_FLAG(flag_remove_source_cb_called);
+	UNSET_FLAG(flag_remove_source_rejected);
+
 	err = bt_bap_broadcast_assistant_rem_src(default_conn, recv_state.src_id);
 	if (err != 0) {
 		FAIL("Could not remove source (err %d)\n", err);
 		return;
 	}
 
+	/* Wait for the remove callback to be invoked */
+	WAIT_FOR_FLAG(flag_remove_source_cb_called);
+
+	if (TEST_FLAG(flag_remove_source_rejected)) {
+		printk("Remove source was rejected as expected\n");
+		return;
+	}
+
 	WAIT_FOR_FLAG(flag_cb_called);
 	WAIT_FOR_FLAG(flag_write_complete);
 	printk("Source removed\n");
@@ -803,6 +824,12 @@ static void test_main_server_sync_client_rem(void)
 	printk("Waiting for receive state with BIS sync\n");
 	WAIT_FOR_FLAG(flag_recv_state_updated_with_bis_sync);
 
+	printk("Attempting to remove source for the first time\n");
+	test_bass_remove_source();
+
+	WAIT_FOR_FLAG(flag_remove_source_rejected);
+	printk("First remove source attempt was rejected as expected\n");
+
 	test_bass_remove_source();
 
 	PASS("BAP Broadcast Assistant Server Sync Passed\n");

tests/bsim/bluetooth/audio/src/bap_scan_delegator_test.c

@@ -40,7 +40,13 @@ CREATE_FLAG(flag_broadcast_code_received);
 CREATE_FLAG(flag_recv_state_updated);
 CREATE_FLAG(flag_bis_sync_requested);
 CREATE_FLAG(flag_bis_sync_term_requested);
+CREATE_FLAG(flag_broadcast_source_added);
+CREATE_FLAG(flag_broadcast_source_modified);
+CREATE_FLAG(flag_broadcast_source_removed);
+CREATE_FLAG(flag_remove_source_rejected);
+
 static volatile uint32_t g_broadcast_id;
+static bool reject_control_op;
 
 struct sync_state {
 	uint8_t src_id;
@@ -240,13 +246,21 @@ static void recv_state_updated_cb(struct bt_conn *conn,
 	SET_FLAG(flag_recv_state_updated);
 }
 
+static void reset_cp_flags(void)
+{
+	UNSET_FLAG(flag_broadcast_source_added);
+	UNSET_FLAG(flag_broadcast_source_modified);
+	UNSET_FLAG(flag_broadcast_source_removed);
+}
+
 static int pa_sync_req_cb(struct bt_conn *conn,
 			  const struct bt_bap_scan_delegator_recv_state *recv_state,
 			  bool past_avail, uint16_t pa_interval)
 {
 	struct sync_state *state;
 	int err;
 
+	reset_cp_flags();
 	printk("PA Sync request: past_avail %u, pa_interval 0x%04x\n: %p",
 	       past_avail, pa_interval, recv_state);
 
@@ -351,12 +365,44 @@ static int bis_sync_req_cb(struct bt_conn *conn,
 	return 0;
 }
 
+static int add_source_cb(struct bt_conn *conn,
+	const struct bt_bap_scan_delegator_recv_state *recv_state)
+{
+	printk("Add Source callback: src_id=%u\n", recv_state->src_id);
+	SET_FLAG(flag_broadcast_source_added);
+	return 0;
+}
+
+static int modify_source_cb(struct bt_conn *conn,
+	   const struct bt_bap_scan_delegator_recv_state *recv_state)
+{
+	printk("Modify Source callback: src_id=%u\n", recv_state->src_id);
+	SET_FLAG(flag_broadcast_source_modified);
+	return 0;
+}
+
+static int remove_source_cb(struct bt_conn *conn, uint8_t src_id)
+{
+	printk("Remove Source callback: src_id=%u\n", src_id);
+
+	if (reject_control_op) {
+		SET_FLAG(flag_remove_source_rejected);
+		return BT_ATT_ERR_WRITE_REQ_REJECTED;
+	}
+
+	SET_FLAG(flag_broadcast_source_removed);
+	return 0;
+}
+
 static struct bt_bap_scan_delegator_cb scan_delegator_cb = {
 	.recv_state_updated = recv_state_updated_cb,
 	.pa_sync_req = pa_sync_req_cb,
 	.pa_sync_term_req = pa_sync_term_req_cb,
 	.broadcast_code = broadcast_code_cb,
 	.bis_sync_req = bis_sync_req_cb,
+	.add_source = add_source_cb,
+	.modify_source = modify_source_cb,
+	.remove_source = remove_source_cb
 };
 
 static void pa_synced_cb(struct bt_le_per_adv_sync *sync,
@@ -728,13 +774,15 @@ static void test_main_client_sync(void)
 		return;
 	}
 
+	WAIT_FOR_FLAG(flag_broadcast_source_added);
 	/* Wait for broadcast assistant to request us to sync to PA */
 	printk("Waiting for flag_pa_synced\n");
 	WAIT_FOR_FLAG(flag_pa_synced);
 
 	/* Mod all sources by modifying the metadata */
 	mod_all_sources();
 
+	WAIT_FOR_FLAG(flag_broadcast_source_modified);
 	/* Wait for broadcast assistant to tell us to BIS sync */
 	printk("Waiting for flag_bis_sync_requested\n");
 	WAIT_FOR_FLAG(flag_bis_sync_requested);
@@ -750,6 +798,7 @@ static void test_main_client_sync(void)
 	printk("Waiting for flag_pa_terminated\n");
 	WAIT_FOR_FLAG(flag_pa_terminated);
 
+	WAIT_FOR_FLAG(flag_broadcast_source_removed);
 	PASS("BAP Scan Delegator Client Sync passed\n");
 }
 
@@ -788,6 +837,13 @@ static void test_main_server_sync_client_rem(void)
 	/* Set the BIS sync state */
 	sync_all_broadcasts();
 
+	/* Enable rejection for the first remove source request */
+	reject_control_op = true;
+
+	WAIT_FOR_FLAG(flag_remove_source_rejected);
+
+	/* Disable rejection for subsequent remove source requests */
+	reject_control_op = false;
 	/* For for client to remove source and thus terminate the PA */
 	printk("Waiting for flag_pa_terminated\n");
 	WAIT_FOR_FLAG(flag_pa_terminated);