[int][new][zbt] Add CCP profiles

Project: Bluetooth

redmine: #5146, REDMINE-id

ext-redmine: bug|feat#id

[Description in detail]

Affected branch: [master]

Change-Id: I8853c96d16a7c66c042d373f07768280d650b1fb

Author: ganghe

zephyr_bt/audio/Kconfig

@@ -40,6 +40,7 @@ config BT_AUDIO_NOTIFY_RETRY_DELAY
 	  available.
 
 rsource "Kconfig.bap"
+rsource "Kconfig.ccp"
 rsource "Kconfig.vocs"
 rsource "Kconfig.aics"
 rsource "Kconfig.vcp"

zephyr_bt/audio/Kconfig.ccp

@@ -0,0 +1,57 @@
+# Bluetooth Audio - Call Control Profile (CCP) configuration options
+#
+# Copyright (c) 2024 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if BT_AUDIO
+
+config BT_CCP_CALL_CONTROL_CLIENT
+	bool "Call Control Profile Client Support"
+	depends on BT_EXT_ADV
+	depends on BT_TBS_CLIENT
+	depends on BT_BONDABLE
+	help
+	  This option enables support for the Call Control Profile Client which uses the Telephone
+	  Bearer Service (TBS) client to control calls on a remote device.
+
+if BT_CCP_CALL_CONTROL_CLIENT
+
+config BT_CCP_CALL_CONTROL_CLIENT_BEARER_COUNT
+	int "Telephone bearer count"
+	default 1
+	range 1 256 if BT_TBS_CLIENT_TBS
+	range 1 1
+	help
+	  The number of supported telephone bearers on the CCP Call Control Client
+
+module = BT_CCP_CALL_CONTROL_CLIENT
+module-str = "Call Control Profile Client"
+
+endif # BT_CCP_CALL_CONTROL_CLIENT
+
+config BT_CCP_CALL_CONTROL_SERVER
+	bool "Call Control Profile Call Control Server Support"
+	depends on BT_EXT_ADV
+	depends on BT_TBS
+	depends on BT_BONDABLE
+	help
+	  This option enables support for the Call Control Profile Call Control Server which uses
+	  the Telephone Bearer Service (TBS) to hold and control calls on a device.
+
+if BT_CCP_CALL_CONTROL_SERVER
+
+config BT_CCP_CALL_CONTROL_SERVER_BEARER_COUNT
+	int "Telephone bearer count"
+	default 1
+	range 1 256
+	help
+	  The number of supported telephone bearers on the CCP Call Control Server
+
+module = BT_CCP_CALL_CONTROL_SERVER
+module-str = "Call Control Profile Call Control Server"
+
+endif # BT_CCP_CALL_CONTROL_SERVER
+
+endif # BT_AUDIO

zephyr_bt/audio/SConscript

@@ -91,6 +91,12 @@ if GetDepend(['BT_BAP_SCAN_DELEGATOR']):
 if GetDepend(['BT_BAP_BROADCAST_ASSISTANT']):
     src+= ['bap_broadcast_assistant.c']
 
+if GetDepend(['BT_CCP_CALL_CONTROL_CLIENT']):
+    src+= ['ccp_call_control_client.c']   
+
+if GetDepend(['BT_CCP_CALL_CONTROL_SERVER']):
+    src+= ['ccp_call_control_server.c']  
+    
 if GetDepend(['BT_HAS']):
     src+= ['has.c']
 
@@ -121,6 +127,7 @@ if GetDepend(['BT_GMAP']):
 if GetDepend(['BT_PBP']):
     src+= ['pbp.c']
 
+
 CPPPATH = [cwd]
 
 group = DefineGroup('zbt_audio', src, depend = ['BT_AUDIO'], CPPPATH=CPPPATH)

zephyr_bt/audio/ccp_call_control_client.c

