* [PATCH BlueZ v1 01/12] input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 20:41 ` Add support for Shorter Connection Interval (SCI) bluez.test.bot
2026-07-24 19:12 ` [PATCH BlueZ v1 02/12] emulator/btdev: Add emulation support for HIDS 1.1 SCI commands Luiz Augusto von Dentz
` (10 subsequent siblings)
11 siblings, 1 reply; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* RE: Add support for Shorter Connection Interval (SCI)
2026-07-24 19:12 ` [PATCH BlueZ v1 01/12] input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes Luiz Augusto von Dentz
@ 2026-07-24 20:41 ` bluez.test.bot
0 siblings, 0 replies; 14+ messages in thread
From: bluez.test.bot @ 2026-07-24 20:41 UTC (permalink / raw)
To: linux-bluetooth, luiz.dentz
[-- 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
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH BlueZ v1 02/12] emulator/btdev: Add emulation support for HIDS 1.1 SCI commands
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 01/12] input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 03/12] mgmt: Add Shorter Connection Interval setting and Load Connection Subrate Luiz Augusto von Dentz
` (9 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 03/12] mgmt: Add Shorter Connection Interval setting and Load Connection Subrate
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 01/12] input/hog-lib: Add discovery support for HIDS 1.1 SCI attributes Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 02/12] emulator/btdev: Add emulation support for HIDS 1.1 SCI commands Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 04/12] mgmt-tester: Add tests for SCI " Luiz Augusto von Dentz
` (8 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 04/12] mgmt-tester: Add tests for SCI setting and Load Connection Subrate
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (2 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 03/12] mgmt: Add Shorter Connection Interval setting and Load Connection Subrate Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 05/12] adapter: Add support for loading connection subrate parameters Luiz Augusto von Dentz
` (7 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 05/12] adapter: Add support for loading connection subrate parameters
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (3 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 04/12] mgmt-tester: Add tests for SCI " Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 06/12] monitor: Add decoding for Load Connection Subrate, SCI setting and event Luiz Augusto von Dentz
` (6 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 06/12] monitor: Add decoding for Load Connection Subrate, SCI setting and event
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (4 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 05/12] adapter: Add support for loading connection subrate parameters Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 07/12] doc: Document ConnectionSubrate storage format Luiz Augusto von Dentz
` (5 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 07/12] doc: Document ConnectionSubrate storage format
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (5 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 06/12] monitor: Add decoding for Load Connection Subrate, SCI setting and event Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 08/12] client/mgmt: Add conn-subrate command Luiz Augusto von Dentz
` (4 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 08/12] client/mgmt: Add conn-subrate command
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (6 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 07/12] doc: Document ConnectionSubrate storage format Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 09/12] mgmt-tester: Add HIDS recommended SCI parameter tests Luiz Augusto von Dentz
` (3 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 09/12] mgmt-tester: Add HIDS recommended SCI parameter tests
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (7 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 08/12] client/mgmt: Add conn-subrate command Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 10/12] l2cap-tester: Add SCI mode tests for LE client connections Luiz Augusto von Dentz
` (2 subsequent siblings)
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 10/12] l2cap-tester: Add SCI mode tests for LE client connections
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (8 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 09/12] mgmt-tester: Add HIDS recommended SCI parameter tests Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 11/12] emulator/bthost: Add LE Connection Rate Request support Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 12/12] l2cap-tester: Add SCI mode tests for LE server connections Luiz Augusto von Dentz
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 11/12] emulator/bthost: Add LE Connection Rate Request support
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (9 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 10/12] l2cap-tester: Add SCI mode tests for LE client connections Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
2026-07-24 19:12 ` [PATCH BlueZ v1 12/12] l2cap-tester: Add SCI mode tests for LE server connections Luiz Augusto von Dentz
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH BlueZ v1 12/12] l2cap-tester: Add SCI mode tests for LE server connections
2026-07-24 19:12 [PATCH BlueZ v1 00/12] Add support for Shorter Connection Interval (SCI) Luiz Augusto von Dentz
` (10 preceding siblings ...)
2026-07-24 19:12 ` [PATCH BlueZ v1 11/12] emulator/bthost: Add LE Connection Rate Request support Luiz Augusto von Dentz
@ 2026-07-24 19:12 ` Luiz Augusto von Dentz
11 siblings, 0 replies; 14+ messages in thread
From: Luiz Augusto von Dentz @ 2026-07-24 19:12 UTC (permalink / raw)
To: linux-bluetooth
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
^ permalink raw reply related [flat|nested] 14+ messages in thread