qcacmn: cdp: Converge cdp_ctrl_ops

Currently cdp ops are given pdev/vdev handle
as its arguments, which is directly accessed
in those APIs. This can cause a race-condition
in access of the respective handles if it has
been deleted in parallel.

Hence as a part of cdp convergence, pass only
the pdev_id/vdev_id which will be used to get the
respective handles, and hence avoiding unwanted
access of the handles if it has been deleted.
Also deleting few ops which stores and retrieves
such handles and adding ops to set/get pdev params.

- txrx_get_psoc_param
- wdi_event_sub
- wdi_event_unsub

Change-Id: Id089d9b6b4737d700d2436e2081291a3741affb5
CRs-Fixed: 2541658

dp/inc/cdp_txrx_ctrl.h

@@ -616,9 +616,15 @@ cdp_set_mgmt_tx_power(ol_txrx_soc_handle soc,
 							subtype, tx_power);
 }
 
+/**
+ * cdp_get_pldev() - function to get pktlog device handle
+ * @soc: datapath soc handle
+ * @pdev_id: physical device id
+ *
+ * Return: pktlog device handle or NULL
+ */
 static inline void *
-cdp_get_pldev(ol_txrx_soc_handle soc,
-		struct cdp_pdev *pdev)
+cdp_get_pldev(ol_txrx_soc_handle soc, uint8_t pdev_id)
 {
 	if (!soc || !soc->ops) {
 		QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL,
@@ -630,7 +636,7 @@ cdp_get_pldev(ol_txrx_soc_handle soc,
 	if (!soc->ops->ctrl_ops || !soc->ops->ctrl_ops->txrx_get_pldev)
 		return NULL;
 
-	return soc->ops->ctrl_ops->txrx_get_pldev(pdev);
+	return soc->ops->ctrl_ops->txrx_get_pldev(soc, pdev_id);
 }
 
 #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)

dp/inc/cdp_txrx_ops.h

@@ -612,7 +612,7 @@ struct cdp_ctrl_ops {
 					  enum cdp_peer_param_type param,
 					  cdp_config_param_type *val);
 
-	void * (*txrx_get_pldev)(struct cdp_pdev *pdev);
+	void * (*txrx_get_pldev)(struct cdp_soc_t *soc, uint8_t pdev_id);
 
 #ifdef ATH_SUPPORT_NAC_RSSI
 	QDF_STATUS (*txrx_vdev_config_for_nac_rssi)(struct cdp_soc_t *cdp_soc,

dp/wifi3.0/dp_internal.h

@@ -1403,7 +1403,15 @@ int dp_wdi_event_attach(struct dp_pdev *txrx_pdev);
 int dp_wdi_event_detach(struct dp_pdev *txrx_pdev);
 int dp_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
 	bool enable);
-void *dp_get_pldev(struct cdp_pdev *txrx_pdev);
+
+/**
+ * dp_get_pldev() - function to get pktlog device handle
+ * @soc_hdl: datapath soc handle
+ * @pdev_id: physical device id
+ *
+ * Return: pktlog device handle or NULL
+ */
+void *dp_get_pldev(struct cdp_soc_t *soc_hdl, uint8_t pdev_id);
 void dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn);
 
 static inline void

dp/wifi3.0/dp_main.c

@@ -385,6 +385,7 @@ void dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn)
 	}
 
 	pktlog_sethandle(&handle->pl_dev, scn);
