wlan-ap-Telecominfraproject/feeds/qca/iw/patches/618-02-wifi-iw-Add-the-SDWF-functionalities-back.patch

From b65dc9557ed05ce4577476257c57639bd44a3d30 Mon Sep 17 00:00:00 2001
From: Nagarajan Maran <quic_nmaran@quicinc.com>
Date: Wed, 27 Dec 2023 16:43:52 +0530
Subject: [PATCH] wifi: iw: Add the SDWF functionalities back with the approved
 identifiers.

With the new approved subcmd enum values in hostap.git for SDWF,
rewrite the SDWF vendor commands handling.

Signed-off-by: Nagarajan Maran <quic_nmaran@quicinc.com>
---
 defqmap.c    |  95 +++++++++++++++-
 iw.h         | 183 ++++++++++++++++++++++++++++++
 sawf.c       | 313 +++++++++++++++++++++++++++++++++++++++++++++++++--
 sawf_stats.c |  59 +++++++++-
 telemetry.c  | 215 ++++++++++++++++++++++++++++++++---
 5 files changed, 837 insertions(+), 28 deletions(-)

--- a/defqmap.c
+++ b/defqmap.c
@@ -40,7 +40,40 @@ static int handle_default_q_map_req(stru
 				struct nl_msg *msg, int argc, char **argv,
 				enum id_input id)
 {
-	return 0;
+	struct nlattr *sdwf_params, *def_q_params;
+	char *end;
+	unsigned long value;
+	char macaddr[MAC_ADDR_LEN] = {0};
+
+	if (argc < 2 || argc > 2 || (argc%2) != 0)
+		goto err;
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_DEV_OPS);
+
+	sdwf_params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!sdwf_params)
+		return -ENOBUFS;
+
+	errno = 0;
+	value = strtoul(argv[0], &end, 10);
+	if (*end != '\0' || value > MAX_RANGE(uint8_t) || errno == ERANGE)
+		goto err;
+
+	strlcpy(macaddr, argv[1], MAC_ADDR_LEN);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_OPERATION, QCA_WLAN_VENDOR_SDWF_DEV_OPER_DEF_Q_MAP);
+	def_q_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_DEF_Q_PARAMS);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_SVC_ID, value);
+	nla_put(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_MAC_ADDR, MAC_ADDR_LEN, macaddr);
+
+	nla_nest_end(msg, def_q_params);
+	nla_nest_end(msg, sdwf_params);
+	return NL_OK;
+err:
+	return -EINVAL;
 }
 
 COMMAND(defqmap, map, "<service_id> <macaddr>", NL80211_CMD_VENDOR, 0, CIB_NETDEV, handle_default_q_map_req, ".");
@@ -49,7 +82,40 @@ static int handle_default_q_unmap_req(st
 				struct nl_msg *msg, int argc, char **argv,
 				enum id_input id)
 {
-	return 0;
+	struct nlattr *sdwf_params, *def_q_params;
+	char *end;
+	unsigned long value;
+	char macaddr[MAC_ADDR_LEN] = {0};
+
+	if (argc < 2 || argc > 2 || (argc%2) != 0)
+		goto err;
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_DEV_OPS);
+
+	sdwf_params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!sdwf_params)
+		return -ENOBUFS;
+
+	errno = 0;
+	value = strtoul(argv[0], &end, 10);
+	if (*end != '\0' || value > MAX_RANGE(uint8_t) || errno == ERANGE)
+		goto err;
+
+	strlcpy(macaddr, argv[1], MAC_ADDR_LEN);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_OPERATION, QCA_WLAN_VENDOR_SDWF_DEV_OPER_DEF_Q_UNMAP);
+	def_q_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_DEF_Q_PARAMS);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_SVC_ID, value);
+	nla_put(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_MAC_ADDR, MAC_ADDR_LEN, macaddr);
+
+	nla_nest_end(msg, def_q_params);
+	nla_nest_end(msg, sdwf_params);
+	return NL_OK;
+err:
+	return -EINVAL;
 }
 
 COMMAND(defqmap, unmap, "<service_id> <macaddr>", NL80211_CMD_VENDOR, 0, CIB_NETDEV, handle_default_q_unmap_req, ".");
@@ -58,7 +124,32 @@ static int handle_default_q_map_report(s
 				struct nl_msg *msg, int argc, char **argv,
 				enum id_input id)
 {
+	struct nlattr *sdwf_params, *def_q_params;
+	char macaddr[MAC_ADDR_LEN] = {0};
+
+	if (argc < 1 || argc > 1)
+		goto err;
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_DEV_OPS);
+
+	sdwf_params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!sdwf_params)
+		return -ENOBUFS;
+
+	errno = 0;
+	strlcpy(macaddr, argv[0], MAC_ADDR_LEN);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_OPERATION, QCA_WLAN_VENDOR_SDWF_DEV_OPER_DEF_Q_MAP_GET);
+	def_q_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_DEF_Q_PARAMS);
+	nla_put(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_MAC_ADDR, MAC_ADDR_LEN, macaddr);
+
+	nla_nest_end(msg, def_q_params);
+	nla_nest_end(msg, sdwf_params);
 	return 0;
