pal: switch to multi-advertising BLE API

This commit prepares PAL to be used alongside other BLE instances.

Signed-off-by: Konrad Derda <[email protected]>

Kconfig

@@ -195,6 +195,14 @@ config SIDEWALK_BLE_ADV_INT_SLOW
 	range 20 10240
 	default 1000
 
+config SIDEWALK_BLE_ID
+	int "Set Sidewalk's BLE identity identifier"
+	range 1 255
+	default 1
+	help
+	  Specify identifier used to distinguish Sidewalk related BLE
+	  events.
+
 config SIDEWALK_BLE_ADV_INT_TRANSITION
 	int "Duration of fast advertisement after sid_start in seconds"
 	range 1 2147483647

Kconfig.dependencies

@@ -31,6 +31,7 @@ config SIDEWALK_BLE
 	default SIDEWALK
 	imply BT
 	imply BT_PERIPHERAL
+	imply BT_EXT_ADV
 	help
 		Sidewalk Bluetooth Low Energy (BLE) module
 

samples/sid_end_device/Kconfig.defconfig

@@ -42,6 +42,12 @@ config BT_PERIPHERAL_PREF_LATENCY
 config BT_PERIPHERAL_PREF_TIMEOUT
 	default 400
 
+config BT_EXT_ADV_MAX_ADV_SET
+	default 2
+
+config BT_ID_MAX
+	default 2
+
 # NVM
 config NVS_LOOKUP_CACHE
 	default y

subsys/sal/sid_pal/include/sid_ble_advert.h

@@ -9,6 +9,13 @@
 
 #include <stdint.h>
 
+/**
+ * @brief Initialize Bluetooth Advertising.
+ *
+ * @return Zero on success or (negative) error code on failure.
+ */
+int sid_ble_advert_init(void);
+
 /**
  * @brief Start Bluetooth advertising.
  *

subsys/sal/sid_pal/src/sid_ble_adapter.c

@@ -57,6 +57,26 @@ static struct sid_pal_ble_adapter_interface ble_ifc = {
 	.deinit = ble_adapter_deinit,
 };
 
+static int create_ble_id() {
+	int ret;
+	size_t count;
+
+	/* Check if Bluetooth identites weren't already created. */
+	bt_id_get(NULL, &count);
+	if (count > CONFIG_SIDEWALK_BLE_ID) {
+		return 0;
+	}
+
+	do {
+		ret = bt_id_create(NULL, NULL);
+		if (ret < 0) {
+			return ret;
+		}
+	} while (ret != CONFIG_SIDEWALK_BLE_ID);
+
+	return 0;
+}
+
 static sid_error_t ble_adapter_init(const sid_ble_config_t *cfg)
 {
 	LOG_DBG("Sidewalk -> BLE");
@@ -82,6 +102,18 @@ static sid_error_t ble_adapter_init(const sid_ble_config_t *cfg)
 		return SID_ERROR_GENERIC;
 	}
 
+	err_code = create_ble_id();
+	if (err_code) {
+		LOG_ERR("BT ID init failed (err: %d)", err_code);
+		return SID_ERROR_GENERIC;
+	}
+
+	err_code = sid_ble_advert_init();
+	if (err_code) {
+		LOG_ERR("BT Advertisement failed (err: %d)", err_code);
+		return SID_ERROR_GENERIC;
+	}
+
 	sid_ble_conn_init();
 
 	return SID_ERROR_NONE;

subsys/sal/sid_pal/src/sid_ble_advert.c

@@ -40,17 +40,24 @@ LOG_MODULE_REGISTER(sid_ble_advert, CONFIG_SIDEWALK_BLE_ADAPTER_LOG_LEVEL);
 #endif
 
 /* Advertising parameters. */
