Bluetooth: A2DP: implement close, suspend and abort

implement avdtp close, suspend and abort and the a2dp
interfaces.

Signed-off-by: Mark Wang <[email protected]>

Author: MarkWangChinese

include/zephyr/bluetooth/classic/a2dp.h

@@ -545,6 +545,28 @@ struct bt_a2dp_cb {
 	 *                          bt_a2dp_err_code or bt_avdtp_err_code
 	 */
 	void (*suspend_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
+	/**
+	 * @brief Stream abort request callback
+	 *
+	 * The callback is called whenever an stream is requested to be
+	 * aborted.
+	 *
+	 *  @param[in] stream    Pointer to stream object.
+	 *  @param[out] rsp_err_code  give the error code if response error.
+	 *                          bt_a2dp_err_code or bt_avdtp_err_code
+	 *
+	 * @return 0 in case of success or negative value in case of error.
+	 */
+	int (*abort_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
+	/** @brief Callback function for bt_a2dp_stream_abort()
+	 *
+	 *  Called when the abort operation is completed.
+	 *
+	 *  @param[in] stream    Pointer to stream object.
+	 *  @param[in] rsp_err_code the remote responded error code
+	 *                          bt_a2dp_err_code or bt_avdtp_err_code
+	 */
+	void (*abort_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
 };
 
 /** @brief A2DP Connect.
@@ -662,6 +684,15 @@ struct bt_a2dp_stream_ops {
 	 * @param stream Stream object that has been suspended.
 	 */
 	void (*suspended)(struct bt_a2dp_stream *stream);
+	/**
+	 * @brief Stream abort callback
+	 *
+	 * The callback is called whenever an Audio Stream has been aborted.
+	 * After aborted, the stream becomes invalid.
+	 *
+	 * @param stream Stream object that has been aborted.
+	 */
+	void (*aborted)(struct bt_a2dp_stream *stream);
 #if defined(CONFIG_BT_A2DP_SINK)
 	/** @brief the media streaming data, only for sink
 	 *
@@ -770,6 +801,17 @@ int bt_a2dp_stream_suspend(struct bt_a2dp_stream *stream);
  */
 int bt_a2dp_stream_reconfig(struct bt_a2dp_stream *stream, struct bt_a2dp_codec_cfg *config);
 
+/** @brief abort a2dp streamer.
+ *
+ * This function sends the AVDTP_ABORT command.
+ * After abort, the stream becomes invalid.
+ *
+ *  @param stream The stream object.
+ *
+ *  @return 0 in case of success and error code in case of error.
+ */
+int bt_a2dp_stream_abort(struct bt_a2dp_stream *stream);
+
 /** @brief get the stream l2cap mtu
  *
  *  @param stream The stream object.

subsys/bluetooth/host/classic/a2dp.c

@@ -351,6 +351,44 @@ static int a2dp_start_ind(struct bt_avdtp *session, struct bt_avdtp_sep *sep, ui
 	return a2dp_ctrl_ind(session, sep, errcode, req_cb, done_cb, false);
 }
 
+static int a2dp_suspend_ind(struct bt_avdtp *session, struct bt_avdtp_sep *sep, uint8_t *errcode)
+{
+	struct bt_a2dp_ep *ep = CONTAINER_OF(sep, struct bt_a2dp_ep, sep);
+	bt_a2dp_ctrl_req_cb req_cb;
+	bt_a2dp_ctrl_done_cb done_cb;
+
+	__ASSERT(sep, "Invalid sep");
+	req_cb = a2dp_cb != NULL ? a2dp_cb->suspend_req : NULL;
+	done_cb =
+		(ep->stream != NULL && ep->stream->ops != NULL) ? ep->stream->ops->suspended : NULL;
+	return a2dp_ctrl_ind(session, sep, errcode, req_cb, done_cb, false);
+}
+
+static int a2dp_close_ind(struct bt_avdtp *session, struct bt_avdtp_sep *sep, uint8_t *errcode)
+{
+	struct bt_a2dp_ep *ep = CONTAINER_OF(sep, struct bt_a2dp_ep, sep);
+	bt_a2dp_ctrl_req_cb req_cb;
+	bt_a2dp_ctrl_done_cb done_cb;
+
+	__ASSERT(sep, "Invalid sep");
+	req_cb = a2dp_cb != NULL ? a2dp_cb->release_req : NULL;
+	done_cb =
+		(ep->stream != NULL && ep->stream->ops != NULL) ? ep->stream->ops->released : NULL;
+	return a2dp_ctrl_ind(session, sep, errcode, req_cb, done_cb, true);
+}
+
+static int a2dp_abort_ind(struct bt_avdtp *session, struct bt_avdtp_sep *sep, uint8_t *errcode)
+{
+	struct bt_a2dp_ep *ep = CONTAINER_OF(sep, struct bt_a2dp_ep, sep);
+	bt_a2dp_ctrl_req_cb req_cb;
+	bt_a2dp_ctrl_done_cb done_cb;
+
+	__ASSERT(sep, "Invalid sep");
+	req_cb = a2dp_cb != NULL ? a2dp_cb->abort_req : NULL;
+	done_cb = (ep->stream != NULL && ep->stream->ops != NULL) ? ep->stream->ops->aborted : NULL;
+	return a2dp_ctrl_ind(session, sep, errcode, req_cb, done_cb, true);
+}
+
 static int bt_a2dp_set_config_cb(struct bt_avdtp_req *req)
 {
 	struct bt_a2dp *a2dp = SET_CONF_PARAM(SET_CONF_REQ(req));
@@ -656,6 +694,36 @@ static int bt_a2dp_start_cb(struct bt_avdtp_req *req)
 	return bt_a2dp_ctrl_cb(req, rsp_cb, done_cb, false);
 }
 
+static int bt_a2dp_suspend_cb(struct bt_avdtp_req *req)
+{
+	struct bt_a2dp_ep *ep = CONTAINER_OF(CTRL_REQ(req)->sep, struct bt_a2dp_ep, sep);
+	bt_a2dp_rsp_cb rsp_cb = a2dp_cb != NULL ? a2dp_cb->suspend_rsp : NULL;
+	bt_a2dp_done_cb done_cb =
+		(ep->stream != NULL && ep->stream->ops != NULL) ? ep->stream->ops->suspended : NULL;
+
+	return bt_a2dp_ctrl_cb(req, rsp_cb, done_cb, false);
+}
+
+static int bt_a2dp_close_cb(struct bt_avdtp_req *req)
+{
+	struct bt_a2dp_ep *ep = CONTAINER_OF(CTRL_REQ(req)->sep, struct bt_a2dp_ep, sep);
+	bt_a2dp_rsp_cb rsp_cb = a2dp_cb != NULL ? a2dp_cb->release_rsp : NULL;
+	bt_a2dp_done_cb done_cb =
+		(ep->stream != NULL && ep->stream->ops != NULL) ? ep->stream->ops->released : NULL;
+
+	return bt_a2dp_ctrl_cb(req, rsp_cb, done_cb, true);
+}
+
+static int bt_a2dp_abort_cb(struct bt_avdtp_req *req)
+{
+	struct bt_a2dp_ep *ep = CONTAINER_OF(CTRL_REQ(req)->sep, struct bt_a2dp_ep, sep);
+	bt_a2dp_rsp_cb rsp_cb = a2dp_cb != NULL ? a2dp_cb->abort_rsp : NULL;
+	bt_a2dp_done_cb done_cb =
+		(ep->stream != NULL && ep->stream->ops != NULL) ? ep->stream->ops->aborted : NULL;
+
+	return bt_a2dp_ctrl_cb(req, rsp_cb, done_cb, true);
+}
+
 static int bt_a2dp_stream_ctrl_pre(struct bt_a2dp_stream *stream, bt_avdtp_func_t cb)
 {
 	struct bt_a2dp *a2dp;
@@ -685,6 +753,18 @@ int bt_a2dp_stream_establish(struct bt_a2dp_stream *stream)
 	return bt_avdtp_open(&a2dp->session, &a2dp->ctrl_param);
 }
 
+int bt_a2dp_stream_release(struct bt_a2dp_stream *stream)
+{
+	int err;
+	struct bt_a2dp *a2dp = stream->a2dp;
+
+	err = bt_a2dp_stream_ctrl_pre(stream, bt_a2dp_close_cb);
+	if (err) {
+		return err;
+	}
+	return bt_avdtp_close(&a2dp->session, &a2dp->ctrl_param);
+}
+
 int bt_a2dp_stream_start(struct bt_a2dp_stream *stream)
 {
 	int err;
@@ -697,6 +777,30 @@ int bt_a2dp_stream_start(struct bt_a2dp_stream *stream)
 	return bt_avdtp_start(&a2dp->session, &a2dp->ctrl_param);
 }
 
+int bt_a2dp_stream_suspend(struct bt_a2dp_stream *stream)
+{
+	int err;
+	struct bt_a2dp *a2dp = stream->a2dp;
+
+	err = bt_a2dp_stream_ctrl_pre(stream, bt_a2dp_suspend_cb);
+	if (err) {
+		return err;
+	}
+	return bt_avdtp_suspend(&a2dp->session, &a2dp->ctrl_param);
+}
+
+int bt_a2dp_stream_abort(struct bt_a2dp_stream *stream)
+{
+	int err;
+	struct bt_a2dp *a2dp = stream->a2dp;
+
+	err = bt_a2dp_stream_ctrl_pre(stream, bt_a2dp_abort_cb);
+	if (err) {
+		return err;
+	}
+	return bt_avdtp_abort(&a2dp->session, &a2dp->ctrl_param);
+}
+
 int bt_a2dp_stream_reconfig(struct bt_a2dp_stream *stream, struct bt_a2dp_codec_cfg *config)
 {
 	uint8_t remote_id;
@@ -749,6 +853,30 @@ int bt_a2dp_stream_send(struct bt_a2dp_stream *stream, struct net_buf *buf, uint
 }
 #endif
 
+int a2dp_stream_l2cap_disconnected(struct bt_avdtp *session, struct bt_avdtp_sep *sep)
+{
+	struct bt_a2dp_ep *ep;
+
+	__ASSERT(sep, "Invalid sep");
+	ep = CONTAINER_OF(sep, struct bt_a2dp_ep, sep);
+	if (ep->stream != NULL) {
+		struct bt_a2dp_stream_ops *ops;
+		struct bt_a2dp_stream *stream = ep->stream;
+
+		ops = stream->ops;
+		/* Many places set ep->stream as NULL like abort and close.
+		 * it should be OK without lock protection because
+		 * all the related callbacks are in the same zephyr task context.
+		 */
+		ep->stream = NULL;
+		if ((ops != NULL) && (ops->released != NULL)) {
+			ops->released(stream);
+		}
+	}
+
+	return 0;
+}
+
 static const struct bt_avdtp_ops_cb signaling_avdtp_ops = {
 	.connected = a2dp_connected,
 	.disconnected = a2dp_disconnected,
@@ -759,6 +887,10 @@ static const struct bt_avdtp_ops_cb signaling_avdtp_ops = {
 	.re_configuration_ind = a2dp_re_config_ind,
 	.open_ind = a2dp_open_ind,
 	.start_ind = a2dp_start_ind,
+	.close_ind = a2dp_close_ind,
+	.suspend_ind = a2dp_suspend_ind,
+	.abort_ind = a2dp_abort_ind,
+	.stream_l2cap_disconnected = a2dp_stream_l2cap_disconnected,
 };
 
 int a2dp_accept(struct bt_conn *conn, struct bt_avdtp **session)