bluetooth: classic: add role switch API

add bt_conn_br_switch_role and bt_conn_br_set_role_switchable to control
the role switch, add DEFAULT_ROLE_SWITCHABLE Kconfig to control the default
role switch state.

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

Author: MarkWangChinese

include/zephyr/bluetooth/conn.h

@@ -2688,6 +2688,28 @@ struct bt_conn *bt_conn_lookup_addr_br(const bt_addr_t *peer);
  */
 const bt_addr_t *bt_conn_get_dst_br(const struct bt_conn *conn);
 
+/** @brief Change the role of the conn.
+ *
+ *  @param conn Connection object.
+ *  @param role The role that want to switch as.
+ *
+ *  @return Zero on success or (negative) error code on failure.
+ *  @return -ENOBUFS HCI command buffer is not available.
+ *  @return -EINVAL @p conn is not a valid @ref BT_CONN_TYPE_BR connection
+ */
+int bt_conn_br_switch_role(const struct bt_conn *conn, uint8_t role);
+
+/** @brief Enable/disable role switch of the connection by setting the connection's link policy.
+ *
+ *  @param conn Connection object.
+ *  @param enable Value allowing/disallowing controller to be role switchable.
+ *
+ *  @return Zero on success or (negative) error code on failure.
+ *  @return -ENOBUFS HCI command buffer is not available.
+ *  @return -EINVAL @p conn is not a valid @ref BT_CONN_TYPE_BR connection.
+ */
+int bt_conn_br_set_role_switchable(const struct bt_conn *conn, bool enable);
+
 #ifdef __cplusplus
 }
 #endif

include/zephyr/bluetooth/hci_types.h