@@ -0,0 +1,280 @@
+/* Bluetooth CCP - Call Control Profile Call Control Server
+ *
+ * Copyright (c) 2024 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <zephyr/autoconf.h>
+#include <zephyr/bluetooth/audio/tbs.h>
+#include <zephyr/bluetooth/audio/ccp.h>
+#include <zephyr/bluetooth/conn.h>
+#include <zephyr/bluetooth/hci_types.h>
+#include <zephyr/logging/log.h>
+#include <zephyr/sys/__assert.h>
+#include <zephyr/sys/atomic.h>
+#include <zephyr/sys/check.h>
+#include <zephyr/sys/slist.h>
+#include <zephyr/sys/util.h>
+#include <zephyr/sys/util_macro.h>
+
+LOG_MODULE_REGISTER(bt_ccp_call_control_client, CONFIG_BT_CCP_CALL_CONTROL_CLIENT_LOG_LEVEL);
+
+static sys_slist_t ccp_call_control_client_cbs =
+    SYS_SLIST_STATIC_INIT(&ccp_call_control_client_cbs);
+
+static struct bt_tbs_client_cb tbs_client_cbs;
+
+/* A service instance can either be a GTBS or a TBS insttance */
+struct bt_ccp_call_control_client_bearer
+{
+    uint8_t tbs_index;
+    bool discovered;
+};
+
+enum ccp_call_control_client_flag
+{
+    CCP_CALL_CONTROL_CLIENT_FLAG_BUSY,
+
+    CCP_CALL_CONTROL_CLIENT_FLAG_NUM_FLAGS, /* keep as last */
+};
+
+struct bt_ccp_call_control_client
+{
+    struct bt_ccp_call_control_client_bearer
+        bearers[CONFIG_BT_CCP_CALL_CONTROL_CLIENT_BEARER_COUNT];
+    struct bt_conn *conn;
+
+    ATOMIC_DEFINE(flags, CCP_CALL_CONTROL_CLIENT_FLAG_NUM_FLAGS);
+};
+
+static struct bt_ccp_call_control_client clients[CONFIG_BT_MAX_CONN];
+
+static struct bt_ccp_call_control_client *get_client_by_conn(const struct bt_conn *conn)
+{
+    return &clients[bt_conn_index(conn)];
+}
+
+static void connected_cb(struct bt_conn *conn, uint8_t err)
+{
+    static bool cbs_registered;
+
+    /* We register the callbacks in the connected callback. That way we ensure that they are
+     * registered before any procedures are completed or we receive any notifications, while
+     * registering them as late as possible
+     */
+    if (err == BT_HCI_ERR_SUCCESS && !cbs_registered)
+    {
+        int cb_err;
+
+        cb_err = bt_tbs_client_register_cb(&tbs_client_cbs);
+        __ASSERT(cb_err == 0, "Failed to register TBS callbacks: %d", cb_err);
+
+        cbs_registered = true;
+    }
+}
+
+static void disconnected_cb(struct bt_conn *conn, uint8_t reason)
+{
+    struct bt_ccp_call_control_client *client = get_client_by_conn(conn);
+
+    /* client->conn may be NULL */
+    if (client->conn == conn)
+    {
+        bt_conn_unref(client->conn);
+        client->conn = NULL;
+    }
+}
+
+BT_CONN_CB_DEFINE(conn_callbacks) =
+{
+    .connected = connected_cb,
+    .disconnected = disconnected_cb,
+};
+
+static void populate_bearers(struct bt_ccp_call_control_client *client,
+                             struct bt_ccp_call_control_client_bearers *bearers)
+{
+    size_t i = 0;
+
+#if defined(CONFIG_BT_TBS_CLIENT_GTBS)
+    if (client->bearers[i].discovered)
+    {
+        bearers->gtbs_bearer = &client->bearers[i++];
+    }
+#endif /* CONFIG_BT_TBS_CLIENT_GTBS */
+
+#if defined(CONFIG_BT_TBS_CLIENT_TBS)
+    for (; i < ARRAY_SIZE(client->bearers); i++)
+    {
+        if (!client->bearers[i].discovered)
+        {
+            break;
+        }
+
+        bearers->tbs_bearers[bearers->tbs_count++] = &client->bearers[i];
+    }
+#endif /* CONFIG_BT_TBS_CLIENT_TBS */
+}
+
+static void tbs_client_discover_cb(struct bt_conn *conn, int err, uint8_t tbs_count,
+                                   bool gtbs_found)
+{
+    struct bt_ccp_call_control_client *client = get_client_by_conn(conn);
+    struct bt_ccp_call_control_client_bearers bearers = {0};
+    struct bt_ccp_call_control_client_cb *listener, *next;
+
+    LOG_DBG("conn %p err %d tbs_count %u gtbs_found %d", (void *)conn, err, tbs_count,
+            gtbs_found);
+
+    memset(client->bearers, 0, sizeof((client->bearers)));
+
+    if (IS_ENABLED(CONFIG_BT_TBS_CLIENT_GTBS) && gtbs_found)
+    {
+        client->bearers[0].discovered = true;
+        client->bearers[0].tbs_index = BT_TBS_GTBS_INDEX;
+    }
+
+    if (IS_ENABLED(CONFIG_BT_TBS_CLIENT_TBS))
+    {
+        for (uint8_t i = 0U; i < tbs_count; i++)
+        {
+            const uint8_t idx = i + (gtbs_found ? 1 : 0);
+
+            if (idx >= ARRAY_SIZE(client->bearers))
+            {
+                LOG_WRN("Discoverd more TBS instances (%u) than the CCP Call "
+                        "Control Client supports %zu",
+                        tbs_count, ARRAY_SIZE(client->bearers));
+                break;
+            }
+
+            client->bearers[idx].discovered = true;
+            client->bearers[idx].tbs_index = i;
+        }
+    }
+
+    populate_bearers(client, &bearers);
+
+    atomic_clear_bit(client->flags, CCP_CALL_CONTROL_CLIENT_FLAG_BUSY);
+
+    SYS_SLIST_FOR_EACH_CONTAINER_SAFE(&ccp_call_control_client_cbs, listener, next, _node)
+    {
+        if (listener->discover != NULL)
+        {
+            listener->discover(client, err, &bearers);
+        }
+    }
+}
+
+int bt_ccp_call_control_client_discover(struct bt_conn *conn,
+                                        struct bt_ccp_call_control_client **out_client)
+{
+    struct bt_ccp_call_control_client *client;
+    int err;
+
+    CHECKIF(conn == NULL)
+    {
+        LOG_DBG("conn is NULL");
+
+        return -EINVAL;
+    }
+
+    CHECKIF(out_client == NULL)
+    {
+        LOG_DBG("client is NULL");
+
+        return -EINVAL;
+    }
+
+    client = get_client_by_conn(conn);
+    if (atomic_test_and_set_bit(client->flags, CCP_CALL_CONTROL_CLIENT_FLAG_BUSY))
+    {
+        return -EBUSY;
+    }
+
+    tbs_client_cbs.discover = tbs_client_discover_cb;
+
+    err = bt_tbs_client_discover(conn);
+    if (err != 0)
+    {
+        LOG_DBG("Failed to discover TBS for %p: %d", (void *)conn, err);
+
+        atomic_clear_bit(client->flags, CCP_CALL_CONTROL_CLIENT_FLAG_BUSY);
+
+        /* Return known errors */
+        if (err == -EBUSY || err == -ENOTCONN)
+        {
+            return err;
+        }
+
+        return -ENOEXEC;
+    }
+
+    client->conn = bt_conn_ref(conn);
+    *out_client = client;
+
+    return 0;
+}
+
+int bt_ccp_call_control_client_register_cb(struct bt_ccp_call_control_client_cb *cb)
+{
+    CHECKIF(cb == NULL)
+    {
+        LOG_DBG("cb is NULL");
+
+        return -EINVAL;
+    }
+
+    if (sys_slist_find(&ccp_call_control_client_cbs, &cb->_node, NULL))
+    {
+        return -EEXIST;
+    }
+
+    sys_slist_append(&ccp_call_control_client_cbs, &cb->_node);
+
+    return 0;
+}
+
+int bt_ccp_call_control_client_unregister_cb(struct bt_ccp_call_control_client_cb *cb)
+{
+    CHECKIF(cb == NULL)
+    {
+        LOG_DBG("cb is NULL");
+        return -EINVAL;
+    }
+
+    if (!sys_slist_find_and_remove(&ccp_call_control_client_cbs, &cb->_node))
+    {
+        return -EALREADY;
+    }
+
+    return 0;
+}
+
+int bt_ccp_call_control_client_get_bearers(struct bt_ccp_call_control_client *client,
+        struct bt_ccp_call_control_client_bearers *bearers)
+{
+    CHECKIF(client == NULL)
+    {
+        LOG_DBG("client is NULL");
+        return -EINVAL;
+    }
+
+    CHECKIF(bearers == NULL)
+    {
+        LOG_DBG("bearers is NULL");
+        return -EINVAL;
+    }
+
+    memset(bearers, 0, sizeof(*bearers));
+    populate_bearers(client, bearers);
+
+    return 0;
+}