+err:
+	return -EINVAL;
 }
 
 COMMAND(defqmap, report, "<macaddr>", NL80211_CMD_VENDOR, 0, CIB_NETDEV, handle_default_q_map_report, ".");
--- a/iw.h
+++ b/iw.h
@@ -70,6 +70,8 @@ enum id_input {
 };
 
 enum qca_nl80211_vendor_subcmds {
+	QCA_NL80211_VENDOR_SUBCMD_SDWF_PHY_OPS = 235,
+	QCA_NL80211_VENDOR_SUBCMD_SDWF_DEV_OPS = 236,
 	QCA_NL80211_VENDOR_SUBCMD_TELEMETRY_GETSTATS = 334,
 };
 /* Attributes for data used by
@@ -85,6 +87,187 @@ enum qca_wlan_vendor_attr_config {
 		QCA_WLAN_VENDOR_ATTR_CONFIG_AFTER_LAST - 1,
 };
 
+enum qca_wlan_vendor_attr_sdwf_phy {
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_OPERATION = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SVC_PARAMS = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SLA_SAMPLES_PARAMS = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SLA_DETECT_PARAMS = 4,
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SLA_THRESHOLD_PARAMS = 5,
+
+	/* keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_PHY_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_sdwf_phy_oper {
+	QCA_WLAN_VENDOR_SDWF_PHY_OPER_SVC_SET = 0,
+	QCA_WLAN_VENDOR_SDWF_PHY_OPER_SVC_DEL = 1,
+	QCA_WLAN_VENDOR_SDWF_PHY_OPER_SVC_GET = 2,
+	QCA_WLAN_VENDOR_SDWF_PHY_OPER_SLA_SAMPLES_SET = 3,
+	QCA_WLAN_VENDOR_SDWF_PHY_OPER_SLA_BREACH_DETECTION_SET = 4,
+	QCA_WLAN_VENDOR_SDWF_PHY_OPER_SLA_THRESHOLD_SET = 5,
+};
+
+enum qca_wlan_vendor_attr_sdwf_svc {
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_ID = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MIN_TP = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX_TP = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_BURST_SIZE = 4,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_INTERVAL = 5,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_DELAY_BOUND = 6,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_TTL = 7,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_PRIO = 8,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TID = 9,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_RATE_LOSS = 10,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_SVC_INTERVAL = 11,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MIN_TPUT = 12,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MAX_LATENCY = 13,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_BURST_SIZE = 14,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_OFDMA_DISABLE = 15,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MU_MIMO_DISABLE = 16,
+	/* The below are used by MCC */
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_BUFFER_LATENCY_TOLERANCE = 17,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TX_TRIGGER_DSCP = 18,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TX_REPLACE_DSCP = 19,
+
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_SVC_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_attr_sdwf_sla_samples {
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_MOVING_AVG_PKT = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_MOVING_AVG_WIN = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_SLA_NUM_PKT = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_SLA_TIME_SEC = 4,
+
+	/* keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_attr_sdwf_sla_detect {
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_PARAM = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MIN_TP = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MAX_TP = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_BURST_SIZE = 4,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_INTERVAL = 5,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_DELAY_BOUND = 6,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MSDU_TTL = 7,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MSDU_RATE_LOSS = 8,
+
+	/* keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_sdwf_sla_detect_param {
+	QCA_WLAN_VENDOR_SDWF_SLA_DETECT_PARAM_NUM_PACKET,
+	QCA_WLAN_VENDOR_SDWF_SLA_DETECT_PARAM_PER_SECOND,
+	QCA_WLAN_VENDOR_SDWF_SLA_DETECT_PARAM_MOV_AVG,
+	QCA_WLAN_VENDOR_SDWF_SLA_DETECT_PARAM_NUM_SECOND,
+	QCA_WLAN_VENDOR_SDWF_SLA_DETECT_PARAM_MAX,
+};
+
+enum qca_wlan_vendor_attr_sdwf_sla_threshold {
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_SVC_ID = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MIN_TP = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MAX_TP = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_BURST_SIZE = 4,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_INTERVAL = 5,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_DELAY_BOUND = 6,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MSDU_TTL = 7,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MSDU_RATE_LOSS = 8,
+
+	/* keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_attr_sdwf_dev {
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_OPERATION = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_DEF_Q_PARAMS = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_STREAMING_STATS_PARAMS = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_RESET_STATS = 4,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_SLA_BREACHED_PARAMS = 5,
+
+	/* keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEV_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_sdwf_dev_oper {
+	QCA_WLAN_VENDOR_SDWF_DEV_OPER_DEF_Q_MAP = 0,
+	QCA_WLAN_VENDOR_SDWF_DEV_OPER_DEF_Q_UNMAP = 1,
+	QCA_WLAN_VENDOR_SDWF_DEV_OPER_DEF_Q_MAP_GET = 2,
+	QCA_WLAN_VENDOR_SDWF_DEV_OPER_STREAMING_STATS = 3,
+	QCA_WLAN_VENDOR_SDWF_DEV_OPER_RESET_STATS = 4,
+	QCA_WLAN_VENDOR_SDWF_DEV_OPER_BREACH_DETECTED = 5,
+};
+
+enum qca_wlan_vendor_attr_sdwf_def_q_map {
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_SVC_ID = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_MAC_ADDR = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_TID = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_STATUS = 4,
+
+	/* keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_DEF_Q_MAP_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_attr_sdwf_streaming_stats {
+	QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_BASIC_STATS = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_EXTND_STATS = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_MLO_LINK_ID = 3,
+
+	/* keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_AFTER_LAST - 1,
+};
+
+enum qca_wlan_vendor_attr_sdwf_sla_breach_param {
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_INVALID = 0,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_PEER_MAC = 1,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_SVC_ID = 2,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_TYPE = 3,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_SET_CLEAR = 4,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_PEER_MLD_MAC = 5,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_AC = 6,
+
+	/* Keep last */
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_AFTER_LAST,
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_MAX =
+	QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_AFTER_LAST - 1
+};
+
+enum qca_wlan_vendor_sdwf_sla_breach_type {
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_INVALID = 0,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_MIN_THROUGHPUT,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_MAX_THROUGHPUT,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_BURST_SIZE,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_SERVICE_INTERVAL,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_DELAY_BOUND,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_MSDU_TTL,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_MSDU_LOSS,
+	QCA_WLAN_VENDOR_SDWF_SLA_BREACH_PARAM_TYPE_MAX,
+};
+
 #define HANDLER_RET_USAGE 1
 #define HANDLER_RET_DONE 3
 