-#define AMA_ADV_PARAM_FAST                                                                         \
-	BT_LE_ADV_PARAM(AMA_ADV_OPTIONS, MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_FAST),     \
-			MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_FAST +                      \
-					   CONFIG_SIDEWALK_BLE_ADV_INT_PRECISION),                 \
-			NULL)
-
-#define AMA_ADV_PARAM_SLOW                                                                         \
-	BT_LE_ADV_PARAM(AMA_ADV_OPTIONS, MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_SLOW),     \
-			MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_SLOW +                      \
-					   CONFIG_SIDEWALK_BLE_ADV_INT_PRECISION),                 \
-			NULL)
+static struct bt_le_adv_param adv_param_fast = {
+	.id = CONFIG_SIDEWALK_BLE_ID,
+	.options = (AMA_ADV_OPTIONS),
+	.interval_min = MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_FAST),
+	.interval_max = MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_FAST +                      \
+					   CONFIG_SIDEWALK_BLE_ADV_INT_PRECISION),
+};
+
+static struct bt_le_adv_param adv_param_slow = {
+	.id = CONFIG_SIDEWALK_BLE_ID,
+	.options = (AMA_ADV_OPTIONS),
+	.interval_min = MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_SLOW),
+	.interval_max = MS_TO_INTERVAL_VAL(CONFIG_SIDEWALK_BLE_ADV_INT_SLOW +                      \
+					   CONFIG_SIDEWALK_BLE_ADV_INT_PRECISION),
+};
+
+static struct bt_le_ext_adv *adv_set_fast;
+static struct bt_le_ext_adv *adv_set_slow;
 
 /**
  * @brief Advertising data items values size in bytes.
@@ -67,7 +74,7 @@ LOG_MODULE_REGISTER(sid_ble_advert, CONFIG_SIDEWALK_BLE_ADAPTER_LOG_LEVEL);
 
 enum adv_data_items { ADV_DATA_FLAGS, ADV_DATA_SERVICES, ADV_DATA_MANUF_DATA };
 
-typedef enum { BLE_ADV_DISABLE, BLE_ADV_ENABLE } sid_ble_adv_state_t;
+typedef enum { BLE_ADV_DISABLE, BLE_ADV_FAST, BLE_ADV_SLOW } sid_ble_adv_state_t;
 
 static void change_advertisement_interval(struct k_work *);
 K_WORK_DELAYABLE_DEFINE(change_adv_work, change_advertisement_interval);
@@ -107,28 +114,68 @@ static uint8_t advert_manuf_data_copy(uint8_t *data, uint8_t data_len)
 static void change_advertisement_interval(struct k_work *work)
 {
 	ARG_UNUSED(work);
-	if (BLE_ADV_ENABLE == atomic_get(&adv_state)) {
-		if (bt_le_adv_stop()) {
+
+	struct bt_le_ext_adv_start_param ext_adv_start_param = {0};
+
+	if (BLE_ADV_FAST == atomic_get(&adv_state)) {
+		if (bt_le_ext_adv_stop(adv_set_fast)) {
 			atomic_set(&adv_state, BLE_ADV_DISABLE);
 			return;
 		}
-		if (bt_le_adv_start(AMA_ADV_PARAM_SLOW, adv_data, ARRAY_SIZE(adv_data), NULL, 0)) {
+
+		if (bt_le_ext_adv_set_data(adv_set_slow, adv_data, ARRAY_SIZE(adv_data), NULL, 0)) {
+ 			atomic_set(&adv_state, BLE_ADV_DISABLE);
+			return;
+ 		}
+
+		if (bt_le_ext_adv_start(adv_set_slow, &ext_adv_start_param)) {
 			atomic_set(&adv_state, BLE_ADV_DISABLE);
 			return;
 		}
+
+		atomic_set(&adv_state, BLE_ADV_SLOW);
+
 		LOG_DBG("BLE -> BLE");
 	}
 }
 
+int sid_ble_advert_init(void)
+{
+	int ret;
+
+	ret = bt_le_ext_adv_create(&adv_param_fast, NULL, &adv_set_fast);
+	if (ret) {
+		LOG_ERR("Failed to create fast advertising set");
+		return ret;
+	}
+
+	ret = bt_le_ext_adv_create(&adv_param_slow, NULL, &adv_set_slow);
+	if (ret) {
+		LOG_ERR("Failed to create slow advertising set");
+		return ret;
+	}
+
+	return 0;
+}
+
 int sid_ble_advert_start(void)
 {
 	k_work_reschedule(&change_adv_work, K_SECONDS(CONFIG_SIDEWALK_BLE_ADV_INT_TRANSITION));
-	int err = bt_le_adv_start(AMA_ADV_PARAM_FAST, adv_data, ARRAY_SIZE(adv_data), NULL, 0);
 
+	struct bt_le_ext_adv_start_param ext_adv_start_param = {0};
+	int err;
+
+	err = bt_le_ext_adv_set_data(adv_set_fast, adv_data, ARRAY_SIZE(adv_data), NULL, 0);
+ 	if (err) {
+ 		return err;
+ 	}
+
+	err = bt_le_ext_adv_start(adv_set_fast, &ext_adv_start_param);;
 	if (err) {
 		return err;
 	}
-	atomic_set(&adv_state, BLE_ADV_ENABLE);
+
+	atomic_set(&adv_state, BLE_ADV_FAST);
 
 #if defined(CONFIG_MAC_ADDRESS_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE)
 	static struct bt_le_oob oob;
@@ -141,7 +188,8 @@ int sid_ble_advert_start(void)
 int sid_ble_advert_stop(void)
 {
 	k_work_cancel_delayable(&change_adv_work);
-	int err = bt_le_adv_stop();
+	int err = bt_le_ext_adv_stop(atomic_get(&adv_state) == BLE_ADV_FAST ? adv_set_fast :
+									      adv_set_slow);
 
 	if (0 == err) {
 		atomic_set(&adv_state, BLE_ADV_DISABLE);
@@ -152,6 +200,8 @@ int sid_ble_advert_stop(void)
 
 int sid_ble_advert_update(uint8_t *data, uint8_t data_len)
 {
+	sid_ble_adv_state_t state = atomic_get(&adv_state);
+
 	if (!data || 0 == data_len) {
 		return -EINVAL;
 	}
@@ -160,8 +210,10 @@ int sid_ble_advert_update(uint8_t *data, uint8_t data_len)
 
 	int err = 0;
 
-	if (BLE_ADV_ENABLE == atomic_get(&adv_state)) {
-		err = bt_le_adv_update_data(adv_data, ARRAY_SIZE(adv_data), NULL, 0);
+	if (BLE_ADV_DISABLE != state) {
+		/* Update currently advertised set, the other one will be set on start/transition */
+		err = bt_le_ext_adv_set_data((state == BLE_ADV_FAST ? adv_set_fast : adv_set_slow),
+					     adv_data, ARRAY_SIZE(adv_data), NULL, 0);
 	}
 
 	return err;