@@ -363,6 +363,7 @@ struct bt_hci_cmd_hdr {
 
 /* OpCode Group Fields */
 #define BT_OGF_LINK_CTRL                        0x01
+#define BT_OGF_LINK_POLICY                      0x02
 #define BT_OGF_BASEBAND                         0x03
 #define BT_OGF_INFO                             0x04
 #define BT_OGF_STATUS                           0x05
@@ -558,6 +559,43 @@ struct bt_hci_cp_io_capability_neg_reply {
 	uint8_t   reason;
 } __packed;
 
+#define BT_HCI_OP_SWITCH_ROLE                   BT_OP(BT_OGF_LINK_POLICY, 0x000b)
+struct bt_hci_cp_switch_role {
+	bt_addr_t bdaddr;
+	uint8_t   role;
+} __packed;
+
+#define BT_HCI_LINK_POLICY_SETTINGS_ENABLE_ROLE_SWITCH  0x01
+#define BT_HCI_LINK_POLICY_SETTINGS_ENABLE_HOLD_MODE    0x02
+#define BT_HCI_LINK_POLICY_SETTINGS_ENABLE_SNIFF_SWITCH 0x04
+
+#define BT_HCI_OP_READ_LINK_POLICY_SETTINGS     BT_OP(BT_OGF_LINK_POLICY, 0x000c)
+struct bt_hci_cp_read_link_policy_settings {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_read_link_policy_settings {
+	uint8_t  status;
+	uint16_t handle;
+	uint16_t  link_policy_settings;
+} __packed;
+
+#define BT_HCI_OP_WRITE_LINK_POLICY_SETTINGS    BT_OP(BT_OGF_LINK_POLICY, 0x000d)
+struct bt_hci_cp_write_link_policy_settings {
+	uint16_t handle;
+	uint16_t  link_policy_settings;
+} __packed;
+
+#define BT_HCI_OP_READ_DEFAULT_LINK_POLICY_SETTINGS  BT_OP(BT_OGF_LINK_POLICY, 0x000e)
+struct bt_hci_rp_read_default_link_policy_settings {
+	uint8_t  status;
+	uint16_t  default_link_policy_settings;
+} __packed;
+
+#define BT_HCI_OP_WRITE_DEFAULT_LINK_POLICY_SETTINGS BT_OP(BT_OGF_LINK_POLICY, 0x000f)
+struct bt_hci_cp_write_default_link_policy_settings {
+	uint16_t  default_link_policy_settings;
+} __packed;
+
 #define BT_HCI_OP_SET_EVENT_MASK                BT_OP(BT_OGF_BASEBAND, 0x0001) /* 0x0c01 */
 struct bt_hci_cp_set_event_mask {
 	uint8_t  events[8];

subsys/bluetooth/host/classic/Kconfig

@@ -508,6 +508,11 @@ config BT_COD
 	  consult the following link:
 	  https://www.bluetooth.com/specifications/assigned-numbers
 
+config BT_DEFAULT_ROLE_SWITCHABLE
+	bool "Default Bluetooth Role Switch Enable/Disable State"
+	help
+	  This option sets the controller's default link policy to enable/disable the role switch.
+
 endif # BT_CLASSIC
 
 endmenu

subsys/bluetooth/host/classic/br.c

@@ -801,7 +801,11 @@ int bt_br_init(void)
 	struct bt_hci_cp_write_inquiry_mode *inq_cp;
 	struct bt_hci_write_local_name *name_cp;
 	struct bt_hci_cp_write_class_of_device *cod;
+	struct bt_hci_rp_read_default_link_policy_settings *rp;
+	struct bt_hci_cp_write_default_link_policy_settings *policy_cp;
+	struct net_buf *rsp;
 	int err;
+	uint16_t default_link_policy_settings;
 
 	/* Read extended local features */
 	if (BT_FEAT_EXT_FEATURES(bt_dev.features)) {
@@ -907,6 +911,42 @@ int bt_br_init(void)
 		}
 	}
 
+	buf = bt_hci_cmd_create(BT_HCI_OP_READ_DEFAULT_LINK_POLICY_SETTINGS, 0);
+	if (!buf) {
+		return -ENOBUFS;
+	}
+
+	err = bt_hci_cmd_send_sync(BT_HCI_OP_READ_DEFAULT_LINK_POLICY_SETTINGS, buf, &rsp);
+	if (err) {
+		return err;
+	}
+
+	rp = (void *)rsp->data;
+	default_link_policy_settings = rp->default_link_policy_settings;
+
+	bool should_enable = CONFIG_BT_DEFAULT_ROLE_SWITCHABLE;
+	bool is_enabled = default_link_policy_settings &
+			  BT_HCI_LINK_POLICY_SETTINGS_ENABLE_ROLE_SWITCH;
+
+	/* Enable/Disable the default role switch */
+	if (should_enable != is_enabled) {
+		default_link_policy_settings ^= BT_HCI_LINK_POLICY_SETTINGS_ENABLE_ROLE_SWITCH;
+
+		buf = bt_hci_cmd_create(BT_HCI_OP_WRITE_DEFAULT_LINK_POLICY_SETTINGS,
+					sizeof(*policy_cp));
+		if (!buf) {
+			return -ENOBUFS;
+		}
+
+		policy_cp = net_buf_add(buf, sizeof(*policy_cp));
+		policy_cp->default_link_policy_settings = default_link_policy_settings;
+
+		err = bt_hci_cmd_send_sync(BT_HCI_OP_WRITE_DEFAULT_LINK_POLICY_SETTINGS, buf, NULL);
+		if (err) {
+			return err;
+		}
+	}
+
 	return 0;
 }
 

subsys/bluetooth/host/classic/conn_br.c

@@ -170,3 +170,105 @@ void bt_br_acl_recv(struct bt_conn *conn, struct net_buf *buf, bool complete)
 
 	net_buf_unref(buf);
 }
+
+int bt_conn_br_switch_role(const struct bt_conn *conn, uint8_t role)
+{
+	struct net_buf *buf = NULL;
+	struct bt_hci_cp_switch_role *cp;
+
+	CHECKIF(conn == NULL) {
+		LOG_DBG("conn is NULL");
+		return -EINVAL;
+	}
+
+	if (!bt_conn_is_type(conn, BT_CONN_TYPE_BR)) {
+		LOG_DBG("Invalid connection type: %u for %p", conn->type, conn);
+		return -EINVAL;
+	}
+
+	buf = bt_hci_cmd_create(BT_HCI_OP_SWITCH_ROLE, sizeof(*cp));
+	if (!buf) {
+		return -ENOBUFS;
+	}
+
+	cp = net_buf_add(buf, sizeof(*cp));
+	bt_addr_copy(&cp->bdaddr, &conn->br.dst);
+	cp->role = role;
+
+	return bt_hci_cmd_send_sync(BT_HCI_OP_SWITCH_ROLE, buf, NULL);
+}
+
+static int bt_conn_br_read_link_policy_settings(const struct bt_conn *conn, uint16_t *link_policy_settings)
+{
+	int err;
+	struct net_buf *buf = NULL;
+	struct bt_hci_cp_read_link_policy_settings *cp;
+	struct bt_hci_rp_read_link_policy_settings *rp;
+	struct net_buf *rsp;
+
+	buf = bt_hci_cmd_create(BT_HCI_OP_READ_LINK_POLICY_SETTINGS, sizeof(*cp));
+	if (!buf) {
+		return -ENOBUFS;
+	}
+
+	cp = net_buf_add(buf, sizeof(*cp));
+	cp->handle = conn->handle;
+
+	err = bt_hci_cmd_send_sync(BT_HCI_OP_READ_LINK_POLICY_SETTINGS, buf, &rsp);
+	if (!err) {
+		rp = (void *)rsp->data;
+		*link_policy_settings = rp->link_policy_settings;
+	}
+
+	return err;
+}
+
+static int bt_conn_br_write_link_policy_settings(const struct bt_conn *conn, uint16_t link_policy_settings)
+{
+	struct net_buf *buf = NULL;
+	struct bt_hci_cp_write_link_policy_settings *cp;
+
+	buf = bt_hci_cmd_create(BT_HCI_OP_WRITE_LINK_POLICY_SETTINGS, sizeof(*cp));
+	if (!buf) {
+		return -ENOBUFS;
+	}
+
+	cp = net_buf_add(buf, sizeof(*cp));
+	cp->handle = conn->handle;
+	cp->link_policy_settings = link_policy_settings;
+
+	return bt_hci_cmd_send_sync(BT_HCI_OP_WRITE_LINK_POLICY_SETTINGS, buf, NULL);
+}
+
+int bt_conn_br_set_role_switchable(const struct bt_conn *conn, bool enable)
+{
+	int err;
+	uint16_t link_policy_settings;
+	bool is_enabled;
+
+	CHECKIF(conn == NULL) {
+		LOG_DBG("conn is NULL");
+		return -EINVAL;
+	}
+
+	if (!bt_conn_is_type(conn, BT_CONN_TYPE_BR)) {
+		LOG_DBG("Invalid connection type: %u for %p", conn->type, conn);
+		return -EINVAL;
+	}
+
+	err = bt_conn_br_read_link_policy_settings(conn, &link_policy_settings);
+	if (err) {
+		return err;
+	}
+
+	is_enabled = link_policy_settings & BT_HCI_LINK_POLICY_SETTINGS_ENABLE_ROLE_SWITCH;
+
+	if (enable == is_enabled) {
+		return 0;
+	}
+
+	link_policy_settings ^= BT_HCI_LINK_POLICY_SETTINGS_ENABLE_ROLE_SWITCH;
+	err = bt_conn_br_write_link_policy_settings(conn, link_policy_settings);
+
+	return err;
+}

subsys/bluetooth/host/classic/shell/bredr.c

@@ -1207,6 +1207,86 @@ static int cmd_info(const struct shell *sh, size_t argc, char *argv[])
 	return err;
 }
 
+void role_changed(struct bt_conn *conn, uint8_t status)
+{
+	struct bt_conn_info info;
+	int err;
+
+	bt_shell_print("Role changed (HCI status 0x%02x)", status);
+
+	err = bt_conn_get_info(conn, &info);
+	if (err) {
+		bt_shell_print("Failed to get info");
+		return;
+	}
+
+	bt_shell_print("Current role is: %s", get_conn_role_str(info.role));
+}
+
+static int cmd_switch_role(const struct shell *sh, size_t argc, char *argv[])
+{
+	int err;
+	const char *action;
+	uint8_t role;
+
+	if (!default_conn) {
+		shell_print(sh, "Not connected");
+		return -ENOEXEC;
+	}
+
+	action = argv[1];
+
+	if (!strcmp(action, "central")) {
+		role = BT_HCI_ROLE_CENTRAL;
+	} else if (!strcmp(action, "peripheral")) {
+		role = BT_HCI_ROLE_PERIPHERAL;
+	} else {
+		shell_help(sh);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	err = bt_conn_br_switch_role(default_conn, role);
+
+	if (err) {
+		shell_error(sh, "fail to change role (err %d)", err);
+	}
+
+	return 0;
+}
+
+static int cmd_set_role_switchable(const struct shell *sh, size_t argc, char *argv[])
+{
+	int err;
+	const char *action;
+	bool enable;
+
+	if (!default_conn) {
+		shell_print(sh, "Not connected");
+		return -ENOEXEC;
+	}
+
+	action = argv[1];
+
+	if (!strcmp(action, "enable")) {
+		enable = true;
+	} else if (!strcmp(action, "disable")) {
+		enable = false;
+	} else {
+		shell_help(sh);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	err = bt_conn_br_set_role_switchable(default_conn, enable);
+
+	if (err) {
+		shell_error(sh, "fail to set role switchable (err %d)", err);
+	} else {
+		shell_print(sh, "success");
+	}
+
+	return 0;
+}
+
 static int cmd_default_handler(const struct shell *sh, size_t argc, char **argv)
 {
 	if (argc == 1) {
@@ -1270,6 +1350,9 @@ SHELL_STATIC_SUBCMD_SET_CREATE(br_cmds,
 	SHELL_CMD_ARG(oob, NULL, NULL, cmd_oob, 1, 0),
 	SHELL_CMD_ARG(pscan, NULL, "<value: on, off>", cmd_connectable, 2, 0),
 	SHELL_CMD_ARG(sdp-find, NULL, "<HFPAG, HFPHF>", cmd_sdp_find_record, 2, 0),
+	SHELL_CMD_ARG(switch-role, NULL, "<value: central, peripheral>", cmd_switch_role, 2, 0),
+	SHELL_CMD_ARG(set-role-switchable, NULL, "<value: enable, disable>",
+		      cmd_set_role_switchable, 2, 0),
 	SHELL_SUBCMD_SET_END
 );
 

subsys/bluetooth/host/classic/shell/bredr.h

@@ -0,0 +1,20 @@
+/** @file
+ *  @brief Bluetooth shell functions
+ *
+ *  This is not to be included by the application.
+ */
+
+/*
+ * Copyright 2025 NXP
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef __BREDR_H
+#define __BREDR_H
+#include <stddef.h>
+#include <stdint.h>
+
+void role_changed(struct bt_conn *conn, uint8_t status);
+
+#endif /* __BREDR_H */

subsys/bluetooth/host/shell/bt.c

@@ -54,6 +54,9 @@
 #endif /* CONFIG_BT_LL_SW_SPLIT */
 #include "host/shell/bt.h"
 #include "mesh/shell/hci.h"
+#if defined(CONFIG_BT_CLASSIC)
+#include "host/classic/shell/bredr.h"
+#endif
 
 static bool no_settings_load;
 
@@ -1193,6 +1196,9 @@ static struct bt_conn_cb conn_callbacks = {
 	.le_cs_config_complete = le_cs_config_created,
 	.le_cs_config_removed = le_cs_config_removed,
 #endif
+#if defined(CONFIG_BT_CLASSIC)
+	.role_changed = role_changed,
+#endif
 };
 #endif /* CONFIG_BT_CONN */