qcacld-3.0: Add wow user pattern support in PMO

Add wow user pattern support in PMO.

Change-Id: I186e650e3a165ea0aeaada4bba880005c5be8b5f
CRs-Fixed: 2135644

components/pmo/core/inc/wlan_pmo_wow.h

@@ -175,6 +175,54 @@ static inline void pmo_decrement_wow_default_ptrn(
 	}
 }
 
+/**
+ * pmo_get_wow_default_ptrn() -Get wow default ptrn
+ * @vdev_ctx: pmo vdev priv ctx
+ *
+ * API to get wow default ptrn
+ *
+ * Return: current wow default ptrn count
+ */
+static inline uint8_t pmo_get_wow_default_ptrn(
+		struct pmo_vdev_priv_obj *vdev_ctx)
+{
+	uint8_t count;
+
+	if (vdev_ctx->pmo_psoc_ctx->psoc_cfg.ptrn_id_per_vdev) {
+		qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
+		count = vdev_ctx->num_wow_default_patterns;
+		qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
+	} else {
+		qdf_spin_lock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
+		count = vdev_ctx->pmo_psoc_ctx->wow.ptrn_id_def;
+		qdf_spin_unlock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
+	}
+
+	return count;
+}
+
+/**
+ * pmo_get_wow_default_ptrn() -Set wow default ptrn
+ * @vdev_ctx: pmo vdev priv ctx
+ *
+ * API to set wow default ptrn
+ *
+ * Return: Set wow default ptrn count
+ */
+static inline void pmo_set_wow_default_ptrn(
+		struct pmo_vdev_priv_obj *vdev_ctx, uint8_t value)
+{
+	if (vdev_ctx->pmo_psoc_ctx->psoc_cfg.ptrn_id_per_vdev) {
+		qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
+		vdev_ctx->num_wow_default_patterns = value;
+		qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
+	} else {
+		qdf_spin_lock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
+		vdev_ctx->pmo_psoc_ctx->wow.ptrn_id_def = value;
+		qdf_spin_unlock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
+	}
+}
+
 /**
  * pmo_increment_wow_user_ptrn() -increment wow user ptrn
  * @vdev_ctx: pmo vdev priv ctx
@@ -219,6 +267,32 @@ static inline void pmo_decrement_wow_user_ptrn(
 	}
 }
 
+/**
+ * pmo_get_wow_user_ptrn() -Get wow user ptrn
+ * @vdev_ctx: pmo vdev priv ctx
+ *
+ * API to Get wow user ptrn
+ *
+ * Return: None
+ */
+static inline uint8_t pmo_get_wow_user_ptrn(
+		struct pmo_vdev_priv_obj *vdev_ctx)
+{
+	uint8_t count;
+
+	if (vdev_ctx->pmo_psoc_ctx->psoc_cfg.ptrn_id_per_vdev) {
+		qdf_spin_lock_bh(&vdev_ctx->pmo_vdev_lock);
+		count = vdev_ctx->num_wow_user_patterns;
+		qdf_spin_unlock_bh(&vdev_ctx->pmo_vdev_lock);
+	} else {
+		qdf_spin_lock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
+		count = vdev_ctx->pmo_psoc_ctx->wow.ptrn_id_usr;
+		qdf_spin_unlock_bh(&vdev_ctx->pmo_psoc_ctx->lock);
+	}
+
+	return count;
+}
+
 void pmo_dump_wow_ptrn(struct pmo_wow_add_pattern *ptrn);
 
 /**
@@ -229,18 +303,18 @@ void pmo_dump_wow_ptrn(struct pmo_wow_add_pattern *ptrn);
  *
  * Return: false if any errors encountered, QDF_STATUS_SUCCESS otherwise
  */
-QDF_STATUS pmo_core_add_wow_pattern(struct wlan_objmgr_vdev *vdev,
-		const char *ptrn);
+QDF_STATUS pmo_core_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+			struct pmo_wow_add_pattern *ptrn);
 
 /**
  * pmo_core_del_wow_pattern() - Function which will delete the WoWL pattern
  * @vdev: pointer to the vdev
- * @ptrn: pointer to the pattern string to be added
+ * @ptrn: pointer to the pattern string to be delete
  *
  * Return: error if any errors encountered, QDF_STATUS_SUCCESS otherwise
  */
-QDF_STATUS pmo_core_del_wow_pattern(struct wlan_objmgr_vdev *vdev,
-		const char *ptrn);
+QDF_STATUS pmo_core_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+			uint8_t pattern_id);
 
 /**
  * pmo_core_wow_enter() - store enable/disable status for pattern

components/pmo/core/src/wlan_pmo_wow.c

@@ -27,30 +27,105 @@
 #include "wlan_pmo_static_config.h"
 #include "wlan_reg_services_api.h"
 
-static inline int pmo_find_wow_ptrn_len(const char *ptrn)
+QDF_STATUS pmo_core_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+		struct pmo_wow_add_pattern *ptrn)
 {
-	int len = 0;
+	QDF_STATUS status;
+	uint8_t id;
+	uint8_t bit_to_check, pos;
+	uint8_t new_mask[PMO_WOWL_BCAST_PATTERN_MAX_SIZE];
+	struct pmo_vdev_priv_obj *vdev_ctx;
+
+	status = pmo_vdev_get_ref(vdev);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto out;
 
-	while (*ptrn != '\0' && *ptrn != PMO_WOW_INTER_PTRN_TOKENIZER) {
-		len++;
-		ptrn++;
+	vdev_ctx = pmo_vdev_get_priv(vdev);
+
+	/* clear all default patterns cofigured by pmo */
+	for (id = 0; id < pmo_get_wow_default_ptrn(vdev_ctx); id++)
+		pmo_tgt_del_wow_pattern(vdev, id, false);
+
+	pmo_set_wow_default_ptrn(vdev_ctx, 0);
+
+	pmo_debug("Add user passed wow pattern id %d vdev id %d",
+		ptrn->pattern_id, ptrn->session_id);
+	/*
+	 * Convert received pattern mask value from bit representation
+	 * to byte representation.
+	 *
+	 * For example, received value from umac,
+	 *
+	 *      Mask value    : A1 (equivalent binary is "1010 0001")
+	 *      Pattern value : 12:00:13:00:00:00:00:44
+	 *
+	 * The value which goes to FW after the conversion from this
+	 * function (1 in mask value will become FF and 0 will
+	 * become 00),
+	 *
+	 *      Mask value    : FF:00:FF:00:0:00:00:FF
+	 *      Pattern value : 12:00:13:00:00:00:00:44
+	 */
+	qdf_mem_zero(new_mask, sizeof(new_mask));
+	for (pos = 0; pos < ptrn->pattern_size; pos++) {
+		bit_to_check = (PMO_NUM_BITS_IN_BYTE - 1) -
+			       (pos % PMO_NUM_BITS_IN_BYTE);
+		bit_to_check = 0x1 << bit_to_check;
+		if (ptrn->pattern_mask[pos / PMO_NUM_BITS_IN_BYTE] &
+							bit_to_check)
+			new_mask[pos] = PMO_WOW_PTRN_MASK_VALID;
 	}
 
-	return len;
-}
+	status = pmo_tgt_send_wow_patterns_to_fw(vdev,
+			ptrn->pattern_id,
+			ptrn->pattern, ptrn->pattern_size,
+			ptrn->pattern_byte_offset, new_mask,
+			ptrn->pattern_size, true);
+	if (status != QDF_STATUS_SUCCESS)
+		pmo_err("Failed to add wow pattern %d", ptrn->pattern_id);
 
-QDF_STATUS pmo_core_add_wow_pattern(struct wlan_objmgr_vdev *vdev,
-		const char *ptrn)
-{
-	return QDF_STATUS_SUCCESS;
+	pmo_vdev_put_ref(vdev);
+out:
+	PMO_EXIT();
+
+	return status;
 }
 
