qcacld-3.0: Add code to process EPCS logic

Add code logic to process EPCS (Emergency Preparedness
Communications Service).

CRs-Fixed: 3511102
Change-Id: I8ed0b98beede5d06b2a118bf8d26af41d9207c64

Kbuild

@@ -1337,6 +1337,7 @@ MLO_MGR_TARGET_IF_DIR := $(WLAN_COMMON_ROOT)/target_if/mlo_mgr
 
 UMAC_MLO_MGR_CLD_DIR := components/umac/mlme/mlo_mgr
 UMAC_MLO_MGR_CLD_INC := -I$(WLAN_ROOT)/$(UMAC_MLO_MGR_CLD_DIR)/inc \
+			-I$(WLAN_ROOT)/$(UMAC_MLO_MGR_CLD_DIR)/dispatcher/inc \
 
 UMAC_MLO_MGR_INC := -I$(WLAN_COMMON_INC)/umac/mlo_mgr/inc \
 		    -I$(WLAN_COMMON_INC)/target_if/mlo_mgr/inc
@@ -1357,6 +1358,9 @@ UMAC_MLO_MGR_OBJS := $(UMAC_MLO_MGR_CMN_DIR)/src/wlan_mlo_mgr_main.o \
 			  $(UMAC_MLO_MGR_CLD_DIR)/src/wlan_mlo_mgr_roam.o \
 			  $(UMAC_MLO_MGR_CLD_DIR)/src/wlan_t2lm_api.o \
 			  $(UMAC_MLO_MGR_CMN_DIR)/src/wlan_mlo_t2lm.o \
+			  $(UMAC_MLO_MGR_CLD_DIR)/src/wlan_epcs_api.o \
+			  $(UMAC_MLO_MGR_CMN_DIR)/src/wlan_mlo_epcs.o \
+			  $(UMAC_MLO_MGR_CLD_DIR)/dispatcher/src/wlan_mlo_epcs_ucfg_api.o \
 
 $(call add-wlan-objs,umac_mlomgr,$(UMAC_MLO_MGR_OBJS))
 endif

components/umac/mlme/mlo_mgr/dispatcher/inc/wlan_mlo_epcs_ucfg_api.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * DOC: wlan_mlo_epcs_ucfg_api.h
+ *
+ * Implementation for mlo epcs public ucfg API interfaces.
+ */
+
+#ifndef _WLAN_MLO_EPCS_UCFG_API_H_
+#define _WLAN_MLO_EPCS_UCFG_API_H_
+
+#include "wlan_epcs_api.h"
+
+/**
+ * ucfg_epcs_deliver_cmd() - Handler to deliver EPCS command
+ * @vdev: vdev pointer
+ * @event: EPCS event
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS ucfg_epcs_deliver_cmd(struct wlan_objmgr_vdev *vdev,
+				 enum wlan_epcs_evt event);
+#endif /* _WLAN_MLO_EPCS_UCFG_API_H_ */

components/umac/mlme/mlo_mgr/dispatcher/src/wlan_mlo_epcs_ucfg_api.c

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * DOC: wlan_mlo_epcs_ucfg_api.c
+ *
+ * Implementation for mlo epcs public ucfg API interfaces.
+ */
+#include "wlan_epcs_api.h"
+#include "wlan_mlo_epcs_ucfg_api.h"
+
+QDF_STATUS ucfg_epcs_deliver_cmd(struct wlan_objmgr_vdev *vdev,
+				 enum wlan_epcs_evt event)
+{
+	return wlan_epcs_deliver_cmd(vdev, event);
+}

