Skip to contentSkip to conversation

provision: Add 311 270 MCC/MNC as Verizon

PATCH Applied Denis Kenzior 2 participants 5 messages Nov 27, 2024 – Dec 2, 2024

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/4 provision: Add 311 270 MCC/MNC as Verizon

---
 data/provision.json | 1 +
 1 file changed, 1 insertion(+)
data/provision.json +1 -0
index 434bfd8d8f7b..50319cf33a51 100644
@@ -14266,6 +14266,7 @@
       "310010",
       "310011",
       "310012",
+      "311270",
       "311480",
       "311481",
       "311482",
Signature · 1 line
2.47.0
#1 lore raw

PATCH v2 2/4 rmnet: Default created interfaces to MTU of 1400

By default the network interface is being created with 16380 byte MTU, which is excessive for cellular links. Typically, cellular links use a maximum MTU of around 1430. Set the MTU to something more reasonable by default.

Unfortunately, the kernel does not support setting the MTU value in the original NEWLINK message. It must be set separately in a different transaction. Add support for this and make sure that cancellation logic still works.

The logic in update_new_link_ifindex() is updated to make it more defensive. Since two rtnl messages are sent (RTM_NEWLINK to create the device followed by RTM_SETLINK to set the MTU), there are now two RTM_NEWLINK events that are triggered for each item in the rmnet request. Since 'current' is incremented after RTM_NEWLINK request succeeds, there is a possibility of buffer overflow.

---
 src/rmnet.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 65 insertions(+), 9 deletions(-)
src/rmnet.c +65 -9
index 83110c33a980..42b03249da54 100644
@@ -25,6 +25,7 @@
 
 #define RMNET_TYPE "rmnet"
 #define MAX_MUX_IDS 254U
+#define DEFAULT_MTU 1400U
 
 struct rmnet_request {
 	uint32_t parent_ifindex;
@@ -195,19 +196,16 @@ next_request:
 		rmnet_start_next_request();
 }
 
-static void rmnet_new_link_cb(int error, uint16_t type, const void *data,
+static void rmnet_set_mtu_cb(int error, uint16_t type, const void *data,
 					uint32_t len, void *user_data)
 {
 	struct rmnet_request *req = l_queue_peek_head(request_q);
 
-	DBG("NEWLINK %u (%u/%u) complete, error: %d",
-		req->netlink_id, req->current + 1, req->n_interfaces, error);
+	DBG("%u (%u/%u) complete, error: %d",
+		req->netlink_id, req->current, req->n_interfaces, error);
 
 	req->netlink_id = 0;
 
-	if (!error)
-		req->current += 1;
-
 	if (error || req->canceled) {
 		__rmnet_cancel_request();
 		req->n_interfaces = 0;
@@ -229,6 +227,48 @@ next_request:
 		rmnet_start_next_request();
 }
 
+static void rmnet_new_link_cb(int error, uint16_t type, const void *data,
+					uint32_t len, void *user_data)
+{
+	struct rmnet_request *req = l_queue_peek_head(request_q);
+	uint32_t ifindex = req->infos[req->current].ifindex;
+
+	DBG("NEWLINK %u (%u/%u) complete, error: %d",
+		req->netlink_id, req->current + 1, req->n_interfaces, error);
+
+	req->netlink_id = 0;
+
+	if (!error)
+		req->current += 1;
+
+	if (error || req->canceled)
+		goto error;
+
+	/*
+	 * Unfortunately the kernel does not take IFLA_MTU into account
+	 * when creating new RMNet links, so this must be done as a separate
+	 * step.  Hopefully this is fixed one day
+	 */
+	error = -EIO;
+	req->netlink_id = l_rtnl_link_set_mtu(rtnl, ifindex, DEFAULT_MTU,
+						rmnet_set_mtu_cb, NULL, NULL);
+	if (req->netlink_id) {
+		DBG("Set MTU: interface: %u/%u, request: %u",
+			req->current, req->n_interfaces, req->netlink_id);
+		return;
+	}
+error:
+	__rmnet_cancel_request();
+	req->n_interfaces = 0;
+
+	if (req->new_cb)
+		req->new_cb(error, req->n_interfaces,
+				req->n_interfaces ? req->infos : NULL,
+				req->user_data);
+
+	rmnet_request_free(req);
+}
+
 static void rmnet_start_next_request(void)
 {
 	struct rmnet_request *req = l_queue_peek_head(request_q);
@@ -429,6 +469,7 @@ static int rmnet_parse_link(const void *data, uint32_t len,
 	bool have_linkinfo = false;
 	const char *ifname = NULL;
 	uint16_t ifnamelen = 0;
+	uint32_t mtu = 0;
 	uint16_t rta_type;
 	uint16_t rta_len;
 	const void *rta_data;
@@ -450,10 +491,16 @@ static int rmnet_parse_link(const void *data, uint32_t len,
 
 			have_linkinfo = true;
 			break;
+		case IFLA_MTU:
+			if (rta_len != sizeof(uint32_t))
+				return -EBADMSG;
+
+			mtu = l_get_u32(rta_data);
+			break;
 		}
 	}
 
-	if (!have_linkinfo || !ifname || !ifnamelen)
+	if (!have_linkinfo || !ifname || !ifnamelen || !mtu)
 		return -ENOENT;
 
 	r = rmnet_parse_info_data(&linkinfo, out_mux_id);
@@ -530,14 +577,23 @@ static void update_new_link_ifindex(uint16_t mux_id,
 {
 	struct rmnet_request *req;
 	struct rmnet_ifinfo *info;
+	unsigned int i;
 
 	req = l_queue_peek_head(request_q);
 	if (!req || req->request_type != RTM_NEWLINK)
 		return;
 
-	info = req->infos + req->current;
-	if (info->mux_id == mux_id && !strcmp(info->ifname, ifname))
+	for (i = 0; i < req->n_interfaces; i++) {
+		info = req->infos + i;
+
+		if (info->mux_id != mux_id)
+			continue;
+
+		if (strcmp(info->ifname, ifname))
+			continue;
+
 		info->ifindex = ifindex;
+	}
 }
 
 static void rmnet_link_notification(uint16_t type, const void *data,
Signature · 1 line
2.47.0
#2 lore raw

PATCH v2 3/4 qrtrqmi: Add multiple bearer support on mhi_net

In reply to Denis Kenzior

Add support for multiple simultaneous active bearers for devices that use the upstream mhi_net driver. Use the newly added rmnet module to request multiple rmnet interfaces that will sit on top of the main mhi_net interface (typically mhi_hwipX). WDA service is also requested, and the data format is setup to perform data aggregation.

For drivers that use pre-multiplexed interfaces (i.e. rmnet / IPA), migrate the pre-multiplexing logic to use rmnet_ifinfo structure.

---
 plugins/qrtrqmi.c | 213 +++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 191 insertions(+), 22 deletions(-)
plugins/qrtrqmi.c +191 -22
index 21103371046a..4a00fa45a110 100644
@@ -42,14 +42,27 @@
 
 #include <drivers/qmimodem/qmi.h>
 #include <drivers/qmimodem/dms.h>
+#include <drivers/qmimodem/wda.h>
 #include <drivers/qmimodem/util.h>
+#include <drivers/qmimodem/common.h>
+#include "src/rmnet.h"
+
+#define MAX_CONTEXTS 4
+#define DEFAULT_DL_DATAGRAMS 32
+#define DEFAULT_DL_AGGREGATION_SIZE 32768
+#define DEFAULT_UL_AGGREGATION_SIZE 16384
 
 struct qrtrqmi_data {
 	struct qmi_qrtr_node *node;
 	struct qmi_service *dms;
+	struct qmi_service *wda;
 	int main_net_ifindex;
 	char main_net_name[IFNAMSIZ];
+	struct rmnet_ifinfo rmnet_interfaces[MAX_CONTEXTS];
+	uint8_t n_premux;
+	int rmnet_id;
 	bool have_voice : 1;
+	bool soc_premux : 1;
 };
 
 static void qrtrqmi_io_debug(const char *str, void *user_data)
@@ -66,6 +79,31 @@ static void qrtrqmi_debug(const char *str, void *user_data)
 	ofono_debug("%s%s", prefix, str);
 }
 
+static int setup_soc_premux_interfaces(struct ofono_modem *modem)
+{
+	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
+	const char *interface;
+	unsigned int i;
+	char buf[256];
+	int mux_id;
+
+	for (i = 0; i < data->n_premux; i++) {
+		sprintf(buf, "PremuxInterface%dMuxId", i + 1);
+		mux_id = ofono_modem_get_integer(modem, buf);
+
+		sprintf(buf, "PremuxInterface%d", i + 1);
+		interface = ofono_modem_get_string(modem, buf);
+		if (!interface)
+			return -ENOENT;
+
+		data->rmnet_interfaces[i].mux_id = mux_id;
+		l_strlcpy(data->rmnet_interfaces[i].ifname, interface,
+				sizeof(data->rmnet_interfaces[i].ifname));
+	}
+
+	return 0;
+}
+
 /*
  * Probe the modem.  The following modem properties are expected to be set
  * in order to initialize the driver properly:
@@ -82,6 +120,15 @@ static void qrtrqmi_debug(const char *str, void *user_data)
  *
  * Bus
  *   The bus of the modem.  Values can be "embedded", or "pci"
+ *
+ * PremuxInterface{0..N}MuxId
+ *   The mux identifier of the pre-multiplexed interface (e.g. 1 for rmnet0)
+ *
+ * PremuxInterface{0..N}
+ *   The netdev name of the pre-multiplexed interface (e.g. rmnet0)
+ *
+ * NumPremuxInterfaces
+ *   The number of pre-multiplexed interfaces
  */
 static int qrtrqmi_probe(struct ofono_modem *modem)
 {
@@ -104,6 +151,9 @@ static int qrtrqmi_probe(struct ofono_modem *modem)
 	if (!if_driver || !ifname || !ifindex || !bus)
 		return -EPROTO;
 
+	if (!L_IN_STRSET(bus, "pcie", "embedded"))
+		return -ENOTSUP;
+
 	data = l_new(struct qrtrqmi_data, 1);
 	data->main_net_ifindex =
 		ofono_modem_get_integer(modem, "NetworkInterfaceIndex");
@@ -113,6 +163,22 @@ static int qrtrqmi_probe(struct ofono_modem *modem)
 	ofono_modem_set_data(modem, data);
 	ofono_modem_set_capabilities(modem, OFONO_MODEM_CAPABILITY_LTE);
 
+	data->n_premux = ofono_modem_get_integer(modem, "NumPremuxInterfaces");
+	if (data->n_premux) {
+		int err;
+
+		if (data->n_premux > MAX_CONTEXTS)
+			data->n_premux = MAX_CONTEXTS;
+
+		err = setup_soc_premux_interfaces(modem);
+		if (err) {
+			l_free(data);
+			return err;
+		}
+
+		data->soc_premux = true;
+	}
+
 	return 0;
 }
 
@@ -120,6 +186,8 @@ static void qrtrqmi_deinit(struct qrtrqmi_data *data)
 {
 	qmi_service_free(data->dms);
 	data->dms = NULL;
+	qmi_service_free(data->wda);
+	data->wda = NULL;
 	qmi_qrtr_node_free(data->node);
 	data->node = NULL;
 }
@@ -132,13 +200,109 @@ static void qrtrqmi_remove(struct ofono_modem *modem)
 
 	ofono_modem_set_data(modem, NULL);
 
+	if (data->rmnet_id) {
+		rmnet_cancel(data->rmnet_id);
+		data->rmnet_id = 0;
+	}
+
 	qrtrqmi_deinit(data);
 	l_free(data);
 }
 
+static void rmnet_get_interfaces_cb(int error, unsigned int n_interfaces,
+					const struct rmnet_ifinfo *interfaces,
+					void *user_data)
+{
+	struct ofono_modem *modem = user_data;
+	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
+	unsigned int i;
+
+	DBG("error: %d, n_interfaces: %u", error, n_interfaces);
+	data->rmnet_id = 0;
+
+	if (error)
+		goto error;
+
+	DBG("RMNet interfaces created:");
+	for (i = 0; i < n_interfaces; i++)
+		DBG("\t%s[%d], mux_id: %u",
+			interfaces[i].ifname, interfaces[i].ifindex,
+			interfaces[i].mux_id);
+
+	memcpy(data->rmnet_interfaces, interfaces,
+			sizeof(struct rmnet_ifinfo) * n_interfaces);
+	data->n_premux = n_interfaces;
+	ofono_modem_set_powered(modem, TRUE);
+	return;
+error:
+	qrtrqmi_deinit(data);
+	ofono_modem_set_powered(modem, FALSE);
+}
+
+static void set_data_format_cb(struct qmi_result *result, void *user_data)
+{
+	struct ofono_modem *modem = user_data;
+	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
+	struct qmi_wda_data_format format;
+	int r;
+
+	DBG("");
+
+	if (qmi_result_set_error(result, NULL))
+		goto error;
+
+	r = qmi_wda_parse_data_format(result, &format);
+	if (r < 0)
+		goto error;
+
+	DBG("DL Aggregation Size: %u", format.dl_max_size);
+	DBG("DL Max Datagrams: %u", format.dl_max_datagrams);
+	DBG("DL Aggregation Protocol: %u", format.dl_aggregation_protocol);
+	DBG("UL Aggregation Protocol: %u", format.ul_aggregation_protocol);
+
+	data->rmnet_id = rmnet_get_interfaces(data->main_net_ifindex,
+						MAX_CONTEXTS,
+						rmnet_get_interfaces_cb,
+						modem, NULL);
+	if (data->rmnet_id > 0)
+		return;
+
+	ofono_error("Unable to request RMNet interfaces");
+error:
+	qrtrqmi_deinit(data);
+	ofono_modem_set_powered(modem, FALSE);
+}
+
+static void setup_data_format(struct ofono_modem *modem)
+{
+	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
+	struct qmi_endpoint_info endpoint_info = {
+		.endpoint_type = QMI_DATA_ENDPOINT_TYPE_PCIE,
+		.interface_number = 0x04,
+	};
+	struct qmi_wda_data_format format = {
+		.ll_protocol = QMI_WDA_DATA_LINK_PROTOCOL_RAW_IP,
+		.dl_aggregation_protocol = QMI_WDA_AGGREGATION_PROTOCOL_QMAPV5,
+		.ul_aggregation_protocol = QMI_WDA_AGGREGATION_PROTOCOL_QMAPV5,
+		.dl_max_datagrams = DEFAULT_DL_DATAGRAMS,
+		.dl_max_size = DEFAULT_DL_AGGREGATION_SIZE,
+	};
+
+	DBG("%p", modem);
+
+	data->wda = qmi_qrtr_node_get_service(data->node, QMI_SERVICE_WDA);
+	if (qmi_wda_set_data_format(data->wda, &endpoint_info, &format,
+					set_data_format_cb, modem, NULL) > 0)
+		return;
+
+	qrtrqmi_deinit(data);
+	ofono_modem_set_powered(modem, FALSE);
+}
+
 static void power_reset_cb(struct qmi_result *result, void *user_data)
 {
 	struct ofono_modem *modem = user_data;
+	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
 
 	DBG("");
 
@@ -148,6 +312,11 @@ static void power_reset_cb(struct qmi_result *result, void *user_data)
 		return;
 	}
 
+	if (!data->soc_premux) {
+		setup_data_format(modem);
+		return;
+	}
+
 	ofono_modem_set_powered(modem, TRUE);
 }
 
@@ -177,7 +346,11 @@ static void get_oper_mode_cb(struct qmi_result *result, void *user_data)
 
 		break;
 	default:
-		ofono_modem_set_powered(modem, TRUE);
+		if (!data->soc_premux)
+			setup_data_format(modem);
+		else
+			ofono_modem_set_powered(modem, TRUE);
+
 		return;
 	}
 
@@ -199,6 +372,10 @@ static void lookup_done(void *user_data)
 			!qmi_qrtr_node_has_service(node, QMI_SERVICE_NAS))
 		goto error;
 
+	if (!data->soc_premux &&
+			!qmi_qrtr_node_has_service(node, QMI_SERVICE_WDA))
+		goto error;
+
 	data->dms = qmi_qrtr_node_get_service(node, QMI_SERVICE_DMS);
 	if (qmi_service_send(data->dms, QMI_DMS_GET_OPER_MODE, NULL,
 					get_oper_mode_cb, modem, NULL) > 0)
@@ -236,10 +413,18 @@ static int qrtrqmi_enable(struct ofono_modem *modem)
 static void power_disable_cb(struct qmi_result *result, void *user_data)
 {
 	struct ofono_modem *modem = user_data;
+	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
 
 	DBG("");
 
-	qrtrqmi_deinit(ofono_modem_get_data(modem));
+	if (!data->soc_premux) {
+		rmnet_del_interfaces(data->n_premux, data->rmnet_interfaces);
+		data->n_premux = 0;
+		memset(data->rmnet_interfaces, 0,
+				sizeof(data->rmnet_interfaces));
+	}
+
+	qrtrqmi_deinit(data);
 	ofono_modem_set_powered(modem, FALSE);
 }
 
@@ -346,11 +531,8 @@ static void setup_gprs(struct ofono_modem *modem)
 {
 	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
 	struct qmi_qrtr_node *node = data->node;
-	int n_premux = ofono_modem_get_integer(modem, "NumPremuxInterfaces");
 	struct ofono_gprs *gprs;
-	const char *interface;
-	char buf[256];
-	int i;
+	unsigned int i;
 
 	gprs = ofono_gprs_create(modem, 0, "qmimodem",
 			qmi_qrtr_node_get_service(node, QMI_SERVICE_WDS),
@@ -361,23 +543,10 @@ static void setup_gprs(struct ofono_modem *modem)
 		return;
 	}
 
-	/* Upstream driver default, single interface, single context */
-	if (!n_premux) {
-		interface = ofono_modem_get_string(modem, "NetworkInterface");
-		setup_gprs_context(0, interface, gprs);
-		return;
-	}
-
-	for (i = 0; i < n_premux; i++) {
-		int mux_id;
-
-		sprintf(buf, "PremuxInterface%dMuxId", i + 1);
-		mux_id = ofono_modem_get_integer(modem, buf);
-
-		sprintf(buf, "PremuxInterface%d", i + 1);
-		interface = ofono_modem_get_string(modem, buf);
+	for (i = 0; i < data->n_premux; i++) {
+		struct rmnet_ifinfo *ifinfo = data->rmnet_interfaces + i;
 
-		setup_gprs_context(mux_id, interface, gprs);
+		setup_gprs_context(ifinfo->mux_id, ifinfo->ifname, gprs);
 	}
 }
 
Signature · 1 line
2.47.0
#3 lore raw

PATCH v2 4/4 qrtrqmi: Manage main netdev as part of .set_online

In reply to Denis Kenzior

The mhi_hwipX interface is created with IFF_UP not set. It must be set IFF_UP when the modem is brought into online state, otherwise packets will not flow properly. Similarly, when bring the modem into offline state, bring down the main network device for consistency.

---
 plugins/qrtrqmi.c | 73 +++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 65 insertions(+), 8 deletions(-)
plugins/qrtrqmi.c +65 -8
index 4a00fa45a110..27d071aa8284 100644
@@ -61,6 +61,7 @@ struct qrtrqmi_data {
 	struct rmnet_ifinfo rmnet_interfaces[MAX_CONTEXTS];
 	uint8_t n_premux;
 	int rmnet_id;
+	uint32_t set_powered_id;
 	bool have_voice : 1;
 	bool soc_premux : 1;
 };
@@ -206,6 +207,12 @@ static void qrtrqmi_remove(struct ofono_modem *modem)
 	}
 
 	qrtrqmi_deinit(data);
+
+	if (data->set_powered_id) {
+		l_netlink_cancel(l_rtnl_get(), data->set_powered_id);
+		data->set_powered_id = 0;
+	}
+
 	l_free(data);
 }
 
@@ -460,25 +467,75 @@ static void set_online_cb(struct qmi_result *result, void *user_data)
 		CALLBACK_WITH_SUCCESS(cb, cbd->data);
 }
 
-static void qrtrqmi_set_online(struct ofono_modem *modem, ofono_bool_t online,
-				ofono_modem_online_cb_t cb, void *user_data)
+static void powered_common_cb(int error, bool online, struct cb_data *cbd)
 {
-	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
-	struct cb_data *cbd = cb_data_new(cb, user_data);
+	struct qrtrqmi_data *data = cbd->user;
 	struct qmi_param *param;
+	ofono_modem_online_cb_t cb = cbd->cb;
 
-	DBG("%p %s", modem, online ? "online" : "offline");
+	data->set_powered_id = 0;
+
+	if (error)
+		goto error;
 
 	param = qmi_param_new_uint8(QMI_DMS_PARAM_OPER_MODE,
 					online ? QMI_DMS_OPER_MODE_ONLINE :
 						QMI_DMS_OPER_MODE_LOW_POWER);
 
-	if (qmi_service_send(data->dms, QMI_DMS_SET_OPER_MODE, param,
-				set_online_cb, cbd, l_free) > 0)
+	if (qmi_service_send(data->dms, QMI_DMS_SET_OPER_MODE,
+					param, set_online_cb,
+					cb_data_ref(cbd), cb_data_unref) > 0)
 		return;
 
 	qmi_param_free(param);
-	l_free(cbd);
+	cb_data_unref(cbd);
+error:
+	CALLBACK_WITH_FAILURE(cb, cbd->data);
+}
+
+static void powered_up_cb(int error, uint16_t type, const void *msg,
+				uint32_t len, void *user_data)
+{
+	struct cb_data *cbd = user_data;
+
+	DBG("error: %d: %s", error, strerror(-error));
+	powered_common_cb(error, true, cbd);
+}
+
+static void powered_down_cb(int error, uint16_t type, const void *msg,
+				uint32_t len, void *user_data)
+{
+	struct cb_data *cbd = user_data;
+
+	DBG("error: %d: %s", error, strerror(-error));
+	powered_common_cb(error, false, cbd);
+}
+
+static void qrtrqmi_set_online(struct ofono_modem *modem, ofono_bool_t online,
+				ofono_modem_online_cb_t cb, void *user_data)
+{
+	struct qrtrqmi_data *data = ofono_modem_get_data(modem);
+	struct l_netlink *rtnl = l_rtnl_get();
+	struct cb_data *cbd = cb_data_new(cb, user_data);
+	l_netlink_command_func_t powered_cb;
+
+	DBG("%p %s", modem, online ? "online" : "offline");
+
+	cbd->user = data;
+
+	if (online)
+		powered_cb = powered_up_cb;
+	else
+		powered_cb = powered_down_cb;
+
+	data->set_powered_id = l_rtnl_set_powered(rtnl, data->main_net_ifindex,
+							online, powered_cb,
+							cbd, cb_data_unref);
+	if (data->set_powered_id)
+		return;
+
+	cb_data_unref(cbd);
+	CALLBACK_WITH_FAILURE(cb, user_data);
 }
 
 static void qrtrqmi_pre_sim(struct ofono_modem *modem)
Signature · 1 line
2.47.0
#4 lore raw
In reply to Denis Kenzior
This series was applied to ofono.git (master) by Denis Kenzior <[email protected]>:

Hello:

This series was applied to ofono.git (master)
by Denis Kenzior <[email protected]>:

Quoted 3 lines · On Wed, 27 Nov 2024 15:31:48 -0600 you wrote:
---
 data/provision.json | 1 +
 1 file changed, 1 insertion(+)

Here is the summary with links:
- [v2,1/4] provision: Add 311 270 MCC/MNC as Verizon

    https://git.kernel.org/pub/scm/network/ofono/ofono.git/?id=e2fd4487c346
  - [v2,2/4] rmnet: Default created interfaces to MTU of 1400
    https://git.kernel.org/pub/scm/network/ofono/ofono.git/?id=470a2b96d233
  - [v2,3/4] qrtrqmi: Add multiple bearer support on mhi_net
    https://git.kernel.org/pub/scm/network/ofono/ofono.git/?id=83155e3c747a
  - [v2,4/4] qrtrqmi: Manage main netdev as part of .set_online
    https://git.kernel.org/pub/scm/network/ofono/ofono.git/?id=571a6aefa39f

You are awesome, thank you!

Signature · 2 lines
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html