-QDF_STATUS pmo_core_del_wow_pattern(struct wlan_objmgr_vdev *vdev,
-		const char *ptrn)
+QDF_STATUS pmo_core_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+		uint8_t pattern_id)
 {
-	return QDF_STATUS_SUCCESS;
+	QDF_STATUS status;
+	struct pmo_vdev_priv_obj *vdev_ctx;
+
+	status = pmo_vdev_get_ref(vdev);
+	if (QDF_IS_STATUS_ERROR(status))
+		goto out;
+
+	vdev_ctx = pmo_vdev_get_priv(vdev);
+	if (pmo_get_wow_user_ptrn(vdev_ctx) <= 0) {
+		pmo_err("No valid user pattern. Num user pattern %u",
+			pmo_get_wow_user_ptrn(vdev_ctx));
+		status = QDF_STATUS_E_INVAL;
+		goto rel_ref;
+	}
+
+	pmo_debug("Delete user passed wow pattern id %d total user pattern %d",
+		pattern_id, pmo_get_wow_user_ptrn(vdev_ctx));
+
+	pmo_tgt_del_wow_pattern(vdev, pattern_id, true);
+
+	/* configure default patterns once all user patterns are deleted */
+	if (!pmo_get_wow_user_ptrn(vdev_ctx))
+		pmo_register_wow_default_patterns(vdev);
+rel_ref:
+	pmo_vdev_put_ref(vdev);
+out:
+	PMO_EXIT();
+
+	return status;
 }
 
+
 QDF_STATUS pmo_core_wow_enter(struct wlan_objmgr_vdev *vdev,
 		struct pmo_wow_enter_params *wow_enter_param)
 {

components/pmo/dispatcher/inc/wlan_pmo_obj_mgmt_public_struct.h

@@ -74,6 +74,7 @@ int (*pmo_pld_auto_resume_cb)(void);
  * @send_enable_wakeup_event_req: fp to send enable wow wakeup events req
  * @send_disable_wakeup_event_req: fp to send disable wow wakeup events req
  * @send_add_wow_pattern: fp to send wow pattern request
+ * @del_wow_pattern: fp to delete wow pattern from firmware
  * @send_enhance_mc_offload_req: fp to send enhanced multicast offload request
  * @send_set_mc_filter_req: fp to send set mc filter request
  * @send_clear_mc_filter_req: fp to send clear mc filter request
@@ -128,6 +129,8 @@ struct wlan_pmo_tx_ops {
 			uint8_t ptrn_id, const uint8_t *ptrn, uint8_t ptrn_len,
 			uint8_t ptrn_offset, const uint8_t *mask,
 			uint8_t mask_len, bool user);
+	QDF_STATUS (*del_wow_pattern)(
+			struct wlan_objmgr_vdev *vdev, uint8_t ptrn_id);
 	QDF_STATUS (*send_enhance_mc_offload_req)(
 			struct wlan_objmgr_vdev *vdev, bool enable);
 	QDF_STATUS (*send_set_mc_filter_req)(

components/pmo/dispatcher/inc/wlan_pmo_tgt_api.h

@@ -150,6 +150,10 @@ QDF_STATUS pmo_tgt_send_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
 		uint8_t ptrn_offset, const uint8_t *mask,
 		uint8_t mask_len, bool user);
 
+QDF_STATUS pmo_tgt_del_wow_pattern(
+		struct wlan_objmgr_vdev *vdev, uint8_t ptrn_id,
+		bool user);
+
 /**
  * pmo_tgt_set_mc_filter_req() - Set mcast filter command to fw
  * @vdev: objmgr vdev

components/pmo/dispatcher/inc/wlan_pmo_ucfg_api.h

@@ -529,6 +529,12 @@ QDF_STATUS pmo_ucfg_psoc_bus_runtime_resume(struct wlan_objmgr_psoc *psoc,
 QDF_STATUS pmo_ucfg_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
 		int disable_target_intr);
 
+QDF_STATUS pmo_ucfg_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+		struct pmo_wow_add_pattern *ptrn);
+
+QDF_STATUS pmo_ucfg_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+		uint8_t pattern_id);
+
 /**
  * pmo_ucfg_psoc_bus_resume() -handle bus resume request for psoc
  * @psoc: objmgr psoc handle

components/pmo/dispatcher/inc/wlan_pmo_wow_public_struct.h

@@ -36,6 +36,9 @@
 #define PMO_WOW_INTER_PTRN_TOKENIZER   ';'
 #define PMO_WOW_INTRA_PTRN_TOKENIZER   ':'
 
+#define PMO_WOW_PTRN_MASK_VALID     0xFF
+#define PMO_NUM_BITS_IN_BYTE           8
+
 
 /* Action frame categories */
 

components/pmo/dispatcher/src/wlan_pmo_tgt_wow.c

@@ -107,7 +107,7 @@ QDF_STATUS pmo_tgt_send_wow_patterns_to_fw(
 	if (status != QDF_STATUS_SUCCESS) {
 		if (!user)
 			pmo_decrement_wow_default_ptrn(vdev_ctx);
-		pmo_err("Failed to sen wow pattern event");
+		pmo_err("Failed to send wow pattern event");
 		goto out;
 	}
 
@@ -119,3 +119,36 @@ out:
 	return status;
 }
 
+QDF_STATUS pmo_tgt_del_wow_pattern(
+		struct wlan_objmgr_vdev *vdev, uint8_t ptrn_id,
+		bool user)
+{
+	QDF_STATUS status;
+	struct pmo_vdev_priv_obj *vdev_ctx;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_pmo_tx_ops pmo_tx_ops;
+
+	PMO_ENTER();
+	psoc = pmo_vdev_get_psoc(vdev);
+	vdev_ctx = pmo_vdev_get_priv(vdev);
+
+	pmo_tx_ops = GET_PMO_TX_OPS_FROM_PSOC(psoc);
+	if (!pmo_tx_ops.del_wow_pattern) {
+		pmo_err("del_wow_pattern is null");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto out;
+	}
+	status = pmo_tx_ops.del_wow_pattern(vdev, ptrn_id);
+	if (status) {
+		status = QDF_STATUS_E_FAILURE;
+		goto out;
+	}
+
+	if (user)
+		pmo_decrement_wow_user_ptrn(vdev_ctx);
+out:
+	PMO_EXIT();
+
+	return status;
+}
+

components/pmo/dispatcher/src/wlan_pmo_ucfg_api.c

@@ -298,6 +298,18 @@ QDF_STATUS pmo_ucfg_psoc_suspend_target(struct wlan_objmgr_psoc *psoc,
 	return pmo_core_psoc_suspend_target(psoc, disable_target_intr);
 }
 
+QDF_STATUS pmo_ucfg_add_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+		struct pmo_wow_add_pattern *ptrn)
+{
+	return pmo_core_add_wow_user_pattern(vdev, ptrn);
+}
+
+QDF_STATUS pmo_ucfg_del_wow_user_pattern(struct wlan_objmgr_vdev *vdev,
+		uint8_t pattern_id)
+{
+	return pmo_core_del_wow_user_pattern(vdev, pattern_id);
+}
+
 QDF_STATUS pmo_ucfg_psoc_bus_resume_req(struct wlan_objmgr_psoc *psoc,
 		enum qdf_suspend_type type)
 {

components/target_if/pmo/inc/target_if_pmo.h

@@ -69,6 +69,9 @@ QDF_STATUS target_if_pmo_send_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
 		uint8_t ptrn_offset, const uint8_t *mask,
 		uint8_t mask_len, bool user);
 
