From: Kevin Dewald <kevin@simpleble.org>
To: linux-bluetooth@vger.kernel.org
Cc: Luiz Augusto von Dentz <luiz.dentz@gmail.com>,
Kevin Dewald <kevin@simpleble.org>
Subject: [PATCH BlueZ v4 3/4] bearer: Add ReadRSSI method
Date: Sun, 15 Nov 2026 23:16:20 -0800 [thread overview]
Message-ID: <20261116071622.35355-4-kevin@simpleble.org> (raw)
In-Reply-To: <20261116071622.35355-1-kevin@simpleble.org>
Implement Bearer.LE1.ReadRSSI with Get Connection Information, as a
testing method. The kernel reads the RSSI from the controller, or
returns the value it read last if that is recent enough
(conn_info_min_age and conn_info_max_age, 1 to 3 seconds by default).
The kernel reports a connection as soon as it is established but only
answers Get Connection Information once it has set it up, so a call made
right after Connect returns fails with NotReady rather than NotConnected.
Calls made while a request is pending get its result rather than sending
another one, as the kernel would answer that with its cached value,
which a new connection does not have yet.
A request still pending when the bearer is destroyed is left to complete
rather than cancelled, as the kernel replies to it anyway and the reply
would be taken for the reply to the next request.
The method is only on Bearer.LE1, as the RSSI of a BR/EDR connection is
relative to the golden receive power range rather than in dBm.
Assisted-by: Claude:claude-opus-5.5
---
src/bearer.c | 132 ++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 130 insertions(+), 2 deletions(-)
diff --git a/src/bearer.c b/src/bearer.c
index ebcdc2b4c..779f6ea3c 100644
--- a/src/bearer.c
+++ b/src/bearer.c
@@ -44,6 +44,12 @@
#define DISCONNECT_TIMER 2
+/* Get Connection Information request of ReadRSSI */
+struct rssi_req {
+ struct btd_bearer *bearer; /* NULL once the bearer is destroyed */
+ struct queue *msgs; /* ReadRSSI calls waiting for the reply */
+};
+
struct btd_bearer {
struct btd_device *device;
uint8_t type;
@@ -57,6 +63,8 @@ struct btd_bearer {
*/
DBusMessage *connect; /* connect message */
+ struct rssi_req *rssi_req;
+
/* LE connection parameters, only valid while connected */
bool conn_params;
uint32_t interval; /* in microseconds */
@@ -213,13 +221,117 @@ static DBusMessage *bearer_disconnect(DBusConnection *conn, DBusMessage *msg,
return NULL;
}
-static const GDBusMethodTable bearer_methods[] = {
+static DBusMessage *rssi_reply(struct btd_bearer *bearer, DBusMessage *msg,
+ uint8_t status, uint16_t length,
+ const struct mgmt_rp_get_conn_info *rp)
+{
+ dbus_int16_t rssi;
+
+ /* The kernel reports the connection as soon as it is established, but
+ * only answers once it has set it up, e.g. read the remote features.
+ */
+ if (status == MGMT_STATUS_NOT_CONNECTED) {
+ if (btd_device_bdaddr_type_connected(bearer->device,
+ bearer->type))
+ return btd_error_not_ready(msg);
+
+ return btd_error_not_connected(msg);
+ }
+
+ if (status != MGMT_STATUS_SUCCESS)
+ return btd_error_failed(msg, mgmt_errstr(status));
+
+ if (length < sizeof(*rp))
+ return btd_error_failed(msg, "Invalid response");
+
+ /* 127 means the controller has no RSSI for the connection */
+ if (rp->rssi == 127)
+ return btd_error_not_available(msg);
+
+ rssi = rp->rssi;
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INT16, &rssi,
+ DBUS_TYPE_INVALID);
+}
+
+static void rssi_req_complete(uint8_t status, uint16_t length,
+ const void *param, void *user_data)
+{
+ struct rssi_req *req = user_data;
+ struct btd_bearer *bearer = req->bearer;
+ DBusMessage *msg;
+
+ if (!bearer)
+ return;
+
+ while ((msg = queue_pop_head(req->msgs))) {
+ g_dbus_send_message(btd_get_dbus_connection(),
+ rssi_reply(bearer, msg, status, length, param));
+ dbus_message_unref(msg);
+ }
+}
+
+static void rssi_req_free(void *data)
+{
+ struct rssi_req *req = data;
+
+ if (req->bearer)
+ req->bearer->rssi_req = NULL;
+
+ queue_destroy(req->msgs, bearer_free_dbus_message);
+ free(req);
+}
+
+static DBusMessage *bearer_read_rssi(DBusConnection *conn, DBusMessage *msg,
+ void *user_data)
+{
+ struct btd_bearer *bearer = user_data;
+ struct btd_device *device = bearer->device;
+ struct rssi_req *req;
+
+ if (!btd_device_bdaddr_type_connected(device, bearer->type))
+ return btd_error_not_connected(msg);
+
+ /* Calls made while a read is pending get the same result */
+ if (!bearer->rssi_req) {
+ req = new0(struct rssi_req, 1);
+ req->bearer = bearer;
+ req->msgs = queue_new();
+
+ if (!btd_adapter_get_conn_info(device_get_adapter(device),
+ device_get_address(device),
+ device_get_le_address_type(device),
+ rssi_req_complete, req,
+ rssi_req_free)) {
+ rssi_req_free(req);
+ return btd_error_failed(msg, "Unable to read RSSI");
+ }
+
+ bearer->rssi_req = req;
+ }
+
+ queue_push_tail(bearer->rssi_req->msgs, dbus_message_ref(msg));
+
+ return NULL;
+}
+
+static const GDBusMethodTable bearer_bredr_methods[] = {
{ GDBUS_ASYNC_METHOD("Connect", NULL, NULL, bearer_connect) },
{ GDBUS_ASYNC_METHOD("Disconnect", NULL, NULL,
bearer_disconnect) },
{}
};
+static const GDBusMethodTable bearer_le_methods[] = {
+ { GDBUS_ASYNC_METHOD("Connect", NULL, NULL, bearer_connect) },
+ { GDBUS_ASYNC_METHOD("Disconnect", NULL, NULL,
+ bearer_disconnect) },
+ { GDBUS_TESTING_ASYNC_METHOD("ReadRSSI", NULL,
+ GDBUS_ARGS({ "rssi", "n" }),
+ bearer_read_rssi) },
+ {}
+};
+
static gboolean bearer_get_adapter(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *data)
{
@@ -404,6 +516,14 @@ static const char *bearer_interface(uint8_t type)
return BTD_BEARER_LE_INTERFACE;
}
+static const GDBusMethodTable *bearer_methods(uint8_t type)
+{
+ if (type == BDADDR_BREDR)
+ return bearer_bredr_methods;
+ else
+ return bearer_le_methods;
+}
+
struct btd_bearer *btd_bearer_new(struct btd_device *device, uint8_t type)
{
struct btd_bearer *bearer;
@@ -429,7 +549,7 @@ struct btd_bearer *btd_bearer_new(struct btd_device *device, uint8_t type)
if (!g_dbus_register_interface(btd_get_dbus_connection(),
bearer->path, bearer_interface(type),
- bearer_methods, bearer_signals,
+ bearer_methods(type), bearer_signals,
bearer_properties,
bearer, bearer_free)) {
error("Unable to register BREDR interface");
@@ -459,6 +579,14 @@ void btd_bearer_destroy(struct btd_bearer *bearer)
bearer->connect = NULL;
}
+ /* Let a pending request complete rather than cancel it, as the kernel
+ * replies to it anyway and the reply would complete the next request.
+ */
+ if (bearer->rssi_req) {
+ bearer->rssi_req->bearer = NULL;
+ bearer->rssi_req = NULL;
+ }
+
g_dbus_unregister_interface(btd_get_dbus_connection(), bearer->path,
bearer_interface(bearer->type));
}
--
2.54.0 (Apple Git-157)
next prev parent reply other threads:[~2026-11-16 7:16 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 7:16 [PATCH BlueZ v4 0/4] Bearer.LE1: Add ReadRSSI Kevin Dewald
2026-11-16 7:16 ` [PATCH BlueZ v4 1/4] org.bluez.Bearer: Add ReadRSSI method Kevin Dewald
2026-11-16 7:16 ` [PATCH BlueZ v4 2/4] adapter: Add btd_adapter_get_conn_info Kevin Dewald
2026-11-16 7:16 ` Kevin Dewald [this message]
2026-11-16 7:16 ` [PATCH BlueZ v4 4/4] test: functional: add bearer ReadRSSI test Kevin Dewald
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261116071622.35355-4-kevin@simpleble.org \
--to=kevin@simpleble.org \
--cc=linux-bluetooth@vger.kernel.org \
--cc=luiz.dentz@gmail.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox