[PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI)

[PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI)

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

This series adds support for the Shorter Connection Interval (SCI) feature
introduced in Bluetooth Core Specification 6.2 and used by HIDS 1.1 / HOGP
v1.2.

SCI allows an LE ACL connection to use very short connection intervals (as
low as 1.25 ms) combined with a subrating factor, so a device such as a HID
peripheral can achieve low input latency while keeping power consumption
manageable. The connection rate parameters (connection interval range,
subrate factor range, peripheral latency, continuation number and
supervision timeout) are negotiated with the LE Connection Rate Request
procedure.

The series covers the full stack:

- HIDS 1.1 GATT discovery: the HID SCI Mode (0x2C39) and HID SCI Information
  (0x2C3A) characteristics, and the SCI flags in the HID Information
  characteristic.

- Management interface: a new Shorter Connection Interval setting (bit 25) to
  advertise controller support, a Load Connection Subrate command (0x005C) to
  load per-device connection subrate parameters, and a Connection Subrate
  event (0x0033) to report rate changes. Parameters are persisted per device
  in the [ConnectionSubrate] storage group.

- bluetoothctl: a conn-subrate command in the mgmt submenu to load subrate
  parameters, pre or post connection.

- monitor (btmon) decoding for the new command, setting and event.

- Emulation and tests: btdev and bthost gain SCI command/event support, and
  mgmt-tester and l2cap-tester cover the setting, the Load Connection Subrate
  command and connections for each of the four HOGP v1.2 recommended modes
  (Fast, Default, Low Power and Full Range), on both the client (central) and
  server (peripheral) side.

The corresponding kernel support (HCI commands/events, the SCI feature init
sequence and the MGMT Load Connection Subrate command) has already been
submitted separately.

HCI reference for the feature this series builds on:

  Commands (OGF 0x08):
    HCI_LE_Connection_Rate_Request              0x00A1 (octet 48 bit 5)
    HCI_LE_Set_Default_Rate_Parameters          0x00A2 (octet 48 bit 6)
    HCI_LE_Read_Min_Supported_Conn_Interval     0x00A3 (octet 48 bit 7)

  Event:
    LE Connection Rate Change                   subevent 0x37

  Feature bits (LE feature page 1, via LE Read All Local Features):
    Shorter Connection Intervals                page 1 bit 8
    Shorter Connection Intervals (Host Support) page 1 bit 9

Luiz Augusto von Dentz (12):
  input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes
  emulator/btdev: Add emulation support for HIDS 1.1 SCI commands
  mgmt: Add Shorter Connection Interval setting and Load Connection
    Subrate
  mgmt-tester: Add tests for SCI setting and Load Connection Subrate
  adapter: Add support for loading connection subrate parameters
  monitor: Add decoding for Load Connection Subrate, SCI setting and
    event
  doc: Document ConnectionSubrate storage format
  client/mgmt: Add conn-subrate command
  mgmt-tester: Add HIDS recommended SCI parameter tests
  l2cap-tester: Add SCI mode tests for LE client connections
  emulator/bthost: Add LE Connection Rate Request support
  l2cap-tester: Add SCI mode tests for LE server connections

 client/mgmt.c             |  88 ++++++++++++++++++
 doc/bluetoothctl-mgmt.rst |  21 +++++
 doc/mgmt-protocol.rst     | 125 ++++++++++++++++++++++++++
 doc/settings-storage.txt  |  22 +++++
 emulator/btdev.c          | 107 ++++++++++++++++++++++
 emulator/btdev.h          |   1 +
 emulator/bthost.c         |  36 ++++++++
 emulator/bthost.h         |  14 +++
 emulator/hciemu.c         |   3 +
 emulator/hciemu.h         |   1 +
 lib/bluetooth/mgmt.h      |  31 +++++++
 monitor/packet.c          |  62 +++++++++++++
 profiles/input/hog-lib.c  | 106 +++++++++++++++++++++-
 src/adapter.c             | 172 ++++++++++++++++++++++++++++++++++++
 tools/l2cap-tester.c      | 181 ++++++++++++++++++++++++++++++++++++++
 tools/mgmt-tester.c       | 163 ++++++++++++++++++++++++++++++++++
 16 files changed, 1132 insertions(+), 1 deletion(-)

-- 
2.54.0

[PATCH BlueZ v1 01/12] input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add support for discovering and reading HIDS 1.1 SCI (Subrated
Connection Interval) characteristics:

 - HID SCI Mode (0x2c39)
 - HID SCI Information (0x2c3a)

When the HID Information flags indicate SCI is supported (bit 2),
the SCI Mode and SCI Information characteristics are read after
the HID Information is obtained.
---
 profiles/input/hog-lib.c | 106 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 105 insertions(+), 1 deletion(-)

diff --git a/profiles/input/hog-lib.c b/profiles/input/hog-lib.c
index 70a1bdcbf4df..054356371ea7 100644
--- a/profiles/input/hog-lib.c
+++ b/profiles/input/hog-lib.c
@@ -56,6 +56,8 @@
 #define HOG_REPORT_UUID		0x2A4D
 #define HOG_PROTO_MODE_UUID	0x2A4E
 #define HOG_CONTROL_POINT_UUID	0x2A4C
+#define HOG_SCI_MODE_UUID	0x2C39
+#define HOG_SCI_INFO_UUID	0x2C3A
 
 #define HOG_REPORT_TYPE_INPUT	1
 #define HOG_REPORT_TYPE_OUTPUT	2
@@ -64,6 +66,8 @@
 #define HOG_PROTO_MODE_BOOT    0
 #define HOG_PROTO_MODE_REPORT  1
 
+#define HOG_INFO_FLAG_SCI_SUPPORTED	0x04
+
 #define HID_INFO_SIZE			4
 #define ATT_NOTIFICATION_HEADER_SIZE	3
 
@@ -98,6 +102,8 @@ struct bt_hog {
 	struct queue		*gatt_op;
 	struct gatt_db		*gatt_db;
 	struct gatt_db_attribute	*report_map_attr;
+	uint16_t		sci_mode_handle;
+	uint16_t		sci_info_handle;
 };
 
 struct report {
@@ -152,6 +158,10 @@ static void destroy_gatt_req(void *data)
 }
 
 static void read_report_map(struct bt_hog *hog);