+QDF_STATUS target_if_pmo_del_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
+		uint8_t ptrn_id);
+
 /**
  * target_if_pmo_send_enhance_mc_offload_req() - send enhance mc offload req
  * @vdev: objmgr vdev

components/target_if/pmo/src/target_if_pmo_main.c

@@ -43,6 +43,8 @@ void target_if_pmo_register_tx_ops(struct wlan_pmo_tx_ops *pmo_tx_ops)
 		target_if_pmo_disable_wow_wakeup_event;
 	pmo_tx_ops->send_add_wow_pattern =
 		target_if_pmo_send_wow_patterns_to_fw;
+	pmo_tx_ops->del_wow_pattern =
+		target_if_pmo_del_wow_patterns_to_fw;
 	pmo_tx_ops->send_enhance_mc_offload_req =
 		target_if_pmo_send_enhance_mc_offload_req;
 	pmo_tx_ops->send_set_mc_filter_req =

components/target_if/pmo/src/target_if_pmo_wow.c

@@ -112,3 +112,29 @@ QDF_STATUS target_if_pmo_send_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
 	return status;
 }
 
+QDF_STATUS target_if_pmo_del_wow_patterns_to_fw(struct wlan_objmgr_vdev *vdev,
+		uint8_t ptrn_id)
+{
+	uint8_t vdev_id;
+	struct wlan_objmgr_psoc *psoc;
+	QDF_STATUS status;
+
+	if (!vdev) {
+		target_if_err("vdev ptr passed is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	psoc = wlan_vdev_get_psoc(vdev);
+	vdev_id = wlan_vdev_get_id(vdev);
+	if (!psoc) {
+		target_if_err("psoc handle is NULL");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = wmi_unified_wow_delete_pattern_cmd(
+				GET_WMI_HDL_FROM_PSOC(psoc), ptrn_id,
+				vdev_id);
+
+	return status;
+}
+

core/hdd/src/wlan_hdd_wowl.c

@@ -35,6 +35,7 @@
 
 #include <wlan_hdd_includes.h>
 #include <wlan_hdd_wowl.h>
+#include <wlan_pmo_wow_public_struct.h>
 
 /* Preprocessor Definitions and Constants */
 #define WOWL_INTER_PTRN_TOKENIZER   ';'