--- a/sawf.c
+++ b/sawf.c
@@ -34,15 +34,10 @@
 #define MAX_OPTIONAL_STRINGS 15
 #define MAX_STRING_SIZE 60
 #define MAX_RANGE(type) pow(2, 8 * sizeof(type)) - 1
-#define SVC_CREATE_MIN_ARGUMENTS 2
-#define SVC_CREATE_MAX_ARGUMENTS 32
+#define SVC_CREATE_MIN_ARGUMENTS 1
+#define SVC_CREATE_MAX_ARGUMENTS 31
 #define SVC_DISABLE_MAX_ARGUMENTS 1
 #define SVC_VIEW_MAX_ARGUMENTS 1
-#define APP_NAME_MAX_BYTES       64
-
-struct sawf_disable_param {
-	uint8_t svc_id;
-};
 
 SECTION(service_class);
 
@@ -50,10 +45,142 @@ static int handle_service_class_create(s
 				       struct nl_msg *msg, int argc,
 				       char **argv, enum id_input id)
 {
-	return 0;
+	struct nlattr *sdwf_params, *svc_params;
+	int parsed = 0, param_count;
+	char *end;
+	unsigned long value;
+	char service_check[MAX_OPTIONAL_STRINGS][MAX_STRING_SIZE] = {"min_tput",
+								     "max_tput",
+								     "burst_size",
+								     "service_interval",
+								     "delay_bound",
+								     "msdu_ttl",
+								     "priority",
+								     "tid",
+								     "msdu_loss",
+								     "ul_service_interval",
+								     "ul_min_tput",
+								     "ul_max_latency",
+								     "ul_burst_size",
+								     "ul_ofdma_disable",
+								     "ul_mu_mimo_disable"};
+
+	if (argc < SVC_CREATE_MIN_ARGUMENTS || argc > SVC_CREATE_MAX_ARGUMENTS ||
+	    (argc % SVC_CREATE_MIN_ARGUMENTS) != 0)
+		goto err;
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_PHY_OPS);
+
+	sdwf_params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!sdwf_params)
+		return -ENOBUFS;
+
+	errno = 0;
+	value = strtoul(argv[0], &end, 10);
+	if (*end != '\0' || value > MAX_RANGE(uint8_t) || errno == ERANGE)
+		goto err;
+
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_OPERATION, QCA_WLAN_VENDOR_SDWF_PHY_OPER_SVC_SET);
+	svc_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SVC_PARAMS);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_ID, value);
+	parsed += 1;
+
+	for (errno = 0; parsed < argc; parsed += 2, errno = 0) {
+		value = strtoul(argv[parsed + 1], &end, 10);
+		if (*end != '\0' || value > MAX_RANGE(uint32_t) || errno == ERANGE)
+			goto err;
+
+		for (param_count = 0; param_count < MAX_OPTIONAL_STRINGS;
+		     param_count++) {
+			if (!strcmp(argv[parsed], service_check[param_count]))
+				break;
+		}
+
+		if (param_count == MAX_OPTIONAL_STRINGS)
+			goto err;
+
+		switch (param_count + QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MIN_TP) {
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MIN_TP:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MIN_TP, value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX_TP:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX_TP, value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_BURST_SIZE:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_BURST_SIZE, value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_INTERVAL:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_INTERVAL, value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_DELAY_BOUND:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_DELAY_BOUND,
+				    value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_TTL:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_TTL, value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_PRIO:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_PRIO, value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TID:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TID, value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_RATE_LOSS:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_RATE_LOSS,
+				    value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_SVC_INTERVAL:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_SVC_INTERVAL,
+				    value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MIN_TPUT:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MIN_TPUT,
+				    value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MAX_LATENCY:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MAX_LATENCY,
+				    value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_BURST_SIZE:
+			nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_BURST_SIZE,
+				    value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_OFDMA_DISABLE:
+			nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_OFDMA_DISABLE,
+				    value);
+			break;
+		case QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MU_MIMO_DISABLE:
+			nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MU_MIMO_DISABLE,
+				    value);
+			break;
+		}
+	}
+
+	nla_nest_end(msg, svc_params);
+	nla_nest_end(msg, sdwf_params);
+	return NL_OK;
+err:
+	printf("Invalid SDWF service class command format: Usage\n");
+	printf("\t iw phy <phyname> service_class create <service_id> ");
+	printf("[min_tput <min_thruput_rate>] [max_tput <max_thruput_rate>] ");
+	printf("[burst_size <burst_size>] [service_interval <service_interval>] ");
+	printf("[delay_bound <delay_bound>] [msdu_ttl <msdu_ttl>] ");
+	printf("[priority <priority>] [tid <tid>] [msdu_loss <msdu_rate_loss>]\n");
+	printf("[ul_service_interval <ul_service_interval>]\n");
+	printf("[ul_min_tput <ul_min_tput>]\n");
+	printf("[ul_max_latency <ul_max_latency>]\n");
+	printf("[ul_burst_size <ul_burst_size>]\n");
+	printf("[ul_ofdma_disable <ul_ofdma_disable>]\n");
+	printf("[ul_mu_mimo_disable <ul_mu_mimo_disable>]\n");
+
+	return -EINVAL;
 }
 
-COMMAND(service_class, create, "<service_id> <app_name> [min_tput <min_thruput_rate>]"
+COMMAND(service_class, create, "<service_id> [min_tput <min_thruput_rate>]"
 	" [max_tput <max_thruput_rate>] [burst_size <burst_size>]"
 	" [service_interval <service_interval>] [delay_bound <delay_bound>]"
 	" [msdu_ttl <msdu_ttl>] [priority <priority>] [tid <tid>]"
@@ -68,14 +195,139 @@ static int handle_service_class_disable(
 					struct nl_msg *msg, int argc,
 					char **argv, enum id_input id)
 {
-	return 0;
+	struct nlattr *sdwf_params, *svc_params;
+	unsigned long value;
+	char *end;
+
+	if (argc != SVC_DISABLE_MAX_ARGUMENTS)
+		goto err;
+
+	errno = 0;
+	value = strtoul(argv[0], &end, 10);
+	if (*end != '\0' || value > MAX_RANGE(uint8_t) || errno == ERANGE)
+		goto err;
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_PHY_OPS);
+
+	sdwf_params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!sdwf_params)
+		return -ENOBUFS;
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_OPERATION, QCA_WLAN_VENDOR_SDWF_PHY_OPER_SVC_DEL);
+	svc_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SVC_PARAMS);
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_ID, value);
+
+	nla_nest_end(msg, svc_params);
+	nla_nest_end(msg, sdwf_params);
+	return NL_OK;
+
+err:
+	printf("Invalid SDWF service class command format: Usage\n");
+	printf("\t iw phy <phyname> service_class disable <service_id>\n");
+	return -EINVAL;
 }
 
 COMMAND(service_class, disable, "<service_id>", NL80211_CMD_VENDOR, 0, CIB_PHY,
 	handle_service_class_disable, ".");
 
-static int print_sawf_service_classes(struct nl_msg *msg, void *arg)
+static int print_sdwf_service_classes(struct nl_msg *msg, void *arg)
 {
+	struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
+	struct nlattr *sdwf_service_classes;
+	struct nlattr *sdwf_service_class;
+	struct nlattr *attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX + 1];
+	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
+	int sdwf_service_classes_len = 0;
+	static struct nla_policy sdwf_policy[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX + 1] = {
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_ID] = {.type = NLA_U8},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MIN_TP] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX_TP] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_BURST_SIZE] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_INTERVAL] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_DELAY_BOUND] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_TTL] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_PRIO] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TID] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_RATE_LOSS] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_SVC_INTERVAL] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MIN_TPUT] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MAX_LATENCY] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_BURST_SIZE] = {.type = NLA_U32},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_OFDMA_DISABLE] = {.type = NLA_U8},
+		[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MU_MIMO_DISABLE] = {.type = NLA_U8},
+	};
+
+	nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
+		  genlmsg_attrlen(gnlh, 0), NULL);
+
+	if (tb_msg[NL80211_ATTR_VENDOR_DATA]) {
+		sdwf_service_classes = nla_data(tb_msg[NL80211_ATTR_VENDOR_DATA]);
+		sdwf_service_classes_len = nla_len(tb_msg[NL80211_ATTR_VENDOR_DATA]);
+	}
+	else
+		return NL_SKIP;
+
+	if (nla_type(sdwf_service_classes) != QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SVC_PARAMS)
+		return NL_SKIP;
+
+	nla_for_each_nested(sdwf_service_class, sdwf_service_classes,
+			    sdwf_service_classes_len) {
+		nla_parse_nested(attrs,
+				 QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX,
+				 sdwf_service_class, sdwf_policy);
+
+		printf("***********************************\n");
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_ID])
+			printf("Service ID\t: %u\n",
+			       nla_get_u8(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_ID]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MIN_TP])
+			printf("Min throughput\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MIN_TP]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX_TP])
+			printf("Max throughput\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MAX_TP]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_BURST_SIZE])
+			printf("Burst Size\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_BURST_SIZE]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_INTERVAL])
+			printf("Service Interval: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_INTERVAL]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_DELAY_BOUND])
+			printf("Delay Bound\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_DELAY_BOUND]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_TTL])
+			printf("MSDU TTL\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_TTL]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_PRIO])
+			printf("Priority\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_PRIO]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TID])
+			printf("TID\t\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_TID]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_RATE_LOSS])
+			printf("MSDU Loss Rate\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_MSDU_RATE_LOSS]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_SVC_INTERVAL]) 
+			printf("UL service interval\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_SVC_INTERVAL]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MIN_TPUT])
+			printf("UL min throughput\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MIN_TPUT]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MAX_LATENCY])
+			printf("UL max latency\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MAX_LATENCY]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_BURST_SIZE])
+			printf("UL burst size\t: %u\n",
+			       nla_get_u32(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_BURST_SIZE]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_OFDMA_DISABLE])
+			printf("UL ofdma disable\t: %u\n",
+			       nla_get_u8(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_OFDMA_DISABLE]));
+		if (attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MU_MIMO_DISABLE])
+			printf("UL mu mimo disable\t: %u\n",
+			       nla_get_u8(attrs[QCA_WLAN_VENDOR_ATTR_SDWF_SVC_UL_MU_MIMO_DISABLE]));
+	}
 	return NL_SKIP;
 }
 
@@ -83,7 +335,44 @@ static int handle_service_class_dump(str
 				     struct nl_msg *msg, int argc,
 				     char **argv, enum id_input id)
 {
-	return 0;
+	struct nlattr *sdwf_params, *svc_params;
+	unsigned long value = 0;
+	char *end;
+
+	if (argc > SVC_VIEW_MAX_ARGUMENTS) {
+		goto err;
+	}
+	else if (argc == SVC_VIEW_MAX_ARGUMENTS) {
+		errno = 0;
+		value = strtoul(argv[0], &end, 10);
+		if (*end != '\0' || value > MAX_RANGE(uint8_t) || errno == ERANGE)
+			goto err;
+	}
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_PHY_OPS);
+
+	sdwf_params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!sdwf_params)
+		return -ENOBUFS;
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_OPERATION, QCA_WLAN_VENDOR_SDWF_PHY_OPER_SVC_GET);
+
+	if (argc) {
+		svc_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SVC_PARAMS);
+		nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SVC_ID, value);
+		nla_nest_end(msg, svc_params);
+	}
+
+	nla_nest_end(msg, sdwf_params);
+
+	register_handler(print_sdwf_service_classes, NULL);
+	return NL_OK;
+err:
+	printf("Invalid SDWF service class command format: Usage\n");
+	printf("\t iw phy <phyname> service_class view [<service_id>]\n");
+	return -EINVAL;
 }
 
 COMMAND(service_class, view, "[<service_id>]", NL80211_CMD_VENDOR, NLM_F_DUMP, CIB_PHY,
--- a/sawf_stats.c
+++ b/sawf_stats.c
@@ -44,7 +44,64 @@ static int handle_streaming_stats(struct
 				  struct nl_msg *msg, int argc, char **argv,
 				  enum id_input id)
 {
-	return 0;
+	struct nlattr *stats, *streaming;
+	unsigned long value;
+	uint8_t basic_stats = 0, extnd_stats = 0, link_id;
+	char *end;
+
+	if (argc < STREAMING_STATS_MIN_ARGUMENTS ||
+	    argc > STREAMING_STATS_MAX_ARGUMENTS)
+		goto err;
+
+	errno = 0;
+	value = strtoul(argv[0], &end, 10);
+	if (*end != '\0' || value > STREAMING_STATS_MAX_VALUE || errno == ERANGE)
+		goto err;
+	argc--;
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_DEV_OPS);
+
+	stats = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!stats)
+		return -ENOBUFS;
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_OPERATION, QCA_WLAN_VENDOR_SDWF_DEV_OPER_STREAMING_STATS);
+	streaming = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_STREAMING_STATS_PARAMS);
+
+	if (value & STREAMING_STATS_BASIC_EN_EXTND_DIS)
+		basic_stats = 1;
+	if (value & STREAMING_STATS_BASIC_DIS_EXTND_EN)
+		extnd_stats = 1;
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_BASIC_STATS, basic_stats);
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_STREAMING_EXTND_STATS, extnd_stats);
+
+	if (argc) {
+		argc--;
+		if (strcmp(argv[1], "-l") || !argc)
+			goto err;
+		errno = 0;
+		link_id = strtoul(argv[2], &end, 10);
+		if (*end != '\0' || value > MAX_MLD_LINK || errno == ERANGE) {
+			goto err;
+		}
+		nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_MLO_LINK_ID, link_id);
+	}
+
+	nla_nest_end(msg, streaming);
+	nla_nest_end(msg, stats);
+	return NL_OK;
+
+err:
+	printf("Invalid SDWF streaming stats command format: Usage\n");
+	printf("iw dev <devname> streaming_stats handle <value> [-l <link_id>]\n");
+	printf("\t value: 0 - Disable both Basic and Extended stats\n");
+	printf("\t value: 1 - Enable Basic and Disable Extended stats\n");
+	printf("\t value: 2 - Disable Basic and Enable Extended stats\n");
+	printf("\t value: 3 - Enable both Basic and Extended stats\n");
+	return -EINVAL;
 }
 
 COMMAND(streaming_stats, handle, "<value> [-l <link_id>]", NL80211_CMD_VENDOR, 0, CIB_NETDEV, handle_streaming_stats, ".");
--- a/telemetry.c
+++ b/telemetry.c
@@ -45,14 +45,14 @@
 #define TELEMETRY_SLA_THERSHOLD_CONFIG_NUM_OF_PARAMS     8
 #define TELEMETRY_SLA_DETECTION_CONFIG_NUM_OF_PARAMS     8
 
-struct telemetry_sawf_generic_param {
+struct telemetry_sdwf_generic_param {
 	uint32_t moving_avg_pkt;
 	uint32_t moving_avg_win;
 	uint32_t sla_num_pkt;
 	uint32_t sla_time_sec;
 };
 
-struct telemetry_sawf_sla_thershold {
+struct telemetry_sdwf_sla_thershold {
 	uint8_t svc_id;
 	uint32_t min_throughput_rate;
 	uint32_t max_throughput_rate;
@@ -63,7 +63,7 @@ struct telemetry_sawf_sla_thershold {
 	uint32_t msdu_rate_loss;
 };
 
-enum telemetry_sawf_sla_detect {
+enum telemetry_sdwf_sla_detect {
 	SLA_DETECT_NUM_PACKET,
 	SLA_DETECT_PER_SECOND,
 	SLA_DETECT_MOV_AVG,
@@ -71,8 +71,8 @@ enum telemetry_sawf_sla_detect {
 	SLA_DETECT_MAX,
 };
 
-struct telemetry_sawf_sla_detect_param {
-	enum telemetry_sawf_sla_detect sla_detect;
+struct telemetry_sdwf_sla_detect_param {
+	enum telemetry_sdwf_sla_detect sla_detect;
 	uint32_t min_throughput_rate;
 	uint32_t max_throughput_rate;
 	uint32_t burst_size;
@@ -85,40 +85,196 @@ struct telemetry_sawf_sla_detect_param {
 
 SECTION(telemetry);
 
-static int handle_telemetry_sawf_sla_samples_colletion_cfg
+static int handle_telemetry_sdwf_sla_samples_colletion_cfg
 		(struct nl80211_state *state, struct nl_msg *msg,
 		int argc, char **argv, enum id_input id)
 {
+	struct nlattr *telemetry_cfg, *sla_params;
+	char *end;
+	struct telemetry_sdwf_generic_param telemetry_param;
+
+	if (argc != TELEMETRY_SLA_SAMPLES_CONFIG_NUM_OF_PARAMS)
+		goto err;
+
+	telemetry_param.moving_avg_pkt = strtoul(argv[0], &end, 10);
+	telemetry_param.moving_avg_win = strtoul(argv[1], &end, 10);
+	telemetry_param.sla_num_pkt = strtoul(argv[2], &end, 10);
+	telemetry_param.sla_time_sec = strtoul(argv[3], &end, 10);
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_PHY_OPS);
+
+	telemetry_cfg = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!telemetry_cfg)
+		return -ENOBUFS;
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_OPERATION, QCA_WLAN_VENDOR_SDWF_PHY_OPER_SLA_SAMPLES_SET);
+	sla_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SLA_SAMPLES_PARAMS);
+
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_MOVING_AVG_PKT,
+		    telemetry_param.moving_avg_pkt);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_MOVING_AVG_WIN,
+		    telemetry_param.moving_avg_win);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_SLA_NUM_PKT,
+		    telemetry_param.sla_num_pkt);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_SAMPLES_SLA_TIME_SEC,
+		    telemetry_param.sla_time_sec);
+
+	nla_nest_end(msg, sla_params);
+	nla_nest_end(msg, telemetry_cfg);
+
 	return 0;
+
+err:
+	printf("invalid telemetry sla samples configuration command format: Usage\n");
+	printf("\t iw phy <phyname> telemetry sla_samples_cfg <moving_avg_pkt> <moving_avg_window> <sla_num_pkt> <sla_time_sec>\n");
+	return -EINVAL;
 }
 
 COMMAND(telemetry, sla_samples_cfg, "<moving_avg_pkt> <moving_avg_window>"
 "<sla_num_pkt> <sla_time_sec>", NL80211_CMD_VENDOR, 0, CIB_PHY,
-handle_telemetry_sawf_sla_samples_colletion_cfg, ".");
+handle_telemetry_sdwf_sla_samples_colletion_cfg, ".");
 
-static int handle_telemetry_sawf_sla_thershold_cfg(struct nl80211_state *state,
+static int handle_telemetry_sdwf_sla_thershold_cfg(struct nl80211_state *state,
 						   struct nl_msg *msg, int argc, char **argv,
 						   enum id_input id)
 {
-	return 0;
+	struct nlattr *telemetry_cfg, *sla_params;
+	char *end;
+	struct telemetry_sdwf_sla_thershold sla_thershold_cfg;
+
+	if (argc != TELEMETRY_SLA_THERSHOLD_CONFIG_NUM_OF_PARAMS)
+		goto err;
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_PHY_OPS);
+
+	telemetry_cfg = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!telemetry_cfg)
+		return -ENOBUFS;
+
+	sla_thershold_cfg.svc_id = strtoul(argv[0], &end, 10);
+	sla_thershold_cfg.min_throughput_rate = strtoul(argv[1], &end, 10);
+	sla_thershold_cfg.max_throughput_rate = strtoul(argv[2], &end, 10);
+	sla_thershold_cfg.burst_size = strtoul(argv[3], &end, 10);
+	sla_thershold_cfg.service_interval = strtoul(argv[4], &end, 10);
+	sla_thershold_cfg.delay_bound = strtoul(argv[5], &end, 10);
+	sla_thershold_cfg.msdu_ttl = strtoul(argv[6], &end, 10);
+	sla_thershold_cfg.msdu_rate_loss = strtoul(argv[7], &end, 10);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_OPERATION, QCA_WLAN_VENDOR_SDWF_PHY_OPER_SLA_THRESHOLD_SET);
+	sla_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SLA_THRESHOLD_PARAMS);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_SVC_ID,
+		   sla_thershold_cfg.svc_id);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MIN_TP,
+		    sla_thershold_cfg.min_throughput_rate);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MAX_TP,
+		    sla_thershold_cfg.max_throughput_rate);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_BURST_SIZE,
+		    sla_thershold_cfg.burst_size);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_INTERVAL,
+		    sla_thershold_cfg.service_interval);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_DELAY_BOUND,
+		    sla_thershold_cfg.delay_bound);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MSDU_TTL,
+		    sla_thershold_cfg.msdu_ttl);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_THRESHOLD_MSDU_RATE_LOSS,
+		    sla_thershold_cfg.msdu_rate_loss);
+
+	nla_nest_end(msg, sla_params);
+	nla_nest_end(msg, telemetry_cfg);
+	return NL_OK;
+
+err:
+	printf("invalid telemetry sla thershold configuration command format: Usage\n");
+	printf("\t iw phy <phyname> telemetry sla_thershold <service_id> ");
+	printf(" <min_throughput_rate> <max_throughput_rate> <burst_size> <service_interval> ");
+	printf(" <delay_bound> <msdu_ttl> <msdu_rate_loss> \n");
+	return -EINVAL;
 }
 
 COMMAND(telemetry, sla_thershold, "<service_id> <min_throughput_rate> <max_throughput_rate>"
 "<burst_size> <service_interval> <delay_bound> <msdu_ttl> <msdu_rate_loss>", NL80211_CMD_VENDOR, 0,
-CIB_PHY, handle_telemetry_sawf_sla_thershold_cfg, ".");
+CIB_PHY, handle_telemetry_sdwf_sla_thershold_cfg, ".");
 
 
-static int handle_telemetry_sawf_sla_detection_cfg(struct nl80211_state *state,
+static int handle_telemetry_sdwf_sla_detection_cfg(struct nl80211_state *state,
 						   struct nl_msg *msg, int argc, char **argv,
 						   enum id_input id)
 {
-	return 0;
+	struct nlattr *telemetry_cfg, *sla_params;
+	char *end;
+	struct telemetry_sdwf_sla_detect_param telemetry_param;
+
+	if (argc != TELEMETRY_SLA_DETECTION_CONFIG_NUM_OF_PARAMS)
+		goto err;
+
+	if (streq(argv[0], "num_packet"))
+		telemetry_param.sla_detect = SLA_DETECT_NUM_PACKET;
+
+	if (streq(argv[0], "per_second"))
+		telemetry_param.sla_detect = SLA_DETECT_PER_SECOND;
+
+	if (streq(argv[0], "moving_avg"))
+		telemetry_param.sla_detect = SLA_DETECT_MOV_AVG;
+
+	if (streq(argv[0], "num_second"))
+		telemetry_param.sla_detect = SLA_DETECT_NUM_SECOND;
+
+	telemetry_param.min_throughput_rate = strtoul(argv[1], &end, 10);
+	telemetry_param.max_throughput_rate = strtoul(argv[2], &end, 10);
+	telemetry_param.burst_size = strtoul(argv[3], &end, 10);
+	telemetry_param.service_interval = strtoul(argv[4], &end, 10);
+	telemetry_param.delay_bound = strtoul(argv[5], &end, 10);
+	telemetry_param.msdu_ttl = strtoul(argv[6], &end, 10);
+	telemetry_param.msdu_rate_loss = strtoul(argv[7], &end, 10);
+
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_PHY_OPS);
+
+	telemetry_cfg = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!telemetry_cfg)
+		return -ENOBUFS;
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_OPERATION, QCA_WLAN_VENDOR_SDWF_PHY_OPER_SLA_BREACH_DETECTION_SET);
+	sla_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_PHY_SLA_DETECT_PARAMS);
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_PARAM,
+		   telemetry_param.sla_detect);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MIN_TP,
+		    telemetry_param.min_throughput_rate);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MAX_TP,
+		    telemetry_param.max_throughput_rate);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_BURST_SIZE,
+		    telemetry_param.burst_size);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_INTERVAL,
+		    telemetry_param.service_interval);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_DELAY_BOUND,
+		    telemetry_param.delay_bound);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MSDU_TTL,
+		    telemetry_param.msdu_ttl);
+	nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_DETECT_MSDU_RATE_LOSS,
+		    telemetry_param.msdu_rate_loss);
+	nla_nest_end(msg, sla_params);
+	nla_nest_end(msg, telemetry_cfg);
+
+	return NL_OK;
+
+err:
+	printf("invalid telemetry sla breach detection configuration command format: Usage\n");
+	printf("\t iw phy <phyname> telemetry sla_detection_cfg <detection_option> <min_throughput_rate> <max_throughput_rate> <burst_size> <service_interval> <delay_bound> <msdu_ttl> <msdu_rate_loss>\n");
+	return -EINVAL;
 }
 
 COMMAND(telemetry, sla_detection_cfg, "<detection_option> <min_throughput_rate>"
 "<max_throughput_rate> <burst_size> <service_interval> <delay_bound> <msdu_ttl>"
 "<msdu_rate_loss>", NL80211_CMD_VENDOR, 0, CIB_PHY,
-handle_telemetry_sawf_sla_detection_cfg, ".");
+handle_telemetry_sdwf_sla_detection_cfg, ".");
 
 #define TELEMETRY_SLA_CLEAR_STATS_MAX_ARG 1
 #define MAC_ADDR_LEN 18
@@ -127,7 +283,40 @@ static int handle_telemetry_sla_clear_st
 					    struct nl_msg *msg, int argc, char **argv,
 					    enum id_input id)
 {
+	struct nlattr *sla_clear, *clr_stats_params;
+	unsigned char mac_addr[MAC_ADDR_LEN];
+
+	if (argc != TELEMETRY_SLA_CLEAR_STATS_MAX_ARG)
+		goto err;
+
+	if (mac_addr_a2n(mac_addr, argv[0])) {
+		printf("Invalid MAC address\n");
+		return -EINVAL;
+	}
+
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA);
+	nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
+		    QCA_NL80211_VENDOR_SUBCMD_SDWF_DEV_OPS);
+
+	sla_clear = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
+	if (!sla_clear)
+		return -ENOBUFS;
+
+	nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_OPERATION,
+		   QCA_WLAN_VENDOR_SDWF_DEV_OPER_RESET_STATS);
+	clr_stats_params = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_SDWF_DEV_RESET_STATS);
+
+	if (nla_put(msg, QCA_WLAN_VENDOR_ATTR_SDWF_SLA_BREACH_PARAM_PEER_MAC,
+		    ETH_ALEN, mac_addr))
+		return -ENOBUFS;
+
+	nla_nest_end(msg, clr_stats_params);
+	nla_nest_end(msg, sla_clear);
 	return NL_OK;
+err:
+	printf("Invalid telemetry sla clear stats, command format: Usage\n");
+	printf("\t iw dev <devname> telemetry sla_clear_stats <peer_mac>\n");
+	return NL_STOP;
 }
 COMMAND(telemetry, sla_clear_stats, "<peer_mac>", NL80211_CMD_VENDOR, 0, CIB_NETDEV,
 	handle_telemetry_sla_clear_stats, ".");