+static void sci_mode_read_cb(guint8 status, const guint8 *pdu, guint16 plen,
+							gpointer user_data);
+static void sci_info_read_cb(guint8 status, const guint8 *pdu, guint16 plen,
+							gpointer user_data);
 
 static void remove_gatt_req(struct gatt_request *req, uint8_t status)
 {
@@ -1105,6 +1115,85 @@ static void info_read_cb(guint8 status, const guint8 *pdu, guint16 plen,
 	DBG("bcdHID: 0x%04X bCountryCode: 0x%02X Flags: 0x%02X",
 			hog->bcdhid, hog->bcountrycode, hog->flags);
 
+	/* Read SCI attributes if SCI is supported */
+	if (hog->flags & HOG_INFO_FLAG_SCI_SUPPORTED) {
+		if (hog->sci_mode_handle)
+			read_char(hog, hog->attrib, hog->sci_mode_handle,
+						sci_mode_read_cb, hog);
+		if (hog->sci_info_handle)
+			read_char(hog, hog->attrib, hog->sci_info_handle,
+						sci_info_read_cb, hog);
+	}
+
+remove:
+	remove_gatt_req(req, status);
+}
+
+static void sci_mode_read_cb(guint8 status, const guint8 *pdu, guint16 plen,
+							gpointer user_data)
+{
+	struct gatt_request *req = user_data;
+	uint8_t value;
+	ssize_t vlen;
+
+	if (status != 0) {
+		error("HID SCI Mode read failed: %s", att_ecode2str(status));
+		goto remove;
+	}
+
+	vlen = dec_read_resp(pdu, plen, &value, sizeof(value));
+	if (vlen != 1) {
+		error("ATT protocol error");
+		goto remove;
+	}
+
+	DBG("SCI Mode: 0x%02X", value);
+
+remove:
+	remove_gatt_req(req, status);
+}
+
+static void sci_info_read_cb(guint8 status, const guint8 *pdu, guint16 plen,
+							gpointer user_data)
+{
+	struct gatt_request *req = user_data;
+	uint8_t value[14];
+	ssize_t vlen;
+	uint8_t min_conn_interval;
+	uint8_t num_grps;
+	uint8_t i;
+
+	if (status != 0) {
+		error("HID SCI Information read failed: %s",
+						att_ecode2str(status));
+		goto remove;
+	}
+
+	vlen = dec_read_resp(pdu, plen, value, sizeof(value));
+	if (vlen < 2) {
+		error("ATT protocol error");
+		goto remove;
+	}
+
+	min_conn_interval = value[0];
+	num_grps = value[1];
+
+	DBG("SCI Info: Minimum Supported Connection Interval: %.3f ms "
+		"(0x%02x) Number of Supported Subgroups: %d",
+		min_conn_interval * 0.125, min_conn_interval, num_grps);
+
+	for (i = 0; i < num_grps && (2 + i * 6 + 5) < vlen; i++) {
+		uint16_t min, max, stride;
+		size_t off = 2 + i * 6;
+
+		min = get_le16(&value[off]);
+		max = get_le16(&value[off + 2]);
+		stride = get_le16(&value[off + 4]);
+
+		DBG("  Subgroup[%u]: Min %.3f ms Max %.3f ms Stride %.3f ms",
+			i, min * 0.125, max * 0.125, stride * 0.125);
+	}
+
 remove:
 	remove_gatt_req(req, status);
 }
@@ -1150,6 +1239,7 @@ static void char_discovered_cb(uint8_t status, GSList *chars, void *user_data)
 	struct gatt_primary *primary = hog->primary;
 	bt_uuid_t report_uuid, report_map_uuid, info_uuid;
 	bt_uuid_t proto_mode_uuid, ctrlpt_uuid;
+	bt_uuid_t sci_mode_uuid, sci_info_uuid;
 	struct report *report;
 	GSList *l;
 	uint16_t info_handle = 0, proto_mode_handle = 0;
@@ -1167,6 +1257,8 @@ static void char_discovered_cb(uint8_t status, GSList *chars, void *user_data)
 	bt_uuid16_create(&info_uuid, HOG_INFO_UUID);
 	bt_uuid16_create(&proto_mode_uuid, HOG_PROTO_MODE_UUID);
 	bt_uuid16_create(&ctrlpt_uuid, HOG_CONTROL_POINT_UUID);
+	bt_uuid16_create(&sci_mode_uuid, HOG_SCI_MODE_UUID);
+	bt_uuid16_create(&sci_info_uuid, HOG_SCI_INFO_UUID);
 
 	for (l = chars; l; l = g_slist_next(l)) {
 		struct gatt_char *chr, *next;
@@ -1201,6 +1293,10 @@ static void char_discovered_cb(uint8_t status, GSList *chars, void *user_data)
 			proto_mode_handle = chr->value_handle;
 		else if (bt_uuid_cmp(&uuid, &ctrlpt_uuid) == 0)
 			hog->ctrlpt_handle = chr->value_handle;
+		else if (bt_uuid_cmp(&uuid, &sci_mode_uuid) == 0)
+			hog->sci_mode_handle = chr->value_handle;
+		else if (bt_uuid_cmp(&uuid, &sci_info_uuid) == 0)
+			hog->sci_info_handle = chr->value_handle;
 	}
 
 	if (proto_mode_handle) {
@@ -1360,7 +1456,7 @@ static void foreach_hog_chrc(struct gatt_db_attribute *attr, void *user_data)
 {
 	struct bt_hog *hog = user_data;
 	bt_uuid_t uuid, report_uuid, report_map_uuid, info_uuid;
-	bt_uuid_t proto_mode_uuid, ctrlpt_uuid;
+	bt_uuid_t proto_mode_uuid, ctrlpt_uuid, sci_mode_uuid, sci_info_uuid;
 	uint16_t handle, value_handle;
 	struct iovec map = {};
 
@@ -1414,6 +1510,14 @@ static void foreach_hog_chrc(struct gatt_db_attribute *attr, void *user_data)
 	bt_uuid16_create(&ctrlpt_uuid, HOG_CONTROL_POINT_UUID);
 	if (!bt_uuid_cmp(&ctrlpt_uuid, &uuid))
 		hog->ctrlpt_handle = value_handle;
+
+	bt_uuid16_create(&sci_mode_uuid, HOG_SCI_MODE_UUID);
+	if (!bt_uuid_cmp(&sci_mode_uuid, &uuid))
+		hog->sci_mode_handle = value_handle;
+
+	bt_uuid16_create(&sci_info_uuid, HOG_SCI_INFO_UUID);
+	if (!bt_uuid_cmp(&sci_info_uuid, &uuid))
+		hog->sci_info_handle = value_handle;
 }
 
 static struct bt_hog *hog_new(int fd, const char *name, uint16_t vendor,
-- 
2.54.0

[PATCH BlueZ v1 02/12] emulator/btdev: Add emulation support for HIDS 1.1 SCI commands

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add BTDEV_TYPE_BREDRLE62 device type with support for Shorter
Connection Interval (SCI) feature from Bluetooth 6.2 spec:

 - LE Connection Rate Request (0x20a1)
 - LE Set Default Rate Parameters (0x20a2)
 - LE Read Minimum Supported Connection Interval (0x20a3)
 - LE Connection Rate Change event (0x37)
 - Shorter Connection Intervals feature bits
---
 emulator/btdev.c  | 107 ++++++++++++++++++++++++++++++++++++++++++++++
 emulator/btdev.h  |   1 +
 emulator/hciemu.c |   3 ++
 emulator/hciemu.h |   1 +
 4 files changed, 112 insertions(+)

diff --git a/emulator/btdev.c b/emulator/btdev.c
index 3206caf5be86..68ec9698c6bc 100644
--- a/emulator/btdev.c
+++ b/emulator/btdev.c
@@ -7963,6 +7963,96 @@ static void set_le_60_commands(struct btdev *btdev)
 	btdev->cmds = cmd_le_6_0;
 }
 
+static int cmd_le_conn_rate(struct btdev *dev, const void *data, uint8_t len)
+{
+	const struct bt_hci_cmd_le_conn_rate *cmd = data;
+	struct bt_hci_evt_le_conn_rate_change ev;
+	struct btdev_conn *conn;
+	uint8_t status = BT_HCI_ERR_SUCCESS;
+
+	conn = queue_find(dev->conns, match_handle,
+				UINT_TO_PTR(le16_to_cpu(cmd->handle)));
+	if (!conn)
+		status = BT_HCI_ERR_UNKNOWN_CONN_ID;
+
+	cmd_status(dev, status, BT_HCI_CMD_LE_CONN_RATE);
+
+	if (status)
+		return 0;
+
+	memset(&ev, 0, sizeof(ev));
+	ev.status = BT_HCI_ERR_SUCCESS;
+	ev.handle = cmd->handle;
+	ev.interval = cmd->interval_min;
+	ev.subrate = cmd->subrate_min;
+	ev.latency = cpu_to_le16(0);
+	ev.cont_number = cmd->cont_num;
+	ev.supv_timeout = cmd->supv_timeout;
+
+	le_meta_event(dev, BT_HCI_EVT_LE_CONN_RATE_CHANGE, &ev, sizeof(ev));
+	if (conn->link)
+		le_meta_event(conn->link->dev, BT_HCI_EVT_LE_CONN_RATE_CHANGE,
+				&ev, sizeof(ev));
+
+	return 0;
+}
+
+static int cmd_le_set_def_rate(struct btdev *dev, const void *data, uint8_t len)
+{
+	uint8_t status = BT_HCI_ERR_SUCCESS;
+
+	cmd_complete(dev, BT_HCI_CMD_LE_SET_DEF_RATE, &status, sizeof(status));
+
+	return 0;
+}
+
+static int cmd_le_read_conn_interval(struct btdev *dev, const void *data,
+					uint8_t len)
+{
+	struct {
+		struct bt_hci_rsp_le_read_conn_interval rsp;
+		struct bt_hci_le_conn_interval_group grp;
+	} __attribute__ ((packed)) pdu;
+
+	memset(&pdu, 0, sizeof(pdu));
+	pdu.rsp.status = BT_HCI_ERR_SUCCESS;
+	pdu.rsp.num_grps = 1;
+	pdu.grp.min = cpu_to_le16(0x0008);	/* 1.000 ms */
+	pdu.grp.max = cpu_to_le16(0x0c80);	/* 400.000 ms */
+	pdu.grp.stride = cpu_to_le16(0x0001);	/* 0.125 ms */
+
+	cmd_complete(dev, BT_HCI_CMD_LE_READ_CONN_INTERVAL, &pdu, sizeof(pdu));
+
+	return 0;
+}
+
+#define CMD_LE_62 \
+	CMD(BT_HCI_CMD_LE_CONN_RATE, cmd_le_conn_rate, NULL), \
+	CMD(BT_HCI_CMD_LE_SET_DEF_RATE, cmd_le_set_def_rate, NULL), \
+	CMD(BT_HCI_CMD_LE_READ_CONN_INTERVAL, cmd_le_read_conn_interval, NULL)
+
+static const struct btdev_cmd cmd_le_6_2[] = {
+	CMD_COMMON_ALL,
+	CMD_COMMON_BREDR_LE,
+	CMD_COMMON_BREDR_20,
+	CMD_COMMON_BREDR_LE_40,
+	CMD_BREDR,
+	CMD_LE,
+	CMD_LE_50,
+	CMD_LE_52,
+	CMD_LE_60,
+	CMD_LE_62,
+	{}
+};
+
+static void set_le_62_commands(struct btdev *btdev)
+{
+	btdev->commands[48] |= BIT(5);	/* LE Connection Rate Request */
+	btdev->commands[48] |= BIT(6);	/* LE Set Default Rate Parameters */
+	btdev->commands[48] |= BIT(7);	/* LE Read Min Supported Conn Interval */
+	btdev->cmds = cmd_le_6_2;
+}
+
 static void set_le_commands(struct btdev *btdev)
 {
 	set_common_commands_all(btdev);
@@ -8037,6 +8127,12 @@ static void set_le_commands(struct btdev *btdev)
 		set_le_60_commands(btdev);
 		btdev->cmds = cmd_le_6_0;
 	}
+
+	/* Extra LE commands for >= 6.2 adapters */
+	if (btdev->type >= BTDEV_TYPE_BREDRLE62) {
+		set_le_62_commands(btdev);
+		btdev->cmds = cmd_le_6_2;
+	}
 }
 
 static void set_bredrle_commands(struct btdev *btdev)
@@ -8112,6 +8208,13 @@ static void set_bredrle_features(struct btdev *btdev)
 		btdev->le_features[7] |= BIT(7); /* LL Extended Features */
 	}
 
+	if (btdev->type >= BTDEV_TYPE_BREDRLE62) {
+		/* Shorter Connection Intervals */
+		btdev->le_features[9] |= BIT(0);
+		/* Shorter Connection Intervals (Host Support) */
+		btdev->le_features[9] |= BIT(1);
+	}
+
 	btdev->feat_page_2[0] |= 0x01;	/* CPB - Central Operation */
 	btdev->feat_page_2[0] |= 0x02;	/* CPB - Peripheral Operation */
 	btdev->feat_page_2[0] |= 0x04;	/* Synchronization Train */
@@ -8217,6 +8320,7 @@ struct btdev *btdev_create(enum btdev_type type, uint16_t id)
 	case BTDEV_TYPE_BREDRLE50:
 	case BTDEV_TYPE_BREDRLE52:
 	case BTDEV_TYPE_BREDRLE60:
+	case BTDEV_TYPE_BREDRLE62:
 		btdev->crypto = bt_crypto_new();
 		if (!btdev->crypto) {
 			free(btdev);
@@ -8240,6 +8344,7 @@ struct btdev *btdev_create(enum btdev_type type, uint16_t id)
 	case BTDEV_TYPE_BREDRLE50:
 	case BTDEV_TYPE_BREDRLE52:
 	case BTDEV_TYPE_BREDRLE60:
+	case BTDEV_TYPE_BREDRLE62:
 		btdev->version = 0x09;
 		set_bredrle_features(btdev);
 		set_bredrle_commands(btdev);
@@ -8933,6 +9038,7 @@ int btdev_set_msft_opcode(struct btdev *btdev, uint16_t opcode)
 	case BTDEV_TYPE_BREDRLE50:
 	case BTDEV_TYPE_BREDRLE52:
 	case BTDEV_TYPE_BREDRLE60:
+	case BTDEV_TYPE_BREDRLE62:
 		btdev->msft_opcode = opcode;
 		btdev->msft_cmds = cmd_msft;
 		return 0;
@@ -8991,6 +9097,7 @@ int btdev_set_emu_opcode(struct btdev *btdev, uint16_t opcode)
 	case BTDEV_TYPE_BREDRLE50:
 	case BTDEV_TYPE_BREDRLE52:
 	case BTDEV_TYPE_BREDRLE60:
+	case BTDEV_TYPE_BREDRLE62:
 		btdev->emu_opcode = opcode;
 		btdev->emu_cmds = cmd_emu;
 		return 0;
diff --git a/emulator/btdev.h b/emulator/btdev.h
index d473bd4b3414..145f7edaa262 100644
--- a/emulator/btdev.h
+++ b/emulator/btdev.h
@@ -53,6 +53,7 @@ enum btdev_type {
 	BTDEV_TYPE_BREDRLE50,
 	BTDEV_TYPE_BREDRLE52,
 	BTDEV_TYPE_BREDRLE60,
+	BTDEV_TYPE_BREDRLE62,
 };
 
 enum btdev_hook_type {
diff --git a/emulator/hciemu.c b/emulator/hciemu.c
index 15d806a62aa6..48ed63b413f4 100644
--- a/emulator/hciemu.c
+++ b/emulator/hciemu.c
@@ -437,6 +437,9 @@ struct hciemu *hciemu_new_num_debug(enum hciemu_type type, uint8_t num,
 	case HCIEMU_TYPE_BREDRLE60:
 		hciemu->btdev_type = BTDEV_TYPE_BREDRLE60;
 		break;
+	case HCIEMU_TYPE_BREDRLE62:
+		hciemu->btdev_type = BTDEV_TYPE_BREDRLE62;
+		break;
 	default:
 		return NULL;
 	}
diff --git a/emulator/hciemu.h b/emulator/hciemu.h
index e832d6350bb3..cdf1ebe16752 100644
--- a/emulator/hciemu.h
+++ b/emulator/hciemu.h
@@ -22,6 +22,7 @@ enum hciemu_type {
 	HCIEMU_TYPE_BREDRLE50,
 	HCIEMU_TYPE_BREDRLE52,
 	HCIEMU_TYPE_BREDRLE60,
+	HCIEMU_TYPE_BREDRLE62,
 };
 
 enum hciemu_hook_type {
-- 
2.54.0

[PATCH BlueZ v1 03/12] mgmt: Add Shorter Connection Interval setting and Load Connection Subrate

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add the Shorter Connection Interval setting bit (25) to indicate
controller support for SCI feature.

Add the Load Connection Subrate command (0x005C) which allows
loading connection subrate parameters for devices that support
shorter connection intervals as defined in Bluetooth 6.2.
---
 doc/mgmt-protocol.rst | 125 ++++++++++++++++++++++++++++++++++++++++++
 lib/bluetooth/mgmt.h  |  31 +++++++++++
 2 files changed, 156 insertions(+)

diff --git a/doc/mgmt-protocol.rst b/doc/mgmt-protocol.rst
index 35446dd974ac..f0564075f92f 100644
--- a/doc/mgmt-protocol.rst
+++ b/doc/mgmt-protocol.rst
@@ -321,6 +321,7 @@ following available bits:
     22, LL Privacy
     23, PAST Sender
     24, PAST Receiver
+    25, Shorter Connection Interval
 
 This command generates a Command Complete event on success or a Command Status
 event on failure.
@@ -4170,6 +4171,86 @@ Possible errors:
 :Failed:
 :Invalid Parameters:
 
+Load Connection Subrate
+```````````````````````
+
+:Command Code:		0x005C
+:Controller Index:	<controller id>
+:Command Parameters:	Param_Count (2 Octets)
+:...:			Address[] (6 Octets)
+:...:			Address_Type[] (1 Octet)
+:...:			Min_Connection_Interval[] (2 Octets)
+:...:			Max_Connection_Interval[] (2 Octets)
+:...:			Subrate_Min[] (2 Octets)
+:...:			Subrate_Max[] (2 Octets)
+:...:			Max_Latency[] (2 Octets)
+:...:			Continuation_Number[] (2 Octets)
+:...:			Supervision_Timeout[] (2 Octets)
+:...:			...[]
+:Return Parameters:
+
+This command is used to load connection subrate parameters from several devices
+into the kernel. This is only supported on controllers with Low Energy support
+and the Shorter Connection Interval (SCI) feature.
+
+This command operates on the same device entries as Load Connection Parameters
+(0x0035). If an entry for the given device already exists, the subrate-specific
+fields are updated on that entry. If no entry exists, a new one is created. The
+device must have been previously added via Load Connection Parameters or this
+command.
+
+Note that the Min_Connection_Interval and Max_Connection_Interval parameters in
+this command refer to the connection rate interval used with the LE Connection
+Rate Request procedure, which has different valid ranges than the connection
+interval in Load Connection Parameters. The Load Connection Parameters interval
+is specified in units of 1.25 ms (range: 6 to 3200), while the connection rate
+interval here is specified in units of 0.125 ms (range: 8 to 3200).
+
+Loading with multiple entries overwrites the subrate parameters for all listed
+devices. Loading with a single entry attempts to update the parameters if an
+entry for the given device already exists, or adds a new entry otherwise.
+
+Possible values for the Address_Type parameter:
+
+.. csv-table::
+	:header: "Value", "Description"
+	:widths: auto
+
+	0x00, BR/EDR
+	0x01, LE Public
+	0x02, LE Random
+
+The provided Address and Address_Type are the identity of a device. So either
+its public address or static random address.
+
+The Min_Connection_Interval and Max_Connection_Interval parameters specify the
+connection rate interval range in units of 0.125 ms (range: 0x0008 to 0x0C80,
+corresponding to 1.0 ms to 400.0 ms). These are distinct from the connection
+parameters interval in Load Connection Parameters which uses units of 1.25 ms.
+
+The Subrate_Min and Subrate_Max parameters specify the acceptable subrate factor
+range.
+
+The Max_Latency parameter specifies the maximum peripheral latency in units of
+subrated connection events.
+
+The Continuation_Number parameter specifies the number of continuation events
+the peripheral will be listened to.
+
+The Supervision_Timeout parameter specifies the link supervision timeout in
+units of 10 ms.
+
+This command can be used when the controller is not powered.
+
+This command generates a Command Complete event on success or a Command Status
+event on failure.
+
+Possible errors:
+
+:Invalid Parameters:
+:Invalid Index:
+:Not Supported:
+
 Events
 ------
 
@@ -5396,3 +5477,47 @@ This event indicates that a requested outbound Mesh packet has completed and no
 longer occupies a transmit slot.
 
 This event will be sent to all management sockets.
+
+Connection Subrate
+``````````````````
+
+:Event Code:		0x0033
+:Controller Index:	<controller id>
+:Event Parameters:	Address (6 Octets)
+:...:			Address_Type (1 Octet)
+:...:			Status (1 Octet)
+:...:			Interval (2 Octets)
+:...:			Subrate (2 Octets)
+:...:			Latency (2 Octets)
+:...:			Continuation_Number (2 Octets)
+:...:			Supervision_Timeout (2 Octets)
+
+This event indicates that the connection rate has changed for a device. This
+can be a result of a successful LE Connection Rate Request or a change
+initiated by the remote device.
+
+Possible values for the Address_Type parameter:
+
+.. csv-table::
+	:header: "Value", "Description"
+	:widths: auto
+
+	0x01, LE Public
+	0x02, LE Random
+
+The Status indicates whether the connection rate change was successful.
+
+The Interval parameter specifies the new connection interval in units of
+0.125 ms.
+
+The Subrate parameter specifies the subrate factor.
+
+The Latency parameter specifies the peripheral latency.
+
+The Continuation_Number parameter specifies the number of continuation
+events.
+
+The Supervision_Timeout parameter specifies the supervision timeout in units
+of 10 ms.
+
+This event will be sent to all management sockets.
diff --git a/lib/bluetooth/mgmt.h b/lib/bluetooth/mgmt.h
index 7fab3d7a0bba..9df0c1ba2fbf 100644
--- a/lib/bluetooth/mgmt.h
+++ b/lib/bluetooth/mgmt.h
@@ -107,6 +107,7 @@ struct mgmt_rp_read_index_list {
 #define MGMT_SETTING_LL_PRIVACY		BIT(22)
 #define MGMT_SETTING_PAST_SENDER	BIT(23)
 #define MGMT_SETTING_PAST_RECEIVER	BIT(24)
+#define MGMT_SETTING_SCI		BIT(25)
 
 #define MGMT_OP_READ_INFO		0x0004
 struct mgmt_rp_read_info {
@@ -814,6 +815,23 @@ struct mgmt_cp_hci_cmd_sync {
 	uint8_t  params[];
 } __packed;
 
+struct mgmt_conn_subrate {
+	struct mgmt_addr_info addr;
+	uint16_t min_interval;
+	uint16_t max_interval;
+	uint16_t subrate_min;
+	uint16_t subrate_max;
+	uint16_t max_latency;
+	uint16_t cont_num;
+	uint16_t supv_timeout;
+} __packed;
+
+#define MGMT_OP_LOAD_CONN_SUBRATE	0x005C
+struct mgmt_cp_load_conn_subrate {
+	uint16_t param_count;
+	struct mgmt_conn_subrate params[];
+} __packed;
+
 #define MGMT_EV_CMD_COMPLETE		0x0001
 struct mgmt_ev_cmd_complete {
 	uint16_t opcode;
@@ -1107,6 +1125,17 @@ struct mgmt_ev_mesh_pkt_cmplt {
 	uint8_t	handle;
 } __packed;
 
+#define MGMT_EV_CONN_SUBRATE			0x0033
+struct mgmt_ev_conn_subrate {
+	struct mgmt_addr_info addr;
+	uint8_t  status;
+	uint16_t interval;
+	uint16_t subrate;
+	uint16_t latency;
+	uint16_t cont_num;
+	uint16_t supv_timeout;
+} __packed;
+
 static const char *mgmt_op[] = {
 	"<0x0000>",
 	"Read Version",
@@ -1200,6 +1229,7 @@ static const char *mgmt_op[] = {
 	"Mesh Send",
 	"Mesh Send Cancel",
 	"HCI Cmd Sync",
+	"Load Connection Subrate",
 };
 
 static const char *mgmt_ev[] = {
@@ -1254,6 +1284,7 @@ static const char *mgmt_ev[] = {
 	"Advertisement Monitor Device Lost",
 	"Mesh Packet Found",
 	"Mesh Packet Complete",
+	"Connection Subrate",
 };
 
 static const char *mgmt_status[] = {
-- 
2.54.0

[PATCH BlueZ v1 04/12] mgmt-tester: Add tests for SCI setting and Load Connection Subrate

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add HCIEMU_TYPE_BREDRLE62 device type for testing Bluetooth 6.2
features and add test cases:

- Set Low Energy on 6.2 - SCI Setting: verifies that the SCI
  setting bit (25) is reported in supported/current settings
  for a 6.2 controller.
- Load Connection Subrate - Invalid Params 1: verifies invalid
  parameters are rejected.
- Load Connection Subrate - Success 1: verifies loading valid
  connection subrate parameters succeeds.
---
 tools/mgmt-tester.c | 59 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/tools/mgmt-tester.c b/tools/mgmt-tester.c
index 4d28090271e9..15c9254e307e 100644
--- a/tools/mgmt-tester.c
+++ b/tools/mgmt-tester.c
@@ -597,6 +597,13 @@ static void test_condition_complete(struct test_data *data)
 #define test_bredrle60(name, data, setup, func) \
 	test_bredrle60_full(name, data, setup, func, 2)
 
+#define test_bredrle62_full(name, data, setup, func, timeout) \
+	test_full(name, data, setup, func, timeout, HCIEMU_TYPE_BREDRLE62, \
+					0x0e, 0x0201beff, 0x00000080)
+
+#define test_bredrle62(name, data, setup, func) \
+	test_bredrle62_full(name, data, setup, func, 2)
+
 #define test_hs_full(name, data, setup, func, timeout) \
 	test_full(name, data, setup, func, timeout, HCIEMU_TYPE_BREDRLE, \
 					0x09, 0x0001bfff, 0x00000080)
@@ -4429,6 +4436,48 @@ static const struct generic_data load_conn_params_fail_1 = {
 	.expect_status = MGMT_STATUS_INVALID_PARAMS,
 };
 
+static const char set_le_settings_param_sci[] = { 0x81, 0x02, 0xfc, 0x03 };
+static const struct generic_data set_le_on_success_sci = {
+	.setup_settings = settings_le,
+	.send_opcode = MGMT_OP_SET_POWERED,
+	.send_param = set_powered_on_param,
+	.send_len = sizeof(set_powered_on_param),
+	.expect_status = MGMT_STATUS_SUCCESS,
+	.expect_param = set_le_settings_param_sci,
+	.expect_len = sizeof(set_le_settings_param_sci),
+	.expect_settings_set = MGMT_SETTING_LE,
+	.expect_hci_command = BT_HCI_CMD_WRITE_LE_HOST_SUPPORTED,
+	.expect_hci_param = set_le_on_write_le_host_param,
+	.expect_hci_len = sizeof(set_le_on_write_le_host_param),
+};
+
+static const uint8_t load_conn_subrate_nval_1[16] = { 0x12, 0x11 };
+static const struct generic_data load_conn_subrate_fail_1 = {
+	.send_opcode = MGMT_OP_LOAD_CONN_SUBRATE,
+	.send_param = load_conn_subrate_nval_1,
+	.send_len = sizeof(load_conn_subrate_nval_1),
+	.expect_status = MGMT_STATUS_INVALID_PARAMS,
+};
+
+static const uint8_t load_conn_subrate_valid_1[] = {
+	0x01, 0x00,				/* param_count */
+	0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,	/* address */
+	0x01,					/* address type */
+	0x08, 0x00,				/* min_interval */
+	0x80, 0x0c,				/* max_interval */
+	0x01, 0x00,				/* subrate_min */
+	0x04, 0x00,				/* subrate_max */
+	0x00, 0x00,				/* max_latency */
+	0x02, 0x00,				/* cont_num */
+	0xc8, 0x00,				/* supv_timeout */
+};
+static const struct generic_data load_conn_subrate_success_1 = {
+	.send_opcode = MGMT_OP_LOAD_CONN_SUBRATE,
+	.send_param = load_conn_subrate_valid_1,
+	.send_len = sizeof(load_conn_subrate_valid_1),
+	.expect_status = MGMT_STATUS_SUCCESS,
+};
+
 static const uint8_t add_device_nval_1[] = {
 					0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
 					0x00,
@@ -13329,6 +13378,9 @@ int main(int argc, char *argv[])
 	test_bredrle60("Set Low Energy on 6.0 - Success 5",
 				&set_le_on_success_test_4,
 				NULL, test_command_generic);
+	test_bredrle62("Set Low Energy on 6.2 - SCI Setting",
+				&set_le_on_success_sci,
+				NULL, test_command_generic);
 	test_bredrle("Set Low Energy on - Invalid parameters 1",
 				&set_le_on_invalid_param_test_1,
 				NULL, test_command_generic);
@@ -13812,6 +13864,13 @@ int main(int argc, char *argv[])
 				&load_conn_params_fail_1,
 				NULL, test_command_generic);
 
+	test_bredrle62("Load Connection Subrate - Invalid Params 1",
+				&load_conn_subrate_fail_1,
+				NULL, test_command_generic);
+	test_bredrle62("Load Connection Subrate - Success 1",
+				&load_conn_subrate_success_1,
+				NULL, test_command_generic);
+
 	test_bredrle("Add Device - Invalid Params 1",
 				&add_device_fail_1,
 				NULL, test_command_generic);
-- 
2.54.0

[PATCH BlueZ v1 05/12] adapter: Add support for loading connection subrate parameters

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Implement load_conn_subrate() to load per-device connection subrate
parameters via the new MGMT_OP_LOAD_CONN_SUBRATE command. Parameters
are read from the [ConnectionSubrate] section of device info files
and sent to the kernel when the SCI setting is supported.

The subrate parameters include connection interval range, subrate
factor range, max latency, continuation number, and supervision
timeout as defined in the Bluetooth 6.2 SCI feature.
---
 src/adapter.c | 172 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 172 insertions(+)

diff --git a/src/adapter.c b/src/adapter.c
index a56eafabea78..c21b3e7fbcc2 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -206,6 +206,18 @@ struct conn_param {
 	uint16_t timeout;
 };
 
+struct conn_subrate {
+	bdaddr_t bdaddr;
+	uint8_t  bdaddr_type;
+	uint16_t min_interval;
+	uint16_t max_interval;
+	uint16_t subrate_min;
+	uint16_t subrate_max;
+	uint16_t max_latency;
+	uint16_t cont_num;
+	uint16_t supv_timeout;
+};
+
 struct discovery_filter {
 	uint8_t type;
 	char *pattern;
@@ -4222,6 +4234,46 @@ static struct conn_param *get_conn_param(GKeyFile *key_file, const char *peer,
 	return param;
 }
 
+static struct conn_subrate *get_conn_subrate(GKeyFile *key_file,
+						const char *peer,
+						uint8_t bdaddr_type)
+{
+	struct conn_subrate *subrate;
+
+	if (!g_key_file_has_group(key_file, "ConnectionSubrate"))
+		return NULL;
+
+	subrate = g_new0(struct conn_subrate, 1);
+
+	subrate->min_interval = g_key_file_get_integer(key_file,
+							"ConnectionSubrate",
+							"MinInterval", NULL);
+	subrate->max_interval = g_key_file_get_integer(key_file,
+							"ConnectionSubrate",
+							"MaxInterval", NULL);
+	subrate->subrate_min = g_key_file_get_integer(key_file,
+							"ConnectionSubrate",
+							"SubrateMin", NULL);
+	subrate->subrate_max = g_key_file_get_integer(key_file,
+							"ConnectionSubrate",
+							"SubrateMax", NULL);
+	subrate->max_latency = g_key_file_get_integer(key_file,
+							"ConnectionSubrate",
+							"MaxLatency", NULL);
+	subrate->cont_num = g_key_file_get_integer(key_file,
+							"ConnectionSubrate",
+							"ContinuationNumber",
+							NULL);
+	subrate->supv_timeout = g_key_file_get_integer(key_file,
+							"ConnectionSubrate",
+							"SupervisionTimeout",
+							NULL);
+	str2ba(peer, &subrate->bdaddr);
+	subrate->bdaddr_type = bdaddr_type;
+
+	return subrate;
+}
+
 static int generate_and_write_irk(uint8_t *irk, GKeyFile *key_file,
 							const char *filename)
 {
@@ -4693,6 +4745,75 @@ void btd_adapter_load_conn_param(struct btd_adapter *adapter,
 	g_slist_free(params);
 }
 
+static void load_conn_subrate_complete(uint8_t status, uint16_t length,
+					const void *param, void *user_data)
+{
+	struct btd_adapter *adapter = user_data;
+
+	if (status != MGMT_STATUS_SUCCESS) {
+		btd_error(adapter->dev_id,
+			"hci%u Load Connection Subrate failed: %s (0x%02x)",
+				adapter->dev_id, mgmt_errstr(status), status);
+		return;
+	}
+
+	DBG("Connection Subrate loaded for hci%u", adapter->dev_id);
+}
+
+static void load_conn_subrate(struct btd_adapter *adapter,
+						struct queue *subrates)
+{
+	struct mgmt_cp_load_conn_subrate *cp;
+	struct mgmt_conn_subrate *entry;
+	size_t count, cp_size;
+	unsigned int id;
+	const struct queue_entry *e;
+
+	if (!(adapter->supported_settings & MGMT_SETTING_SCI))
+		return;
+
+	count = queue_length(subrates);
+
+	DBG("hci%u conn subrates %zu", adapter->dev_id, count);
+
+	cp_size = sizeof(*cp) + (count * sizeof(*entry));
+
+	cp = g_try_malloc0(cp_size);
+	if (cp == NULL) {
+		btd_error(adapter->dev_id,
+			"Failed to allocate memory for connection subrate");
+		return;
+	}
+
+	cp->param_count = htobs(count);
+
+	entry = cp->params;
+	for (e = queue_get_entries(subrates); e; e = e->next) {
+		struct conn_subrate *info = e->data;
+
+		bacpy(&entry->addr.bdaddr, &info->bdaddr);
+		entry->addr.type = info->bdaddr_type;
+		entry->min_interval = htobs(info->min_interval);
+		entry->max_interval = htobs(info->max_interval);
+		entry->subrate_min = htobs(info->subrate_min);
+		entry->subrate_max = htobs(info->subrate_max);
+		entry->max_latency = htobs(info->max_latency);
+		entry->cont_num = htobs(info->cont_num);
+		entry->supv_timeout = htobs(info->supv_timeout);
+		entry++;
+	}
+
+	id = mgmt_send(adapter->mgmt, MGMT_OP_LOAD_CONN_SUBRATE,
+			adapter->dev_id, cp_size, cp,
+			load_conn_subrate_complete, adapter, NULL);
+
+	g_free(cp);
+
+	if (id == 0)
+		btd_error(adapter->dev_id,
+					"Load connection subrate failed");
+}
+
 static uint8_t get_addr_type(GKeyFile *keyfile)
 {
 	uint8_t addr_type;
@@ -4980,6 +5101,7 @@ static void load_devices(struct btd_adapter *adapter)
 	GSList *ltks = NULL;
 	GSList *irks = NULL;
 	GSList *params = NULL;
+	struct queue *subrates = NULL;
 	GSList *added_devices = NULL;
 	GError *gerr = NULL;
 	DIR *dir;
@@ -5006,6 +5128,7 @@ static void load_devices(struct btd_adapter *adapter)
 		GSList *list;
 		struct irk_info *irk_info;
 		struct conn_param *param;
+		struct conn_subrate *subrate;
 		uint8_t bdaddr_type;
 
 		if (entry->d_type == DT_UNKNOWN)
@@ -5082,6 +5205,14 @@ static void load_devices(struct btd_adapter *adapter)
 		if (param)
 			params = g_slist_append(params, param);
 
+		subrate = get_conn_subrate(key_file, entry->d_name,
+								bdaddr_type);
+		if (subrate) {
+			if (!subrates)
+				subrates = queue_new();
+			queue_push_tail(subrates, subrate);
+		}
+
 		list = g_slist_find_custom(adapter->devices, entry->d_name,
 							device_address_cmp);
 		if (list) {
@@ -5125,6 +5256,8 @@ free:
 	g_slist_free_full(irks, g_free);
 	load_conn_params(adapter, params);
 	g_slist_free_full(params, g_free);
+	load_conn_subrate(adapter, subrates);
+	queue_destroy(subrates, free);
 
 	g_slist_free_full(added_devices, probe_devices);
 }
@@ -9221,6 +9354,40 @@ static void new_conn_param(uint16_t index, uint16_t length,
 					ev->latency, ev->timeout);
 }
 
+static void conn_subrate_evt(uint16_t index, uint16_t length,
+					const void *param, void *user_data)
+{
+	const struct mgmt_ev_conn_subrate *ev = param;
+	struct btd_adapter *adapter = user_data;
+	uint16_t interval, subrate, latency, cont_num, supv_timeout;
+	char dst[18];
+
+	if (length < sizeof(*ev)) {
+		btd_error(adapter->dev_id,
+				"Too small Connection Subrate event");
+		return;
+	}
+
+	ba2str(&ev->addr.bdaddr, dst);
+
+	if (ev->status) {
+		DBG("hci%u %s (%u) subrate failed status 0x%02x",
+			adapter->dev_id, dst, ev->addr.type, ev->status);
+		return;
+	}
+
+	interval = btohs(ev->interval);
+	subrate = btohs(ev->subrate);
+	latency = btohs(ev->latency);
+	cont_num = btohs(ev->cont_num);
+	supv_timeout = btohs(ev->supv_timeout);
+
+	DBG("hci%u %s (%u) interval 0x%04x subrate 0x%04x latency 0x%04x "
+		"cont_num 0x%04x timeout 0x%04x", adapter->dev_id, dst,
+		ev->addr.type, interval, subrate, latency, cont_num,
+		supv_timeout);
+}
+
 int adapter_set_io_capability(struct btd_adapter *adapter,
 						enum mgmt_io_capability io_cap)
 {
@@ -10548,6 +10715,11 @@ static void read_info_complete(uint8_t status, uint16_t length,
 						new_conn_param,
 						adapter, NULL);
 
+	mgmt_register(adapter->mgmt, MGMT_EV_CONN_SUBRATE,
+						adapter->dev_id,
+						conn_subrate_evt,
+						adapter, NULL);
+
 	mgmt_register(adapter->mgmt, MGMT_EV_DEVICE_BLOCKED,
 						adapter->dev_id,
 						device_blocked_callback,
-- 
2.54.0

[PATCH BlueZ v1 06/12] monitor: Add decoding for Load Connection Subrate, SCI setting and event

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add decoding support for the new MGMT_OP_LOAD_CONN_SUBRATE (0x005C)
command, the MGMT_EV_CONN_SUBRATE (0x0033) event and the Shorter
Connection Interval setting bit (25) to btmon.
---
 monitor/packet.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/monitor/packet.c b/monitor/packet.c
index 82afef6011d2..0d3b23cc3fb7 100644
--- a/monitor/packet.c
+++ b/monitor/packet.c
@@ -14941,6 +14941,7 @@ static const struct bitfield_data mgmt_settings_table[] = {
 	{ 22, "LL Privacy"		},
 	{ 23, "PAST Sender"		},
 	{ 24, "PAST Receiver"		},
+	{ 25, "Shorter Connection Interval"	},
 	{}
 };
 
@@ -15101,6 +15102,27 @@ static void mgmt_print_connection_parameter(const void *data)
 	print_field("Supervision timeout: %u", supv_timeout);
 }
 
+static void mgmt_print_connection_subrate(const void *data)
+{
+	uint8_t address_type = get_u8(data + 6);
+	uint16_t min_interval = get_le16(data + 7);
+	uint16_t max_interval = get_le16(data + 9);
+	uint16_t subrate_min = get_le16(data + 11);
+	uint16_t subrate_max = get_le16(data + 13);
+	uint16_t max_latency = get_le16(data + 15);
+	uint16_t cont_num = get_le16(data + 17);
+	uint16_t supv_timeout = get_le16(data + 19);
+
+	mgmt_print_address(data, address_type);
+	print_field("Min connection interval: %u", min_interval);
+	print_field("Max connection interval: %u", max_interval);
+	print_field("Subrate min: %u", subrate_min);
+	print_field("Subrate max: %u", subrate_max);
+	print_field("Max latency: %u", max_latency);
+	print_field("Continuation number: %u", cont_num);
+	print_field("Supervision timeout: %u", supv_timeout);
+}
+
 static void mgmt_print_link_key(const void *data)
 {
 	uint8_t address_type = get_u8(data + 6);
@@ -16026,6 +16048,22 @@ static void mgmt_load_connection_parameters_cmd(const void *data, uint16_t size)
 		mgmt_print_connection_parameter(data + 2 + (i * 15));
 }
 
+static void mgmt_load_conn_subrate_cmd(const void *data, uint16_t size)
+{
+	uint16_t num_parameters = get_le16(data);
+	int i;
+
+	print_field("Parameters: %u", num_parameters);
+
+	if (size - 2 != num_parameters * 21) {
+		packet_hexdump(data + 2, size - 2);
+		return;
+	}
+
+	for (i = 0; i < num_parameters; i++)
+		mgmt_print_connection_subrate(data + 2 + (i * 21));
+}
+
 static void mgmt_read_unconf_index_list_rsp(const void *data, uint16_t size)
 {
 	uint16_t num_controllers = get_le16(data);
@@ -17096,6 +17134,9 @@ static const struct mgmt_data mgmt_command_table[] = {
 	{ 0x005B, "Send HCI command and wait for event",
 				mgmt_hci_cmd_sync_cmd, 6, false,
 				mgmt_hci_cmd_sync_rsp, 0, false},
+	{ 0x005C, "Load Connection Subrate",
+				mgmt_load_conn_subrate_cmd, 2, false,
+				mgmt_null_rsp, 0, true },
 	{ }
 };
 
@@ -17620,6 +17661,25 @@ static void mgmt_mesh_packet_cmplt_evt(const void *data, uint16_t size)
 	print_field("Handle: %d", handle);
 }
 
+static void mgmt_conn_subrate_evt(const void *data, uint16_t size)
+{
+	uint8_t address_type = get_u8(data + 6);
+	uint8_t status = get_u8(data + 7);
+	uint16_t interval = get_le16(data + 8);
+	uint16_t subrate = get_le16(data + 10);
+	uint16_t latency = get_le16(data + 12);
+	uint16_t cont_num = get_le16(data + 14);
+	uint16_t supv_timeout = get_le16(data + 16);
+
+	mgmt_print_address(data, address_type);
+	mgmt_print_status(status);
+	print_field("Interval: %u", interval);
+	print_field("Subrate: %u", subrate);
+	print_field("Latency: %u", latency);
+	print_field("Continuation number: %u", cont_num);
+	print_field("Supervision timeout: %u", supv_timeout);
+}
+
 static const struct mgmt_data mgmt_event_table[] = {
 	{ 0x0001, "Command Complete",
 			mgmt_command_complete_evt, 3, false },
@@ -17717,6 +17777,8 @@ static const struct mgmt_data mgmt_event_table[] = {
 			mgmt_mesh_device_found_evt, 22, false },
 	{ 0x0032, "Mesh Packet Complete",
 			mgmt_mesh_packet_cmplt_evt, 1, true },
+	{ 0x0033, "Connection Subrate",
+			mgmt_conn_subrate_evt, 18, true },
 	{ }
 };
 
-- 
2.54.0

[PATCH BlueZ v1 07/12] doc: Document ConnectionSubrate storage format

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Document the [ConnectionSubrate] group in the device info file which
stores per-device connection subrate parameters for the SCI feature.
---
 doc/settings-storage.txt | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/doc/settings-storage.txt b/doc/settings-storage.txt
index 15f55f9ed908..8bd677e24548 100644
--- a/doc/settings-storage.txt
+++ b/doc/settings-storage.txt
@@ -361,3 +361,25 @@ Long term key) related to a remote device.
 
   CCC_LE		Integer		CCC value for LE transport
   CCC_BR/EDR		Integer		CCC value for BR/EDR transport
+
+
+[ConnectionSubrate] group contains:
+
+  MinInterval		Integer		Minimum Connection Interval
+					(in units of 0.125 ms)
+
+  MaxInterval		Integer		Maximum Connection Interval
+					(in units of 0.125 ms)
+
+  SubrateMin		Integer		Minimum Subrate Factor
+
+  SubrateMax		Integer		Maximum Subrate Factor
+
+  MaxLatency		Integer		Maximum Peripheral Latency
+					(in units of subrated connection
+					events)
+
+  ContinuationNumber	Integer		Number of continuation events
+
+  SupervisionTimeout	Integer		Link Supervision Timeout
+					(in units of 10 ms)
-- 
2.54.0

[PATCH BlueZ v1 08/12] client/mgmt: Add conn-subrate command

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add conn-subrate command to load connection subrate parameters
for a device via MGMT_OP_LOAD_CONN_SUBRATE.

Usage:
  conn-subrate [-t type] <address> <min_interval> <max_interval> \
               <subrate_min> <subrate_max> <max_latency> \
               <cont_num> <supv_timeout>
---
 client/mgmt.c             | 88 +++++++++++++++++++++++++++++++++++++++
 doc/bluetoothctl-mgmt.rst | 21 ++++++++++
 2 files changed, 109 insertions(+)

diff --git a/client/mgmt.c b/client/mgmt.c
index 50558a313866..cd2ef80221ad 100644
--- a/client/mgmt.c
+++ b/client/mgmt.c
@@ -6038,6 +6038,90 @@ static void register_mgmt_callbacks(struct mgmt *mgmt, uint16_t index)
 								NULL, NULL);
 }
 
+static void conn_subrate_rsp(uint8_t status, uint16_t len, const void *param,
+							void *user_data)
+{
+	if (status != 0)
+		error("Load Connection Subrate failed with status 0x%02x (%s)",
+						status, mgmt_errstr(status));
+	else
+		print("Connection Subrate loaded successfully");
+
+	bt_shell_noninteractive_quit(EXIT_SUCCESS);
+}
+
+static const struct option conn_subrate_options[] = {
+	{ "help",	0, 0, 'h' },
+	{ "type",	1, 0, 't' },
+	{ 0, 0, 0, 0 }
+};
+
+static void cmd_conn_subrate(int argc, char **argv)
+{
+	struct mgmt_cp_load_conn_subrate *cp;
+	uint8_t type = BDADDR_LE_PUBLIC;
+	int opt;
+	uint16_t index;
+	size_t cp_size;
+
+	while ((opt = getopt_long(argc, argv, "+t:h", conn_subrate_options,
+								NULL)) != -1) {
+		switch (opt) {
+		case 't':
+			type = strtol(optarg, NULL, 0);
+			break;
+		case 'h':
+			bt_shell_usage();
+			optind = 0;
+			return bt_shell_noninteractive_quit(EXIT_SUCCESS);
+		default:
+			bt_shell_usage();
+			optind = 0;
+			return bt_shell_noninteractive_quit(EXIT_FAILURE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+	optind = 0;
+
+	if (argc < 8) {
+		bt_shell_usage();
+		return bt_shell_noninteractive_quit(EXIT_FAILURE);
+	}
+
+	index = mgmt_index;
+	if (index == MGMT_INDEX_NONE)
+		index = 0;
+
+	cp_size = sizeof(*cp) + sizeof(struct mgmt_conn_subrate);
+	cp = malloc0(cp_size);
+	if (!cp) {
+		error("Unable to allocate memory");
+		return bt_shell_noninteractive_quit(EXIT_FAILURE);
+	}
+
+	cp->param_count = cpu_to_le16(1);
+	str2ba(argv[0], &cp->params[0].addr.bdaddr);
+	cp->params[0].addr.type = type;
+	cp->params[0].min_interval = cpu_to_le16(strtol(argv[1], NULL, 0));
+	cp->params[0].max_interval = cpu_to_le16(strtol(argv[2], NULL, 0));
+	cp->params[0].subrate_min = cpu_to_le16(strtol(argv[3], NULL, 0));
+	cp->params[0].subrate_max = cpu_to_le16(strtol(argv[4], NULL, 0));
+	cp->params[0].max_latency = cpu_to_le16(strtol(argv[5], NULL, 0));
+	cp->params[0].cont_num = cpu_to_le16(strtol(argv[6], NULL, 0));
+	cp->params[0].supv_timeout = cpu_to_le16(strtol(argv[7], NULL, 0));
+
+	if (mgmt_send(mgmt, MGMT_OP_LOAD_CONN_SUBRATE, index, cp_size, cp,
+					conn_subrate_rsp, NULL, NULL) == 0) {
+		error("Unable to send load connection subrate command");
+		free(cp);
+		return bt_shell_noninteractive_quit(EXIT_FAILURE);
+	}
+
+	free(cp);
+}
+
 static void cmd_select(int argc, char **argv)
 {
 	mgmt_cancel_all(mgmt);
@@ -6233,6 +6317,10 @@ static const struct bt_shell_menu mgmt_menu = {
 		cmd_get_flags,		"Get device flags"		},
 	{ "set-flags",		"[-f flags] [-t type] <address>",
 		cmd_set_flags,		"Set device flags"		},
+	{ "conn-subrate",	"[-t type] <address> <min_interval> "
+				"<max_interval> <subrate_min> <subrate_max> "
+				"<max_latency> <cont_num> <supv_timeout>",
+		cmd_conn_subrate,	"Load Connection Subrate"	},
 	{ "hci-cmd",		"<opcode> [event] [timeout] [param...]",
 		cmd_hci_cmd,	"Send HCI Command and wait for Event"	},
 	{} },
diff --git a/doc/bluetoothctl-mgmt.rst b/doc/bluetoothctl-mgmt.rst
index 646c2dcb4365..91406041c3cb 100644
--- a/doc/bluetoothctl-mgmt.rst
+++ b/doc/bluetoothctl-mgmt.rst
@@ -1293,6 +1293,27 @@ Set device flags
 :Example Clear all flags for LE public device:
 	| **> set-flags -f 0x00 -t le_public 11:22:33:44:55:66**
 
+conn-subrate
+------------
+
+Load Connection Subrate
+
+:Usage: **> conn-subrate [-t type] <address> <min_interval> <max_interval>
+	<subrate_min> <subrate_max> <max_latency> <cont_num> <supv_timeout>**
+:[-t type]: Address type - 1 for LE Public, 2 for LE Random
+:<address>: Bluetooth address of the device
+:<min_interval>: Minimum connection interval (units of 0.125 ms)
+:<max_interval>: Maximum connection interval (units of 0.125 ms)
+:<subrate_min>: Minimum subrate factor
+:<subrate_max>: Maximum subrate factor
+:<max_latency>: Maximum peripheral latency (subrated connection events)
+:<cont_num>: Continuation number
+:<supv_timeout>: Supervision timeout (units of 10 ms)
+:Example Load subrate for LE public address device:
+	| **> conn-subrate -t 1 00:11:22:33:44:55 8 3200 1 4 0 2 200**
+:Example Load subrate for LE random address device:
+	| **> conn-subrate -t 2 AA:BB:CC:DD:EE:FF 16 1600 2 8 0 4 100**
+
 RESOURCES
 =========
 
-- 
2.54.0

[PATCH BlueZ v1 09/12] mgmt-tester: Add HIDS recommended SCI parameter tests

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add Load Connection Subrate test cases using the recommended
connection subrate parameters from the HOGP v1.2 specification for
each of the four HID modes:

 - Fast: interval 1.25-5 ms, latency 0, subrate 1-4, cont_num 3
 - Default: interval 7.5-15 ms, latency 0, subrate 1-4, cont_num 0
 - Low Power: interval 7.5-15 ms, latency 100, subrate 1-4, cont_num 0
 - Full Range: interval 1.25-15 ms, latency 0, subrate 1-4, cont_num 1

Supervision timeouts are computed as (1 + Peripheral Latency) *
Subrate Max * Connection Interval Max * 2 per the spec.
---
 tools/mgmt-tester.c | 104 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 104 insertions(+)

diff --git a/tools/mgmt-tester.c b/tools/mgmt-tester.c
index 15c9254e307e..4b432002d49f 100644
--- a/tools/mgmt-tester.c
+++ b/tools/mgmt-tester.c
@@ -4478,6 +4478,98 @@ static const struct generic_data load_conn_subrate_success_1 = {
 	.expect_status = MGMT_STATUS_SUCCESS,
 };
 
+/* HIDS 1.2 recommended SCI parameters (see HOGP v1.2 spec).
+ * Connection intervals are in units of 0.125 ms, supervision timeout in
+ * units of 10 ms.
+ *
+ * Fast mode: interval 1.25-5 ms, latency 0, subrate 1-4, cont_num 3,
+ * timeout >= (1 + 0) * 4 * 5 ms * 2 = 40 ms.
+ */
+static const uint8_t load_conn_subrate_hids_fast[] = {
+	0x01, 0x00,				/* param_count */
+	0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,	/* address */
+	0x01,					/* address type (LE Public) */
+	0x0a, 0x00,				/* min_interval (1.25 ms) */
+	0x28, 0x00,				/* max_interval (5 ms) */
+	0x01, 0x00,				/* subrate_min */
+	0x04, 0x00,				/* subrate_max */
+	0x00, 0x00,				/* max_latency */
+	0x03, 0x00,				/* cont_num */
+	0x04, 0x00,				/* supv_timeout (40 ms) */
+};
+static const struct generic_data load_conn_subrate_hids_fast_test = {
+	.send_opcode = MGMT_OP_LOAD_CONN_SUBRATE,
+	.send_param = load_conn_subrate_hids_fast,
+	.send_len = sizeof(load_conn_subrate_hids_fast),
+	.expect_status = MGMT_STATUS_SUCCESS,
+};
+
+/* Default mode: interval 7.5-15 ms, latency 0, subrate 1-4, cont_num 0,
+ * timeout >= (1 + 0) * 4 * 15 ms * 2 = 120 ms.
+ */
+static const uint8_t load_conn_subrate_hids_default[] = {
+	0x01, 0x00,				/* param_count */
+	0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,	/* address */
+	0x01,					/* address type (LE Public) */
+	0x3c, 0x00,				/* min_interval (7.5 ms) */
+	0x78, 0x00,				/* max_interval (15 ms) */
+	0x01, 0x00,				/* subrate_min */
+	0x04, 0x00,				/* subrate_max */
+	0x00, 0x00,				/* max_latency */
+	0x00, 0x00,				/* cont_num */
+	0x0c, 0x00,				/* supv_timeout (120 ms) */
+};
+static const struct generic_data load_conn_subrate_hids_default_test = {
+	.send_opcode = MGMT_OP_LOAD_CONN_SUBRATE,
+	.send_param = load_conn_subrate_hids_default,
+	.send_len = sizeof(load_conn_subrate_hids_default),
+	.expect_status = MGMT_STATUS_SUCCESS,
+};
+
+/* Low Power mode: interval 7.5-15 ms, latency 100, subrate 1-4,
+ * cont_num 0, timeout >= (1 + 100) * 4 * 15 ms * 2 = 12120 ms.
+ */
+static const uint8_t load_conn_subrate_hids_low_power[] = {
+	0x01, 0x00,				/* param_count */
+	0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,	/* address */
+	0x01,					/* address type (LE Public) */
+	0x3c, 0x00,				/* min_interval (7.5 ms) */
+	0x78, 0x00,				/* max_interval (15 ms) */
+	0x01, 0x00,				/* subrate_min */
+	0x04, 0x00,				/* subrate_max */
+	0x64, 0x00,				/* max_latency (100) */
+	0x00, 0x00,				/* cont_num */
+	0xbc, 0x04,				/* supv_timeout (12120 ms) */
+};
+static const struct generic_data load_conn_subrate_hids_low_power_test = {
+	.send_opcode = MGMT_OP_LOAD_CONN_SUBRATE,
+	.send_param = load_conn_subrate_hids_low_power,
+	.send_len = sizeof(load_conn_subrate_hids_low_power),
+	.expect_status = MGMT_STATUS_SUCCESS,
+};
+
+/* Full Range mode: interval 1.25-15 ms, latency 0, subrate 1-4,
+ * cont_num 1, timeout >= (1 + 0) * 4 * 15 ms * 2 = 120 ms.
+ */
+static const uint8_t load_conn_subrate_hids_full_range[] = {
+	0x01, 0x00,				/* param_count */
+	0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,	/* address */
+	0x01,					/* address type (LE Public) */
+	0x0a, 0x00,				/* min_interval (1.25 ms) */
+	0x78, 0x00,				/* max_interval (15 ms) */
+	0x01, 0x00,				/* subrate_min */
+	0x04, 0x00,				/* subrate_max */
+	0x00, 0x00,				/* max_latency */
+	0x01, 0x00,				/* cont_num */
+	0x0c, 0x00,				/* supv_timeout (120 ms) */
+};
+static const struct generic_data load_conn_subrate_hids_full_range_test = {
+	.send_opcode = MGMT_OP_LOAD_CONN_SUBRATE,
+	.send_param = load_conn_subrate_hids_full_range,
+	.send_len = sizeof(load_conn_subrate_hids_full_range),
+	.expect_status = MGMT_STATUS_SUCCESS,
+};
+
 static const uint8_t add_device_nval_1[] = {
 					0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
 					0x00,
@@ -13870,6 +13962,18 @@ int main(int argc, char *argv[])
 	test_bredrle62("Load Connection Subrate - Success 1",
 				&load_conn_subrate_success_1,
 				NULL, test_command_generic);
+	test_bredrle62("Load Connection Subrate - HIDS Fast",
+				&load_conn_subrate_hids_fast_test,
+				NULL, test_command_generic);
+	test_bredrle62("Load Connection Subrate - HIDS Default",
+				&load_conn_subrate_hids_default_test,
+				NULL, test_command_generic);
+	test_bredrle62("Load Connection Subrate - HIDS Low Power",
+				&load_conn_subrate_hids_low_power_test,
+				NULL, test_command_generic);
+	test_bredrle62("Load Connection Subrate - HIDS Full Range",
+				&load_conn_subrate_hids_full_range_test,
+				NULL, test_command_generic);
 
 	test_bredrle("Add Device - Invalid Params 1",
 				&add_device_fail_1,
-- 
2.54.0

[PATCH BlueZ v1 10/12] l2cap-tester: Add SCI mode tests for LE client connections

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add L2CAP LE client connection tests that load Connection Subrate
parameters (via MGMT_OP_LOAD_CONN_SUBRATE) before establishing the
connection, using the HOGP v1.2 recommended values for each of the
four HID SCI modes:

 - Fast: interval 1.25-5 ms, latency 0, subrate 1-4, cont_num 3
 - Default: interval 7.5-15 ms, latency 0, subrate 1-4, cont_num 0
 - Low Power: interval 7.5-15 ms, latency 100, subrate 1-4, cont_num 0
 - Full Range: interval 1.25-15 ms, latency 0, subrate 1-4, cont_num 1

Add the test_l2cap_le_62 macro (HCIEMU_TYPE_BREDRLE62) since SCI
requires a 6.2 controller. The subrate parameters are loaded with
the client's runtime bdaddr during setup_powered_client before the
outgoing LE connection is initiated.
---
 tools/l2cap-tester.c | 130 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 130 insertions(+)

diff --git a/tools/l2cap-tester.c b/tools/l2cap-tester.c
index 2771aee65814..88bfd71bf580 100644
--- a/tools/l2cap-tester.c
+++ b/tools/l2cap-tester.c
@@ -54,6 +54,16 @@ struct test_data {
 	struct tx_tstamp_data tx_ts;
 };
 
+struct l2cap_conn_subrate {
+	uint16_t min_interval;
+	uint16_t max_interval;
+	uint16_t subrate_min;
+	uint16_t subrate_max;
+	uint16_t max_latency;
+	uint16_t cont_num;
+	uint16_t supv_timeout;
+};
+
 struct l2cap_data {
 	uint16_t client_psm;
 	uint16_t server_psm;
@@ -112,6 +122,11 @@ struct l2cap_data {
 
 	/* Set PHY */
 	uint32_t phy;
+
+	/* Connection Subrate parameters to load before connecting.
+	 * The address is filled in with the client bdaddr at runtime.
+	 */
+	const struct l2cap_conn_subrate *conn_subrate;
 };
 
 static void print_debug(const char *str, void *user_data)
@@ -298,6 +313,9 @@ static void test_data_free(void *test_data)
 #define test_l2cap_le_52(name, data, setup, func) \
 	test_l2cap(name, HCIEMU_TYPE_BREDRLE52, data, setup, func)
 
+#define test_l2cap_le_62(name, data, setup, func) \
+	test_l2cap(name, HCIEMU_TYPE_BREDRLE62, data, setup, func)
+
 static uint8_t pair_device_pin[] = { 0x30, 0x30, 0x30, 0x30 }; /* "0000" */
 
 static const struct l2cap_data client_connect_success_test = {
@@ -654,6 +672,74 @@ static const struct l2cap_data le_client_connect_success_test_1 = {
 	.server_psm = 0x0080,
 };
 
+/* HIDS 1.2 recommended SCI parameters (see HOGP v1.2 spec).
+ * Connection intervals are in units of 0.125 ms, supervision timeout in
+ * units of 10 ms.
+ */
+static const struct l2cap_conn_subrate conn_subrate_hids_fast = {
+	.min_interval = 0x000a,		/* 1.25 ms */
+	.max_interval = 0x0028,		/* 5 ms */
+	.subrate_min = 0x0001,
+	.subrate_max = 0x0004,
+	.max_latency = 0x0000,
+	.cont_num = 0x0003,
+	.supv_timeout = 0x0004,		/* 40 ms */
+};
+
+static const struct l2cap_conn_subrate conn_subrate_hids_default = {
+	.min_interval = 0x003c,		/* 7.5 ms */
+	.max_interval = 0x0078,		/* 15 ms */
+	.subrate_min = 0x0001,
+	.subrate_max = 0x0004,
+	.max_latency = 0x0000,
+	.cont_num = 0x0000,
+	.supv_timeout = 0x000c,		/* 120 ms */
+};
+
+static const struct l2cap_conn_subrate conn_subrate_hids_low_power = {
+	.min_interval = 0x003c,		/* 7.5 ms */
+	.max_interval = 0x0078,		/* 15 ms */
+	.subrate_min = 0x0001,
+	.subrate_max = 0x0004,
+	.max_latency = 0x0064,		/* 100 */
+	.cont_num = 0x0000,
+	.supv_timeout = 0x04bc,		/* 12120 ms */
+};
+
+static const struct l2cap_conn_subrate conn_subrate_hids_full_range = {
+	.min_interval = 0x000a,		/* 1.25 ms */
+	.max_interval = 0x0078,		/* 15 ms */
+	.subrate_min = 0x0001,
+	.subrate_max = 0x0004,
+	.max_latency = 0x0000,
+	.cont_num = 0x0001,
+	.supv_timeout = 0x000c,		/* 120 ms */
+};
+
+static const struct l2cap_data le_client_connect_subrate_fast_test = {
+	.client_psm = 0x0080,
+	.server_psm = 0x0080,
+	.conn_subrate = &conn_subrate_hids_fast,
+};
+
+static const struct l2cap_data le_client_connect_subrate_default_test = {
+	.client_psm = 0x0080,
+	.server_psm = 0x0080,
+	.conn_subrate = &conn_subrate_hids_default,
+};
+
+static const struct l2cap_data le_client_connect_subrate_low_power_test = {
+	.client_psm = 0x0080,
+	.server_psm = 0x0080,
+	.conn_subrate = &conn_subrate_hids_low_power,
+};
+
+static const struct l2cap_data le_client_connect_subrate_full_range_test = {
+	.client_psm = 0x0080,
+	.server_psm = 0x0080,
+	.conn_subrate = &conn_subrate_hids_full_range,
+};
+
 static const struct l2cap_data le_client_connect_close_test_1 = {
 	.client_psm = 0x0080,
 };
@@ -1512,6 +1598,37 @@ static void setup_powered_client(const void *test_data)
 		mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
 				sizeof(param), param, NULL, NULL, NULL);
 
+	if (test && test->conn_subrate) {
+		const struct l2cap_conn_subrate *cs = test->conn_subrate;
+		const uint8_t *client_bdaddr;
+		struct {
+			struct mgmt_cp_load_conn_subrate cp;
+			struct mgmt_conn_subrate param;
+		} __attribute__((packed)) load;
+
+		client_bdaddr = hciemu_get_client_bdaddr(data->hciemu);
+		if (!client_bdaddr) {
+			tester_setup_failed();
+			return;
+		}
+
+		memset(&load, 0, sizeof(load));
+		load.cp.param_count = cpu_to_le16(1);
+		memcpy(&load.param.addr.bdaddr, client_bdaddr, 6);
+		load.param.addr.type = BDADDR_LE_PUBLIC;
+		load.param.min_interval = cpu_to_le16(cs->min_interval);
+		load.param.max_interval = cpu_to_le16(cs->max_interval);
+		load.param.subrate_min = cpu_to_le16(cs->subrate_min);
+		load.param.subrate_max = cpu_to_le16(cs->subrate_max);
+		load.param.max_latency = cpu_to_le16(cs->max_latency);
+		load.param.cont_num = cpu_to_le16(cs->cont_num);
+		load.param.supv_timeout = cpu_to_le16(cs->supv_timeout);
+
+		mgmt_send(data->mgmt, MGMT_OP_LOAD_CONN_SUBRATE,
+				data->mgmt_index, sizeof(load), &load,
+				NULL, NULL, NULL);
+	}
+
 	mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
 			sizeof(param), param, setup_powered_client_callback,
 			NULL, NULL);
@@ -3118,6 +3235,19 @@ int main(int argc, char *argv[])
 	test_l2cap_le("L2CAP LE Client - Success",
 				&le_client_connect_success_test_1,
 				setup_powered_client, test_connect);
+
+	test_l2cap_le_62("L2CAP LE Client - SCI Fast Mode",
+				&le_client_connect_subrate_fast_test,
+				setup_powered_client, test_connect);
+	test_l2cap_le_62("L2CAP LE Client - SCI Default Mode",
+				&le_client_connect_subrate_default_test,
+				setup_powered_client, test_connect);
+	test_l2cap_le_62("L2CAP LE Client - SCI Low Power Mode",
+				&le_client_connect_subrate_low_power_test,
+				setup_powered_client, test_connect);
+	test_l2cap_le_62("L2CAP LE Client - SCI Full Range Mode",
+				&le_client_connect_subrate_full_range_test,
+				setup_powered_client, test_connect);
 	test_l2cap_le("L2CAP LE Client - Close",
 				&le_client_connect_close_test_1,
 				setup_powered_client, test_connect_close);
-- 
2.54.0

[PATCH BlueZ v1 11/12] emulator/bthost: Add LE Connection Rate Request support

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add bthost_le_conn_rate() to send the LE Connection Rate Request
(0x20a1) command for a given connection handle.

Also handle the LE Connection Rate Change event (0x37).

This allows testing a peripheral (server) handling of the Shorter
Connection Interval feature by having the emulated central initiate
the connection rate request on connect.
---
 emulator/bthost.c | 36 ++++++++++++++++++++++++++++++++++++
 emulator/bthost.h | 14 ++++++++++++++
 2 files changed, 50 insertions(+)

diff --git a/emulator/bthost.c b/emulator/bthost.c
index 2732b7f83f8b..46c6a52f5729 100644
--- a/emulator/bthost.c
+++ b/emulator/bthost.c
@@ -1729,6 +1729,21 @@ static void evt_le_conn_update_complete(struct bthost *bthost, const void *data,
 		return;
 }
 
+static void evt_le_conn_rate_change(struct bthost *bthost, const void *data,
+								uint8_t len)
+{
+	const struct bt_hci_evt_le_conn_rate_change *ev = data;
+
+	if (len < sizeof(*ev))
+		return;
+
+	if (ev->status)
+		return;
+
+	bthost_debug(bthost, "conn rate change: handle %u subrate %u",
+			le16_to_cpu(ev->handle), le16_to_cpu(ev->subrate));
+}
+
 static void evt_le_remote_features_complete(struct bthost *bthost,
 						const void *data, uint8_t len)
 {
@@ -1963,6 +1978,9 @@ static void evt_le_meta_event(struct bthost *bthost, const void *data,
 	case BT_HCI_EVT_LE_BIG_INFO_ADV_REPORT:
 		evt_le_big_info_adv_report(bthost, evt_data, len - 1);
 		break;
+	case BT_HCI_EVT_LE_CONN_RATE_CHANGE:
+		evt_le_conn_rate_change(bthost, evt_data, len - 1);
+		break;
 	default:
 		bthost_debug(bthost, "Unsupported LE Meta event 0x%2.2x",
 								*event);
@@ -3999,6 +4017,24 @@ void bthost_le_start_encrypt(struct bthost *bthost, uint16_t handle,
 	send_command(bthost, BT_HCI_CMD_LE_START_ENCRYPT, &cmd, sizeof(cmd));
 }
 
+void bthost_le_conn_rate(struct bthost *bthost, uint16_t handle,
+					const struct bthost_conn_rate *rate)
+{
+	struct bt_hci_cmd_le_conn_rate cmd;
+
+	memset(&cmd, 0, sizeof(cmd));
+	cmd.handle = cpu_to_le16(handle);
+	cmd.interval_min = cpu_to_le16(rate->interval_min);
+	cmd.interval_max = cpu_to_le16(rate->interval_max);
+	cmd.subrate_min = cpu_to_le16(rate->subrate_min);
+	cmd.subrate_max = cpu_to_le16(rate->subrate_max);
+	cmd.max_latency = cpu_to_le16(rate->max_latency);
+	cmd.cont_num = cpu_to_le16(rate->cont_num);
+	cmd.supv_timeout = cpu_to_le16(rate->supv_timeout);
+
+	send_command(bthost, BT_HCI_CMD_LE_CONN_RATE, &cmd, sizeof(cmd));
+}
+
 uint64_t bthost_conn_get_fixed_chan(struct bthost *bthost, uint16_t handle)
 {
 	struct btconn *conn;
diff --git a/emulator/bthost.h b/emulator/bthost.h
index c88ea0329a65..e104e68af782 100644
--- a/emulator/bthost.h
+++ b/emulator/bthost.h
@@ -66,6 +66,20 @@ void bthost_hci_connect(struct bthost *bthost, const uint8_t *bdaddr,
 void bthost_hci_ext_connect(struct bthost *bthost, const uint8_t *bdaddr,
 							uint8_t addr_type);
 
+struct bthost_conn_rate {
+	uint16_t interval_min;
+	uint16_t interval_max;
+	uint16_t subrate_min;
+	uint16_t subrate_max;
+	uint16_t max_latency;
+	uint16_t cont_num;
+	uint16_t supv_timeout;
+};
+
+/* Send LE Connection Rate Request for the given connection handle. */
+void bthost_le_conn_rate(struct bthost *bthost, uint16_t handle,
+					const struct bthost_conn_rate *rate);
+
 void bthost_hci_disconnect(struct bthost *bthost, uint16_t handle,
 								uint8_t reason);
 
-- 
2.54.0

[PATCH BlueZ v1 12/12] l2cap-tester: Add SCI mode tests for LE server connections

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

Add L2CAP LE server connection tests that exercise the peripheral
side of the Shorter Connection Interval feature. The emulated client
(central) is configured via bthost_le_conn_rate() to send an LE
Connection Rate Request once connected, using the HOGP v1.2
recommended values for each of the four HID SCI modes (Fast, Default,
Low Power, Full Range).
---
 tools/l2cap-tester.c | 51 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/tools/l2cap-tester.c b/tools/l2cap-tester.c
index 88bfd71bf580..3011a811e15e 100644
--- a/tools/l2cap-tester.c
+++ b/tools/l2cap-tester.c
@@ -740,6 +740,26 @@ static const struct l2cap_data le_client_connect_subrate_full_range_test = {
 	.conn_subrate = &conn_subrate_hids_full_range,
 };
 
+static const struct l2cap_data le_server_subrate_fast_test = {
+	.cid = 0x0004,
+	.conn_subrate = &conn_subrate_hids_fast,
+};
+
+static const struct l2cap_data le_server_subrate_default_test = {
+	.cid = 0x0004,
+	.conn_subrate = &conn_subrate_hids_default,
+};
+
+static const struct l2cap_data le_server_subrate_low_power_test = {
+	.cid = 0x0004,
+	.conn_subrate = &conn_subrate_hids_low_power,
+};
+
+static const struct l2cap_data le_server_subrate_full_range_test = {
+	.cid = 0x0004,
+	.conn_subrate = &conn_subrate_hids_full_range,
+};
+
 static const struct l2cap_data le_client_connect_close_test_1 = {
 	.client_psm = 0x0080,
 };
@@ -2963,6 +2983,24 @@ static void send_req_new_conn(uint16_t handle, void *user_data)
 
 	data->handle = handle;
 
+	if (l2data->conn_subrate) {
+		const struct l2cap_conn_subrate *cs = l2data->conn_subrate;
+		struct bthost_conn_rate rate;
+
+		rate.interval_min = cs->min_interval;
+		rate.interval_max = cs->max_interval;
+		rate.subrate_min = cs->subrate_min;
+		rate.subrate_max = cs->subrate_max;
+		rate.max_latency = cs->max_latency;
+		rate.cont_num = cs->cont_num;
+		rate.supv_timeout = cs->supv_timeout;
+
+		tester_print("Sending LE Connection Rate Request from client");
+
+		bthost = hciemu_client_get_host(data->hciemu);
+		bthost_le_conn_rate(bthost, handle, &rate);
+	}
+
 	if (l2data->send_cmd) {
 		bthost_l2cap_rsp_cb cb;
 
@@ -3248,6 +3286,19 @@ int main(int argc, char *argv[])
 	test_l2cap_le_62("L2CAP LE Client - SCI Full Range Mode",
 				&le_client_connect_subrate_full_range_test,
 				setup_powered_client, test_connect);
+
+	test_l2cap_le_62("L2CAP LE Server - SCI Fast Mode",
+				&le_server_subrate_fast_test,
+				setup_powered_server, test_server);
+	test_l2cap_le_62("L2CAP LE Server - SCI Default Mode",
+				&le_server_subrate_default_test,
+				setup_powered_server, test_server);
+	test_l2cap_le_62("L2CAP LE Server - SCI Low Power Mode",
+				&le_server_subrate_low_power_test,
+				setup_powered_server, test_server);
+	test_l2cap_le_62("L2CAP LE Server - SCI Full Range Mode",
+				&le_server_subrate_full_range_test,
+				setup_powered_server, test_server);
 	test_l2cap_le("L2CAP LE Client - Close",
 				&le_client_connect_close_test_1,
 				setup_powered_client, test_connect_close);
-- 
2.54.0

RE: Add support for Shorter Connection Interval (SCI)

[bluez.test.bot]

[-- Attachment #1: Type: text/plain, Size: 4612 bytes --]

This is automated email and please do not reply to this email!

Dear submitter,

Thank you for submitting the patches to the linux bluetooth mailing list.
This is a CI test results with your patch series:
PW Link:https://patchwork.kernel.org/project/bluetooth/list/?series=1134176

---Test result---

Test Summary:
CheckPatch                    FAIL      3.79 seconds
GitLint                       FAIL      2.99 seconds
BuildEll                      PASS      15.82 seconds
BluezMake                     PASS      456.61 seconds
MakeCheck                     PASS      18.51 seconds
MakeDistcheck                 PASS      121.29 seconds
CheckValgrind                 PASS      172.27 seconds
CheckSmatch                   WARNING   228.67 seconds
bluezmakeextell               PASS      73.20 seconds
IncrementalBuild              PASS      571.48 seconds
ScanBuild                     PASS      675.72 seconds

Details
##############################
Test: CheckPatch - FAIL
Desc: Run checkpatch.pl script
Output:
[BlueZ,v1,02/12] emulator/btdev: Add emulation support for HIDS 1.1 SCI commands
WARNING:PREFER_DEFINED_ATTRIBUTE_MACRO: Prefer __packed over __attribute__((packed))
#173: FILE: emulator/btdev.c:8015:
+	} __attribute__ ((packed)) pdu;

WARNING:LONG_LINE_COMMENT: line length of 81 exceeds 80 columns
#210: FILE: emulator/btdev.c:8052:
+	btdev->commands[48] |= BIT(7);	/* LE Read Min Supported Conn Interval */

/github/workspace/src/patch/14709597.patch total: 0 errors, 2 warnings, 172 lines checked

NOTE: For some of the reported defects, checkpatch may be able to
      mechanically convert to the typical style using --fix or --fix-inplace.

/github/workspace/src/patch/14709597.patch has style problems, please review.

NOTE: Ignored message types: COMMIT_MESSAGE COMPLEX_MACRO CONST_STRUCT FILE_PATH_CHANGES MISSING_SIGN_OFF PREFER_PACKED SPDX_LICENSE_TAG SPLIT_STRING SSCANF_TO_KSTRTO

NOTE: If any of the errors are false positives, please report
      them to the maintainer, see CHECKPATCH in MAINTAINERS.


[BlueZ,v1,10/12] l2cap-tester: Add SCI mode tests for LE client connections
WARNING:PREFER_DEFINED_ATTRIBUTE_MACRO: Prefer __packed over __attribute__((packed))
#247: FILE: tools/l2cap-tester.c:1607:
+		} __attribute__((packed)) load;

/github/workspace/src/patch/14709606.patch total: 0 errors, 1 warnings, 166 lines checked

NOTE: For some of the reported defects, checkpatch may be able to
      mechanically convert to the typical style using --fix or --fix-inplace.

/github/workspace/src/patch/14709606.patch has style problems, please review.

NOTE: Ignored message types: COMMIT_MESSAGE COMPLEX_MACRO CONST_STRUCT FILE_PATH_CHANGES MISSING_SIGN_OFF PREFER_PACKED SPDX_LICENSE_TAG SPLIT_STRING SSCANF_TO_KSTRTO

NOTE: If any of the errors are false positives, please report
      them to the maintainer, see CHECKPATCH in MAINTAINERS.


##############################
Test: GitLint - FAIL
Desc: Run gitlint
Output:
[BlueZ,v1,01/12] input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes

1: T1 Title exceeds max length (81>80): "[BlueZ,v1,01/12] input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes"
[BlueZ,v1,03/12] mgmt: Add Shorter Connection Interval setting and Load Connection Subrate

1: T1 Title exceeds max length (90>80): "[BlueZ,v1,03/12] mgmt: Add Shorter Connection Interval setting and Load Connection Subrate"
[BlueZ,v1,04/12] mgmt-tester: Add tests for SCI setting and Load Connection Subrate

1: T1 Title exceeds max length (83>80): "[BlueZ,v1,04/12] mgmt-tester: Add tests for SCI setting and Load Connection Subrate"
[BlueZ,v1,06/12] monitor: Add decoding for Load Connection Subrate, SCI setting and event

1: T1 Title exceeds max length (89>80): "[BlueZ,v1,06/12] monitor: Add decoding for Load Connection Subrate, SCI setting and event"
##############################
Test: CheckSmatch - WARNING
Desc: Run smatch tool with source
Output:
emulator/btdev.c:478:29: warning: Variable length array is used.monitor/packet.c:2002:26: warning: Variable length array is used.monitor/packet.c: note: in included file:monitor/bt.h:3924:52: warning: array of flexible structuresmonitor/bt.h:3912:40: warning: array of flexible structuresemulator/bthost.c:703:28: warning: Variable length array is used.emulator/bthost.c:704:32: warning: Variable length array is used.emulator/bthost.c:944:28: warning: Variable length array is used.emulator/bthost.c:978:28: warning: Variable length array is used.emulator/bthost.c:979:32: warning: Variable length array is used.


https://github.com/bluez/bluez/pull/2347

---
Regards,
Linux Bluetooth