+	pktlog_set_pdev_id(handle->pl_dev, pdev_id);
 	pktlog_set_callback_regtype(PKTLOG_DEFAULT_CALLBACK_REGISTRATION);
 
 	if (pktlogmod_init(scn)) {

dp/wifi3.0/dp_wdi_event.c

@@ -21,9 +21,14 @@
 #include "qdf_mem.h"   /* qdf_mem_malloc,free */
 
 #ifdef WDI_EVENT_ENABLE
-void *dp_get_pldev(struct cdp_pdev *txrx_pdev)
+void *dp_get_pldev(struct cdp_soc_t *soc_hdl, uint8_t pdev_id)
 {
-	struct dp_pdev *pdev = (struct dp_pdev *)txrx_pdev;
+	struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
+	struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
+
+	if (!pdev)
+		return NULL;
+
 	return pdev->pl_dev;
 }
 /*

utils/pktlog/include/pktlog_ac.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2019 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2020 The Linux Foundation. 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
@@ -61,7 +61,15 @@ extern void pktlog_release_buf(struct hif_opaque_softc *scn);
 
 ssize_t pktlog_read_proc_entry(char *buf, size_t nbytes, loff_t *ppos,
 		struct ath_pktlog_info *pl_info, bool *read_complete);
-A_STATUS wdi_pktlog_unsubscribe(struct cdp_pdev *txrx_pdev, uint32_t log_state);
+
+/**
+ * wdi_pktlog_unsubscribe() - Unsubscribe pktlog callbacks
+ * @pdev_id: pdev id
+ * @log_state: Pktlog registration
+ *
+ * Return: zero on success, non-zero on failure
+ */
+A_STATUS wdi_pktlog_unsubscribe(uint8_t pdev_id, uint32_t log_state);
 
 struct ol_pl_arch_dep_funcs {
 	void (*pktlog_init)(struct hif_opaque_softc *scn);
@@ -93,6 +101,7 @@ struct pktlog_dev_t {
 	struct ol_pl_arch_dep_funcs *pl_funcs;
 	struct ath_pktlog_info *pl_info;
 	ol_ath_generic_softc_handle scn;
+	uint8_t pdev_id;
 	char *name;
 	bool tgt_pktlog_alloced;
 	bool is_pktlog_cb_subscribed;
@@ -141,7 +150,17 @@ int pktlog_disable(struct hif_opaque_softc *scn);
 int pktlogmod_init(void *context);
 void pktlogmod_exit(void *context);
 int pktlog_htc_attach(void);
-void pktlog_process_fw_msg(uint32_t *msg_word, uint32_t msg_len);
+
+/**
+ * pktlog_process_fw_msg() - process packetlog message
+ * @pdev_id: physical device instance id
+ * @msg_word: message buffer
+ * @msg_len: message length
+ *
+ * Return: None
+ */
+void pktlog_process_fw_msg(uint8_t pdev_id, uint32_t *msg_word,
+			   uint32_t msg_len);
 void lit_pktlog_callback(void *context, enum WDI_EVENT event, void *log_data,
 	u_int16_t peer_id, uint32_t status);
 
@@ -204,7 +223,8 @@ static inline int pktlog_htc_attach(void)
 	return 0;
 }
 
-static inline void pktlog_process_fw_msg(uint32_t *msg_word, uint32_t msg_len)
+static inline void pktlog_process_fw_msg(uint8_t pdev_id, uint32_t *msg_word,
+					 uint32_t msg_len)
 { }
 #endif /* REMOVE_PKT_LOG */
 #endif /* _PKTLOG_AC_H_ */

utils/pktlog/include/pktlog_ac_api.h

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2012-2014, 2016-2018 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2014, 2016-2018, 2020 The Linux Foundation.
+ * 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
@@ -54,6 +55,7 @@ struct pktlog_dev_t;
 
 void pktlog_sethandle(struct pktlog_dev_t **pl_handle,
 		     hif_opaque_softc_handle scn);
+void pktlog_set_pdev_id(struct pktlog_dev_t *pl_dev, uint8_t pdev_id);
 
 void *get_txrx_context(void);
 
@@ -129,6 +131,12 @@ struct ath_pktlog_info {
 #endif /* _PKTLOG_INFO */
 #else                           /* REMOVE_PKT_LOG */
 typedef void *pktlog_dev_handle;
+#define pktlog_set_pdev_id(pl_dev, pdev_id)	\
+	do {					\
+		(void)pl_dev;			\
+		(void)pdev_id;			\
+	} while (0)
+
 #define pktlog_sethandle(pl_handle, scn)	\
 	do {				\
 		(void)pl_handle;	\

utils/pktlog/pktlog_ac.c

@@ -75,6 +75,11 @@ void pktlog_sethandle(struct pktlog_dev_t **pl_handle,
 	*pl_handle = &pl_dev;
 }
 
+void pktlog_set_pdev_id(struct pktlog_dev_t *pl_dev, uint8_t pdev_id)
+{
+	pl_dev->pdev_id = pdev_id;
+}
+
 void pktlog_set_callback_regtype(
 		enum pktlog_callback_regtype callback_type)
 {
@@ -90,19 +95,10 @@ void pktlog_set_callback_regtype(
 
 struct pktlog_dev_t *get_pktlog_handle(void)
 {
-	struct cdp_pdev *pdev_txrx_handle =
-				cds_get_context(QDF_MODULE_ID_TXRX);
+	uint8_t pdev_id = WMI_PDEV_ID_SOC;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
-	return cdp_get_pldev(soc, pdev_txrx_handle);
-}
-
-/*
- * Get current txrx context
- */
-void *get_txrx_context(void)
-{
-	return cds_get_context(QDF_MODULE_ID_TXRX);
+	return cdp_get_pldev(soc, pdev_id);
 }
 
 static A_STATUS pktlog_wma_post_msg(WMI_PKTLOG_EVENT event_types,
@@ -170,56 +166,56 @@ pktlog_enable_tgt(struct hif_opaque_softc *_scn, uint32_t log_state,
 #ifdef PKTLOG_LEGACY
 /**
  * wdi_pktlog_subscribe() - Subscribe pktlog callbacks
- * @cdp_pdev: abstract pdev handle
+ * @pdev_id: pdev id
  * @log_state: Pktlog registration
  *
  * Return: zero on success, non-zero on failure
  */
 static inline A_STATUS
-wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
+wdi_pktlog_subscribe(uint8_t pdev_id, int32_t log_state)
 {
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
-	if (!cdp_pdev) {
+	if (pdev_id < 0) {
 		qdf_print("Invalid pdev in %s", __func__);
 		return A_ERROR;
 	}
 
 	if (log_state & ATH_PKTLOG_TX) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev, &PKTLOG_TX_SUBSCRIBER,
-				WDI_EVENT_TX_STATUS)) {
+		if (cdp_wdi_event_sub(soc, pdev_id, &PKTLOG_TX_SUBSCRIBER,
+				      WDI_EVENT_TX_STATUS)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_RX) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev, &PKTLOG_RX_SUBSCRIBER,
-				WDI_EVENT_RX_DESC)) {
+		if (cdp_wdi_event_sub(soc, pdev_id, &PKTLOG_RX_SUBSCRIBER,
+				      WDI_EVENT_RX_DESC)) {
 			return A_ERROR;
 		}
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
-				&PKTLOG_RX_REMOTE_SUBSCRIBER,
-				WDI_EVENT_RX_DESC_REMOTE)) {
+		if (cdp_wdi_event_sub(soc, pdev_id,
+				      &PKTLOG_RX_REMOTE_SUBSCRIBER,
+				      WDI_EVENT_RX_DESC_REMOTE)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_RCFIND) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
-				  &PKTLOG_RCFIND_SUBSCRIBER,
-				  WDI_EVENT_RATE_FIND)) {
+		if (cdp_wdi_event_sub(soc, pdev_id,
+				      &PKTLOG_RCFIND_SUBSCRIBER,
+				      WDI_EVENT_RATE_FIND)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_RCUPDATE) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
-				  &PKTLOG_RCUPDATE_SUBSCRIBER,
-				  WDI_EVENT_RATE_UPDATE)) {
+		if (cdp_wdi_event_sub(soc, pdev_id,
+				      &PKTLOG_RCUPDATE_SUBSCRIBER,
+				      WDI_EVENT_RATE_UPDATE)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_SW_EVENT) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
-				  &PKTLOG_SW_EVENT_SUBSCRIBER,
-				  WDI_EVENT_SW_EVENT)) {
+		if (cdp_wdi_event_sub(soc, pdev_id,
+				      &PKTLOG_SW_EVENT_SUBSCRIBER,
+				      WDI_EVENT_SW_EVENT)) {
 			return A_ERROR;
 		}
 	}
@@ -228,11 +224,11 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
 }
 #else
 static inline A_STATUS
-wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
+wdi_pktlog_subscribe(uint8_t pdev_id, int32_t log_state)
 {
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
-	if (!cdp_pdev) {
+	if (pdev_id < 0) {
 		qdf_print("Invalid pdev in %s", __func__);
 		return A_ERROR;
 	}
@@ -242,7 +238,7 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
 	    (log_state & ATH_PKTLOG_RCUPDATE) ||
 	    (log_state & ATH_PKTLOG_SW_EVENT)) {
 		if (cdp_wdi_event_sub(soc,
-				      cdp_pdev,
+				      pdev_id,
 				      &PKTLOG_OFFLOAD_SUBSCRIBER,
 				      WDI_EVENT_OFFLOAD_ALL)) {
 			return A_ERROR;
@@ -250,15 +246,15 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
 	}
 
 	if (log_state & ATH_PKTLOG_RX) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
-					&PKTLOG_RX_SUBSCRIBER,
-					WDI_EVENT_RX_DESC)) {
+		if (cdp_wdi_event_sub(soc, pdev_id,
+				      &PKTLOG_RX_SUBSCRIBER,
+				      WDI_EVENT_RX_DESC)) {
 			return A_ERROR;
 		}
 	}
 
 	if (log_state & ATH_PKTLOG_SW_EVENT) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
+		if (cdp_wdi_event_sub(soc, pdev_id,
 				      &PKTLOG_SW_EVENT_SUBSCRIBER,
 				      WDI_EVENT_SW_EVENT)) {
 			return A_ERROR;
@@ -266,7 +262,7 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
 	}
 
 	if (log_state & ATH_PKTLOG_LITE_T2H) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
+		if (cdp_wdi_event_sub(soc, pdev_id,
 				      &PKTLOG_LITE_T2H_SUBSCRIBER,
 				      WDI_EVENT_LITE_T2H)) {
 			return A_ERROR;
@@ -274,7 +270,7 @@ wdi_pktlog_subscribe(struct cdp_pdev *cdp_pdev, int32_t log_state)
 	}
 
 	if (log_state & ATH_PKTLOG_LITE_RX) {
-		if (cdp_wdi_event_sub(soc, cdp_pdev,
+		if (cdp_wdi_event_sub(soc, pdev_id,
 				      &PKTLOG_LITE_RX_SUBSCRIBER,
 				      WDI_EVENT_LITE_RX)) {
 			return A_ERROR;
@@ -405,56 +401,50 @@ lit_pktlog_callback(void *context, enum WDI_EVENT event, void *log_data,
 }
 
 #ifdef PKTLOG_LEGACY
-/**
- * wdi_pktlog_unsubscribe() - Unsubscribe pktlog callbacks
- * @cdp_pdev: abstract pdev handle
- * @log_state: Pktlog registration
- *
- * Return: zero on success, non-zero on failure
- */
 A_STATUS
-wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
+wdi_pktlog_unsubscribe(uint8_t pdev_id, uint32_t log_state)
 {
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	/* TODO: WIN implementation to get soc */
 
 	if (log_state & ATH_PKTLOG_TX) {
-		if (cdp_wdi_event_unsub(soc, pdev,
-				    &PKTLOG_TX_SUBSCRIBER,
-				    WDI_EVENT_TX_STATUS)) {
+		if (cdp_wdi_event_unsub(soc, pdev_id,
+					&PKTLOG_TX_SUBSCRIBER,
+					WDI_EVENT_TX_STATUS)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_RX) {
-		if (cdp_wdi_event_unsub(soc, pdev,
-				    &PKTLOG_RX_SUBSCRIBER, WDI_EVENT_RX_DESC)) {
+		if (cdp_wdi_event_unsub(soc, pdev_id,
+					&PKTLOG_RX_SUBSCRIBER,
+					WDI_EVENT_RX_DESC)) {
 			return A_ERROR;
 		}
-		if (cdp_wdi_event_unsub(soc, pdev,
-				    &PKTLOG_RX_REMOTE_SUBSCRIBER,
-				    WDI_EVENT_RX_DESC_REMOTE)) {
+		if (cdp_wdi_event_unsub(soc, pdev_id,
+					&PKTLOG_RX_REMOTE_SUBSCRIBER,
+					WDI_EVENT_RX_DESC_REMOTE)) {
 			return A_ERROR;
 		}
 	}
 
 	if (log_state & ATH_PKTLOG_RCFIND) {
-		if (cdp_wdi_event_unsub(soc, pdev,
-				    &PKTLOG_RCFIND_SUBSCRIBER,
-				    WDI_EVENT_RATE_FIND)) {
+		if (cdp_wdi_event_unsub(soc, pdev_id,
+					&PKTLOG_RCFIND_SUBSCRIBER,
+					WDI_EVENT_RATE_FIND)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_RCUPDATE) {
-		if (cdp_wdi_event_unsub(soc, pdev,
-				    &PKTLOG_RCUPDATE_SUBSCRIBER,
-				    WDI_EVENT_RATE_UPDATE)) {
+		if (cdp_wdi_event_unsub(soc, pdev_id,
+					&PKTLOG_RCUPDATE_SUBSCRIBER,
+					WDI_EVENT_RATE_UPDATE)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_RCUPDATE) {
-		if (cdp_wdi_event_unsub(soc, pdev,
-				    &PKTLOG_SW_EVENT_SUBSCRIBER,
-				    WDI_EVENT_SW_EVENT)) {
+		if (cdp_wdi_event_unsub(soc, pdev_id,
+					&PKTLOG_SW_EVENT_SUBSCRIBER,
+					WDI_EVENT_SW_EVENT)) {
 			return A_ERROR;
 		}
 	}
@@ -463,7 +453,7 @@ wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
 }
 #else
 A_STATUS
-wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
+wdi_pktlog_unsubscribe(uint8_t pdev_id, uint32_t log_state)
 {
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
@@ -472,28 +462,28 @@ wdi_pktlog_unsubscribe(struct cdp_pdev *pdev, uint32_t log_state)
 	    (log_state & ATH_PKTLOG_RCUPDATE) ||
 	    (log_state & ATH_PKTLOG_SW_EVENT)) {
 		if (cdp_wdi_event_unsub(soc,
-					pdev,
+					pdev_id,
 					&PKTLOG_OFFLOAD_SUBSCRIBER,
 					WDI_EVENT_OFFLOAD_ALL)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_RX) {
-		if (cdp_wdi_event_unsub(soc, pdev,
+		if (cdp_wdi_event_unsub(soc, pdev_id,
 					&PKTLOG_RX_SUBSCRIBER,
 					WDI_EVENT_RX_DESC)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_LITE_T2H) {
-		if (cdp_wdi_event_unsub(soc, pdev,
+		if (cdp_wdi_event_unsub(soc, pdev_id,
 					&PKTLOG_LITE_T2H_SUBSCRIBER,
 					WDI_EVENT_LITE_T2H)) {
 			return A_ERROR;
 		}
 	}
 	if (log_state & ATH_PKTLOG_LITE_RX) {
-		if (cdp_wdi_event_unsub(soc, pdev,
+		if (cdp_wdi_event_unsub(soc, pdev_id,
 					&PKTLOG_LITE_RX_SUBSCRIBER,
 					WDI_EVENT_LITE_RX)) {
 			return A_ERROR;
@@ -509,7 +499,7 @@ int pktlog_disable(struct hif_opaque_softc *scn)
 	struct pktlog_dev_t *pl_dev;
 	struct ath_pktlog_info *pl_info;
 	uint8_t save_pktlog_state;
-	struct cdp_pdev *txrx_pdev = get_txrx_context();
+	uint8_t pdev_id = WMI_PDEV_ID_SOC;
 
 	pl_dev = get_pktlog_handle();
 
@@ -525,8 +515,8 @@ int pktlog_disable(struct hif_opaque_softc *scn)
 		return -EINVAL;
 	}
 
-	if (!txrx_pdev) {
-		qdf_print("Invalid cdp_pdev");
+	if (pdev_id < 0) {
+		qdf_print("Invalid pdev");
 		return -EINVAL;
 	}
 
@@ -548,7 +538,7 @@ int pktlog_disable(struct hif_opaque_softc *scn)
 	}
 
 	if (pl_dev->is_pktlog_cb_subscribed &&
-		wdi_pktlog_unsubscribe(txrx_pdev, pl_info->log_state)) {
+		wdi_pktlog_unsubscribe(pdev_id, pl_info->log_state)) {
 		pl_info->curr_pkt_state = PKTLOG_OPR_NOT_IN_PROGRESS;
 		qdf_print("Cannot unsubscribe pktlog from the WDI");
 		return -EINVAL;
@@ -636,7 +626,7 @@ int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 {
 	struct pktlog_dev_t *pl_dev;
 	struct ath_pktlog_info *pl_info;
-	struct cdp_pdev *cdp_pdev;
+	uint8_t pdev_id;
 	int error;
 
 	if (!scn) {
@@ -652,8 +642,8 @@ int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 		return -EINVAL;
 	}
 
-	cdp_pdev = get_txrx_context();
-	if (!cdp_pdev) {
+	pdev_id = WMI_PDEV_ID_SOC;
+	if (pdev_id < 0) {
 		qdf_print("%s: Invalid txrx context", __func__);
 		ASSERT(0);
 		return -EINVAL;
@@ -724,7 +714,7 @@ int __pktlog_enable(struct hif_opaque_softc *scn, int32_t log_state,
 	if (log_state != 0) {
 		/* WDI subscribe */
 		if (!pl_dev->is_pktlog_cb_subscribed) {
-			error = wdi_pktlog_subscribe(cdp_pdev, log_state);
+			error = wdi_pktlog_subscribe(pdev_id, log_state);
 			if (error) {
 				pl_info->curr_pkt_state =
 						PKTLOG_OPR_NOT_IN_PROGRESS;
@@ -797,7 +787,7 @@ static int __pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 {
 	struct pktlog_dev_t *pl_dev;
 	struct ath_pktlog_info *pl_info;
-	struct cdp_pdev *pdev;
+	uint8_t pdev_id = WMI_PDEV_ID_SOC;
 
 	pl_dev = get_pktlog_handle();
 
@@ -813,10 +803,8 @@ static int __pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 		return -EINVAL;
 	}
 
-	pdev = get_txrx_context();
-
-	if (!pdev) {
-		qdf_print("%s: invalid pdev handle", __func__);
+	if (pdev_id < 0) {
+		qdf_print("%s: invalid pdev", __func__);
 		return -EINVAL;
 	}
 
@@ -853,7 +841,7 @@ static int __pktlog_setsize(struct hif_opaque_softc *scn, int32_t size)
 	qdf_spin_lock_bh(&pl_info->log_lock);
 	if (pl_info->buf) {
 		if (pl_dev->is_pktlog_cb_subscribed &&
-			wdi_pktlog_unsubscribe(pdev, pl_info->log_state)) {
+			wdi_pktlog_unsubscribe(pdev_id, pl_info->log_state)) {
 			pl_info->curr_pkt_state =
 				PKTLOG_OPR_NOT_IN_PROGRESS;
 			qdf_spin_unlock_bh(&pl_info->log_lock);
@@ -968,21 +956,14 @@ int pktlog_clearbuff(struct hif_opaque_softc *scn, bool clear_buff)
 	return 0;
 }
 
-/**
- * pktlog_process_fw_msg() - process packetlog message
- * @buff: buffer
- *
- * Return: None
- */
-void pktlog_process_fw_msg(uint32_t *buff, uint32_t len)
+void pktlog_process_fw_msg(uint8_t pdev_id, uint32_t *buff, uint32_t len)
 {
 	uint32_t *pl_hdr;
 	uint32_t log_type;
-	struct cdp_pdev *pdev = get_txrx_context();
 	struct ol_fw_data pl_fw_data;
 
-	if (!pdev) {
-		qdf_print("%s: txrx_pdev is NULL", __func__);
+	if (pdev_id == OL_TXRX_INVALID_PDEV_ID) {
+		qdf_print("%s: txrx pdev_id is invalid", __func__);
 		return;
 	}
 	pl_hdr = buff;
@@ -999,19 +980,19 @@ void pktlog_process_fw_msg(uint32_t *buff, uint32_t len)
 		|| (log_type == PKTLOG_TYPE_TX_FRM_HDR)
 		|| (log_type == PKTLOG_TYPE_TX_VIRT_ADDR))
 		wdi_event_handler(WDI_EVENT_TX_STATUS,
-				  pdev, &pl_fw_data);
+				  pdev_id, &pl_fw_data);
 	else if (log_type == PKTLOG_TYPE_RC_FIND)
 		wdi_event_handler(WDI_EVENT_RATE_FIND,
-				  pdev, &pl_fw_data);
+				  pdev_id, &pl_fw_data);
 	else if (log_type == PKTLOG_TYPE_RC_UPDATE)
 		wdi_event_handler(WDI_EVENT_RATE_UPDATE,
-				  pdev, &pl_fw_data);
+				  pdev_id, &pl_fw_data);
 	else if (log_type == PKTLOG_TYPE_RX_STAT)
 		wdi_event_handler(WDI_EVENT_RX_DESC,
-				  pdev, &pl_fw_data);
+				  pdev_id, &pl_fw_data);
 	else if (log_type == PKTLOG_TYPE_SW_EVENT)
 		wdi_event_handler(WDI_EVENT_SW_EVENT,
-				  pdev, &pl_fw_data);
+				  pdev_id, &pl_fw_data);
 }
 
 #if defined(QCA_WIFI_3_0_ADRASTEA)
@@ -1062,7 +1043,7 @@ static void pktlog_t2h_msg_handler(void *context, HTC_PACKET *pkt)
 
 	msg_word = (uint32_t *) qdf_nbuf_data(pktlog_t2h_msg);
 	msg_len = qdf_nbuf_len(pktlog_t2h_msg);
-	pktlog_process_fw_msg(msg_word, msg_len);
+	pktlog_process_fw_msg(pdev->pdev_id, msg_word, msg_len);
 
 	qdf_nbuf_free(pktlog_t2h_msg);
 }