qcacld-3.0: Configure and clear packet filter

Add PMO changes to configure and clear default packet filters
over suspend and resume.

Change-Id: Icd0acdbb58bebb5726a4213b13db59fe083835a5
CRs-Fixed: 2034398

core/hdd/src/wlan_hdd_wext.c

@@ -11607,9 +11607,10 @@ static int wlan_hdd_set_filter(hdd_context_t *hdd_ctx,
 				struct pkt_filter_cfg *request,
 				uint8_t sessionId)
 {
-	tSirRcvPktFilterCfgType packetFilterSetReq = {0};
-	tSirRcvFltPktClearParam packetFilterClrReq = {0};
+	struct pmo_rcv_pkt_fltr_cfg *pmo_set_pkt_fltr_req = NULL;
+	struct pmo_rcv_pkt_fltr_clear_param *pmo_clr_pkt_fltr_param = NULL;
 	int i = 0;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (hdd_ctx->config->disablePacketFilter) {
 		hdd_warn("Packet filtering disabled in ini");
@@ -11625,25 +11626,33 @@ static int wlan_hdd_set_filter(hdd_context_t *hdd_ctx,
 		hdd_debug("Set Packet Filter Request for Id: %d",
 			request->filter_id);
 
-		packetFilterSetReq.filterId = request->filter_id;
+		pmo_set_pkt_fltr_req =
+			qdf_mem_malloc(sizeof(*pmo_set_pkt_fltr_req));
+		if (!pmo_set_pkt_fltr_req) {
+			pmo_err("unable to allocate pmo_set_pkt_fltr_req");
+			return QDF_STATUS_E_NOMEM;
+		}
+
+		pmo_set_pkt_fltr_req->filter_id = request->filter_id;
 		if (request->num_params >= HDD_MAX_CMP_PER_PACKET_FILTER) {
 			hdd_err("Number of Params exceed Max limit %d",
 				request->num_params);
-			return -EINVAL;
+			status = QDF_STATUS_E_INVAL;
+			goto out;
 		}
-		packetFilterSetReq.numFieldParams = request->num_params;
-		packetFilterSetReq.coalesceTime = 0;
-		packetFilterSetReq.filterType = HDD_RCV_FILTER_SET;
+		pmo_set_pkt_fltr_req->num_params = request->num_params;
+		pmo_set_pkt_fltr_req->coalesce_time = 0;
+		pmo_set_pkt_fltr_req->filter_type = HDD_RCV_FILTER_SET;
 		for (i = 0; i < request->num_params; i++) {
-			packetFilterSetReq.paramsData[i].protocolLayer =
+			pmo_set_pkt_fltr_req->params_data[i].protocol_layer =
 				request->params_data[i].protocol_layer;
-			packetFilterSetReq.paramsData[i].cmpFlag =
+			pmo_set_pkt_fltr_req->params_data[i].compare_flag =
 				request->params_data[i].compare_flag;
-			packetFilterSetReq.paramsData[i].dataOffset =
+			pmo_set_pkt_fltr_req->params_data[i].data_offset =
 				request->params_data[i].data_offset;
-			packetFilterSetReq.paramsData[i].dataLength =
+			pmo_set_pkt_fltr_req->params_data[i].data_length =
 				request->params_data[i].data_length;
-			packetFilterSetReq.paramsData[i].reserved = 0;
+			pmo_set_pkt_fltr_req->params_data[i].reserved = 0;
 
 			if (request->params_data[i].data_offset >
 			    SIR_MAX_FILTER_TEST_DATA_OFFSET) {
@@ -11651,36 +11660,41 @@ static int wlan_hdd_set_filter(hdd_context_t *hdd_ctx,
 					request->params_data[i].data_offset,
 					i,
 					SIR_MAX_FILTER_TEST_DATA_OFFSET);
-				return -EINVAL;
+				status = QDF_STATUS_E_INVAL;
+				goto out;
 			}
 
 			if (request->params_data[i].data_length >
 				SIR_MAX_FILTER_TEST_DATA_LEN) {
 				hdd_err("Error invalid data length %d",
 					request->params_data[i].data_length);
-				return -EINVAL;
+				status = QDF_STATUS_E_INVAL;
+				goto out;
 			}
 
 			hdd_debug("Proto %d Comp Flag %d Filter Type %d",
 				request->params_data[i].protocol_layer,
 				request->params_data[i].compare_flag,
-				packetFilterSetReq.filterType);
+				pmo_set_pkt_fltr_req->filter_type);
 
 			hdd_debug("Data Offset %d Data Len %d",
 				request->params_data[i].data_offset,
 				request->params_data[i].data_length);
 
-			if (sizeof(packetFilterSetReq.paramsData[i].compareData)
+			if (sizeof(
+			    pmo_set_pkt_fltr_req->params_data[i].compare_data)
 				< (request->params_data[i].data_length)) {
 				hdd_err("Error invalid data length %d",
 					request->params_data[i].data_length);
-				return -EINVAL;
+				status = QDF_STATUS_E_INVAL;
+				goto out;
 			}
 
-			memcpy(&packetFilterSetReq.paramsData[i].compareData,
+			memcpy(
+			    &pmo_set_pkt_fltr_req->params_data[i].compare_data,
 			       request->params_data[i].compare_data,
 			       request->params_data[i].data_length);
-			memcpy(&packetFilterSetReq.paramsData[i].dataMask,
+			memcpy(&pmo_set_pkt_fltr_req->params_data[i].data_mask,
 			       request->params_data[i].data_mask,
 			       request->params_data[i].data_length);
 
@@ -11702,26 +11716,35 @@ static int wlan_hdd_set_filter(hdd_context_t *hdd_ctx,
 		}
 
 		if (QDF_STATUS_SUCCESS !=
-			sme_receive_filter_set_filter(hdd_ctx->hHal,
-				&packetFilterSetReq,
+			pmo_ucfg_set_pkt_filter(hdd_ctx->hdd_psoc,
+				pmo_set_pkt_fltr_req,
 				sessionId)) {
 			hdd_err("Failure to execute Set Filter");
-			return -EINVAL;
+			status = QDF_STATUS_E_INVAL;
+			goto out;
 		}
 
 		break;
 
 	case HDD_RCV_FILTER_CLEAR:
-
 		hdd_debug("Clear Packet Filter Request for Id: %d",
 			request->filter_id);
-		packetFilterClrReq.filterId = request->filter_id;
+
+		pmo_clr_pkt_fltr_param = qdf_mem_malloc(
+					sizeof(*pmo_clr_pkt_fltr_param));
+		if (!pmo_clr_pkt_fltr_param) {
+			hdd_err("unable to allocate pmo_clr_pkt_fltr_param");
+			return QDF_STATUS_E_NOMEM;
+		}
+
+		pmo_clr_pkt_fltr_param->filter_id = request->filter_id;
 		if (QDF_STATUS_SUCCESS !=
-		    sme_receive_filter_clear_filter(hdd_ctx->hHal,
-						    &packetFilterClrReq,
-						    sessionId)) {
+			pmo_ucfg_clear_pkt_filter(hdd_ctx->hdd_psoc,
+			    pmo_clr_pkt_fltr_param,
+			    sessionId)) {
 			hdd_err("Failure to execute Clear Filter");
-			return -EINVAL;
+			status = QDF_STATUS_E_INVAL;
+			goto out;
 		}
 		break;
 
@@ -11730,7 +11753,14 @@ static int wlan_hdd_set_filter(hdd_context_t *hdd_ctx,
 		       request->filter_action);
 		return -EINVAL;
 	}
-	return 0;
+
+out:
+	if (pmo_set_pkt_fltr_req)
+		qdf_mem_free(pmo_set_pkt_fltr_req);
+	if (pmo_clr_pkt_fltr_param)
+		qdf_mem_free(pmo_clr_pkt_fltr_param);
+
+	return status;
 }
 
 /**

core/mac/inc/sir_api.h

@@ -3031,60 +3031,6 @@ typedef struct sSirRoamOffloadScanRsp {
 #define    SIR_MAX_NUM_FILTERS               20
 #define    SIR_MAX_NUM_TESTS_PER_FILTER      10
 
-/* */
-/* Receive Filter Parameters */
-/* */
-typedef enum {
-	SIR_RCV_FILTER_TYPE_INVALID,
-	SIR_RCV_FILTER_TYPE_FILTER_PKT,
-	SIR_RCV_FILTER_TYPE_BUFFER_PKT,
-	SIR_RCV_FILTER_TYPE_MAX_ENUM_SIZE
-} eSirReceivePacketFilterType;
-
-typedef enum {
-	SIR_FILTER_HDR_TYPE_INVALID,
-	SIR_FILTER_HDR_TYPE_MAC,
-	SIR_FILTER_HDR_TYPE_ARP,
-	SIR_FILTER_HDR_TYPE_IPV4,
-	SIR_FILTER_HDR_TYPE_IPV6,
-	SIR_FILTER_HDR_TYPE_UDP,
-	SIR_FILTER_HDR_TYPE_MAX
-} eSirRcvPktFltProtocolType;
-
-typedef enum {
-	SIR_FILTER_CMP_TYPE_INVALID,
-	SIR_FILTER_CMP_TYPE_EQUAL,
-	SIR_FILTER_CMP_TYPE_MASK_EQUAL,
-	SIR_FILTER_CMP_TYPE_NOT_EQUAL,
-	SIR_FILTER_CMP_TYPE_MASK_NOT_EQUAL,
-	SIR_FILTER_CMP_TYPE_MAX
-} eSirRcvPktFltCmpFlagType;
-
-typedef struct sSirRcvPktFilterFieldParams {
-	eSirRcvPktFltProtocolType protocolLayer;
-	eSirRcvPktFltCmpFlagType cmpFlag;
-	/* Length of the data to compare */
-	uint16_t dataLength;
-	/* from start of the respective frame header */
-	uint8_t dataOffset;
-	/* Reserved field */
-	uint8_t reserved;
-	/* Data to compare */
-	uint8_t compareData[SIR_MAX_FILTER_TEST_DATA_LEN];
-	/* Mask to be applied on the received packet data before compare */
-	uint8_t dataMask[SIR_MAX_FILTER_TEST_DATA_LEN];
-} tSirRcvPktFilterFieldParams, *tpSirRcvPktFilterFieldParams;
-
-typedef struct sSirRcvPktFilterCfg {
-	uint8_t filterId;
-	eSirReceivePacketFilterType filterType;
-	uint32_t numFieldParams;
-	uint32_t coalesceTime;
-	struct qdf_mac_addr self_macaddr;
-	struct qdf_mac_addr bssid;      /* Bssid of the connected AP */
-	tSirRcvPktFilterFieldParams paramsData[SIR_MAX_NUM_TESTS_PER_FILTER];
-} tSirRcvPktFilterCfgType, *tpSirRcvPktFilterCfgType;
-
 /* */
 /* Filter Packet Match Count Parameters */
 /* */

core/sme/inc/sme_api.h

@@ -537,12 +537,6 @@ QDF_STATUS sme_get_cfg_valid_channels(uint8_t *aValidChannels,
 #ifdef WLAN_FEATURE_PACKET_FILTERING
 QDF_STATUS sme_8023_multicast_list(tHalHandle hHal, uint8_t sessionId,
 		tpSirRcvFltMcAddrList pMulticastAddrs);
-QDF_STATUS sme_receive_filter_set_filter(tHalHandle hHal,
-		tpSirRcvPktFilterCfgType pRcvPktFilterCfg,
-		uint8_t sessionId);
-QDF_STATUS sme_receive_filter_clear_filter(tHalHandle hHal,
-		tpSirRcvFltPktClearParam pRcvFltPktClearParam,
-		uint8_t sessionId);
 #endif /* WLAN_FEATURE_PACKET_FILTERING */
 bool sme_is_channel_valid(tHalHandle hHal, uint8_t channel);
 QDF_STATUS sme_set_freq_band(tHalHandle hHal, uint8_t sessionId,

core/sme/src/common/sme_api.c

@@ -7042,156 +7042,6 @@ QDF_STATUS sme_8023_multicast_list(tHalHandle hHal, uint8_t sessionId,
 
 	return QDF_STATUS_SUCCESS;
 }
-
-QDF_STATUS sme_receive_filter_set_filter(tHalHandle hHal,
-					 tpSirRcvPktFilterCfgType pRcvPktFilterCfg,
-					 uint8_t sessionId)
-{
-	tpSirRcvPktFilterCfgType request_buf;
-	int32_t allocSize;
-	struct scheduler_msg msg = {0};
-	tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
-	tCsrRoamSession *pSession = CSR_GET_SESSION(pMac, sessionId);
-	uint8_t idx = 0;
-
-	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO, "%s: filterType=%d, "
-		  "filterId = %d", __func__,
-		  pRcvPktFilterCfg->filterType, pRcvPktFilterCfg->filterId);
-
-	allocSize = sizeof(tSirRcvPktFilterCfgType);
-
-	request_buf = qdf_mem_malloc(allocSize);
-
-	if (NULL == request_buf) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  "%s: Not able to "
-			  "allocate memory for Receive Filter Set Filter request",
-			  __func__);
-		return QDF_STATUS_E_NOMEM;
-	}
-
-	if (NULL == pSession) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  "%s: Session Not found ", __func__);
-		qdf_mem_free(request_buf);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	qdf_copy_macaddr(&pRcvPktFilterCfg->self_macaddr,
-			 &pSession->selfMacAddr);
-	qdf_copy_macaddr(&pRcvPktFilterCfg->bssid,
-			 &pSession->connectedProfile.bssid);
-	qdf_mem_copy(request_buf, pRcvPktFilterCfg, allocSize);
-
-	msg.type = WMA_RECEIVE_FILTER_SET_FILTER_REQ;
-	msg.reserved = 0;
-	msg.bodyptr = request_buf;
-	MTRACE(qdf_trace(QDF_MODULE_ID_SME, TRACE_CODE_SME_TX_WMA_MSG,
-			 sessionId, msg.type));
-	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO, "Pkt Flt Req : "
-		  "FT %d FID %d ",
-		  request_buf->filterType, request_buf->filterId);
-
-	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO, "Pkt Flt Req : "
-		  "params %d CT %d",
-		  request_buf->numFieldParams, request_buf->coalesceTime);
-
-	for (idx = 0; idx < request_buf->numFieldParams; idx++) {
-
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO,
-			  "Proto %d Comp Flag %d ",
-			  request_buf->paramsData[idx].protocolLayer,
-			  request_buf->paramsData[idx].cmpFlag);
-
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO,
-			  "Data Offset %d Data Len %d",
-			  request_buf->paramsData[idx].dataOffset,
-			  request_buf->paramsData[idx].dataLength);
-
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO,
-			  "CData: %d:%d:%d:%d:%d:%d",
-			  request_buf->paramsData[idx].compareData[0],
-			  request_buf->paramsData[idx].compareData[1],
-			  request_buf->paramsData[idx].compareData[2],
-			  request_buf->paramsData[idx].compareData[3],
-			  request_buf->paramsData[idx].compareData[4],
-			  request_buf->paramsData[idx].compareData[5]);
-
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO,
-			  "MData: %d:%d:%d:%d:%d:%d",
-			  request_buf->paramsData[idx].dataMask[0],
-			  request_buf->paramsData[idx].dataMask[1],
-			  request_buf->paramsData[idx].dataMask[2],
-			  request_buf->paramsData[idx].dataMask[3],
-			  request_buf->paramsData[idx].dataMask[4],
-			  request_buf->paramsData[idx].dataMask[5]);
-
-	}
-
-	if (QDF_STATUS_SUCCESS != scheduler_post_msg(QDF_MODULE_ID_WMA,
-						      &msg)) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  "%s: Not able to post "
-			  "WMA_RECEIVE_FILTER_SET_FILTER message to WMA",
-			  __func__);
-		qdf_mem_free(request_buf);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	return QDF_STATUS_SUCCESS;
-}
-
-QDF_STATUS sme_receive_filter_clear_filter(tHalHandle hHal,
-					   tpSirRcvFltPktClearParam
-					   pRcvFltPktClearParam, uint8_t sessionId)
-{
-	tpSirRcvFltPktClearParam request_buf;
-	struct scheduler_msg msg = {0};
-	tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
-	tCsrRoamSession *pSession = CSR_GET_SESSION(pMac, sessionId);
-
-	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_INFO, "%s: filterId = %d",
-		  __func__, pRcvFltPktClearParam->filterId);
-
-	if (NULL == pSession) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  "%s: Session Not found", __func__);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	request_buf = qdf_mem_malloc(sizeof(tSirRcvFltPktClearParam));
-	if (NULL == request_buf) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  "%s: Not able to allocate memory for Receive Filter "
-			  "Clear Filter request", __func__);
-		return QDF_STATUS_E_NOMEM;
-	}
-
-	qdf_copy_macaddr(&pRcvFltPktClearParam->self_macaddr,
-			 &pSession->selfMacAddr);
-	qdf_copy_macaddr(&pRcvFltPktClearParam->bssid,
-			 &pSession->connectedProfile.bssid);
-
-	qdf_mem_copy(request_buf, pRcvFltPktClearParam,
-		     sizeof(tSirRcvFltPktClearParam));
-
-	msg.type = WMA_RECEIVE_FILTER_CLEAR_FILTER_REQ;
-	msg.reserved = 0;
-	msg.bodyptr = request_buf;
-	MTRACE(qdf_trace(QDF_MODULE_ID_SME, TRACE_CODE_SME_TX_WMA_MSG,
-			 sessionId, msg.type));
-	if (QDF_STATUS_SUCCESS != scheduler_post_msg(QDF_MODULE_ID_WMA,
-						      &msg)) {
-		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
-			  "%s: Not able to post "
-			  "WMA_RECEIVE_FILTER_CLEAR_FILTER message to WMA",
-			  __func__);
-		qdf_mem_free(request_buf);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	return QDF_STATUS_SUCCESS;
-}
 #endif /* WLAN_FEATURE_PACKET_FILTERING */
 
 /* ---------------------------------------------------------------------------

core/wma/inc/wma_internal.h

@@ -949,14 +949,6 @@ void wma_aggr_qos_req(tp_wma_handle wma,
 
 void wma_add_ts_req(tp_wma_handle wma, tAddTsParams *msg);
 
-int wma_process_receive_filter_set_filter_req(tp_wma_handle wma_handle,
-						     tSirRcvPktFilterCfgType *
-						     rcv_filter_param);
-
-int wma_process_receive_filter_clear_filter_req(tp_wma_handle wma_handle,
-						       tSirRcvFltPktClearParam *
-						       rcv_clear_param);
-
 #ifdef FEATURE_WLAN_ESE
 QDF_STATUS wma_process_tsm_stats_req(tp_wma_handle wma_handler,
 				     void *pTsmStatsMsg);

core/wma/src/wma_features.c

@@ -2782,114 +2782,6 @@ void wma_add_ts_req(tp_wma_handle wma, tAddTsParams *msg)
 	wma_send_msg(wma, WMA_ADD_TS_RSP, msg, 0);
 }
 
-/**
- * wma_enable_disable_packet_filter() - enable/disable packet filter in target
- * @wma: Pointer to wma handle
- * @vdev_id: vdev id
- * @enable: Flag to enable/disable packet filter
- *
- * Return: 0 for success or error code
- */
-static int wma_enable_disable_packet_filter(tp_wma_handle wma,
-					uint8_t vdev_id, bool enable)
-{
-	int ret;
-
-	ret = wmi_unified_enable_disable_packet_filter_cmd(wma->wmi_handle,
-			 vdev_id, enable);
-	if (ret)
-		WMA_LOGE("Failed to send packet filter wmi cmd to fw");
-
-	return ret;
-}
-
-/**
- * wma_config_packet_filter() - configure packet filter in target
- * @wma: Pointer to wma handle
- * @vdev_id: vdev id
- * @rcv_filter_param: Packet filter parameters
- * @filter_id: Filter id
- * @enable: Flag to add/delete packet filter configuration
- *
- * Return: 0 for success or error code
- */
-static int wma_config_packet_filter(tp_wma_handle wma,
-		uint8_t vdev_id, tSirRcvPktFilterCfgType *rcv_filter_param,
-		uint8_t filter_id, bool enable)
-{
-	int err;
-
-	/* send the command along with data */
-	err = wmi_unified_config_packet_filter_cmd(wma->wmi_handle, vdev_id,
-			(struct rcv_pkt_filter_config *)rcv_filter_param,
-			filter_id, enable);
-	if (err) {
-		WMA_LOGE("Failed to send pkt_filter cmd");
-		return -EIO;
-	}
-
-	/* Enable packet filter */
-	if (enable)
-		wma_enable_disable_packet_filter(wma, vdev_id, true);
-
-	return 0;
-}
-
-/**
- * wma_process_receive_filter_set_filter_req() - enable packet filter
- * @wma_handle: wma handle
- * @rcv_filter_param: filter params
- *
- * Return: 0 for success or error code
- */
-int wma_process_receive_filter_set_filter_req(tp_wma_handle wma,
-				tSirRcvPktFilterCfgType *rcv_filter_param)
-{
-	int ret = 0;
-	uint8_t vdev_id;
-
-	/* Get the vdev id */
-	if (!wma_find_vdev_by_bssid(wma,
-		rcv_filter_param->bssid.bytes, &vdev_id)) {
-		WMA_LOGE("vdev handle is invalid for %pM",
-			rcv_filter_param->bssid.bytes);
-		return -EINVAL;
-	}
-
-	ret = wma_config_packet_filter(wma, vdev_id, rcv_filter_param,
-				rcv_filter_param->filterId, true);
-
-	return ret;
-}
-
-/**
- * wma_process_receive_filter_clear_filter_req() - disable packet filter
- * @wma_handle: wma handle
- * @rcv_clear_param: filter params
- *
- * Return: 0 for success or error code
- */
-int wma_process_receive_filter_clear_filter_req(tp_wma_handle wma,
-				tSirRcvFltPktClearParam *rcv_clear_param)
-{
-	int ret = 0;
-	uint8_t vdev_id;
-
-	/* Get the vdev id */
-	if (!wma_find_vdev_by_addr(wma,
-				rcv_clear_param->self_macaddr.bytes,
-				&vdev_id)) {
-		WMA_LOGE("vdev handle is invalid for %pM",
-			 rcv_clear_param->bssid.bytes);
-		return -EINVAL;
-	}
-
-	ret = wma_config_packet_filter(wma, vdev_id, NULL,
-			rcv_clear_param->filterId, false);
-
-	return ret;
-}
-
 #ifdef FEATURE_WLAN_ESE
 
 #define TSM_DELAY_HISTROGRAM_BINS 4

core/wma/src/wma_main.c

@@ -6501,18 +6501,6 @@ QDF_STATUS wma_mc_process_msg(void *cds_context, struct scheduler_msg *msg)
 		wma_aggr_qos_req(wma_handle, (tAggrAddTsParams *) msg->bodyptr);
 		break;
 
-	case WMA_RECEIVE_FILTER_SET_FILTER_REQ:
-		wma_process_receive_filter_set_filter_req(wma_handle,
-				(tSirRcvPktFilterCfgType *) msg->bodyptr);
-		qdf_mem_free(msg->bodyptr);
-		break;
-
-	case WMA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
-		wma_process_receive_filter_clear_filter_req(wma_handle,
-				(tSirRcvFltPktClearParam *) msg->bodyptr);
-		qdf_mem_free(msg->bodyptr);
-		break;
-
 	case WMA_WOW_ADD_PTRN:
 		wma_wow_add_pattern(wma_handle,
 				    (struct wow_add_pattern *) msg->bodyptr);