components/umac/mlme/mlo_mgr/inc/wlan_epcs_api.h

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * DOC: contains EPCS (Emergency Preparedness Communications Service)
+ * related functionality
+ */
+#ifndef _WLAN_EPCS_API_H_
+#define _WLAN_EPCS_API_H_
+
+#include "lim_types.h"
+#include "lim_utils.h"
+#include "lim_send_sme_rsp_messages.h"
+#include "parser_api.h"
+#include "lim_send_messages.h"
+
+#define RSVD_SHIFT_BIT 0x7
+#define ACI_SHIFT_BIT 0x5
+#define ACM_SHIFT_BIT 0x4
+#define AIFSN_SHIFT_BIT 0x0
+#define CWMAX_SHIFT_BIT 0x4
+#define CWMIN_SHIFT_BIT 0x0
+
+#define RSVD_MASK 0x1
+#define ACI_MASK 0x3
+#define ACM_MASK 0x1
+#define AIFSN_MASK 0xf
+#define CWMAX_MASK 0xf
+#define CWMIN_MASK 0xf
+
+/**
+ * enum wlan_epcs_evt: EPCS manager events
+ * @WLAN_EPCS_EV_ACTION_FRAME_RX_REQ:Handle EPCS request frame received from AP
+ * @WLAN_EPCS_EV_ACTION_FRAME_TX_RESP:Handle EPCS response frame sent to AP
+ * @WLAN_EPCS_EV_ACTION_FRAME_TX_REQ:Handle EPCS request frame sent by STA
+ * @WLAN_EPCS_EV_ACTION_FRAME_RX_RESP:Handle EPCS response frame received from AP
+ * @WLAN_EPCS_EV_ACTION_FRAME_RX_TEARDOWN:Handle received teardown frame event
+ * @WLAN_EPCS_EV_ACTION_FRAME_TX_TEARDOWN:Handle sending teardown frame event
+ * @WLAN_EPCS_EV_ACTION_FRAME_MAX: Maximum EPCS action frame event value
+ */
+enum wlan_epcs_evt {
+	WLAN_EPCS_EV_ACTION_FRAME_RX_REQ = 0,
+	WLAN_EPCS_EV_ACTION_FRAME_TX_RESP = 1,
+	WLAN_EPCS_EV_ACTION_FRAME_TX_REQ = 2,
+	WLAN_EPCS_EV_ACTION_FRAME_RX_RESP = 3,
+	WLAN_EPCS_EV_ACTION_FRAME_RX_TEARDOWN = 4,
+	WLAN_EPCS_EV_ACTION_FRAME_TX_TEARDOWN = 5,
+	WLAN_EPCS_EV_ACTION_FRAME_MAX = 6,
+};
+
+#ifdef WLAN_FEATURE_11BE_MLO
+/**
+ * wlan_epcs_deliver_event() - Handler to deliver EPCS event
+ * @vdev: vdev pointer
+ * @peer: pointer to peer
+ * @event: EPCS event
+ * @event_data: EPCS event data pointer
+ * @len: length of data
+ *
+ * This api will be called from lim  layers, to process EPCS event
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_epcs_deliver_event(struct wlan_objmgr_vdev *vdev,
+				   struct wlan_objmgr_peer *peer,
+				   enum wlan_epcs_evt event,
+				   void *event_data, uint32_t len);
+
+/**
+ * wlan_epcs_deliver_cmd() - Handler to deliver EPCS command
+ * @vdev: vdev pointer
+ * @event: EPCS event
+ *
+ * This api will be called from os_if layers, to process EPCS command
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_epcs_deliver_cmd(struct wlan_objmgr_vdev *vdev,
+				 enum wlan_epcs_evt event);
+#else
+static inline
+QDF_STATUS wlan_epcs_deliver_event(struct wlan_objmgr_vdev *vdev,
+				   struct wlan_objmgr_peer *peer,
+				   enum wlan_epcs_evt event,
+				   void *event_data, uint32_t len)
+{
+	return QDF_STATUS_E_NOSUPPORT;
+}
+
+static inline
+QDF_STATUS wlan_epcs_deliver_cmd(struct wlan_objmgr_vdev *vdev,
+				 enum wlan_epcs_evt event)
+{
+	return QDF_STATUS_E_NOSUPPORT;
+}
+#endif
+#endif

components/umac/mlme/mlo_mgr/src/wlan_epcs_api.c

@@ -0,0 +1,526 @@
+/*
+ * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * DOC: contains EPCS (Emergency Preparedness Communications Service)
+ * related functionality
+ */
+#include <wlan_cmn.h>
+#include <wlan_cm_public_struct.h>
+#include "wlan_epcs_api.h"
+#include <wlan_mlo_epcs.h>
+#include "wlan_cm_api.h"
+#include "wlan_mlo_mgr_roam.h"
+#include "wlan_cmn_ieee80211.h"
+#include "dot11f.h"
+
+#define EPCS_MIN_DIALOG_TOKEN         1
+#define EPCS_MAX_DIALOG_TOKEN         0xFF
+
+static struct ac_param_record default_epcs_edca[] = {
+#ifndef ANI_LITTLE_BIT_ENDIAN
+	/* The txop is multiple of 32us units */
+	{0x07, 0x95, 79 /* 2.528ms */},
+	{0x03, 0x95, 79 /* 2.528ms */},
+	{0x02, 0x54, 128 /* 4.096ms */},
+	{0x02, 0x43, 65 /* 2.080ms */}
+#else
+	{0x70, 0x59, 79 /* 2.528ms */},
+	{0x30, 0x59, 79 /* 2.528ms */},
+	{0x20, 0x45, 128 /* 4.096ms */},
+	{0x20, 0x34, 65 /* 2.080ms */}
+#endif
+};
+
+static
+const char *epcs_get_event_str(enum wlan_epcs_evt event)
+{
+	if (event > WLAN_EPCS_EV_ACTION_FRAME_MAX)
+		return "";
+
+	switch (event) {
+	CASE_RETURN_STRING(WLAN_EPCS_EV_ACTION_FRAME_RX_REQ);
+	CASE_RETURN_STRING(WLAN_EPCS_EV_ACTION_FRAME_TX_RESP);
+	CASE_RETURN_STRING(WLAN_EPCS_EV_ACTION_FRAME_TX_REQ);
+	CASE_RETURN_STRING(WLAN_EPCS_EV_ACTION_FRAME_RX_RESP);
+	CASE_RETURN_STRING(WLAN_EPCS_EV_ACTION_FRAME_RX_TEARDOWN);
+	CASE_RETURN_STRING(WLAN_EPCS_EV_ACTION_FRAME_TX_TEARDOWN);
+	default:
+		return "Unknown";
+	}
+}
+
+static uint8_t
+epcs_gen_dialog_token(struct wlan_mlo_peer_epcs_info *epcs_info)
+{
+	if (!epcs_info)
+		return 0;
+
+	if (epcs_info->self_gen_dialog_token == EPCS_MAX_DIALOG_TOKEN)
+		/* wrap is ok */
+		epcs_info->self_gen_dialog_token = EPCS_MIN_DIALOG_TOKEN;
+	else
+		epcs_info->self_gen_dialog_token += 1;
+
+	mlme_debug("gen dialog token %d", epcs_info->self_gen_dialog_token);
+	return epcs_info->self_gen_dialog_token;
+}
+
+static void epcs_update_ac_value(tSirMacEdcaParamRecord *edca,
+				 struct ac_param_record *epcs)
+{
+	edca->aci.rsvd = epcs->aci_aifsn >> RSVD_SHIFT_BIT & RSVD_MASK;
+	edca->aci.aci = epcs->aci_aifsn >> ACI_SHIFT_BIT & ACI_MASK;
+	edca->aci.acm = epcs->aci_aifsn >> ACM_SHIFT_BIT & ACM_MASK;
+	edca->aci.aifsn = epcs->aci_aifsn >> AIFSN_SHIFT_BIT & AIFSN_MASK;
+
+	edca->cw.max = epcs->ecw_min_max >> CWMAX_SHIFT_BIT & CWMAX_MASK;
+	edca->cw.min = epcs->ecw_min_max >> CWMIN_SHIFT_BIT & CWMIN_MASK;
+
+	edca->txoplimit = epcs->txop_limit;
+	mlme_debug("edca rsvd %d, aci %d, acm %d, aifsn %d, cwmax %d, cwmin %d",
+		   edca->aci.rsvd, edca->aci.aci, edca->aci.acm,
+		   edca->aci.aifsn, edca->cw.max, edca->cw.min);
+}
+
+static void epcs_update_mu_ac_value(tSirMacEdcaParamRecord *edca,
+				    struct muac_param_record *epcs)
+{
+	edca->aci.rsvd = epcs->aci_aifsn >> RSVD_SHIFT_BIT & RSVD_MASK;
+	edca->aci.aci = epcs->aci_aifsn >> ACI_SHIFT_BIT & ACI_MASK;
+	edca->aci.acm = epcs->aci_aifsn >> ACM_SHIFT_BIT & ACM_MASK;
+	edca->aci.aifsn = epcs->aci_aifsn >> AIFSN_SHIFT_BIT & AIFSN_MASK;
+
+	edca->cw.max = epcs->ecw_min_max >> CWMAX_SHIFT_BIT & CWMAX_MASK;
+	edca->cw.min = epcs->ecw_min_max >> CWMIN_SHIFT_BIT & CWMIN_MASK;
+
+	edca->txoplimit = epcs->mu_edca_timer;
+	mlme_debug("muac rsvd %d, aci %d, acm %d, aifsn %d, cwmax %d, cwmin %d",
+		   edca->aci.rsvd, edca->aci.aci, edca->aci.acm,
+		   edca->aci.aifsn, edca->cw.max, edca->cw.min);
+}
+
+static QDF_STATUS
+epcs_update_def_edca_param(struct wlan_objmgr_vdev *vdev,
+			   struct mac_context *mac_ctx,
+			   tSirMacEdcaParamRecord *edca)
+{
+	int i;
+
+	for (i = 0; i < QCA_WLAN_AC_ALL; i++) {
+		epcs_update_ac_value(&edca[i], &default_epcs_edca[i]);
+		edca[i].no_ack = mac_ctx->no_ack_policy_cfg[i];
+	}
+
+	return lim_send_epcs_update_edca_params(vdev, edca, false);
+}
+
+static QDF_STATUS
+epcs_update_edca_param(struct wlan_objmgr_vdev *vdev,
+		       struct edca_ie *edca_ie)
+{
+	struct mac_context *mac_ctx;
+	struct ac_param_record *ac_record;
+	tSirMacEdcaParamRecord edca[QCA_WLAN_AC_ALL] = {0};
+	int i;
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	if (edca_ie->ie != DOT11F_EID_EDCAPARAMSET ||
+	    edca_ie->len != DOT11F_IE_EDCAPARAMSET_MIN_LEN) {
+		mlme_debug("edca info is not valid or not exist, using def");
+		return epcs_update_def_edca_param(vdev, mac_ctx, edca);
+	}
+
+	ac_record = edca_ie->ac_record;
+	for (i = 0; i < QCA_WLAN_AC_ALL; i++) {
+		epcs_update_ac_value(&edca[i], &ac_record[i]);
+		edca[i].no_ack = mac_ctx->no_ack_policy_cfg[i];
+	}
+
+	return lim_send_epcs_update_edca_params(vdev, edca, false);
+}
+
+static QDF_STATUS
+epcs_update_mu_edca_param(struct wlan_objmgr_vdev *vdev,
+			  struct muedca_ie *muedca)
+{
+	struct mac_context *mac_ctx;
+	struct muac_param_record *mu_record;
+	tSirMacEdcaParamRecord edca[QCA_WLAN_AC_ALL] = {0};
+	int i;
+
+	if (muedca->elem_id != DOT11F_EID_MU_EDCA_PARAM_SET ||
+	    muedca->elem_len != (DOT11F_IE_MU_EDCA_PARAM_SET_MIN_LEN + 1)) {
+		mlme_debug("mu edca info for epcs is not valid or not exist");
+		return QDF_STATUS_SUCCESS;
+	}
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	mu_record = muedca->mu_record;
+	for (i = 0; i < QCA_WLAN_AC_ALL; i++) {
+		epcs_update_mu_ac_value(&edca[i], &mu_record[i]);
+		edca[i].no_ack = mac_ctx->no_ack_policy_cfg[i];
+	}
+
+	return lim_send_epcs_update_edca_params(vdev, edca, true);
+}
+
+static QDF_STATUS
+epcs_restore_edca_param(struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_objmgr_vdev *link_vdev;
+	struct wlan_mlo_dev_context *mlo_dev_ctx;
+	int i;
+
+	if (!vdev)
+		return QDF_STATUS_E_INVAL;
+
+	mlo_dev_ctx = vdev->mlo_dev_ctx;
+	if (!mlo_dev_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	for (i = 0; i < WLAN_UMAC_MLO_MAX_VDEVS; i++) {
+		link_vdev = mlo_dev_ctx->wlan_vdev_list[i];
+		if (!link_vdev)
+			continue;
+		lim_send_epcs_restore_edca_params(link_vdev);
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS epcs_handle_rx_req(struct wlan_objmgr_vdev *vdev,
+				     struct wlan_objmgr_peer *peer,
+				     void *event_data, uint32_t len)
+{
+	struct wlan_mlo_peer_context *ml_peer;
+	struct wlan_mlo_peer_epcs_info *epcs_info;
+	struct wlan_epcs_info epcs_req = {0};
+	struct wlan_action_frame_args args;
+	struct ml_pa_info *edca_info;
+	struct ml_pa_partner_link_info *link;
+	struct wlan_objmgr_vdev *link_vdev;
+	uint32_t i;
+	QDF_STATUS status;
+
+	if (!vdev || !peer)
+		return QDF_STATUS_E_INVAL;
+
+	ml_peer = peer->mlo_peer_ctx;
+	if (!ml_peer)
+		return QDF_STATUS_E_FAILURE;
+
+	epcs_info = &ml_peer->epcs_info;
+	if (epcs_info->state == EPCS_ENABLE) {
+		mlme_err("EPCS has been enable, ignore the req.");
+		return QDF_STATUS_E_ALREADY;
+	}
+
+	status = wlan_mlo_parse_epcs_action_frame(&epcs_req, event_data, len);
+	if (status != QDF_STATUS_SUCCESS) {
+		mlme_err("Unable to parse EPCS request action frame");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	epcs_info->self_gen_dialog_token = epcs_req.dialog_token;
+	edca_info = &epcs_req.pa_info;
+	for (i = 0; i < edca_info->num_links; i++) {
+		link = &edca_info->link_info[i];
+		link_vdev = mlo_get_vdev_by_link_id(vdev, link->link_id);
+		epcs_update_edca_param(link_vdev, &link->edca);
+		epcs_update_mu_edca_param(link_vdev, &link->muedca);
+	}
+
+	args.category = ACTION_CATEGORY_PROTECTED_EHT;
+	args.action = EHT_EPCS_RESPONSE;
+	args.arg1 = epcs_info->self_gen_dialog_token;
+	args.arg2 = QDF_STATUS_SUCCESS;
+
+	status = lim_send_epcs_action_rsp_frame(vdev,
+						wlan_peer_get_macaddr(peer),
+						&args);
+	if (status != QDF_STATUS_SUCCESS) {
+		mlme_err("Send EPCS response frame error");
+		epcs_restore_edca_param(vdev);
+	} else {
+		epcs_info->state = EPCS_ENABLE;
+		mlme_debug("EPCS (responder) state: Teardown -> Enable");
+	}
+
+	return status;
+}
+
+static QDF_STATUS epcs_handle_rx_resp(struct wlan_objmgr_vdev *vdev,
+				      struct wlan_objmgr_peer *peer,
+				      void *event_data, uint32_t len)
+{
+	struct wlan_mlo_peer_context *ml_peer;
+	struct wlan_mlo_peer_epcs_info *epcs_info;
+	struct wlan_epcs_info epcs_rsp = {0};
+	struct ml_pa_info *edca_info;
+	struct ml_pa_partner_link_info *link;
+	struct wlan_objmgr_vdev *link_vdev;
+	uint32_t i;
+	QDF_STATUS status;
+
+	if (!vdev || !peer)
+		return QDF_STATUS_E_INVAL;
+
+	ml_peer = peer->mlo_peer_ctx;
+	if (!ml_peer)
+		return QDF_STATUS_E_FAILURE;
+
+	epcs_info = &ml_peer->epcs_info;
+	if (epcs_info->state == EPCS_ENABLE) {
+		mlme_err("EPCS has been enable, ignore the rsp.");
+		return QDF_STATUS_E_ALREADY;
+	}
+
+	status = wlan_mlo_parse_epcs_action_frame(&epcs_rsp, event_data, len);
+	if (status != QDF_STATUS_SUCCESS) {
+		mlme_err("Unable to parse EPCS response action frame");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	if (epcs_info->self_gen_dialog_token != epcs_rsp.dialog_token) {
+		mlme_err("epcs rsp dialog token %d does not match",
+			 epcs_rsp.dialog_token);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	if (epcs_rsp.status) {
+		mlme_err("epcs rsp status error %d", epcs_rsp.status);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	edca_info = &epcs_rsp.pa_info;
+	for (i = 0; i < edca_info->num_links; i++) {
+		link = &edca_info->link_info[i];
+		link_vdev = mlo_get_vdev_by_link_id(vdev, link->link_id);
+		epcs_update_edca_param(link_vdev, &link->edca);
+		epcs_update_mu_edca_param(link_vdev, &link->muedca);
+	}
+
+	epcs_info->state = EPCS_ENABLE;
+	mlme_debug("EPCS (initiator) state: Teardown -> Enable");
+
+	return status;
+}
+
+static QDF_STATUS epcs_handle_rx_teardown(struct wlan_objmgr_vdev *vdev,
+					  struct wlan_objmgr_peer *peer,
+					  void *event_data, uint32_t len)
+{
+	struct wlan_mlo_peer_context *ml_peer;
+	struct wlan_mlo_peer_epcs_info *epcs_info;
+	struct wlan_epcs_info epcs_req = {0};
+	struct mac_context *mac_ctx;
+	QDF_STATUS status;
+
+	if (!vdev || !peer)
+		return QDF_STATUS_E_INVAL;
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	ml_peer = peer->mlo_peer_ctx;
+	if (!ml_peer)
+		return QDF_STATUS_E_FAILURE;
+
+	epcs_info = &ml_peer->epcs_info;
+	if (epcs_info->state == EPCS_DOWN) {
+		mlme_err("EPCS has been down, ignore the teardown req.");
+		return QDF_STATUS_E_ALREADY;
+	}
+
+	status = wlan_mlo_parse_epcs_action_frame(&epcs_req, event_data, len);
+	if (status != QDF_STATUS_SUCCESS) {
+		mlme_err("Unable to parse EPCS teardown action frame");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	epcs_restore_edca_param(vdev);
+
+	epcs_info->state = EPCS_DOWN;
+	mlme_debug("EPCS state: Enale -> Teardown.");
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS epcs_handle_tx_req(struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_mlo_peer_context *ml_peer;
+	struct wlan_objmgr_peer *peer;
+	struct wlan_action_frame_args args;
+	struct wlan_mlo_peer_epcs_info *epcs_info;
+	QDF_STATUS status;
+
+	if (!vdev)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	peer = wlan_objmgr_vdev_try_get_bsspeer(vdev, WLAN_MLO_MGR_ID);
+	if (!peer)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	ml_peer = peer->mlo_peer_ctx;
+	if (!ml_peer) {
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto release_peer;
+	}
+
+	epcs_info = &ml_peer->epcs_info;
+	if (epcs_info->state == EPCS_ENABLE) {
+		mlme_err("EPCS has been enable, ignore the req cmd.");
+		status = QDF_STATUS_E_ALREADY;
+		goto release_peer;
+	}
+
+	args.category = ACTION_CATEGORY_PROTECTED_EHT;
+	args.action = EHT_EPCS_REQUEST;
+	args.arg1 = epcs_gen_dialog_token(epcs_info);
+
+	status = lim_send_epcs_action_req_frame(vdev,
+						wlan_peer_get_macaddr(peer),
+						&args);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Failed to send EPCS action request frame");
+
+release_peer:
+	wlan_objmgr_peer_release_ref(peer, WLAN_MLO_MGR_ID);
+
+	return status;
+}
+
+static QDF_STATUS epcs_handle_tx_teardown(struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_mlo_peer_context *ml_peer;
+	struct wlan_objmgr_peer *peer;
+	struct wlan_action_frame_args args;
+	struct wlan_mlo_peer_epcs_info *epcs_info;
+	QDF_STATUS status;
+
+	if (!vdev)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	peer = wlan_objmgr_vdev_try_get_bsspeer(vdev, WLAN_MLO_MGR_ID);
+	if (!peer)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	ml_peer = peer->mlo_peer_ctx;
+	if (!ml_peer) {
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto release_peer;
+	}
+
+	epcs_info = &ml_peer->epcs_info;
+	if (epcs_info->state == EPCS_DOWN) {
+		mlme_err("EPCS has been down, ignore the teardwon cmd.");
+		status = QDF_STATUS_E_ALREADY;
+		goto release_peer;
+	}
+
+	args.category = ACTION_CATEGORY_PROTECTED_EHT;
+	args.action = EHT_EPCS_TEARDOWN;
+
+	status =
+	    lim_send_epcs_action_teardown_frame(vdev,
+						wlan_peer_get_macaddr(peer),
+						&args);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Failed to send EPCS tear down frame");
+	} else {
+		epcs_restore_edca_param(vdev);
+		epcs_info->state = EPCS_DOWN;
+		mlme_debug("EPCS state: Enale -> Teardown.");
+	}
+
+release_peer:
+	wlan_objmgr_peer_release_ref(peer, WLAN_MLO_MGR_ID);
+
+	return status;
+}
+
+static QDF_STATUS epcs_deliver_event(struct wlan_objmgr_vdev *vdev,
+				     struct wlan_objmgr_peer *peer,
+				     enum wlan_epcs_evt event,
+				     void *event_data, uint32_t len)
+{
+	QDF_STATUS status;
+
+	mlme_debug("EPCS event received: %s(%d)",
+		   epcs_get_event_str(event), event);
+
+	switch (event) {
+	case WLAN_EPCS_EV_ACTION_FRAME_RX_REQ:
+		status = epcs_handle_rx_req(vdev, peer, event_data, len);
+		break;
+	case WLAN_EPCS_EV_ACTION_FRAME_RX_RESP:
+		status = epcs_handle_rx_resp(vdev, peer, event_data, len);
+		break;
+	case WLAN_EPCS_EV_ACTION_FRAME_RX_TEARDOWN:
+		status = epcs_handle_rx_teardown(vdev, peer, event_data, len);
+		break;
+	default:
+		status = QDF_STATUS_E_FAILURE;
+		mlme_err("Unhandled EPCS event");
+	}
+
+	return status;
+}
+
+QDF_STATUS wlan_epcs_deliver_event(struct wlan_objmgr_vdev *vdev,
+				   struct wlan_objmgr_peer *peer,
+				   enum wlan_epcs_evt event,
+				   void *event_data, uint32_t len)
+{
+	return epcs_deliver_event(vdev, peer, event, event_data, len);
+}
+
+static QDF_STATUS epcs_deliver_cmd(struct wlan_objmgr_vdev *vdev,
+				   enum wlan_epcs_evt event)
+{
+	QDF_STATUS status;
+
+	mlme_debug("EPCS cmd received: %s(%d)",
+		   epcs_get_event_str(event), event);
+
+	switch (event) {
+	case WLAN_EPCS_EV_ACTION_FRAME_TX_REQ:
+		status = epcs_handle_tx_req(vdev);
+		break;
+	case WLAN_EPCS_EV_ACTION_FRAME_TX_TEARDOWN:
+		status = epcs_handle_tx_teardown(vdev);
+		break;
+	default:
+		status = QDF_STATUS_E_FAILURE;
+		mlme_err("Unhandled EPCS cmd");
+	}
+
+	return status;
+}
+
+QDF_STATUS wlan_epcs_deliver_cmd(struct wlan_objmgr_vdev *vdev,
+				 enum wlan_epcs_evt event)
+{
+	return epcs_deliver_cmd(vdev, event);
+}

core/mac/src/pe/lim/lim_process_action_frame.c

@@ -55,6 +55,7 @@
 #include "wlan_p2p_cfg_api.h"
 #include "son_api.h"
 #include "wlan_t2lm_api.h"
+#include "wlan_epcs_api.h"
 #include "wlan_mlo_mgr_public_structs.h"
 
 #define SA_QUERY_REQ_MIN_LEN \
@@ -2150,7 +2151,7 @@ void lim_process_action_frame(struct mac_context *mac_ctx,
 		}
 		break;
 	case ACTION_CATEGORY_PROTECTED_EHT:
-		pe_debug("EHT T2LM action category: %d action: %d",
+		pe_debug("EHT T2LM/EPCS action category: %d action: %d",
 			 action_hdr->category, action_hdr->actionID);
 		mac_hdr = WMA_GET_RX_MAC_HEADER(rx_pkt_info);
 		body_ptr = WMA_GET_RX_MPDU_DATA(rx_pkt_info);
@@ -2194,8 +2195,26 @@ void lim_process_action_frame(struct mac_context *mac_ctx,
 					WLAN_T2LM_EV_ACTION_FRAME_RX_TEARDOWN,
 					(void *)body_ptr, NULL);
 			break;
+		case EHT_EPCS_REQUEST:
+			wlan_epcs_deliver_event(
+					session->vdev, peer,
+					WLAN_EPCS_EV_ACTION_FRAME_RX_REQ,
+					(void *)body_ptr, frame_len);
+			break;
+		case EHT_EPCS_RESPONSE:
+			wlan_epcs_deliver_event(
+					session->vdev, peer,
+					WLAN_EPCS_EV_ACTION_FRAME_RX_RESP,
+					(void *)body_ptr, frame_len);
+			break;
+		case EHT_EPCS_TEARDOWN:
+			wlan_epcs_deliver_event(
+					session->vdev, peer,
+					WLAN_EPCS_EV_ACTION_FRAME_RX_TEARDOWN,
+					(void *)body_ptr, frame_len);
+			break;
 		default:
-			pe_err("Unhandled T2LM action frame");
+			pe_err("Unhandled T2LM/EPCS action frame");
 			break;
 		}
 		break;

core/mac/src/pe/lim/lim_send_management_frames.c

@@ -6324,6 +6324,370 @@ error_addba_rsp:
 }
 
 #ifdef WLAN_FEATURE_11BE_MLO
+QDF_STATUS
+lim_send_epcs_update_edca_params(struct wlan_objmgr_vdev *vdev,
+				 tSirMacEdcaParamRecord *edca, bool mu_edca)
+{
+	struct mac_context *mac_ctx;
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	return lim_send_edca_params(mac_ctx, edca,
+				    wlan_vdev_get_id(vdev), mu_edca);
+}
+
+QDF_STATUS
+lim_send_epcs_restore_edca_params(struct wlan_objmgr_vdev *vdev)
+{
+	struct mac_context *mac_ctx;
+	struct pe_session *session;
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	session = pe_find_session_by_vdev_id(mac_ctx, wlan_vdev_get_id(vdev));
+	if (!session)
+		return QDF_STATUS_E_INVAL;
+
+	lim_send_edca_params(mac_ctx, session->gLimEdcaParamsActive,
+			     session->vdev_id, false);
+
+	if (mac_ctx->usr_cfg_mu_edca_params)
+		lim_send_edca_params(mac_ctx, mac_ctx->usr_mu_edca_params,
+				     session->vdev_id, true);
+	else if (session->mu_edca_present)
+		lim_send_edca_params(mac_ctx, session->ap_mu_edca_params,
+				     session->vdev_id, true);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+lim_send_epcs_action_rsp_frame(struct wlan_objmgr_vdev *vdev,
+			       uint8_t *peer_mac,
+			       struct wlan_action_frame_args *args)
+{
+	struct mac_context *mac_ctx;
+	struct pe_session *session;
+	tDot11fepcs_neg_rsp frm;
+	uint8_t *frame_ptr;
+	tpSirMacMgmtHdr mgmt_hdr;
+	uint32_t num_bytes, payload_size, status;
+	void *pkt_ptr = NULL;
+	uint8_t vdev_id = 0;
+	uint8_t tx_flag = 0;
+	QDF_STATUS qdf_status;
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	session = pe_find_session_by_vdev_id(mac_ctx, wlan_vdev_get_id(vdev));
+	if (!session)
+		return QDF_STATUS_E_INVAL;
+
+	frm.Category.category = args->category;
+	frm.Action.action = args->action;
+	frm.DialogToken.token = args->arg1;
+	frm.Status.status = args->arg2;
+
+	pe_debug("Sending a EPCS negotiation Response from " QDF_MAC_ADDR_FMT " to " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(session->self_mac_addr),
+		 QDF_MAC_ADDR_REF(peer_mac));
+	pe_debug("Dialog token %d status %d", frm.DialogToken.token,
+		 frm.Status.status);
+
+	status = dot11f_get_packed_epcs_neg_rspSize(mac_ctx, &frm,
+						    &payload_size);
+	if (DOT11F_FAILED(status)) {
+		pe_err("Failed to calculate packed size for a EPCS negotiation Response (0x%08x).",
+		       status);
+		/* We'll fall back on the worst case scenario: */
+		payload_size = sizeof(tDot11fepcs_neg_rsp);
+	} else if (DOT11F_WARNED(status)) {
+		pe_warn("There were warnings while calculating packed size for a EPCS negotiation Response (0x%08x).",
+			status);
+	}
+
+	num_bytes = payload_size + sizeof(*mgmt_hdr);
+	qdf_status = cds_packet_alloc(num_bytes, (void **)&frame_ptr,
+				      (void **)&pkt_ptr);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status) || !pkt_ptr) {
+		pe_err("Failed to allocate %d bytes for a EPCS rsp action frm",
+		       num_bytes);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	lim_populate_mac_header(mac_ctx, frame_ptr, SIR_MAC_MGMT_FRAME,
+				SIR_MAC_MGMT_ACTION, peer_mac,
+				session->self_mac_addr);
+
+	/* Update A3 with the BSSID */
+	mgmt_hdr = (tpSirMacMgmtHdr)frame_ptr;
+	sir_copy_mac_addr(mgmt_hdr->bssId, session->bssId);
+
+	lim_set_protected_bit(mac_ctx, session, peer_mac, mgmt_hdr);
+
+	status = dot11f_pack_epcs_neg_rsp(mac_ctx, &frm,
+					  frame_ptr + sizeof(tSirMacMgmtHdr),
+					  payload_size, &payload_size);
+
+	if (DOT11F_FAILED(status)) {
+		pe_err("Failed to pack a EPCS negotiation response (0x%08x)",
+		       status);
+		qdf_status = QDF_STATUS_E_FAILURE;
+		goto error_epcs_rsp;
+	} else if (DOT11F_WARNED(status)) {
+		pe_warn("There were warnings while packing EPCS rsp (0x%08x)",
+			status);
+	}
+
+	if (!wlan_reg_is_24ghz_ch_freq(session->curr_op_freq) ||
+	    session->opmode == QDF_P2P_CLIENT_MODE ||
+	    session->opmode == QDF_P2P_GO_MODE)
+		tx_flag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
+
+	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_MGMT,
+			 session->peSessionId, mgmt_hdr->fc.subType));
+
+	vdev_id = session->vdev_id;
+	qdf_status = wma_tx_frame(mac_ctx, pkt_ptr, (uint16_t)num_bytes,
+				  TXRX_FRM_802_11_MGMT, ANI_TXDIR_TODS, 7,
+				  lim_tx_complete, frame_ptr, tx_flag,
+				  vdev_id, 0, RATEID_DEFAULT, 0);
+	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_COMPLETE,
+			 session->peSessionId, qdf_status));
+	if (QDF_STATUS_SUCCESS != qdf_status) {
+		pe_err("wma_tx_frame FAILED! Status [%d]", qdf_status);
+		return QDF_STATUS_E_FAILURE;
+	} else {
+		return QDF_STATUS_SUCCESS;
+	}
+
+error_epcs_rsp:
+	cds_packet_free((void *)pkt_ptr);
+	return qdf_status;
+}
+
+QDF_STATUS
+lim_send_epcs_action_req_frame(struct wlan_objmgr_vdev *vdev,
+			       uint8_t *peer_mac,
+			       struct wlan_action_frame_args *args)
+{
+	tDot11fepcs_neg_req frm;
+	struct mac_context *mac_ctx;
+	struct pe_session *session;
+	uint8_t *frame_ptr;
+	tpSirMacMgmtHdr mgmt_hdr;
+	uint32_t num_bytes, payload_size, status;
+	void *pkt_ptr = NULL;
+	QDF_STATUS qdf_status;
+	uint8_t vdev_id = 0;
+	uint8_t tx_flag = 0;
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	if (!vdev)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	vdev_id = wlan_vdev_get_id(vdev);
+
+	session = pe_find_session_by_vdev_id(mac_ctx, vdev_id);
+
+	frm.Category.category = args->category;
+	frm.Action.action = args->action;
+	frm.DialogToken.token = args->arg1;
+
+	pe_debug("Sending a EPCS negotiation Request from " QDF_MAC_ADDR_FMT " to " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(session->self_mac_addr),
+		 QDF_MAC_ADDR_REF(peer_mac));
+	pe_debug("Dialog token %d", frm.DialogToken.token);
+
+	status = dot11f_get_packed_epcs_neg_reqSize(mac_ctx, &frm,
+						    &payload_size);
+	if (DOT11F_FAILED(status)) {
+		pe_err("Failed to calculate packed size for a EPCS negotiation Request (0x%08x).",
+		       status);
+		/* We'll fall back on the worst case scenario: */
+		payload_size = sizeof(tDot11fepcs_neg_req);
+	} else if (DOT11F_WARNED(status)) {
+		pe_warn("There were warnings while calculating packed size for a EPCS negotiation Request (0x%08x).",
+			status);
+	}
+
+	num_bytes = payload_size + sizeof(*mgmt_hdr);
+	qdf_status = cds_packet_alloc(num_bytes, (void **)&frame_ptr,
+				      (void **)&pkt_ptr);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status) || (!pkt_ptr)) {
+		pe_err("Failed to allocate %d bytes for a EPCS req action frm",
+		       num_bytes);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	lim_populate_mac_header(mac_ctx, frame_ptr, SIR_MAC_MGMT_FRAME,
+				SIR_MAC_MGMT_ACTION, peer_mac,
+				session->self_mac_addr);
+
+	/* Update A3 with the BSSID */
+	mgmt_hdr = (tpSirMacMgmtHdr)frame_ptr;
+	sir_copy_mac_addr(mgmt_hdr->bssId, session->bssId);
+	lim_set_protected_bit(mac_ctx, session, peer_mac, mgmt_hdr);
+
+	status = dot11f_pack_epcs_neg_req(mac_ctx, &frm,
+					  frame_ptr + sizeof(tSirMacMgmtHdr),
+					  payload_size, &payload_size);
+
+	if (DOT11F_FAILED(status)) {
+		pe_err("Failed to pack a EPCS negotiation request (0x%08x)",
+		       status);
+		qdf_status = QDF_STATUS_E_FAILURE;
+		goto error_epcs_req;
+	} else if (DOT11F_WARNED(status)) {
+		pe_warn("There were warnings while packing EPCS req (0x%08x)",
+			status);
+	}
+
+	pe_debug("Dump EPCS TX req action frame");
+	qdf_trace_hex_dump(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG, frame_ptr,
+			   num_bytes);
+
+	if (!wlan_reg_is_24ghz_ch_freq(session->curr_op_freq) ||
+	    session->opmode == QDF_P2P_CLIENT_MODE ||
+	    session->opmode == QDF_P2P_GO_MODE)
+		tx_flag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
+
+	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_MGMT,
+			 session->peSessionId, mgmt_hdr->fc.subType));
+	qdf_status = wma_tx_frame(mac_ctx, pkt_ptr, (uint16_t)num_bytes,
+				  TXRX_FRM_802_11_MGMT, ANI_TXDIR_TODS, 7,
+				  lim_tx_complete, frame_ptr, tx_flag,
+				  vdev_id, 0, RATEID_DEFAULT, 0);
+	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_COMPLETE,
+			 session->peSessionId, qdf_status));
+	if (qdf_status != QDF_STATUS_SUCCESS) {
+		pe_err("wma_tx_frame FAILED! Status [%d]", qdf_status);
+		return QDF_STATUS_E_FAILURE;
+	} else {
+		return QDF_STATUS_SUCCESS;
+	}
+
+error_epcs_req:
+	cds_packet_free((void *)pkt_ptr);
+	return qdf_status;
+}
+
+QDF_STATUS
+lim_send_epcs_action_teardown_frame(struct wlan_objmgr_vdev *vdev,
+				    uint8_t *peer_mac,
+				    struct wlan_action_frame_args *args)
+{
+	tDot11fepcs_teardown frm;
+	struct mac_context *mac_ctx;
+	struct pe_session *session;
+	uint8_t *frame_ptr;
+	tpSirMacMgmtHdr mgmt_hdr;
+	uint32_t num_bytes, payload_size, status;
+	void *pkt_ptr = NULL;
+	QDF_STATUS qdf_status;
+	uint8_t vdev_id = 0;
+	uint8_t tx_flag = 0;
+
+	mac_ctx = cds_get_context(QDF_MODULE_ID_PE);
+	if (!mac_ctx)
+		return QDF_STATUS_E_INVAL;
+
+	if (!vdev)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	vdev_id = wlan_vdev_get_id(vdev);
+
+	session = pe_find_session_by_vdev_id(mac_ctx, vdev_id);
+
+	frm.Category.category = args->category;
+	frm.Action.action = args->action;
+
+	pe_debug("Sending a EPCS tear down from " QDF_MAC_ADDR_FMT " to " QDF_MAC_ADDR_FMT,
+		 QDF_MAC_ADDR_REF(session->self_mac_addr),
+		 QDF_MAC_ADDR_REF(peer_mac));
+
+	status = dot11f_get_packed_epcs_teardownSize(mac_ctx, &frm,
+						     &payload_size);
+	if (DOT11F_FAILED(status)) {
+		pe_err("Failed to calculate packed size for a EPCS tear down (0x%08x).",
+		       status);
+		/* We'll fall back on the worst case scenario: */
+		payload_size = sizeof(tDot11fepcs_teardown);
+	} else if (DOT11F_WARNED(status)) {
+		pe_warn("There were warnings while calculating packed size for a EPCS tear down (0x%08x).",
+			status);
+	}
+
+	num_bytes = payload_size + sizeof(*mgmt_hdr);
+	qdf_status = cds_packet_alloc(num_bytes, (void **)&frame_ptr,
+				      (void **)&pkt_ptr);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status) || (!pkt_ptr)) {
+		pe_err("Failed to allocate %d bytes for a EPCS req action frm",
+		       num_bytes);
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_mem_zero(frame_ptr, num_bytes);
+
+	lim_populate_mac_header(mac_ctx, frame_ptr, SIR_MAC_MGMT_FRAME,
+				SIR_MAC_MGMT_ACTION, peer_mac,
+				session->self_mac_addr);
+
+	/* Update A3 with the BSSID */
+	mgmt_hdr = (tpSirMacMgmtHdr)frame_ptr;
+	sir_copy_mac_addr(mgmt_hdr->bssId, session->bssId);
+	lim_set_protected_bit(mac_ctx, session, peer_mac, mgmt_hdr);
+
+	status = dot11f_pack_epcs_teardown(mac_ctx, &frm,
+					   frame_ptr + sizeof(tSirMacMgmtHdr),
+					   payload_size, &payload_size);
+	if (DOT11F_FAILED(status)) {
+		pe_err("Failed to pack a EPCS tear down (0x%08x)",
+		       status);
+		qdf_status = QDF_STATUS_E_FAILURE;
+		goto error_epcs_td;
+	} else if (DOT11F_WARNED(status)) {
+		pe_warn("There were warnings while packing EPCS tear down(0x%08x)",
+			status);
+	}
+
+	pe_debug("Dump EPCS TX tear down action frame");
+	qdf_trace_hex_dump(QDF_MODULE_ID_PE, QDF_TRACE_LEVEL_DEBUG, frame_ptr,
+			   num_bytes);
+
+	if (!wlan_reg_is_24ghz_ch_freq(session->curr_op_freq) ||
+	    session->opmode == QDF_P2P_CLIENT_MODE ||
+	    session->opmode == QDF_P2P_GO_MODE)
+		tx_flag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
+
+	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_MGMT,
+			 session->peSessionId, mgmt_hdr->fc.subType));
+	qdf_status = wma_tx_frame(mac_ctx, pkt_ptr, (uint16_t)num_bytes,
+				  TXRX_FRM_802_11_MGMT, ANI_TXDIR_TODS, 7,
+				  lim_tx_complete, frame_ptr, tx_flag,
+				  vdev_id, 0, RATEID_DEFAULT, 0);
+	MTRACE(qdf_trace(QDF_MODULE_ID_PE, TRACE_CODE_TX_COMPLETE,
+			 session->peSessionId, qdf_status));
+	if (qdf_status != QDF_STATUS_SUCCESS) {
+		pe_err("wma_tx_frame FAILED! Status [%d]", qdf_status);
+		return QDF_STATUS_E_FAILURE;
+	} else {
+		return QDF_STATUS_SUCCESS;
+	}
+
+error_epcs_td:
+	cds_packet_free((void *)pkt_ptr);
+	return qdf_status;
+}
+
 QDF_STATUS
 lim_send_t2lm_action_rsp_frame(struct mac_context *mac_ctx,
 			       tSirMacAddr peer_mac,

core/mac/src/pe/lim/lim_types.h

@@ -1495,6 +1495,66 @@ lim_send_t2lm_action_rsp_frame(struct mac_context *mac_ctx,
 			       struct pe_session *session,
 			       uint8_t token,
 			       enum wlan_t2lm_resp_frm_type status_code);
+
+/**
+ * lim_send_epcs_update_edca_params() - Wrapper for EPCS update edca
+ * @vdev: vdev object
+ * @edca: the pointer of edca parameters
+ * @mu_edca: the flag of mu edca
+ *
+ * Return: 0 for success, non-zero for failure
+ */
+QDF_STATUS
+lim_send_epcs_update_edca_params(struct wlan_objmgr_vdev *vdev,
+				 tSirMacEdcaParamRecord *edca, bool mu_edca);
+
+/**
+ * lim_send_epcs_restore_edca_params() - Restore edca parameters
+ * @vdev: vdev object
+ *
+ * Return: 0 for success, non-zero for failure
+ */
+QDF_STATUS
+lim_send_epcs_restore_edca_params(struct wlan_objmgr_vdev *vdev);
+
+/**
+ * lim_send_epcs_action_rsp_frame() - Send EPCS action response frame
+ * @vdev: vdev object
+ * @peer_mac: peer mac address pointer
+ * @args: the pointer of action frame args
+ *
+ * Return: 0 for success, non-zero for failure
+ */
+QDF_STATUS
+lim_send_epcs_action_rsp_frame(struct wlan_objmgr_vdev *vdev,
+			       uint8_t *peer_mac,
+			       struct wlan_action_frame_args *args);
+
+/**
+ * lim_send_epcs_action_req_frame() - Send EPCS action request frame
+ * @vdev: vdev object
+ * @peer_mac: peer mac address pointer
+ * @args: the pointer of action frame args
+ *
+ * Return: 0 for success, non-zero for failure
+ */
+QDF_STATUS
+lim_send_epcs_action_req_frame(struct wlan_objmgr_vdev *vdev,
+			       uint8_t *peer_mac,
+			       struct wlan_action_frame_args *args);
+
+/**
+ * lim_send_epcs_action_teardown_frame() - Send EPCS action teardown frame
+ * @vdev: vdev object
+ * @peer_mac: peer mac address pointer
+ * @args: the pointer of action frame args
+ *
+ * Return: 0 for success, non-zero for failure
+ */
+QDF_STATUS
+lim_send_epcs_action_teardown_frame(struct wlan_objmgr_vdev *vdev,
+				    uint8_t *peer_mac,
+				    struct wlan_action_frame_args *args);
 #else
 static inline QDF_STATUS
 lim_send_t2lm_action_rsp_frame(struct mac_context *mac_ctx,