diff --git a/doc/connectivity/bluetooth/api/shell/csip.rst b/doc/connectivity/bluetooth/api/shell/csip.rst
index f8b856b6e5..e2daf744ca 100644
--- a/doc/connectivity/bluetooth/api/shell/csip.rst
+++ b/doc/connectivity/bluetooth/api/shell/csip.rst
@@ -141,8 +141,8 @@ Using the Set Member
 
 .. code-block:: console
 
-   csip --help
-   csip - Bluetooth CSIP shell commands
+   csip_set_member --help
+   csip_set_member - Bluetooth CSIP set member shell commands
    Subcommands:
       register      :Initialize the service and register callbacks [size <int>]
                      [rank <int>] [not-lockable] [sirk <data>]
@@ -162,4 +162,4 @@ Setup
 .. code-block:: console
 
    uart:~$ bt init
-   uart:~$ csip register
+   uart:~$ csip_set_member register
diff --git a/doc/connectivity/bluetooth/bluetooth-audio-arch.rst b/doc/connectivity/bluetooth/bluetooth-audio-arch.rst
index 80d05c9150..245d1cc66e 100644
--- a/doc/connectivity/bluetooth/bluetooth-audio-arch.rst
+++ b/doc/connectivity/bluetooth/bluetooth-audio-arch.rst
@@ -132,7 +132,7 @@ Coordinated Sets is implemented by the Coordinated Sets Identification Profile
 
 The CSIP implementation supports the following roles
 
-* Coordinated Set Identification Service (CSIP) Server
+* Coordinated Set Identification Service (CSIP) Set Member
 * Coordinated Set Identification Service (CSIP) Set Coordinator
 
 The API reference for media control can be found in
