Bluetooth: HFP_HF: Initiate SLC establishment

Add function `bt_hfp_hf_connect` to initialize the Service Level
Connection establishment procedure.

Add function `bt_hfp_hf_disconnect` to release the Service Level
Connection.

Clear HF object if the RFCOMM is disconnected.

Signed-off-by: Lyle Zhu <[email protected]>

Author: lylezhu2012

include/zephyr/bluetooth/classic/hfp_hf.h

@@ -429,6 +429,55 @@ struct bt_hfp_hf_cb {
  */
 int bt_hfp_hf_register(struct bt_hfp_hf_cb *cb);
 
+/** @brief Initiate the service level connection establishment procedure
+ *
+ *  Initiate the service level connection establishment procedure on the
+ *  ACL connection specified by the parameter `conn` using the specific
+ *  RFCOMM channel discovered by the function `bt_br_discovery_start`.
+ *
+ *  The parameter `hf` is a output parameter. When the service level
+ *  connection establishment procedure is initiated without any error,
+ *  the HFP HF object is allocated and it will be returned via the parameter
+ *  `hf` if the parameter `hf` is not a NULL pointer.
+ *
+ *  When service level conenction is established, the registered callback
+ *  `connected` will be triggered to notify the application that the service
+ *  level connection establishment procedure is done. And the HFP HF object
+ *  is valid at this time. It means after the function is called without
+ *  any error, all interfaces provided by HFP HF can only be called after
+ *  the registered callback `connected` is triggered.
+ *
+ *  @param conn ACL connection object.
+ *  @param hf Created HFP HF object.
+ *  @param channel Peer RFCOMM channel to be connected.
+ *
+ *  @return 0 in case of success or negative value in case of error.
+ */
+int bt_hfp_hf_connect(struct bt_conn *conn, struct bt_hfp_hf **hf, uint8_t channel);
+
+/** @brief Release the service level connection
+ *
+ *  Release the service level connection from the peer device.
+ *
+ *  The function can only be called after the registered callback `connected`
+ *  is triggered.
+ *
+ *  If the function is called without any error, the HFP HF object is
+ *  invalid at this time. All interfaces provided by HFP HF should not
+ *  be called anymore.
+ *
+ *  If the service level connection is released, the registered callback
+ *  `disconnected` will be triggered to notify the application that the
+ *  service level connection release procedure is done. And the HFP HF
+ *  object will be freed after the registered callback `disconnected`
+ *  returned.
+ *
+ *  @param hf HFP HF object.
+ *
+ *  @return 0 in case of success or negative value in case of error.
+ */
+int bt_hfp_hf_disconnect(struct bt_hfp_hf *hf);
+
 /** @brief Handsfree HF enable/disable Calling Line Identification (CLI) Notification
  *
  *  Enable/disable Calling Line Identification (CLI) Notification.

subsys/bluetooth/host/classic/hfp_hf.c

@@ -3919,6 +3919,10 @@ static void hfp_hf_disconnected(struct bt_rfcomm_dlc *dlc)
 	if (bt_hf->disconnected) {
 		bt_hf->disconnected(hf);
 	}
+
+	k_work_cancel(&hf->work);
+	k_work_cancel_delayable(&hf->deferred_work);
+	hf->acl = NULL;
 }
 
 static void hfp_hf_recv(struct bt_rfcomm_dlc *dlc, struct net_buf *buf)
@@ -3945,60 +3949,68 @@ static void bt_hf_work(struct k_work *work)
 	hfp_hf_send_data(hf);
 }
 
-static int hfp_hf_accept(struct bt_conn *conn, struct bt_rfcomm_server *server,
-			 struct bt_rfcomm_dlc **dlc)
+static struct bt_hfp_hf *hfp_hf_create(struct bt_conn *conn)
 {
-	int i;
+	size_t index;
 	static struct bt_rfcomm_dlc_ops ops = {
 		.connected = hfp_hf_connected,
 		.disconnected = hfp_hf_disconnected,
 		.recv = hfp_hf_recv,
 		.sent = hfp_hf_sent,
 	};
+	struct bt_hfp_hf *hf;
 
 	LOG_DBG("conn %p", conn);
 
-	for (i = 0; i < ARRAY_SIZE(bt_hfp_hf_pool); i++) {
-		struct bt_hfp_hf *hf = &bt_hfp_hf_pool[i];
-		int j;
+	index = (size_t)bt_conn_index(conn);
+	hf = &bt_hfp_hf_pool[index];
+	if (hf->acl) {
+		LOG_ERR("HF connection (%p) is established", conn);
+		return NULL;
+	}
 
-		if (hf->rfcomm_dlc.session) {
-			continue;
-		}
+	memset(hf, 0, sizeof(*hf));
+
+	hf->acl = conn;
+	hf->at.buf = hf->hf_buffer;
+	hf->at.buf_max_len = HF_MAX_BUF_LEN;
 
-		memset(hf, 0, sizeof(*hf));
+	hf->rfcomm_dlc.ops = &ops;
+	hf->rfcomm_dlc.mtu = BT_HFP_MAX_MTU;
 
-		hf->acl = conn;
-		hf->at.buf = hf->hf_buffer;
-		hf->at.buf_max_len = HF_MAX_BUF_LEN;
+	/* Set the supported features*/
+	hf->hf_features = BT_HFP_HF_SUPPORTED_FEATURES;
 
-		hf->rfcomm_dlc.ops = &ops;
-		hf->rfcomm_dlc.mtu = BT_HFP_MAX_MTU;
+	/* Set supported codec ids */
+	hf->hf_codec_ids = BT_HFP_HF_SUPPORTED_CODEC_IDS;
 
-		*dlc = &hf->rfcomm_dlc;
+	k_fifo_init(&hf->tx_pending);
 
-		/* Set the supported features*/
-		hf->hf_features = BT_HFP_HF_SUPPORTED_FEATURES;
+	k_work_init(&hf->work, bt_hf_work);
 
-		/* Set supported codec ids */
-		hf->hf_codec_ids = BT_HFP_HF_SUPPORTED_CODEC_IDS;
+	k_work_init_delayable(&hf->deferred_work, bt_hf_deferred_work);
 
-		k_fifo_init(&hf->tx_pending);
+	for (index = 0; index < ARRAY_SIZE(hf->ind_table); index++) {
+		hf->ind_table[index] = -1;
+	}
 
-		k_work_init(&hf->work, bt_hf_work);
+	return hf;
+}
 
-		k_work_init_delayable(&hf->deferred_work, bt_hf_deferred_work);
+static int hfp_hf_accept(struct bt_conn *conn, struct bt_rfcomm_server *server,
+			 struct bt_rfcomm_dlc **dlc)
+{
+	struct bt_hfp_hf *hf;
 
-		for (j = 0; j < HF_MAX_AG_INDICATORS; j++) {
-			hf->ind_table[j] = -1;
-		}
+	hf = hfp_hf_create(conn);
 
-		return 0;
+	if (!hf) {
+		return -ECONNREFUSED;
 	}
 
-	LOG_ERR("Unable to establish HF connection (%p)", conn);
+	*dlc = &hf->rfcomm_dlc;
 
-	return -ENOMEM;
+	return 0;
 }
 
 static void hfp_hf_sco_connected(struct bt_sco_chan *chan)
@@ -4086,3 +4098,43 @@ int bt_hfp_hf_register(struct bt_hfp_hf_cb *cb)
 
 	return 0;
 }
+
+int bt_hfp_hf_connect(struct bt_conn *conn, struct bt_hfp_hf **hf, uint8_t channel)
+{
+	struct bt_hfp_hf *new_hf;
+	int err;
+
+	if (!conn || !hf || !channel) {
+		return -EINVAL;
+	}
+
+	if (!bt_hf) {
+		return -EFAULT;
+	}
+
+	new_hf = hfp_hf_create(conn);
+	if (!new_hf) {
+		return -ECONNREFUSED;
+	}
+
+	err = bt_rfcomm_dlc_connect(conn, &new_hf->rfcomm_dlc, channel);
+	if (err != 0) {
+		(void)memset(new_hf, 0, sizeof(*new_hf));
+		*hf = NULL;
+	} else {
+		*hf = new_hf;
+	}
+
+	return err;
+}
+
+int bt_hfp_hf_disconnect(struct bt_hfp_hf *hf)
+{
+	LOG_DBG("");
+
+	if (!hf) {
+		return -EINVAL;
+	}
+
+	return bt_rfcomm_dlc_disconnect(&hf->rfcomm_dlc);
+}