@@ -78,7 +79,7 @@ static void hdd_wowl_wake_indication_callback(void *pContext,
  *
  * Return: none
  */
-static void dump_hdd_wowl_ptrn(struct wow_add_pattern *ptrn)
+static void dump_hdd_wowl_ptrn(struct pmo_wow_add_pattern *ptrn)
 {
 	int i;
 
@@ -104,11 +105,10 @@ static void dump_hdd_wowl_ptrn(struct wow_add_pattern *ptrn)
  */
 bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
 {
-	struct wow_add_pattern localPattern;
+	struct pmo_wow_add_pattern localPattern;
 	int i, first_empty_slot, len, offset;
 	QDF_STATUS qdf_ret_status;
 	const char *temp;
-	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
 	uint8_t sessionId = adapter->session_id;
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 
@@ -166,7 +166,7 @@ bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
 			(hex_to_bin(ptrn[3]) * 0x10) +
 						hex_to_bin(ptrn[4]);
 
-		if (localPattern.pattern_size > SIR_WOWL_BCAST_PATTERN_MAX_SIZE
+		if (localPattern.pattern_size > PMO_WOWL_BCAST_PATTERN_MAX_SIZE
 		    || localPattern.pattern_mask_size >
 		    WOWL_PTRN_MASK_MAX_SIZE) {
 			hdd_err("Invalid length specified. Skip!");
@@ -229,9 +229,8 @@ bool hdd_add_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
 		localPattern.session_id = sessionId;
 
 		/* Register the pattern downstream */
-		qdf_ret_status =
-			sme_wow_add_pattern(hHal, &localPattern,
-						   sessionId);
+		qdf_ret_status = pmo_ucfg_add_wow_user_pattern(
+					adapter->hdd_vdev, &localPattern);
 		if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
 			/* Add failed, so invalidate the local storage */
 			hdd_err("sme_wowl_add_bcast_pattern failed with error code (%d)",
@@ -264,12 +263,9 @@ next_ptrn:
  */
 bool hdd_del_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
 {
-	struct wow_delete_pattern delPattern;
 	unsigned char id;
-	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
 	bool patternFound = false;
 	QDF_STATUS qdf_ret_status;
-	uint8_t sessionId = adapter->session_id;
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 
 	/* Detect pattern */
@@ -284,11 +280,8 @@ bool hdd_del_wowl_ptrn(struct hdd_adapter *adapter, const char *ptrn)
 
 	/* If pattern present, remove it from downstream */
 	if (patternFound) {
-		delPattern.pattern_id = id;
-		delPattern.session_id = sessionId;
-		qdf_ret_status =
-			sme_wow_delete_pattern(hHal, &delPattern,
-						   sessionId);
+		qdf_ret_status = pmo_ucfg_del_wow_user_pattern(
+					adapter->hdd_vdev, id);
 		if (QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
 			/* Remove from local storage as well */
 			hdd_err("Deleted pattern with id %d [%s]", id,
@@ -317,9 +310,8 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
 			       uint8_t pattern_offset, char *pattern_buf,
 			       char *pattern_mask)
 {
-	struct wow_add_pattern localPattern;
+	struct pmo_wow_add_pattern localPattern;
 	QDF_STATUS qdf_ret_status;
-	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
 	uint8_t session_id = adapter->session_id;
 	uint16_t pattern_len, mask_len, i;
 
@@ -352,10 +344,10 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
 	localPattern.pattern_size = pattern_len;
 	localPattern.session_id = session_id;
 
-	if (localPattern.pattern_size > SIR_WOWL_BCAST_PATTERN_MAX_SIZE) {
+	if (localPattern.pattern_size > PMO_WOWL_BCAST_PATTERN_MAX_SIZE) {
 		hdd_err("WoW pattern size (%d) greater than max (%d)",
 			localPattern.pattern_size,
-			SIR_WOWL_BCAST_PATTERN_MAX_SIZE);
+			PMO_WOWL_BCAST_PATTERN_MAX_SIZE);
 		return false;
 	}
 	/* Extract the pattern */
@@ -397,11 +389,10 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
 	}
 
 	/* Register the pattern downstream */
-	qdf_ret_status =
-		sme_wow_add_pattern(hHal, &localPattern, session_id);
-
+	qdf_ret_status = pmo_ucfg_add_wow_user_pattern(
+				adapter->hdd_vdev, &localPattern);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
-		hdd_err("sme_wowl_add_bcast_pattern failed with error code (%d).",
+		hdd_err("pmo_wow_user_pattern failed with error code (%d).",
 			  qdf_ret_status);
 
 		return false;
@@ -429,10 +420,7 @@ bool hdd_add_wowl_ptrn_debugfs(struct hdd_adapter *adapter, uint8_t pattern_idx,
 bool hdd_del_wowl_ptrn_debugfs(struct hdd_adapter *adapter,
 			       uint8_t pattern_idx)
 {
-	struct wow_delete_pattern delPattern;
-	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
 	QDF_STATUS qdf_ret_status;
-	uint8_t sessionId = adapter->session_id;
 
 	if (pattern_idx > (WOWL_MAX_PTRNS_ALLOWED - 1)) {
 		hdd_err("WoW pattern index %d is not in the range (0 ~ %d).",
@@ -448,11 +436,8 @@ bool hdd_del_wowl_ptrn_debugfs(struct hdd_adapter *adapter,
 		return false;
 	}
 
-	delPattern.pattern_id = pattern_idx;
-	delPattern.session_id = sessionId;
-	qdf_ret_status = sme_wow_delete_pattern(hHal, &delPattern,
-						    sessionId);
-
+	qdf_ret_status = pmo_ucfg_del_wow_user_pattern(
+				adapter->hdd_vdev, pattern_idx);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_ret_status)) {
 		hdd_err("sme_wowl_del_bcast_pattern failed with error code (%d).",
 			 qdf_ret_status);

core/mac/inc/sir_api.h

@@ -2384,40 +2384,6 @@ typedef struct sSmeCsaOffloadInd {
 	struct qdf_mac_addr bssid;      /* BSSID */
 } tSmeCsaOffloadInd, *tpSmeCsaOffloadInd;
 
-/* WOW related structures */
-#define SIR_WOWL_BCAST_PATTERN_MAX_SIZE 146
-
-/**
- * struct wow_add_pattern - wow pattern add structure
- * @pattern_id: pattern id
- * @pattern_byte_offset: pattern byte offset from beginning of the 802.11
- *			 packet to start of the wake-up pattern
- * @pattern_size: pattern size
- * @pattern: pattern byte stream
- * @pattern_mask_size: pattern mask size
- * @pattern_mask: pattern mask
- * @session_id: session id
- */
-struct wow_add_pattern {
-	uint8_t pattern_id;
-	uint8_t pattern_byte_offset;
-	uint8_t pattern_size;
-	uint8_t pattern[SIR_WOWL_BCAST_PATTERN_MAX_SIZE];
-	uint8_t pattern_mask_size;
-	uint8_t pattern_mask[SIR_WOWL_BCAST_PATTERN_MAX_SIZE];
-	uint8_t session_id;
-};
-
-/**
- * struct wow_delete_patern - wow pattern delete structure
- * @pattern_id: pattern id of wake up pattern to be deleted
- * @session_id: session id
- */
-struct wow_delete_pattern {
-	uint8_t pattern_id;
-	uint8_t session_id;
-};
-
 /* SME->PE: Enter WOWLAN parameters */
 typedef struct sSirSmeWowlEnterParams {
 	uint8_t sessionId;

core/sme/inc/sme_api.h

@@ -412,11 +412,6 @@ static inline void sme_deregister_oem_data_rsp_callback(tHalHandle h_hal)
 
 #endif
 
-extern QDF_STATUS sme_wow_add_pattern(tHalHandle hHal,
-		struct wow_add_pattern *pattern, uint8_t sessionId);
-extern QDF_STATUS sme_wow_delete_pattern(tHalHandle hHal,
-		struct wow_delete_pattern *pattern, uint8_t sessionId);
-
 void sme_register_ftm_msg_processor(tHalHandle hal,
 				    hdd_ftm_msg_processor callback);
 

core/sme/src/common/sme_api.c

@@ -4197,93 +4197,6 @@ void sme_register_ftm_msg_processor(tHalHandle hal,
 	mac_ctx->ftm_msg_processor_callback = callback;
 }
 
-/**
- * sme_wow_add_pattern() - add a wow pattern in fw
- * @hHal: handle returned by mac_open
- * @pattern: pointer to input pattern
- *
- * Add a pattern for Pattern Byte Matching in WoW mode. Firmware will
- * do a pattern match on these patterns when WoW is enabled during system
- * suspend.
- *
- * Return: QDF_STATUS
- */
-QDF_STATUS sme_wow_add_pattern(tHalHandle hal,
-			struct wow_add_pattern *pattern,
-			uint8_t session_id)
-{
-	tpAniSirGlobal pMac = PMAC_STRUCT(hal);
-	struct wow_add_pattern *ptrn;
-	tSirRetStatus ret_code = eSIR_SUCCESS;
-	struct scheduler_msg msg_q = {0};
-
-	MTRACE(qdf_trace(QDF_MODULE_ID_SME,
-			TRACE_CODE_SME_RX_HDD_WOWL_ADDBCAST_PATTERN, session_id,
-			0));
-	ptrn = qdf_mem_malloc(sizeof(*ptrn));
-	if (NULL == ptrn) {
-		sme_err("Fail to allocate memory for WoWLAN Add Bcast Pattern");
-		return QDF_STATUS_E_NOMEM;
-	}
-	(void)qdf_mem_copy(ptrn, pattern, sizeof(*ptrn));
-
-	msg_q.type = WMA_WOW_ADD_PTRN;
-	msg_q.reserved = 0;
-	msg_q.bodyptr = ptrn;
-	msg_q.bodyval = 0;
-
-	sme_debug("Sending WMA_WOWL_ADD_BCAST_PTRN to HAL");
-	ret_code = wma_post_ctrl_msg(pMac, &msg_q);
-	if (eSIR_SUCCESS != ret_code) {
-		sme_err("Posting WMA_WOWL_ADD_BCAST_PTRN failed, reason: %X",
-			ret_code);
-		return QDF_STATUS_E_FAILURE;
-	}
-	return QDF_STATUS_SUCCESS;
-}
-
-/**
- * sme_wow_delete_pattern() - delete user configured wow pattern in target
- * @hHal: handle returned by mac_open.
- * @pattern: pointer to delete pattern parameter
- * @sessionId: session id
- *
- * Return: QDF_STATUS
- */
-QDF_STATUS sme_wow_delete_pattern(tHalHandle hal,
-		struct wow_delete_pattern *pattern, uint8_t sessionId)
-{
-	tpAniSirGlobal pMac = PMAC_STRUCT(hal);
-	struct wow_delete_pattern *delete_ptrn;
-	tSirRetStatus ret_code = eSIR_SUCCESS;
-	struct scheduler_msg msg_q = {0};
-
-	MTRACE(qdf_trace(QDF_MODULE_ID_SME,
-			 TRACE_CODE_SME_RX_HDD_WOWL_DELBCAST_PATTERN, sessionId,
-			 0));
-	delete_ptrn = qdf_mem_malloc(sizeof(*delete_ptrn));
-	if (NULL == delete_ptrn) {
-		sme_err("Allocation failed for WoWLAN Delete Bcast Pattern");
-		return QDF_STATUS_E_NOMEM;
-	}
-	(void)qdf_mem_copy(delete_ptrn, pattern, sizeof(*delete_ptrn));
-	msg_q.type = WMA_WOW_DEL_PTRN;
-	msg_q.reserved = 0;
-	msg_q.bodyptr = delete_ptrn;
-	msg_q.bodyval = 0;
-
-	sme_debug("Sending WMA_WOWL_DEL_BCAST_PTRN");
-
-	ret_code = wma_post_ctrl_msg(pMac, &msg_q);
-	if (eSIR_SUCCESS != ret_code) {
-		sme_err("Posting WMA_WOWL_DEL_BCAST_PTRN failed, reason: %X",
-			ret_code);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	return QDF_STATUS_SUCCESS;
-}
-
 /**
  * sme_enter_wowl(): SME API exposed to HDD to request enabling of WOWL mode.
  * @hal_ctx - The handle returned by mac_open.

core/wma/inc/wma_internal.h

@@ -997,12 +997,6 @@ int wma_wow_wakeup_host_event(void *handle, uint8_t *event,
 				     uint32_t len);
 int wma_pdev_resume_event_handler(void *handle, uint8_t *event, uint32_t len);
 
-QDF_STATUS wma_wow_add_pattern(tp_wma_handle wma,
-			struct wow_add_pattern *ptrn);
-
-QDF_STATUS wma_wow_delete_user_pattern(tp_wma_handle wma,
-			struct wow_delete_pattern *pattern);
-
 QDF_STATUS wma_wow_enter(tp_wma_handle wma, tpSirHalWowlEnterParams info);
 
 QDF_STATUS wma_wow_exit(tp_wma_handle wma, tpSirHalWowlExitParams info);

core/wma/src/wma_features.c

@@ -2846,43 +2846,6 @@ static inline void wma_set_wow_bus_suspend(tp_wma_handle wma, int val)
 	wmi_set_is_wow_bus_suspended(wma->wmi_handle, val);
 }
 
-/**
- * wma_wow_add_pattern() - add wow pattern in target
- * @wma: wma handle
- * @ptrn: wow pattern
- *
- * This function does following:
- * 1) Delete all default patterns of the vdev
- * 2) Add received wow patterns for given vdev in target.
- *
- * Target is responsible for caching wow patterns accross multiple
- * suspend/resumes until the pattern is deleted by user
- *
- * Return: QDF status
- */
-QDF_STATUS wma_wow_add_pattern(tp_wma_handle wma, struct wow_add_pattern *ptrn)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-/**
- * wma_wow_delete_user_pattern() - delete user configured wow pattern in target
- * @wma: wma handle
- * @ptrn: wow pattern
- *
- * This function does following:
- * 1) Deletes a particular user configured wow pattern in target
- * 2) After deleting all user wow patterns add default wow patterns
- *    specific to that vdev.
- *
- * Return: QDF status
- */
-QDF_STATUS wma_wow_delete_user_pattern(tp_wma_handle wma,
-					struct wow_delete_pattern *pattern)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
 /**
  * wma_wow_enter() - store enable/disable status for pattern
  * @wma: wma handle

core/wma/src/wma_main.c

@@ -7437,16 +7437,6 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
 		wma_aggr_qos_req(wma_handle, (tAggrAddTsParams *) msg->bodyptr);
 		break;
 
-	case WMA_WOW_ADD_PTRN:
-		wma_wow_add_pattern(wma_handle,
-				    (struct wow_add_pattern *) msg->bodyptr);
-		qdf_mem_free(msg->bodyptr);
-		break;
-	case WMA_WOW_DEL_PTRN:
-		wma_wow_delete_user_pattern(wma_handle,
-				    (struct wow_delete_pattern *) msg->bodyptr);
-		qdf_mem_free(msg->bodyptr);
-		break;
 	case WMA_WOWL_ENTER_REQ:
 		wma_wow_enter(wma_handle,
 			      (tpSirHalWowlEnterParams) msg->bodyptr);