diff --git a/include/zephyr/bluetooth/audio/cap.h b/include/zephyr/bluetooth/audio/cap.h
index efaea96345..9fdd36907f 100644
--- a/include/zephyr/bluetooth/audio/cap.h
+++ b/include/zephyr/bluetooth/audio/cap.h
@@ -45,7 +45,7 @@ extern "C" {
  *
  * @return 0 if success, errno on failure.
  */
-int bt_cap_acceptor_register(const struct bt_csip_register_param *param,
+int bt_cap_acceptor_register(const struct bt_csip_set_member_register_param *param,
 			     struct bt_csip **csip);
 
 /** Callback structure for CAP procedures */
diff --git a/include/zephyr/bluetooth/audio/csip.h b/include/zephyr/bluetooth/audio/csip.h
index 53f29de0ec..8e5aad6742 100644
--- a/include/zephyr/bluetooth/audio/csip.h
+++ b/include/zephyr/bluetooth/audio/csip.h
@@ -76,13 +76,13 @@ extern "C" {
 struct bt_csip;
 
 /** Callback structure for the Coordinated Set Identification Service */
-struct bt_csip_cb {
+struct bt_csip_set_member_cb {
 	/**
 	 * @brief Callback whenever the lock changes on the server.
 	 *
 	 * @param conn    The connection to the client that changed the lock.
 	 *                NULL if server changed it, either by calling
-	 *                bt_csip_lock() or by timeout.
+	 *                bt_csip_set_member_lock() or by timeout.
 	 * @param csip    Pointer to the Coordinated Set Identification Service.
 	 * @param locked  Whether the lock was locked or released.
 	 *
@@ -106,7 +106,7 @@ struct bt_csip_cb {
 };
 
 /** Register structure for Coordinated Set Identification Service */
-struct bt_csip_register_param {
+struct bt_csip_set_member_register_param {
 	/**
 	 * @brief Size of the set.
 	 *
@@ -139,20 +139,20 @@ struct bt_csip_register_param {
 	uint8_t rank;
 
 	/** Pointer to the callback structure. */
-	struct bt_csip_cb *cb;
+	struct bt_csip_set_member_cb *cb;
 
-#if CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1
+#if CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1
 	/**
 	 * @brief Parent service pointer
 	 *
 	 * Mandatory parent service pointer if this CSIS instance is included
 	 * by another service. All CSIS instances when
-	 * @kconfig{CONFIG_BT_CSIP_MAX_INSTANCE_COUNT} is above 1 shall
-	 * be included by another service, as per the
+	 * @kconfig{CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT} is above 1
+	 * shall be included by another service, as per the
 	 * Coordinated Set Identification Profile (CSIP).
 	 */
 	const struct bt_gatt_service *parent;
-#endif /* CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1 */
+#endif /* CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1 */
 };
 
 /**
@@ -164,7 +164,7 @@ struct bt_csip_register_param {
  *
  * @return The first CSIS attribute instance.
  */
-void *bt_csip_svc_decl_get(const struct bt_csip *csip);
+void *bt_csip_set_member_svc_decl_get(const struct bt_csip *csip);
 
 /**
  * @brief Register a Coordinated Set Identification Service instance.
@@ -180,15 +180,15 @@ void *bt_csip_svc_decl_get(const struct bt_csip *csip);
  *
  * @return 0 if success, errno on failure.
  */
-int bt_csip_register(const struct bt_csip_register_param *param,
-		     struct bt_csip **csip);
+int bt_csip_set_member_register(const struct bt_csip_set_member_register_param *param,
+				struct bt_csip **csip);
 
 /**
  * @brief Print the SIRK to the debug output
  *
  * @param csip   Pointer to the Coordinated Set Identification Service.
  */
-void bt_csip_print_sirk(const struct bt_csip *csip);
+void bt_csip_set_member_print_sirk(const struct bt_csip *csip);
 
 /**
  * @brief Generate the Resolvable Set Identifier (RSI) value.
@@ -200,7 +200,8 @@ void bt_csip_print_sirk(const struct bt_csip *csip);
  *
  * @return int		0 if on success, errno on error.
  */
-int bt_csip_generate_rsi(const struct bt_csip *csip, uint8_t rsi[BT_CSIP_RSI_SIZE]);
+int bt_csip_set_member_generate_rsi(const struct bt_csip *csip,
+				    uint8_t rsi[BT_CSIP_RSI_SIZE]);
 
 /**
  * @brief Locks a specific Coordinated Set Identification Service instance on the server.
@@ -213,7 +214,7 @@ int bt_csip_generate_rsi(const struct bt_csip *csip, uint8_t rsi[BT_CSIP_RSI_SIZ
  *
  * @return 0 on success, GATT error on error.
  */
-int bt_csip_lock(struct bt_csip *csip, bool lock, bool force);
+int bt_csip_set_member_lock(struct bt_csip *csip, bool lock, bool force);
 
 /** Information about a specific set */
 struct bt_csip_set_coordinator_set_info {
diff --git a/samples/bluetooth/hap_ha/Kconfig b/samples/bluetooth/hap_ha/Kconfig
index 8ac4b4ece1..c1d941962e 100644
--- a/samples/bluetooth/hap_ha/Kconfig
+++ b/samples/bluetooth/hap_ha/Kconfig
@@ -14,7 +14,7 @@ menu "Hearing Aid"
 
 config HAP_HA_SET_RANK
 	int "Device rank in set"
-	depends on BT_CSIP
+	depends on BT_CSIP_SET_MEMBER
 	range 1 2
 	help
 	  Rank of this device in set.
diff --git a/samples/bluetooth/hap_ha/binaural.conf b/samples/bluetooth/hap_ha/binaural.conf
index d102b0fc84..28562c2778 100644
--- a/samples/bluetooth/hap_ha/binaural.conf
+++ b/samples/bluetooth/hap_ha/binaural.conf
@@ -1,3 +1,3 @@
-CONFIG_BT_CSIP=y
+CONFIG_BT_CSIP_SET_MEMBER=y
 CONFIG_BT_HAS_HEARING_AID_BINAURAL=y
 CONFIG_BT_CAP_ACCEPTOR_SET_MEMBER=y
diff --git a/samples/bluetooth/hap_ha/src/csip_set_member.c b/samples/bluetooth/hap_ha/src/csip_set_member.c
index 3eb709e7c4..c844ee641c 100644
--- a/samples/bluetooth/hap_ha/src/csip_set_member.c
+++ b/samples/bluetooth/hap_ha/src/csip_set_member.c
@@ -27,14 +27,14 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
 	return BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT;
 }
 
-static struct bt_csip_cb csip_cb = {
+static struct bt_csip_set_member_cb csip_cb = {
 	.lock_changed = csip_lock_changed_cb,
 	.sirk_read_req = sirk_read_req_cb,
 };
 
 int csip_set_member_init(void)
 {
-	struct bt_csip_register_param param = {
+	struct bt_csip_set_member_register_param param = {
 		.set_size = 2,
 		.rank = CONFIG_HAP_HA_SET_RANK,
 		.lockable = false,
@@ -53,7 +53,7 @@ int csip_generate_rsi(uint8_t *rsi)
 		return -ENODEV;
 	}
 
-	err = bt_csip_generate_rsi(csip, rsi);
+	err = bt_csip_set_member_generate_rsi(csip, rsi);
 	if (err) {
 		printk("Failed to generate RSI (err %d)\n", err);
 		return err;
diff --git a/samples/bluetooth/hap_ha/src/main.c b/samples/bluetooth/hap_ha/src/main.c
index 4a1a2e837a..75d994e9af 100644
--- a/samples/bluetooth/hap_ha/src/main.c
+++ b/samples/bluetooth/hap_ha/src/main.c
@@ -44,9 +44,9 @@ static uint8_t csis_rsi_addata[BT_CSIP_RSI_SIZE];
 static const struct bt_data ad[] = {
 	BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
 	BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_ASCS_VAL)),
-#if defined(CONFIG_BT_CSIP)
+#if defined(CONFIG_BT_CSIP_SET_MEMBER)
 	BT_DATA(BT_DATA_CSIS_RSI, csis_rsi_addata, ARRAY_SIZE(csis_rsi_addata)),
-#endif /* CONFIG_BT_CSIP */
+#endif /* CONFIG_BT_CSIP_SET_MEMBER */
 	BT_DATA(BT_DATA_SVC_DATA16, unicast_server_addata, ARRAY_SIZE(unicast_server_addata)),
 };
 
@@ -63,7 +63,7 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
 	.disconnected = disconnected,
 };
 
-#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP)
+#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP_SET_MEMBER)
 static bool adv_rpa_expired_cb(struct bt_le_ext_adv *adv)
 {
 	char rsi_str[13];
@@ -89,12 +89,12 @@ static bool adv_rpa_expired_cb(struct bt_le_ext_adv *adv)
 
 	return true;
 }
-#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP */
+#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP_SET_MEMBER */
 
 static const struct bt_le_ext_adv_cb adv_cb = {
-#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP)
+#if defined(CONFIG_BT_PRIVACY) && defined(CONFIG_BT_CSIP_SET_MEMBER)
 	.rpa_expired = adv_rpa_expired_cb,
-#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP */
+#endif /* CONFIG_BT_PRIVACY && CONFIG_BT_CSIP_SET_MEMBER */
 };
 
 static void adv_work_handler(struct k_work *work)
diff --git a/subsys/bluetooth/audio/CMakeLists.txt b/subsys/bluetooth/audio/CMakeLists.txt
index 8b6f94c2c9..90b44eac43 100644
--- a/subsys/bluetooth/audio/CMakeLists.txt
+++ b/subsys/bluetooth/audio/CMakeLists.txt
@@ -30,9 +30,9 @@ zephyr_library_sources_ifdef(CONFIG_BT_CCID ccid.c)
 
 zephyr_library_link_libraries(subsys__bluetooth)
 
-zephyr_library_sources_ifdef(CONFIG_BT_CSIP csip.c)
+zephyr_library_sources_ifdef(CONFIG_BT_CSIP_SET_MEMBER csip_set_member.c)
 zephyr_library_sources_ifdef(CONFIG_BT_CSIP_SET_COORDINATOR csip_set_coordinator.c)
-if (CONFIG_BT_CSIP OR CONFIG_BT_CSIP_SET_COORDINATOR)
+if (CONFIG_BT_CSIP_SET_MEMBER OR CONFIG_BT_CSIP_SET_COORDINATOR)
 	zephyr_library_sources(csip_crypto.c)
 endif()
 
diff --git a/subsys/bluetooth/audio/Kconfig.cap b/subsys/bluetooth/audio/Kconfig.cap
index c2baf7895e..316ac1a5cd 100644
--- a/subsys/bluetooth/audio/Kconfig.cap
+++ b/subsys/bluetooth/audio/Kconfig.cap
@@ -19,12 +19,12 @@ config BT_CAP_ACCEPTOR
 config BT_CAP_ACCEPTOR_SET_MEMBER
 	bool "Common Audio Profile Acceptor Role Set Member support"
 	depends on BT_CAP_ACCEPTOR
-	depends on BT_CSIP
+	depends on BT_CSIP_SET_MEMBER
 	help
 	  Enabling this will allow a CAP acceptor to be a set member.
 	  Enabling this will require a manual register of the CAS service.
 	  Enabling will take one of the allocated CSIS instances
-	  (BT_CSIP_MAX_INSTANCE_COUNT).
+	  (BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT).
 
 config BT_DEBUG_CAP_ACCEPTOR
 	bool "Common Audio Profile debug"
diff --git a/subsys/bluetooth/audio/Kconfig.csip b/subsys/bluetooth/audio/Kconfig.csip
index 5ce9314fe6..a8a1b17ed2 100644
--- a/subsys/bluetooth/audio/Kconfig.csip
+++ b/subsys/bluetooth/audio/Kconfig.csip
@@ -8,17 +8,18 @@
 
 #################### Coordinated Set Identification Service ####################
 
-config BT_CSIP
-	bool "Coordinated Set Identification Service Support [EXPERIMENTAL]"
+config BT_CSIP_SET_MEMBER
+	bool "Coordinated Set Identification Profile Set Member support [EXPERIMENTAL]"
 	imply BT_EXT_ADV if BT_PRIVACY
 	select EXPERIMENTAL
 	help
 	  This option enables support for Coordinated Set Identification
+	  Profile Set Member role and the Coordinated Set Identification
 	  Service.
 
-if BT_CSIP
+if BT_CSIP_SET_MEMBER
 
-config BT_CSIP_TEST_SAMPLE_DATA
+config BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA
 	bool "Coordinated Set Identification Service Test Sample Data"
 	help
 	  Enable the use of the sample data defined by the CSIS spec SIRK.
@@ -28,14 +29,14 @@ config BT_CSIP_TEST_SAMPLE_DATA
 	  (if encrypted) using public sample data.
 	  Should not be used for production builds.
 
-config BT_CSIP_ENC_SIRK_SUPPORT
+config BT_CSIP_SET_MEMBER_ENC_SIRK_SUPPORT
 	bool "Support for encrypted SIRK"
 	default y
 	help
 	  Enables support encrypting the SIRK.
 
-config BT_CSIP_MAX_INSTANCE_COUNT
-	int "Coordinated Set Identification Service max instance count"
+config BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT
+	int "Coordinated Set Identification Profle max service instance count"
 	default 1
 	range 1 255
 	help
@@ -48,13 +49,13 @@ config BT_CSIP_MAX_INSTANCE_COUNT
 
 ############### DEBUG ###############
 
-config BT_DEBUG_CSIP
+config BT_DEBUG_CSIP_SET_MEMBER
 	bool "Coordinated Set Identification Service debug"
 	help
 	  Use this option to enable Coordinated Set Identification Service debug
 	  logs for the Bluetooth Audio functionality.
 
-endif # BT_CSIP
+endif # BT_CSIP_SET_MEMBER
 
 #################### Coordinated Set Identification Client ####################
 
@@ -97,16 +98,16 @@ config BT_CSIP_SET_COORDINATOR_ENC_SIRK_SUPPORT
 ############### DEBUG ###############
 
 config BT_DEBUG_CSIP_SET_COORDINATOR
-	bool "Coordinated Set Identification Profile debug"
+	bool "Coordinated Set Identification Profile Set Coordinator debug"
 	help
-	  Use this option to enable Coordinated Set Identification Profile debug
-	  logs for the Bluetooth Audio functionality.
+	  Use this option to enable Coordinated Set Identification Profile
+	  Set Coordinator debug logs for the Bluetooth Audio functionality.
 
 endif # BT_CSIP_SET_COORDINATOR
 
-config BT_DEBUG_CSIP_CRYPTO
+config BT_DEBUG_CSIP_SET_MEMBER_CRYPTO
 	bool "Coordinated Set Identification Profile crypto functions debug"
-	depends on BT_CSIP_SET_COORDINATOR || BT_CSIP
+	depends on BT_CSIP_SET_COORDINATOR || BT_CSIP_SET_MEMBER
 	help
 	  Use this option to enable Coordinated Set Identification Profile
 	  crypto functions debug logs for the Bluetooth Audio functionality.
diff --git a/subsys/bluetooth/audio/Kconfig.has b/subsys/bluetooth/audio/Kconfig.has
index e6d065c504..695bb78057 100644
--- a/subsys/bluetooth/audio/Kconfig.has
+++ b/subsys/bluetooth/audio/Kconfig.has
@@ -23,7 +23,7 @@ config BT_HAS_HEARING_AID_MONAURAL
 	bool "Monaural Hearing Aid"
 
 config BT_HAS_HEARING_AID_BINAURAL
-	depends on BT_CSIP
+	depends on BT_CSIP_SET_MEMBER
 	bool "Binaural Hearing Aid"
 
 config BT_HAS_HEARING_AID_BANDED
diff --git a/subsys/bluetooth/audio/cap_acceptor.c b/subsys/bluetooth/audio/cap_acceptor.c
index a3577d21d6..8d0ee9fc4c 100644
--- a/subsys/bluetooth/audio/cap_acceptor.c
+++ b/subsys/bluetooth/audio/cap_acceptor.c
@@ -21,13 +21,13 @@ static struct bt_gatt_attr svc_attrs[] = {
 	BT_GATT_INCLUDE_SERVICE(NULL) /* To be overwritten */
 };
 
-int bt_cap_acceptor_register(const struct bt_csip_register_param *param,
+int bt_cap_acceptor_register(const struct bt_csip_set_member_register_param *param,
 			     struct bt_csip **csip)
 {
 	static struct bt_gatt_service cas;
 	int err;
 
-	err = bt_csip_register(param, csip);
+	err = bt_csip_set_member_register(param, csip);
 	if (err != 0) {
 		BT_DBG("Failed to register CSIP");
 		return err;
@@ -36,7 +36,7 @@ int bt_cap_acceptor_register(const struct bt_csip_register_param *param,
 	cas = (struct bt_gatt_service)BT_GATT_SERVICE(svc_attrs);
 
 	/* Overwrite the include definition with the CSIP */
-	cas.attrs[1].user_data = bt_csip_svc_decl_get(*csip);
+	cas.attrs[1].user_data = bt_csip_set_member_svc_decl_get(*csip);
 
 	err = bt_gatt_service_register(&cas);
 	if (err) {
diff --git a/subsys/bluetooth/audio/csip_crypto.c b/subsys/bluetooth/audio/csip_crypto.c
index 914acf6b96..9b3b32aeb2 100644
--- a/subsys/bluetooth/audio/csip_crypto.c
+++ b/subsys/bluetooth/audio/csip_crypto.c
@@ -18,7 +18,7 @@
 #include <tinycrypt/ccm_mode.h>
 #include <zephyr/sys/byteorder.h>
 
-#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_CSIP_CRYPTO)
+#define BT_DBG_ENABLED IS_ENABLED(CONFIG_BT_DEBUG_CSIP_SET_MEMBER_CRYPTO)
 #define LOG_MODULE_NAME bt_csip_crypto
 #include "common/log.h"
 #include "common/bt_str.h"
diff --git a/subsys/bluetooth/audio/csip_internal.h b/subsys/bluetooth/audio/csip_internal.h
index a0ec7b6eca..8048295c3b 100644
--- a/subsys/bluetooth/audio/csip_internal.h
+++ b/subsys/bluetooth/audio/csip_internal.h
@@ -59,12 +59,12 @@ struct bt_csip_set_coordinator_svc_inst {
 };
 
 /* TODO: Rename to bt_csip_svc_inst */
-struct bt_csip_server {
+struct bt_csip_set_member_server {
 	struct bt_csip_set_sirk set_sirk;
 	uint8_t set_size;
 	uint8_t set_lock;
 	uint8_t rank;
-	struct bt_csip_cb *cb;
+	struct bt_csip_set_member_cb *cb;
 	struct k_work_delayable set_lock_timer;
 	bt_addr_le_t lock_client_addr;
 	struct bt_gatt_service *service_p;
@@ -77,9 +77,9 @@ struct bt_csip_server {
 struct bt_csip {
 	bool client_instance;
 	union {
-#if defined(CONFIG_BT_CSIP)
-		struct bt_csip_server srv;
-#endif /* CONFIG_BT_CSIP */
+#if defined(CONFIG_BT_CSIP_SET_MEMBER)
+		struct bt_csip_set_member_server srv;
+#endif /* CONFIG_BT_CSIP_SET_MEMBER */
 #if defined(CONFIG_BT_CSIP_SET_COORDINATOR)
 		struct bt_csip_set_coordinator_svc_inst cli;
 #endif /* CONFIG_BT_CSIP_SET_COORDINATOR */
diff --git a/subsys/bluetooth/audio/csip.c b/subsys/bluetooth/audio/csip_set_member.c
similarity index 94%
rename from subsys/bluetooth/audio/csip.c
rename to subsys/bluetooth/audio/csip_set_member.c
index 19282c9c70..fbd169b4fc 100644
--- a/subsys/bluetooth/audio/csip.c
+++ b/subsys/bluetooth/audio/csip_set_member.c
@@ -37,7 +37,7 @@
 #include "common/log.h"
 #include "common/bt_str.h"
 
-static struct bt_csip csip_insts[CONFIG_BT_CSIP_MAX_INSTANCE_COUNT];
+static struct bt_csip csip_insts[CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT];
 static bt_addr_le_t server_dummy_addr; /* 0'ed address */
 
 struct csip_notify_foreach {
@@ -126,7 +126,7 @@ static int sirk_encrypt(struct bt_conn *conn,
 	int err;
 	uint8_t *k;
 
-	if (IS_ENABLED(CONFIG_BT_CSIP_TEST_SAMPLE_DATA)) {
+	if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA)) {
 		/* test_k is from the sample data from A.2 in the CSIS spec */
 		static uint8_t test_k[] = {0x67, 0x6e, 0x1b, 0x9b,
 					   0xd4, 0x48, 0x69, 0x6f,
@@ -181,13 +181,14 @@ static int generate_prand(uint32_t *dest)
 	return 0;
 }
 
-int bt_csip_generate_rsi(const struct bt_csip *csip, uint8_t rsi[BT_CSIP_RSI_SIZE])
+int bt_csip_set_member_generate_rsi(const struct bt_csip *csip,
+				    uint8_t rsi[BT_CSIP_RSI_SIZE])
 {
 	int res = 0;
 	uint32_t prand;
 	uint32_t hash;
 
-	if (IS_ENABLED(CONFIG_BT_CSIP_TEST_SAMPLE_DATA)) {
+	if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA)) {
 		/* prand is from the sample data from A.2 in the CSIS spec */
 		prand = 0x69f563;
 	} else {
@@ -227,7 +228,7 @@ static ssize_t read_set_sirk(struct bt_conn *conn,
 
 		if (cb_rsp == BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT) {
 			sirk = &csip->srv.set_sirk;
-		} else if (IS_ENABLED(CONFIG_BT_CSIP_ENC_SIRK_SUPPORT) &&
+		} else if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_ENC_SIRK_SUPPORT) &&
 			   cb_rsp == BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT_ENC) {
 			int err;
 
@@ -414,11 +415,12 @@ static ssize_t read_rank(struct bt_conn *conn, const struct bt_gatt_attr *attr,
 static void set_lock_timer_handler(struct k_work *work)
 {
 	struct k_work_delayable *delayable;
-	struct bt_csip_server *server;
+	struct bt_csip_set_member_server *server;
 	struct bt_csip *csip;
 
 	delayable = CONTAINER_OF(work, struct k_work_delayable, work);
-	server = CONTAINER_OF(delayable, struct bt_csip_server, set_lock_timer);
+	server = CONTAINER_OF(delayable, struct bt_csip_set_member_server,
+			      set_lock_timer);
 	csip = CONTAINER_OF(server, struct bt_csip, srv);
 
 	BT_DBG("Lock timeout, releasing");
@@ -640,16 +642,16 @@ static struct bt_conn_auth_info_cb auth_callbacks = {
 	}
 
 BT_GATT_SERVICE_INSTANCE_DEFINE(csip_service_list, csip_insts,
-				CONFIG_BT_CSIP_MAX_INSTANCE_COUNT,
+				CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT,
 				BT_CSIP_SERVICE_DEFINITION);
 
 /****************************** Public API ******************************/
-void *bt_csip_svc_decl_get(const struct bt_csip *csip)
+void *bt_csip_set_member_svc_decl_get(const struct bt_csip *csip)
 {
 	return csip->srv.service_p->attrs;
 }
 
-static bool valid_register_param(const struct bt_csip_register_param *param)
+static bool valid_register_param(const struct bt_csip_set_member_register_param *param)
 {
 	if (param->lockable && param->rank == 0) {
 		BT_DBG("Rank cannot be 0 if service is lockable");
@@ -662,18 +664,18 @@ static bool valid_register_param(const struct bt_csip_register_param *param)
 		return false;
 	}
 
-#if CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1
+#if CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1
 	if (param->parent == NULL) {
 		BT_DBG("Parent service not provided");
 		return false;
 	}
-#endif /* CONFIG_BT_CSIP_MAX_INSTANCE_COUNT > 1 */
+#endif /* CONFIG_BT_CSIP_SET_MEMBER_MAX_INSTANCE_COUNT > 1 */
 
 	return true;
 }
 
-int bt_csip_register(const struct bt_csip_register_param *param,
-		     struct bt_csip **csip)
+int bt_csip_set_member_register(const struct bt_csip_set_member_register_param *param,
+				struct bt_csip **csip)
 {
 	static uint8_t instance_cnt;
 	struct bt_csip *inst;
@@ -714,7 +716,7 @@ int bt_csip_register(const struct bt_csip_register_param *param,
 	inst->srv.set_sirk.type = BT_CSIP_SIRK_TYPE_PLAIN;
 	inst->srv.cb = param->cb;
 
-	if (IS_ENABLED(CONFIG_BT_CSIP_TEST_SAMPLE_DATA)) {
+	if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA)) {
 		uint8_t test_sirk[] = {
 			0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
 			0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45,
@@ -732,7 +734,7 @@ int bt_csip_register(const struct bt_csip_register_param *param,
 	return 0;
 }
 
-int bt_csip_lock(struct bt_csip *csip, bool lock, bool force)
+int bt_csip_set_member_lock(struct bt_csip *csip, bool lock, bool force)
 {
 	uint8_t lock_val;
 	int err = 0;
@@ -761,7 +763,7 @@ int bt_csip_lock(struct bt_csip *csip, bool lock, bool force)
 	}
 }
 
-void bt_csip_print_sirk(const struct bt_csip *csip)
+void bt_csip_set_member_print_sirk(const struct bt_csip *csip)
 {
 	LOG_HEXDUMP_DBG(&csip->srv.set_sirk, sizeof(csip->srv.set_sirk),
 			"Set SIRK");
diff --git a/subsys/bluetooth/shell/CMakeLists.txt b/subsys/bluetooth/shell/CMakeLists.txt
index 4bd1f40186..024fc96e9b 100644
--- a/subsys/bluetooth/shell/CMakeLists.txt
+++ b/subsys/bluetooth/shell/CMakeLists.txt
@@ -42,8 +42,8 @@ zephyr_library_sources_ifdef(
   micp_mic_ctlr.c
   )
 zephyr_library_sources_ifdef(
-  CONFIG_BT_CSIP
-  csip.c
+  CONFIG_BT_CSIP_SET_MEMBER
+  csip_set_member.c
   )
 zephyr_library_sources_ifdef(
   CONFIG_BT_CSIP_SET_COORDINATOR
diff --git a/subsys/bluetooth/shell/bt.c b/subsys/bluetooth/shell/bt.c
index e37aa895b3..fa39f8f908 100644
--- a/subsys/bluetooth/shell/bt.c
+++ b/subsys/bluetooth/shell/bt.c
@@ -1245,7 +1245,9 @@ static ssize_t ad_init(struct bt_data *data_array, const size_t data_array_size,
 		/* A privacy-enabled Set Member should advertise RSI values only when in
 		 * the GAP Limited Discoverable mode.
 		 */
-		if (IS_ENABLED(CONFIG_BT_PRIVACY) && IS_ENABLED(CONFIG_BT_CSIP) && csip != NULL) {
+		if (IS_ENABLED(CONFIG_BT_PRIVACY) &&
+		    IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER) &&
+		    csip != NULL) {
 			ad_flags |= BT_LE_AD_LIMITED;
 		} else {
 			ad_flags |= BT_LE_AD_GENERAL;
@@ -1272,7 +1274,7 @@ static ssize_t ad_init(struct bt_data *data_array, const size_t data_array_size,
 		ad_len++;
 	}
 
-	if (IS_ENABLED(CONFIG_BT_CSIP)) {
+	if (IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER)) {
 		ssize_t csis_ad_len;
 
 		csis_ad_len = csis_ad_data_add(&data_array[ad_len],
diff --git a/subsys/bluetooth/shell/cap_acceptor.c b/subsys/bluetooth/shell/cap_acceptor.c
index 4e69e2421c..c83f389f22 100644
--- a/subsys/bluetooth/shell/cap_acceptor.c
+++ b/subsys/bluetooth/shell/cap_acceptor.c
@@ -16,7 +16,7 @@
 #include "bt.h"
 
 extern const struct shell *ctx_shell;
-static struct bt_csip *cap_csip;
+static struct bt_csip *cap_csip_set_member;
 static uint8_t sirk_read_rsp = BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT;
 
 static void locked_cb(struct bt_conn *conn, struct bt_csip *csip, bool locked)
@@ -49,7 +49,7 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
 	return sirk_read_rsp;
 }
 
-static struct bt_csip_cb csip_cbs = {
+static struct bt_csip_set_member_cb csip_set_member_cbs = {
 	.lock_changed = locked_cb,
 	.sirk_read_req = sirk_read_req_cb,
 };
@@ -58,14 +58,14 @@ static int cmd_cap_acceptor_init(const struct shell *sh, size_t argc,
 				 char **argv)
 {
 	int err;
-	struct bt_csip_register_param param = {
+	struct bt_csip_set_member_register_param param = {
 		.set_size = 2,
 		.rank = 1,
 		.lockable = true,
 		/* Using the CSIS test sample SIRK */
 		.set_sirk = { 0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
 			      0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45 },
-		.cb = &csip_cbs
+		.cb = &csip_set_member_cbs
 	};
 
 	for (size_t argn = 1; argn < argc; argn++) {
@@ -95,7 +95,7 @@ static int cmd_cap_acceptor_init(const struct shell *sh, size_t argc,
 		}
 	}
 
-	err = bt_cap_acceptor_register(&param, &cap_csip);
+	err = bt_cap_acceptor_register(&param, &cap_csip_set_member);
 	if (err != 0) {
 		shell_error(sh, "Could not register CAS: %d", err);
 
@@ -108,7 +108,7 @@ static int cmd_cap_acceptor_init(const struct shell *sh, size_t argc,
 static int cmd_cap_acceptor_print_sirk(const struct shell *sh, size_t argc,
 				       char *argv[])
 {
-	bt_csip_print_sirk(cap_csip);
+	bt_csip_set_member_print_sirk(cap_csip_set_member);
 
 	return 0;
 }
@@ -118,7 +118,7 @@ static int cmd_cap_acceptor_lock(const struct shell *sh, size_t argc,
 {
 	int err;
 
-	err = bt_csip_lock(cap_csip, true, false);
+	err = bt_csip_set_member_lock(cap_csip_set_member, true, false);
 	if (err != 0) {
 		shell_error(sh, "Failed to set lock: %d", err);
 
@@ -146,7 +146,7 @@ static int cmd_cap_acceptor_release(const struct shell *sh, size_t argc,
 		}
 	}
 
-	err = bt_csip_lock(cap_csip, false, force);
+	err = bt_csip_set_member_lock(cap_csip_set_member, false, force);
 
 	if (err != 0) {
 		shell_error(sh, "Failed to release lock: %d", err);
diff --git a/subsys/bluetooth/shell/csip.c b/subsys/bluetooth/shell/csip_set_member.c
similarity index 78%
rename from subsys/bluetooth/shell/csip.c
rename to subsys/bluetooth/shell/csip_set_member.c
index 364be39d32..d4b0aeedd6 100644
--- a/subsys/bluetooth/shell/csip.c
+++ b/subsys/bluetooth/shell/csip_set_member.c
@@ -1,6 +1,6 @@
 /**
  * @file
- * @brief Shell APIs for Bluetooth CSIP
+ * @brief Shell APIs for Bluetooth CSIP set member
  *
  * Copyright (c) 2020 Bose Corporation
  * Copyright (c) 2021 Nordic Semiconductor ASA
@@ -53,22 +53,22 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
 	return sirk_read_rsp;
 }
 
-static struct bt_csip_cb csip_cbs = {
+static struct bt_csip_set_member_cb csip_set_member_cbs = {
 	.lock_changed = locked_cb,
 	.sirk_read_req = sirk_read_req_cb,
 };
 
-static int cmd_csip_register(const struct shell *sh, size_t argc, char **argv)
+static int cm_csip_set_member_register(const struct shell *sh, size_t argc, char **argv)
 {
 	int err;
-	struct bt_csip_register_param param = {
+	struct bt_csip_set_member_register_param param = {
 		.set_size = 2,
 		.rank = 1,
 		.lockable = true,
 		/* Using the CSIS test sample SIRK */
 		.set_sirk = { 0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
 			      0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45 },
-		.cb = &csip_cbs
+		.cb = &csip_set_member_cbs
 	};
 
 	for (size_t argn = 1; argn < argc; argn++) {
@@ -96,7 +96,7 @@ static int cmd_csip_register(const struct shell *sh, size_t argc, char **argv)
 		}
 	}
 
-	err = bt_csip_register(&param, &csip);
+	err = bt_csip_set_member_register(&param, &csip);
 	if (err != 0) {
 		shell_error(sh, "Could not register CSIP: %d", err);
 		return err;
@@ -105,18 +105,18 @@ static int cmd_csip_register(const struct shell *sh, size_t argc, char **argv)
 	return 0;
 }
 
-static int cmd_csip_print_sirk(const struct shell *sh, size_t argc,
+static int cm_csip_set_member_print_sirk(const struct shell *sh, size_t argc,
 			       char *argv[])
 {
-	bt_csip_print_sirk(csip);
+	bt_csip_set_member_print_sirk(csip);
 	return 0;
 }
 
-static int cmd_csip_lock(const struct shell *sh, size_t argc, char *argv[])
+static int cm_csip_set_member_lock(const struct shell *sh, size_t argc, char *argv[])
 {
 	int err;
 
-	err = bt_csip_lock(csip, true, false);
+	err = bt_csip_set_member_lock(csip, true, false);
 	if (err != 0) {
 		shell_error(sh, "Failed to set lock: %d", err);
 		return -ENOEXEC;
@@ -127,7 +127,7 @@ static int cmd_csip_lock(const struct shell *sh, size_t argc, char *argv[])
 	return 0;
 }
 
-static int cmd_csip_release(const struct shell *sh, size_t argc,
+static int cm_csip_set_member_release(const struct shell *sh, size_t argc,
 			    char *argv[])
 {
 	bool force = false;
@@ -142,7 +142,7 @@ static int cmd_csip_release(const struct shell *sh, size_t argc,
 		}
 	}
 
-	err = bt_csip_lock(csip, false, force);
+	err = bt_csip_set_member_lock(csip, false, force);
 
 	if (err != 0) {
 		shell_error(sh, "Failed to release lock: %d", err);
@@ -154,7 +154,7 @@ static int cmd_csip_release(const struct shell *sh, size_t argc,
 	return 0;
 }
 
-static int cmd_csip_set_sirk_rsp(const struct shell *sh, size_t argc,
+static int cm_csip_set_member_set_sirk_rsp(const struct shell *sh, size_t argc,
 				 char *argv[])
 {
 	if (strcmp(argv[1], "accept") == 0) {
@@ -173,36 +173,37 @@ static int cmd_csip_set_sirk_rsp(const struct shell *sh, size_t argc,
 	return 0;
 }
 
-static int cmd_csip(const struct shell *sh, size_t argc, char **argv)
+static int cm_csip_set_member(const struct shell *sh, size_t argc, char **argv)
 {
 	shell_error(sh, "%s unknown parameter: %s", argv[0], argv[1]);
 
 	return -ENOEXEC;
 }
 
-SHELL_STATIC_SUBCMD_SET_CREATE(csip_cmds,
+SHELL_STATIC_SUBCMD_SET_CREATE(csip_set_member_cmds,
 	SHELL_CMD_ARG(register, NULL,
 		      "Initialize the service and register callbacks "
 		      "[size <int>] [rank <int>] [not-lockable] [sirk <data>]",
-		      cmd_csip_register, 1, 4),
+		      cm_csip_set_member_register, 1, 4),
 	SHELL_CMD_ARG(lock, NULL,
 		      "Lock the set",
-		      cmd_csip_lock, 1, 0),
+		      cm_csip_set_member_lock, 1, 0),
 	SHELL_CMD_ARG(release, NULL,
 		      "Release the set [force]",
-		      cmd_csip_release, 1, 1),
+		      cm_csip_set_member_release, 1, 1),
 	SHELL_CMD_ARG(print_sirk, NULL,
 		      "Print the currently used SIRK",
-		      cmd_csip_print_sirk, 1, 0),
+		      cm_csip_set_member_print_sirk, 1, 0),
 	SHELL_CMD_ARG(set_sirk_rsp, NULL,
 		      "Set the response used in SIRK requests "
 		      "<accept, accept_enc, reject, oob>",
-		      cmd_csip_set_sirk_rsp, 2, 0),
+		      cm_csip_set_member_set_sirk_rsp, 2, 0),
 		      SHELL_SUBCMD_SET_END
 );
 
-SHELL_CMD_ARG_REGISTER(csip, &csip_cmds, "Bluetooth CSIP shell commands",
-		       cmd_csip, 1, 1);
+SHELL_CMD_ARG_REGISTER(csip_set_member, &csip_set_member_cmds,
+		       "Bluetooth CSIP set member shell commands",
+		       cm_csip_set_member, 1, 1);
 
 ssize_t csis_ad_data_add(struct bt_data *data_array, const size_t data_array_size,
 			 const bool discoverable)
@@ -218,11 +219,11 @@ ssize_t csis_ad_data_add(struct bt_data *data_array, const size_t data_array_siz
 		 * from a SIRK that is exposed in encrypted form.
 		 */
 		if (IS_ENABLED(CONFIG_BT_PRIVACY) &&
-		    !IS_ENABLED(CONFIG_BT_CSIP_ENC_SIRK_SUPPORT)) {
+		    !IS_ENABLED(CONFIG_BT_CSIP_SET_MEMBER_ENC_SIRK_SUPPORT)) {
 			shell_warn(ctx_shell, "RSI derived from unencrypted SIRK");
 		}
 
-		err = bt_csip_generate_rsi(csip, ad_rsi);
+		err = bt_csip_set_member_generate_rsi(csip, ad_rsi);
 		if (err != 0) {
 			shell_error(ctx_shell, "Failed to generate RSI (err %d)", err);
 			return err;
diff --git a/tests/bluetooth/bsim_bt/bsim_test_audio/prj.conf b/tests/bluetooth/bsim_bt/bsim_test_audio/prj.conf
index bad89604ae..124ff394f0 100644
--- a/tests/bluetooth/bsim_bt/bsim_test_audio/prj.conf
+++ b/tests/bluetooth/bsim_bt/bsim_test_audio/prj.conf
@@ -60,8 +60,8 @@ CONFIG_BT_MICP_MIC_CTLR=y
 CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST=2
 
 # Coordinated Set Identification
-CONFIG_BT_CSIP=y
-CONFIG_BT_CSIP_TEST_SAMPLE_DATA=y
+CONFIG_BT_CSIP_SET_MEMBER=y
+CONFIG_BT_CSIP_SET_MEMBER_TEST_SAMPLE_DATA=y
 CONFIG_BT_CSIP_SET_COORDINATOR=y
 CONFIG_BT_CSIP_SET_COORDINATOR_TEST_SAMPLE_DATA=y
 
@@ -132,9 +132,9 @@ CONFIG_BT_DEBUG_MCC=y
 CONFIG_BT_OTS_LOG_LEVEL_DBG=y
 CONFIG_BT_DEBUG_OTS_CLIENT=y
 CONFIG_MCTL_DEBUG=y
-CONFIG_BT_DEBUG_CSIP=y
+CONFIG_BT_DEBUG_CSIP_SET_MEMBER=y
 CONFIG_BT_DEBUG_CSIP_SET_COORDINATOR=y
-CONFIG_BT_DEBUG_CSIP_CRYPTO=y
+CONFIG_BT_DEBUG_CSIP_SET_MEMBER_CRYPTO=y
 CONFIG_BT_AUDIO_DEBUG_UNICAST_CLIENT=y
 CONFIG_BT_AUDIO_DEBUG_UNICAST_SERVER=y
 CONFIG_BT_AUDIO_DEBUG_BROADCAST_SINK=y
diff --git a/tests/bluetooth/bsim_bt/bsim_test_audio/src/cap_acceptor_test.c b/tests/bluetooth/bsim_bt/bsim_test_audio/src/cap_acceptor_test.c
index 8cd9e545cc..35f9ed6866 100644
--- a/tests/bluetooth/bsim_bt/bsim_test_audio/src/cap_acceptor_test.c
+++ b/tests/bluetooth/bsim_bt/bsim_test_audio/src/cap_acceptor_test.c
@@ -19,7 +19,7 @@ static const struct bt_data cap_acceptor_ad[] = {
 	BT_DATA_BYTES(BT_DATA_UUID16_ALL, BT_UUID_16_ENCODE(BT_UUID_CAS_VAL)),
 };
 
-static struct bt_csip *csis;
+static struct bt_csip *csip_set_member;
 
 CREATE_FLAG(flag_connected);
 
@@ -45,11 +45,11 @@ BT_CONN_CB_DEFINE(conn_callbacks) = {
 
 static void init(void)
 {
-	struct bt_csip_register_param csis_param = {
+	struct bt_csip_set_member_register_param csip_set_member_param = {
 		.set_size = 3,
 		.rank = 1,
 		.lockable = true,
-		/* Using the CSIS test sample SIRK */
+		/* Using the CSIP_SET_MEMBER test sample SIRK */
 		.set_sirk = { 0xcd, 0xcc, 0x72, 0xdd, 0x86, 0x8c, 0xcd, 0xce,
 			0x22, 0xfd, 0xa1, 0x21, 0x09, 0x7d, 0x7d, 0x45 },
 	};
@@ -64,7 +64,8 @@ static void init(void)
 	printk("Bluetooth initialized\n");
 
 	if (IS_ENABLED(CONFIG_BT_CAP_ACCEPTOR_SET_MEMBER)) {
-		err = bt_cap_acceptor_register(&csis_param, &csis);
+		err = bt_cap_acceptor_register(&csip_set_member_param,
+					       &csip_set_member);
 		if (err != 0) {
 			FAIL("CAP acceptor failed to register (err %d)\n", err);
 			return;
diff --git a/tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_test.c b/tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_set_member_test.c
similarity index 87%
rename from tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_test.c
rename to tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_set_member_test.c
index 2e79f49300..8c69ae756d 100644
--- a/tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_test.c
+++ b/tests/bluetooth/bsim_bt/bsim_test_audio/src/csip_set_member_test.c
@@ -4,7 +4,7 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-#ifdef CONFIG_BT_CSIP
+#ifdef CONFIG_BT_CSIP_SET_MEMBER
 #include <zephyr/bluetooth/audio/csip.h>
 
 #include "common.h"
@@ -14,7 +14,7 @@ static struct bt_conn_cb conn_callbacks;
 extern enum bst_result_t bst_result;
 static volatile bool g_locked;
 static uint8_t sirk_read_req_rsp = BT_CSIP_READ_SIRK_REQ_RSP_ACCEPT;
-struct bt_csip_register_param param = {
+struct bt_csip_set_member_register_param param = {
 	.set_size = 3,
 	.rank = 1,
 	.lockable = true,
@@ -59,7 +59,7 @@ static uint8_t sirk_read_req_cb(struct bt_conn *conn, struct bt_csip *csip)
 	return sirk_read_req_rsp;
 }
 
-static struct bt_csip_cb csip_cbs = {
+static struct bt_csip_set_member_cb csip_cbs = {
 	.lock_changed = csip_lock_changed_cb,
 	.sirk_read_req = sirk_read_req_cb,
 };
@@ -81,13 +81,13 @@ static void bt_ready(int err)
 
 	param.cb = &csip_cbs;
 
-	err = bt_csip_register(&param, &csip);
+	err = bt_csip_set_member_register(&param, &csip);
 	if (err != 0) {
 		FAIL("Could not register CSIP (err %d)\n", err);
 		return;
 	}
 
-	err = bt_csip_generate_rsi(csip, rsi);
+	err = bt_csip_set_member_generate_rsi(csip, rsi);
 	if (err != 0) {
 		FAIL("Failed to generate RSI (err %d)\n", err);
 		return;
@@ -133,7 +133,7 @@ static void test_force_release(void)
 
 	WAIT_FOR_COND(g_locked);
 	printk("Force releasing set\n");
-	bt_csip_lock(csip, false, true);
+	bt_csip_set_member_lock(csip, false, true);
 }
 
 static void test_csip_enc(void)
@@ -173,21 +173,21 @@ static void test_args(int argc, char *argv[])
 
 static const struct bst_test_instance test_connect[] = {
 	{
-		.test_id = "csip",
+		.test_id = "csip_set_member",
 		.test_post_init_f = test_init,
 		.test_tick_f = test_tick,
 		.test_main_f = test_main,
 		.test_args_f = test_args,
 	},
 	{
-		.test_id = "csip_release",
+		.test_id = "csip_set_member_release",
 		.test_post_init_f = test_init,
 		.test_tick_f = test_tick,
 		.test_main_f = test_force_release,
 		.test_args_f = test_args,
 	},
 	{
-		.test_id = "csip_enc",
+		.test_id = "csip_set_member_enc",
 		.test_post_init_f = test_init,
 		.test_tick_f = test_tick,
 		.test_main_f = test_csip_enc,
@@ -197,15 +197,15 @@ static const struct bst_test_instance test_connect[] = {
 	BSTEST_END_MARKER
 };
 
-struct bst_test_list *test_csip_install(struct bst_test_list *tests)
+struct bst_test_list *test_csip_set_member_install(struct bst_test_list *tests)
 {
 	return bst_add_tests(tests, test_connect);
 }
 #else
 
-struct bst_test_list *test_csip_install(struct bst_test_list *tests)
+struct bst_test_list *test_csip_set_member_install(struct bst_test_list *tests)
 {
 	return tests;
 }
 
-#endif /* CONFIG_BT_CSIP */
+#endif /* CONFIG_BT_CSIP_SET_MEMBER */
diff --git a/tests/bluetooth/bsim_bt/bsim_test_audio/src/main.c b/tests/bluetooth/bsim_bt/bsim_test_audio/src/main.c
index cb6725743c..0e03acd4cb 100644
--- a/tests/bluetooth/bsim_bt/bsim_test_audio/src/main.c
+++ b/tests/bluetooth/bsim_bt/bsim_test_audio/src/main.c
@@ -10,7 +10,7 @@ extern struct bst_test_list *test_vcs_install(struct bst_test_list *tests);
 extern struct bst_test_list *test_vcs_client_install(struct bst_test_list *tests);
 extern struct bst_test_list *test_micp_install(struct bst_test_list *tests);
 extern struct bst_test_list *test_micp_mic_ctlr_install(struct bst_test_list *tests);
-extern struct bst_test_list *test_csip_install(struct bst_test_list *tests);
+extern struct bst_test_list *test_csip_set_member_install(struct bst_test_list *tests);
 extern struct bst_test_list *test_csip_set_coordinator_install(struct bst_test_list *tests);
 extern struct bst_test_list *test_tbs_install(struct bst_test_list *tests);
 extern struct bst_test_list *test_tbs_client_install(struct bst_test_list *tests);
@@ -36,7 +36,7 @@ bst_test_install_t test_installers[] = {
 	test_vcs_client_install,
 	test_micp_install,
 	test_micp_mic_ctlr_install,
-	test_csip_install,
+	test_csip_set_member_install,
 	test_csip_set_coordinator_install,
 	test_tbs_install,
 	test_tbs_client_install,
diff --git a/tests/bluetooth/bsim_bt/bsim_test_audio/test_scripts/csip.sh b/tests/bluetooth/bsim_bt/bsim_test_audio/test_scripts/csip.sh
index f1049daa72..92dcf72cd7 100755
--- a/tests/bluetooth/bsim_bt/bsim_test_audio/test_scripts/csip.sh
+++ b/tests/bluetooth/bsim_bt/bsim_test_audio/test_scripts/csip.sh
@@ -33,15 +33,15 @@ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
   -RealEncryption=1 -rs=1
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_set_member \
   -RealEncryption=1 -rs=2 -argstest rank 1
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_set_member \
   -RealEncryption=1 -rs=3 -argstest rank 2
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_set_member \
   -RealEncryption=1 -rs=4 -argstest rank 3
 
 # Simulation time should be larger than the WAIT_TIME in common.h
@@ -61,15 +61,15 @@ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
   -RealEncryption=1 -rs=1
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_set_member \
   -RealEncryption=1 -rs=2 -argstest rank 1
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_set_member \
   -RealEncryption=1 -rs=3 -argstest rank 2
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_release \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_set_member_release \
   -RealEncryption=1 -rs=4 -argstest rank 3
 
 # Simulation time should be larger than the WAIT_TIME in common.h
@@ -87,15 +87,15 @@ Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
   -RealEncryption=1 -rs=1
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_enc \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=1 -testid=csip_set_member_enc \
   -RealEncryption=1 -rs=2 -argstest rank 1
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_enc \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=2 -testid=csip_set_member_enc \
   -RealEncryption=1 -rs=3 -argstest rank 2
 
 Execute ./bs_${BOARD}_tests_bluetooth_bsim_bt_bsim_test_audio_prj_conf \
-  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_enc \
+  -v=${VERBOSITY_LEVEL} -s=${SIMULATION_ID} -d=3 -testid=csip_set_member_enc \
   -RealEncryption=1 -rs=4 -argstest rank 3
 
 # Simulation time should be larger than the WAIT_TIME in common.h
diff --git a/tests/bluetooth/shell/audio.conf b/tests/bluetooth/shell/audio.conf
index 7142437a7e..762f746255 100644
--- a/tests/bluetooth/shell/audio.conf
+++ b/tests/bluetooth/shell/audio.conf
@@ -83,7 +83,7 @@ CONFIG_BT_MICP_MIC_CTLR=y
 CONFIG_BT_MICP_MIC_CTLR_MAX_AICS_INST=1
 
 # Coordinated Set Identification
-CONFIG_BT_CSIP=y
+CONFIG_BT_CSIP_SET_MEMBER=y
 CONFIG_BT_CSIP_SET_COORDINATOR=y
 CONFIG_BT_CSIP_SET_COORDINATOR_MAX_CSIS_INSTANCES=2