applications: nrf_desktop: Add device description discovery

Change adds discovering custom device description service on central.

Jira:DESK-748

Signed-off-by: Marek Pieta <[email protected]>

Author: MarekPieta

applications/nrf_desktop/src/events/ble_event.h

@@ -107,6 +107,7 @@ struct ble_discovery_complete_event {
 
 	struct bt_gatt_dm *dm;
 	u16_t pid;
+	bool peer_llpm_support;
 	enum peer_type peer_type;
 };
 EVENT_TYPE_DECLARE(ble_discovery_complete_event);

applications/nrf_desktop/src/modules/ble_discovery.c

@@ -15,15 +15,28 @@
 
 #include "ble_event.h"
 #include "ble_discovery_def.h"
+#include "dev_descr.h"
 
 #include <logging/log.h>
 LOG_MODULE_REGISTER(MODULE, CONFIG_DESKTOP_BLE_DISCOVERY_LOG_LEVEL);
 
+enum discovery_state {
+	DISCOVERY_STATE_START,
+	DISCOVERY_STATE_DEV_DESCR,
+	DISCOVERY_STATE_DIS,
+	DISCOVERY_STATE_HIDS,
+
+	DISCOVERY_STATE_COUNT,
+};
+
+static enum discovery_state state;
+
 static u16_t peer_vid;
 static u16_t peer_pid;
+static bool peer_llpm_support;
 static struct bt_conn *discovering_peer_conn;
 
-static struct k_work hids_discovery_start;
+static struct k_work next_discovery_step;
 
 #define VID_POS_IN_PNP_ID	sizeof(u8_t)
 #define PID_POS_IN_PNP_ID	(VID_POS_IN_PNP_ID + sizeof(u16_t))
@@ -41,10 +54,12 @@ static void peer_unpair(void)
 	}
 	bt_conn_unref(discovering_peer_conn);
 	discovering_peer_conn = NULL;
+	state = DISCOVERY_STATE_START;
 }
 
 static void hids_discovery_completed(struct bt_gatt_dm *dm, void *context)
 {
+	__ASSERT_NO_MSG(dm != NULL);
 	__ASSERT_NO_MSG(bt_gatt_dm_conn_get(dm) == discovering_peer_conn);
 	BUILD_ASSERT_MSG(PEER_TYPE_COUNT <= __CHAR_BIT__, "");
 	LOG_INF("HIDS discovery procedure succeeded");
@@ -56,6 +71,7 @@ static void hids_discovery_completed(struct bt_gatt_dm *dm, void *context)
 
 	event->dm = dm;
 	event->pid = peer_pid;
+	event->peer_llpm_support = peer_llpm_support;
 
 	for (size_t i = 0; i < ARRAY_SIZE(bt_peripherals); i++) {
 		if (bt_peripherals[i].pid == peer_pid) {
@@ -81,93 +97,94 @@ static void hids_discovery_completed(struct bt_gatt_dm *dm, void *context)
 	peer_unpair();
 }
 
-static void hids_discovery_service_not_found(struct bt_conn *conn,
-					     void *context)
+static void service_not_found(struct bt_conn *conn, void *context)
 {
-	LOG_ERR("Cannot find HIDS during the discovery");
+	LOG_ERR("Service not found");
 	__ASSERT_NO_MSG(discovering_peer_conn == conn);
 	peer_unpair();
 }
 
-static void hids_discovery_error_found(struct bt_conn *conn, int err,
-				       void *context)
+static void discovery_error(struct bt_conn *conn, int err, void *context)
 {
-	LOG_ERR("HIDS discovery failed (err:%d)", err);
+	LOG_ERR("Error discovering peer (err:%d)", err);
 	__ASSERT_NO_MSG(discovering_peer_conn == conn);
 	peer_unpair();
 }
 
-static void start_hids_discovery(struct bt_conn *conn)
+static void read_dev_descr(const u8_t *ptr, u16_t len)
 {
-	static const struct bt_gatt_dm_cb discovery_cb = {
-		.completed = hids_discovery_completed,
-		.service_not_found = hids_discovery_service_not_found,
-		.error_found = hids_discovery_error_found,
-	};
-
-	int err = bt_gatt_dm_start(conn, BT_UUID_HIDS, &discovery_cb, NULL);
-
-	if (err == -EALREADY) {
-		LOG_ERR("Discovery already in progress");
-		module_set_state(MODULE_STATE_ERROR);
-	} else if (err) {
-		LOG_ERR("Cannot start the discovery (err:%d)", err);
-		peer_unpair();
-	}
+	__ASSERT_NO_MSG(len >= DEV_DESCR_LEN);
+	peer_llpm_support = ptr[DEV_DESCR_LLPM_SUPPORT_POS];
+	LOG_INF("LLPM %ssupported", peer_llpm_support ? ("") : ("not "));
 }
 
-static bool verify_peer(void)
+static void read_dis(const u8_t *ptr, u16_t len)
 {
-	if (peer_vid != vendor_vid) {
-		LOG_WRN("Invalid peripheral VID");
-		return false;
-	}
+	__ASSERT_NO_MSG(len >= MIN_LEN_DIS_PNP_ID);
 
-	return true;
-}
+	peer_vid = sys_get_le16(&ptr[VID_POS_IN_PNP_ID]);
+	peer_pid = sys_get_le16(&ptr[PID_POS_IN_PNP_ID]);
 
-static void hids_discovery_start_fn(struct k_work *w)
-{
-	if (!verify_peer()) {
-		peer_unpair();
-	} else {
-		start_hids_discovery(discovering_peer_conn);
-	}
+	LOG_INF("VID: %02x PID: %02x", peer_vid, peer_pid);
 }
 
 static u8_t read_attr(struct bt_conn *conn, u8_t err,
-	       struct bt_gatt_read_params *params,
-	       const void *data, u16_t length)
+		      struct bt_gatt_read_params *params,
+		      const void *data, u16_t length)
 {
 	if (err) {
-		LOG_ERR("Problem with reading GATT (err:%u)", err);
+		LOG_ERR("Problem reading GATT (err:%" PRIu8 ")", err);
 		peer_unpair();
 		return BT_GATT_ITER_STOP;
 	}
 
-	__ASSERT_NO_MSG(length >= MIN_LEN_DIS_PNP_ID);
+	__ASSERT_NO_MSG(data != NULL);
 	const u8_t *data_ptr = data;
 
-	peer_vid = sys_get_le16(&data_ptr[VID_POS_IN_PNP_ID]);
-	peer_pid = sys_get_le16(&data_ptr[PID_POS_IN_PNP_ID]);
+	switch (state) {
+	case DISCOVERY_STATE_DEV_DESCR:
+		read_dev_descr(data_ptr, length);
+		break;
 
-	LOG_INF("VID: %02x PID: %02x", peer_vid, peer_pid);
+	case DISCOVERY_STATE_DIS:
+		read_dis(data_ptr, length);
+		break;
+
+	default:
+		__ASSERT_NO_MSG(false);
+	}
 
-	k_work_submit(&hids_discovery_start);
+	k_work_submit(&next_discovery_step);
 
 	return BT_GATT_ITER_STOP;
 }
 
-static void dis_read_completed(struct bt_gatt_dm *dm, void *context)
+static void discovery_completed(struct bt_gatt_dm *dm, void *context)
 {
+	__ASSERT_NO_MSG(dm != NULL);
 	__ASSERT_NO_MSG(discovering_peer_conn == bt_gatt_dm_conn_get(dm));
+	const struct bt_uuid *uuid = NULL;
 	const struct bt_gatt_attr *attr;
 	int err;
 
-	attr = bt_gatt_dm_char_by_uuid(dm, BT_UUID_DIS_PNP_ID);
+	switch (state) {
+	case DISCOVERY_STATE_DEV_DESCR:
+		uuid = &custom_desc_chrc_uuid.uuid;
+		break;
+
+	case DISCOVERY_STATE_DIS:
+		uuid = BT_UUID_DIS_PNP_ID;
+		break;
+
+	default:
+		/* Should not happen. */
+		__ASSERT_NO_MSG(false);
+	}
+
+	attr = bt_gatt_dm_char_by_uuid(dm, uuid);
 
 	if (!attr) {
-		LOG_ERR("PnP ID characteristic not found - disconnecting");
+		LOG_ERR("Characteristic not found - disconnecting");
 		err = bt_gatt_dm_data_release(dm);
 		if (err) {
 			goto error;
@@ -184,48 +201,99 @@ static void dis_read_completed(struct bt_gatt_dm *dm, void *context)
 
 	rp.single.handle = attr->handle + 1;
 
+	err = bt_gatt_read(bt_gatt_dm_conn_get(dm), &rp);
+	if (err) {
+		LOG_ERR("GATT read problem (err:%d)", err);
+		peer_unpair();
+	}
+
 	err = bt_gatt_dm_data_release(dm);
 	if (err) {
 		goto error;
 	}
 
-	bt_gatt_read(discovering_peer_conn, &rp);
 	return;
 error:
 	LOG_ERR("Discovery data release failed (err:%d)", err);
 	module_set_state(MODULE_STATE_ERROR);
 }
 
-static void dis_not_found(struct bt_conn *conn, void *context)
+static void start_discovery(struct bt_conn *conn,
+			    const struct bt_uuid *svc_uuid,
+			    bool discovery_hids)
 {
-	LOG_ERR("DIS not found");
-	__ASSERT_NO_MSG(discovering_peer_conn == conn);
-	peer_unpair();
+	static const struct bt_gatt_dm_cb discovery_cb = {
+		.completed = discovery_completed,
+		.service_not_found = service_not_found,
+		.error_found = discovery_error,
+	};
+
+	static const struct bt_gatt_dm_cb hids_discovery_cb = {
+		.completed = hids_discovery_completed,
+		.service_not_found = service_not_found,
+		.error_found = discovery_error,
+	};
+
+	int err = bt_gatt_dm_start(conn, svc_uuid,
+			discovery_hids ? &hids_discovery_cb : &discovery_cb,
+			NULL);
+
+	__ASSERT_NO_MSG(err != -EALREADY);
+	__ASSERT_NO_MSG(err != -EINVAL);
+	if (err) {
+		LOG_ERR("Cannot start discovery (err:%d)", err);
+		peer_unpair();
+	}
 }
 
-static void dis_read_error(struct bt_conn *conn, int err, void *context)
+static bool verify_peer(void)
 {
-	LOG_ERR("Error discovering DIS (err:%d)", err);
-	__ASSERT_NO_MSG(discovering_peer_conn == conn);
-	peer_unpair();
+	if (peer_vid != vendor_vid) {
+		LOG_WRN("Invalid peripheral VID");
+		return false;
+	}
+
+	return true;
 }
 
-static void start_dis_read(struct bt_conn *conn)
+static void next_discovery_step_fn(struct k_work *w)
 {
-	static const struct bt_gatt_dm_cb dis_discovery_cb = {
-		.completed = dis_read_completed,
-		.service_not_found = dis_not_found,
-		.error_found = dis_read_error,
-	};
+	BUILD_ASSERT_MSG((DISCOVERY_STATE_HIDS + 1) == DISCOVERY_STATE_COUNT,
+		"HIDs must be discovered last - after device is verified");
 
-	int err = bt_gatt_dm_start(conn, BT_UUID_DIS, &dis_discovery_cb, NULL);
+	state++;
 
-	if (err) {
-		LOG_ERR("Cannot start DIS discovery (err:%d)", err);
-		peer_unpair();
+	switch (state) {
+	case DISCOVERY_STATE_DEV_DESCR:
+		start_discovery(discovering_peer_conn, &custom_desc_uuid.uuid, false);
+		break;
+
+	case DISCOVERY_STATE_DIS:
+		start_discovery(discovering_peer_conn, BT_UUID_DIS, false);
+		break;
+
+	case DISCOVERY_STATE_HIDS:
+		if (!verify_peer()) {
+			peer_unpair();
+		} else {
+			start_discovery(discovering_peer_conn, BT_UUID_HIDS, true);
+		}
+		break;
+
+	case DISCOVERY_STATE_START:
+	case DISCOVERY_STATE_COUNT:
+	default:
+		__ASSERT_NO_MSG(false);
 	}
 }
 
+static void init(void)
+{
+	k_work_init(&next_discovery_step, next_discovery_step_fn);
+	state = DISCOVERY_STATE_START;
+	module_set_state(MODULE_STATE_READY);
+}
+
 static bool event_handler(const struct event_header *eh)
 {
 	if (is_ble_peer_event(eh)) {
@@ -236,8 +304,7 @@ static bool event_handler(const struct event_header *eh)
 		case PEER_STATE_SECURED:
 			discovering_peer_conn = event->id;
 			bt_conn_ref(discovering_peer_conn);
-
-			start_dis_read(event->id);
+			k_work_submit(&next_discovery_step);
 			break;
 
 		default:
@@ -258,6 +325,7 @@ static bool event_handler(const struct event_header *eh)
 		}
 		bt_conn_unref(discovering_peer_conn);
 		discovering_peer_conn = NULL;
+		state = DISCOVERY_STATE_START;
 
 		return false;
 	}
@@ -267,9 +335,7 @@ static bool event_handler(const struct event_header *eh)
 			cast_module_state_event(eh);
 
 		if (check_state(event, MODULE_ID(main), MODULE_STATE_READY)) {
-			k_work_init(&hids_discovery_start,
-				    hids_discovery_start_fn);
-			module_set_state(MODULE_STATE_READY);
+			init();
 		}
 
 		return false;