subsys/sal/sid_pal/src/sid_ble_connection.c

@@ -33,6 +33,16 @@ static struct bt_conn_cb conn_callbacks = {
 
 static struct bt_gatt_cb gatt_callbacks = { .att_mtu_updated = ble_mtu_cb };
 
+static bool should_handle_event(struct bt_conn *conn) {
+	struct bt_conn_info conn_info;
+
+	if (!conn || bt_conn_get_info(conn, &conn_info) || conn_info.id != CONFIG_SIDEWALK_BLE_ID) {
+		return false;
+	}
+
+	return true;
+}
+
 /**
  * @brief The function is called when a new connection is established.
  *
@@ -41,12 +51,18 @@ static struct bt_gatt_cb gatt_callbacks = { .att_mtu_updated = ble_mtu_cb };
  */
 static void ble_connect_cb(struct bt_conn *conn, uint8_t err)
 {
+	const bt_addr_le_t *bt_addr_le;
+
+	if (!should_handle_event(conn)) {
+		return;
+	}
+
 	if (err) {
 		LOG_ERR("Connection failed (err %u)\n", err);
 		return;
 	}
 
-	const bt_addr_le_t *bt_addr_le = bt_conn_get_dst(conn);
+	bt_addr_le = bt_conn_get_dst(conn);
 
 	if (bt_addr_le) {
 		memcpy(conn_params.addr, bt_addr_le->a.val, BT_ADDR_SIZE);
@@ -72,10 +88,10 @@ static void ble_connect_cb(struct bt_conn *conn, uint8_t err)
  */
 static void ble_disconnect_cb(struct bt_conn *conn, uint8_t reason)
 {
-	if (!conn || conn_params.conn != conn) {
-		LOG_WRN("Unknow connection");
+	if (!should_handle_event(conn)) {
 		return;
 	}
+
 	sid_ble_adapter_conn_disconnected((const uint8_t *)conn_params.addr);
 
 	k_mutex_lock(&bt_conn_mutex, K_FOREVER);