qcacmn: Add debug support for peer reference and release

Add function name and line number while taking/releasing
references for peer to trace object manager references

Change-Id: I93c30d62ecaa979f8c2680eec68f723d2d3c4292

umac/cmn_services/obj_mgr/inc/wlan_objmgr_peer_obj.h

@@ -381,8 +381,17 @@ static inline void wlan_peer_obj_unlock(struct wlan_objmgr_peer *peer)
  *
  * Return: void
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+void wlan_objmgr_peer_get_ref_debug(struct wlan_objmgr_peer *peer,
+				    wlan_objmgr_ref_dbgid id,
+				    const char *func, int line);
+
+#define wlan_objmgr_peer_get_ref(peer, dbgid) \
+		wlan_objmgr_peer_get_ref_debug(peer, dbgid, __func__, __LINE__)
+#else
 void wlan_objmgr_peer_get_ref(struct wlan_objmgr_peer *peer,
 					wlan_objmgr_ref_dbgid id);
+#endif
 
 /**
  * wlan_objmgr_peer_try_get_ref() - increment ref count, if allowed
@@ -393,8 +402,18 @@ void wlan_objmgr_peer_get_ref(struct wlan_objmgr_peer *peer,
  *
  * Return: void
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+QDF_STATUS wlan_objmgr_peer_try_get_ref_debug(struct wlan_objmgr_peer *peer,
+					      wlan_objmgr_ref_dbgid id,
+					      const char *func, int line);
+
+#define wlan_objmgr_peer_try_get_ref(peer, dbgid) \
+		wlan_objmgr_peer_try_get_ref_debug(peer, dbgid, \
+		__func__, __LINE__)
+#else
 QDF_STATUS wlan_objmgr_peer_try_get_ref(struct wlan_objmgr_peer *peer,
 						 wlan_objmgr_ref_dbgid id);
+#endif
 
 /**
  * wlan_objmgr_peer_release_ref() - decrement ref count
@@ -406,36 +425,147 @@ QDF_STATUS wlan_objmgr_peer_try_get_ref(struct wlan_objmgr_peer *peer,
  *
  * Return: void
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+void wlan_objmgr_peer_release_ref_debug(struct wlan_objmgr_peer *peer,
+					wlan_objmgr_ref_dbgid id,
+					const char *func, int line);
+
+#define wlan_objmgr_peer_release_ref(peer, dbgid) \
+		wlan_objmgr_peer_release_ref_debug(peer, dbgid, \
+		__func__, __LINE__)
+#else
 void wlan_objmgr_peer_release_ref(struct wlan_objmgr_peer *peer,
 						 wlan_objmgr_ref_dbgid id);
+#endif
 
 /**
- * wlan_psoc_peer_list_peek_head() - get head of psoc peer list
- * @peer_list: qdf_list_t
+ * wlan_peer_get_next_peer_of_psoc_ref() - get next peer to psoc peer list
+ *                                         with lock and ref taken
+ * @peer_list: Peer list
+ * @hash_index: peer list hash index
+ * @peer: PEER object
+ * @dbg_id: Ref count debug module id
  *
- * API to get the head peer of given peer (of psoc's peer list)
+ * API to get the next peer of given peer (of psoc's peer list)
  *
- * Caller need to acquire lock with wlan_peer_obj_lock()
+ * Return:
+ * @next_peer: PEER object
+ */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref_debug(
+				struct wlan_peer_list *peer_list,
+				uint8_t hash_index,
+				struct wlan_objmgr_peer *peer,
+				wlan_objmgr_ref_dbgid dbg_id,
+				const char *func, int line);
+
+#define wlan_peer_get_next_peer_of_psoc_ref(peer_list, hash_index, peer, \
+	dbgid) \
+		wlan_peer_get_next_peer_of_psoc_ref_debug(peer_list, \
+		hash_index, peer, dbgid, __func__, __LINE__)
+#else
+struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref(
+				struct wlan_peer_list *peer_list,
+				uint8_t hash_index,
+				struct wlan_objmgr_peer *peer,
+				wlan_objmgr_ref_dbgid dbg_id);
+#endif
+
+/**
+ * wlan_peer_get_next_active_peer_of_psoc() - get next active peer to psoc peer
+ *                                            list
+ * @peer_list: Peer list
+ * @hash_index: peer list hash index
+ * @peer: PEER object
+ * @dbg_id: Ref count debug module id
+ *
+ * API to get the next peer of given peer (of psoc's peer list)
  *
  * Return:
- * @peer: head peer
+ * @next_peer: PEER object
  */
-static inline struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head(
-					qdf_list_t *peer_list)
-{
-	struct wlan_objmgr_peer *peer;
-	qdf_list_node_t *psoc_node = NULL;
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc_debug(
+					struct wlan_peer_list *peer_list,
+					uint8_t hash_index,
+					struct wlan_objmgr_peer *peer,
+					wlan_objmgr_ref_dbgid dbg_id,
+					const char *func, int line);
+
+#define wlan_peer_get_next_active_peer_of_psoc(peer_list, hash_index, \
+	peer, dbgid) \
+		wlan_peer_get_next_active_peer_of_psoc_debug(peer_list, \
+		hash_index, peer, dbgid, __func__, __LINE__)
+#else
+struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc(
+					struct wlan_peer_list *peer_list,
+					uint8_t hash_index,
+					struct wlan_objmgr_peer *peer,
+					wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
-	/* This API is invoked with lock acquired, do not add log prints */
-	if (qdf_list_peek_front(peer_list, &psoc_node) != QDF_STATUS_SUCCESS)
-		return NULL;
+/**
+ * wlan_peer_get_next_active_peer_of_vdev() - get next active_peer of vdev list
+ * @vdev: VDEV object
+ * @peer_list: Peer object list
+ * @peer: PEER object
+ * @dbg_id: Ref count debug module id
+ *
+ * API to get the next active peer of given peer (of vdev's peer list)
+ *
+ * Return:
+ * @next_peer: PEER object
+ */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev_debug(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_list_t *peer_list,
+				struct wlan_objmgr_peer *peer,
+				wlan_objmgr_ref_dbgid dbg_id,
+				const char *func, int line);
 
-	peer = qdf_container_of(psoc_node, struct wlan_objmgr_peer, psoc_peer);
-	return peer;
-}
+#define wlan_peer_get_next_active_peer_of_vdev(vdev, peer_list, peer, dbgid) \
+		wlan_peer_get_next_active_peer_of_vdev_debug(vdev, peer_list, \
+		peer, dbgid, __func__, __LINE__)
+#else
+struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_list_t *peer_list,
+				struct wlan_objmgr_peer *peer,
+				wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
- * wlan_psoc_peer_list_peek_active_head() - get active head of psoc peer list
+ * wlan_vdev_peer_list_peek_active_head() - get active head of vdev peer list
+ * @vdev: VDEV object
+ * @peer_list: qdf_list_t
+ * @dbg_id: Ref count debug module id
+ *
+ * API to get the active head peer of given peer (of vdev's peer list)
+ *
+ * Return:
+ * @peer: active head peer
+ */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head_debug(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_list_t *peer_list,
+				wlan_objmgr_ref_dbgid dbg_id,
+				const char *func, int line);
+
+#define wlan_vdev_peer_list_peek_active_head(vdev, peer_list, dbgid) \
+		wlan_vdev_peer_list_peek_active_head_debug(vdev, peer_list, \
+		dbgid, __func__, __LINE__)
+#else
+struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_list_t *peer_list,
+				wlan_objmgr_ref_dbgid dbg_id);
+#endif
+
+/**
+ * wlan_psoc_peer_list_peek_head_ref() - get head of psoc peer list
+ *                                            with ref and lock protected
  * @peer_list: wlan_peer_list
  * @hash_index: peer list hash index
  * @dbg_id: Ref count debug module id
@@ -445,14 +575,25 @@ static inline struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head(
  * Return:
  * @peer: head peer
  */
-struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head(
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref_debug(
+					struct wlan_peer_list *peer_list,
+					uint8_t hash_index,
+					wlan_objmgr_ref_dbgid dbg_id,
+					const char *func, int line);
+
+#define wlan_psoc_peer_list_peek_head_ref(peer_list, hash_index, dbgid) \
+		wlan_psoc_peer_list_peek_head_ref_debug(peer_list, hash_index, \
+		dbgid, __func__, __LINE__)
+#else
+struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref(
 					struct wlan_peer_list *peer_list,
 					uint8_t hash_index,
 					wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
- * wlan_psoc_peer_list_peek_head_lock_ref() - get head of psoc peer list
- *                                            with ref and lock protected
+ * wlan_psoc_peer_list_peek_active_head() - get active head of psoc peer list
  * @peer_list: wlan_peer_list
  * @hash_index: peer list hash index
  * @dbg_id: Ref count debug module id
@@ -462,51 +603,72 @@ struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head(
  * Return:
  * @peer: head peer
  */
-struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref(
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head_debug(
+					struct wlan_peer_list *peer_list,
+					uint8_t hash_index,
+					wlan_objmgr_ref_dbgid dbg_id,
+					const char *func, int line);
+
+#define wlan_psoc_peer_list_peek_active_head(peer_list, hash_index, dbgid) \
+		wlan_psoc_peer_list_peek_active_head_debug(peer_list, \
+		hash_index, dbgid, __func__, __LINE__)
+#else
+struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head(
 					struct wlan_peer_list *peer_list,
 					uint8_t hash_index,
 					wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
- * wlan_vdev_peer_list_peek_head() - get head of vdev peer list
+ * wlan_psoc_peer_list_peek_head() - get head of psoc peer list
  * @peer_list: qdf_list_t
  *
- * API to get the head peer of given peer (of vdev's peer list)
+ * API to get the head peer of given peer (of psoc's peer list)
  *
  * Caller need to acquire lock with wlan_peer_obj_lock()
  *
  * Return:
  * @peer: head peer
  */
-static inline struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_head(
+static inline struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head(
 					qdf_list_t *peer_list)
 {
 	struct wlan_objmgr_peer *peer;
-	qdf_list_node_t *vdev_node = NULL;
+	qdf_list_node_t *psoc_node = NULL;
 
 	/* This API is invoked with lock acquired, do not add log prints */
-	if (qdf_list_peek_front(peer_list, &vdev_node) != QDF_STATUS_SUCCESS)
+	if (qdf_list_peek_front(peer_list, &psoc_node) != QDF_STATUS_SUCCESS)
 		return NULL;
 
-	peer = qdf_container_of(vdev_node, struct wlan_objmgr_peer, vdev_peer);
+	peer = qdf_container_of(psoc_node, struct wlan_objmgr_peer, psoc_peer);
 	return peer;
 }
 
 /**
- * wlan_vdev_peer_list_peek_active_head() - get active head of vdev peer list
- * @vdev: VDEV object
+ * wlan_vdev_peer_list_peek_head() - get head of vdev peer list
  * @peer_list: qdf_list_t
- * @dbg_id: Ref count debug module id
  *
- * API to get the active head peer of given peer (of vdev's peer list)
+ * API to get the head peer of given peer (of vdev's peer list)
+ *
+ * Caller need to acquire lock with wlan_peer_obj_lock()
  *
  * Return:
- * @peer: active head peer
+ * @peer: head peer
  */
-struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head(
-				struct wlan_objmgr_vdev *vdev,
-				qdf_list_t *peer_list,
-				wlan_objmgr_ref_dbgid dbg_id);
+static inline struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_head(
+					qdf_list_t *peer_list)
+{
+	struct wlan_objmgr_peer *peer;
+	qdf_list_node_t *vdev_node = NULL;
+
+	/* This API is invoked with lock acquired, do not add log prints */
+	if (qdf_list_peek_front(peer_list, &vdev_node) != QDF_STATUS_SUCCESS)
+		return NULL;
+
+	peer = qdf_container_of(vdev_node, struct wlan_objmgr_peer, vdev_peer);
+	return peer;
+}
 
 /**
  * wlan_peer_get_next_peer_of_vdev() - get next peer of vdev list
@@ -540,24 +702,6 @@ static inline struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_vdev(
 	return peer_next;
 }
 
-/**
- * wlan_peer_get_next_active_peer_of_vdev() - get next active_peer of vdev list
- * @vdev: VDEV object
- * @peer_list: Peer object list
- * @peer: PEER object
- * @dbg_id: Ref count debug module id
- *
- * API to get the next active peer of given peer (of vdev's peer list)
- *
- * Return:
- * @next_peer: PEER object
- */
-struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev(
-				struct wlan_objmgr_vdev *vdev,
-				qdf_list_t *peer_list,
-				struct wlan_objmgr_peer *peer,
-				wlan_objmgr_ref_dbgid dbg_id);
-
 /**
  * wlan_peer_set_next_peer_of_vdev() - add peer to vdev peer list
  * @peer: PEER object
@@ -611,45 +755,6 @@ static inline struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc(
 	return peer_next;
 }
 
-/**
- * wlan_peer_get_next_active_peer_of_psoc() - get next active peer to psoc peer
- *                                            list
- * @peer_list: Peer list
- * @hash_index: peer list hash index
- * @peer: PEER object
- * @dbg_id: Ref count debug module id
- *
- * API to get the next peer of given peer (of psoc's peer list)
- *
- * Return:
- * @next_peer: PEER object
- */
-struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc(
-					struct wlan_peer_list *peer_list,
-					uint8_t hash_index,
-					struct wlan_objmgr_peer *peer,
-					wlan_objmgr_ref_dbgid dbg_id);
-
-
-/**
- * wlan_peer_get_next_peer_of_psoc_ref() - get next peer to psoc peer list
- *                                         with lock and ref taken
- * @peer_list: Peer list
- * @hash_index: peer list hash index
- * @peer: PEER object
- * @dbg_id: Ref count debug module id
- *
- * API to get the next peer of given peer (of psoc's peer list)
- *
- * Return:
- * @next_peer: PEER object
- */
-struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref(
-				struct wlan_peer_list *peer_list,
-				uint8_t hash_index,
-				struct wlan_objmgr_peer *peer,
-				wlan_objmgr_ref_dbgid dbg_id);
-
 /**
  * wlan_peer_set_next_peer_of_psoc() - add peer to psoc peer list
  * @peer: PEER object

umac/cmn_services/obj_mgr/inc/wlan_objmgr_psoc_obj.h

@@ -201,6 +201,7 @@
 
 	/* Invalid VHT cap */
 #define WLAN_SOC_OP_VHT_INVALID_CAP    0x00000001
+
 /**
  * struct wlan_objmgr_psoc_regulatory -  Regulatory sub structure of PSOC
  * @country_code:  Country code
@@ -552,9 +553,19 @@ QDF_STATUS wlan_objmgr_trigger_psoc_comp_priv_object_deletion(
  * Return: peer pointer
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_debug(
+		struct wlan_objmgr_psoc *psoc, uint8_t *macaddr,
+		wlan_objmgr_ref_dbgid dbg_id, const char *func, int line);
+
+#define wlan_objmgr_get_peer_by_mac(psoc, macaddr, dbgid) \
+		wlan_objmgr_get_peer_by_mac_debug(psoc, macaddr, dbgid, \
+		__func__, __LINE__)
+#else
 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac(
 		struct wlan_objmgr_psoc *psoc, uint8_t *macaddr,
 		wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_get_peer() - find peer from psoc's peer list
@@ -572,9 +583,20 @@ struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac(
  * Return: peer pointer
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_objmgr_get_peer_debug(
+			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
+			uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line);
+
+#define wlan_objmgr_get_peer(psoc, pdev_id, macaddr, dbgid) \
+		wlan_objmgr_get_peer_debug(psoc, pdev_id, macaddr, dbgid, \
+		__func__, __LINE__)
+#else
 struct wlan_objmgr_peer *wlan_objmgr_get_peer(
 			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
 			uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_get_peer_nolock() - find peer from psoc's peer list (lock free)
@@ -592,9 +614,20 @@ struct wlan_objmgr_peer *wlan_objmgr_get_peer(
  * Return: peer pointer
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_objmgr_get_peer_nolock_debug(
+			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
+			uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line);
+
+#define wlan_objmgr_get_peer_nolock(psoc, pdev_id, macaddr, dbgid) \
+		wlan_objmgr_get_peer_nolock_debug(psoc, pdev_id, macaddr, \
+		dbgid, __func__, __LINE__)
+#else
 struct wlan_objmgr_peer *wlan_objmgr_get_peer_nolock(
 			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
 			uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_get_peer_logically_deleted() - find peer
@@ -612,9 +645,20 @@ struct wlan_objmgr_peer *wlan_objmgr_get_peer_nolock(
  * Return: peer pointer
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_objmgr_get_peer_logically_deleted_debug(
+			struct wlan_objmgr_psoc *psoc, uint8_t *macaddr,
+			wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line);
+
+#define wlan_objmgr_get_peer_logically_deleted(psoc, macaddr, dbgid) \
+		wlan_objmgr_get_peer_logically_deleted_debug(psoc, macaddr, \
+		dbgid, __func__, __LINE__)
+#else
 struct wlan_objmgr_peer *wlan_objmgr_get_peer_logically_deleted(
 			struct wlan_objmgr_psoc *psoc, uint8_t *macaddr,
 			wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_get_peer_no_state() - find peer from psoc's peer list
@@ -633,9 +677,20 @@ struct wlan_objmgr_peer *wlan_objmgr_get_peer_logically_deleted(
  * Return: peer pointer
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_objmgr_get_peer_no_state_debug(
+			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
+			uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line);
+
+#define wlan_objmgr_get_peer_no_state(psoc, pdev_id, macaddr, dbgid) \
+		wlan_objmgr_get_peer_no_state_debug(psoc, pdev_id, macaddr, \
+		dbgid, __func__, __LINE__)
+#else
 struct wlan_objmgr_peer *wlan_objmgr_get_peer_no_state(
 			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
 			uint8_t *macaddr, wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev() - get peer from
@@ -658,10 +713,23 @@ struct wlan_objmgr_peer *wlan_objmgr_get_peer_no_state(
  * Return: List of peer pointers
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+qdf_list_t *wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev_debug(
+			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
+			uint8_t *bssid, uint8_t *macaddr,
+			wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line);
+
+#define wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev( \
+	psoc, pdev_id, bssid, macaddr, dbgid) \
+		wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev_debug( \
+		psoc, pdev_id, bssid, macaddr, dbgid, __func__, __LINE__)
+#else
 qdf_list_t *wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev(
 			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
 			uint8_t *bssid, uint8_t *macaddr,
 			wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_get_peer_by_mac_n_vdev() - find peer from psoc's peer list
@@ -682,10 +750,23 @@ qdf_list_t *wlan_objmgr_populate_logically_deleted_peerlist_by_mac_n_vdev(
  * Return: peer pointer
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev_debug(
+			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
+			uint8_t *bssid, uint8_t *macaddr,
+			wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line);
+
+#define wlan_objmgr_get_peer_by_mac_n_vdev(psoc, pdevid, bssid, macaddr, \
+	dbgid) \
+		wlan_objmgr_get_peer_by_mac_n_vdev_debug(psoc, pdevid, \
+		bssid, macaddr, dbgid, __func__, __LINE__)
+#else
 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev(
 			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
 			uint8_t *bssid, uint8_t *macaddr,
 			wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_get_peer_by_mac_n_vdev_no_state() - find peer from psoc's peer
@@ -706,10 +787,23 @@ struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev(
  * Return: peer pointer
  *         NULL on FAILURE
  */
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev_no_state_debug(
+			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
+			uint8_t *bssid,  uint8_t *macaddr,
+			wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line);
+
+#define wlan_objmgr_get_peer_by_mac_n_vdev_no_state(psoc, pdevid, bssid, \
+	macaddr, dbgid) \
+		wlan_objmgr_get_peer_by_mac_n_vdev_no_state_debug(psoc, \
+		pdevid, bssid, macaddr, dbgid, __func__, __LINE__)
+#else
 struct wlan_objmgr_peer *wlan_objmgr_get_peer_by_mac_n_vdev_no_state(
 			struct wlan_objmgr_psoc *psoc, uint8_t pdev_id,
 			uint8_t *bssid,  uint8_t *macaddr,
 			wlan_objmgr_ref_dbgid dbg_id);
+#endif
 
 /**
  * wlan_objmgr_get_pdev_by_id() - retrieve pdev by id
@@ -1567,7 +1661,6 @@ static inline uint8_t wlan_psoc_get_id(
  *
  * Return: void
  */
-
 #ifdef WLAN_OBJMGR_DEBUG
 void wlan_print_psoc_info(struct wlan_objmgr_psoc *psoc);
 #else

umac/cmn_services/obj_mgr/src/wlan_objmgr_peer_obj.c

@@ -604,8 +604,57 @@ wlan_objmgr_peer_get_debug_id_ref(struct wlan_objmgr_peer *peer,
 				  wlan_objmgr_ref_dbgid id) {}
 #endif
 
-void wlan_objmgr_peer_get_ref(struct wlan_objmgr_peer *peer,
-			      wlan_objmgr_ref_dbgid id)
+#ifdef WLAN_OBJMGR_REF_ID_DEBUG
+static QDF_STATUS
+wlan_objmgr_peer_release_debug_id_ref(struct wlan_objmgr_peer *peer,
+				      wlan_objmgr_ref_dbgid id)
+{
+	if (!qdf_atomic_read(&peer->peer_objmgr.ref_id_dbg[id])) {
+		uint8_t *macaddr;
+
+		macaddr = wlan_peer_get_macaddr(peer);
+		obj_mgr_err(
+		"peer(%02x:%02x:%02x:%02x:%02x:%02x) ref was not taken by %d",
+			macaddr[0], macaddr[1], macaddr[2],
+			macaddr[3], macaddr[4], macaddr[5], id);
+		wlan_objmgr_print_ref_ids(peer->peer_objmgr.ref_id_dbg,
+					  QDF_TRACE_LEVEL_FATAL);
+		WLAN_OBJMGR_BUG(0);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	qdf_atomic_dec(&peer->peer_objmgr.ref_id_dbg[id]);
+	return QDF_STATUS_SUCCESS;
+}
+#else
+static QDF_STATUS
+wlan_objmgr_peer_release_debug_id_ref(struct wlan_objmgr_peer *peer,
+				      wlan_objmgr_ref_dbgid id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+static inline void
+wlan_objmgr_peer_ref_trace(struct wlan_objmgr_peer *peer,
+			   wlan_objmgr_ref_dbgid id,
+			   const char *func, int line)
+{
+}
+
+static inline void
+wlan_objmgr_peer_deref_trace(struct wlan_objmgr_peer *peer,
+			     wlan_objmgr_ref_dbgid id,
+			     const char *func, int line)
+{
+}
+#endif
+
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+void wlan_objmgr_peer_get_ref_debug(struct wlan_objmgr_peer *peer,
+				    wlan_objmgr_ref_dbgid id,
+				    const char *func, int line)
 {
 	if (!peer) {
 		obj_mgr_err("peer obj is NULL for %d", id);
@@ -616,12 +665,65 @@ void wlan_objmgr_peer_get_ref(struct wlan_objmgr_peer *peer,
 	qdf_atomic_inc(&peer->peer_objmgr.ref_cnt);
 	wlan_objmgr_peer_get_debug_id_ref(peer, id);
 
+	wlan_objmgr_peer_ref_trace(peer, id, func, line);
 	return;
 }
+
+qdf_export_symbol(wlan_objmgr_peer_get_ref_debug);
+#else
+void wlan_objmgr_peer_get_ref(struct wlan_objmgr_peer *peer,
+			      wlan_objmgr_ref_dbgid id)
+{
+	if (!peer) {
+		obj_mgr_err("peer obj is NULL for %d", id);
+		QDF_ASSERT(0);
+		return;
+	}
+	/* Increment ref count */
+	qdf_atomic_inc(&peer->peer_objmgr.ref_cnt);
+	wlan_objmgr_peer_get_debug_id_ref(peer, id);
+}
+
 qdf_export_symbol(wlan_objmgr_peer_get_ref);
+#endif
+
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+QDF_STATUS wlan_objmgr_peer_try_get_ref_debug(struct wlan_objmgr_peer *peer,
+					      wlan_objmgr_ref_dbgid id,
+					      const char *func, int line)
+{
+	if (!peer) {
+		obj_mgr_err("peer obj is NULL for %d", id);
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	wlan_peer_obj_lock(peer);
+	if (peer->obj_state != WLAN_OBJ_STATE_CREATED) {
+		wlan_peer_obj_unlock(peer);
+		if (peer->peer_objmgr.print_cnt++ <=
+				WLAN_OBJMGR_RATELIMIT_THRESH) {
+			uint8_t *macaddr;
+
+			macaddr = wlan_peer_get_macaddr(peer);
+			obj_mgr_debug(
+			"peer(" QDF_MAC_ADDR_STR ") not in Created st(%d)",
+			QDF_MAC_ADDR_ARRAY(macaddr),
+			peer->obj_state);
+		}
+		return QDF_STATUS_E_RESOURCES;
+	}
+
+	wlan_objmgr_peer_get_ref_debug(peer, id, func, line);
+	wlan_peer_obj_unlock(peer);
 
+	return QDF_STATUS_SUCCESS;
+}
+
+qdf_export_symbol(wlan_objmgr_peer_try_get_ref_debug);
+#else
 QDF_STATUS wlan_objmgr_peer_try_get_ref(struct wlan_objmgr_peer *peer,
-						 wlan_objmgr_ref_dbgid id)
+					wlan_objmgr_ref_dbgid id)
 {
 	if (!peer) {
 		obj_mgr_err("peer obj is NULL for %d", id);
@@ -650,81 +752,120 @@ QDF_STATUS wlan_objmgr_peer_try_get_ref(struct wlan_objmgr_peer *peer,
 
 	return QDF_STATUS_SUCCESS;
 }
+
 qdf_export_symbol(wlan_objmgr_peer_try_get_ref);
+#endif
 
-#ifdef WLAN_OBJMGR_REF_ID_DEBUG
-static QDF_STATUS
-wlan_objmgr_peer_release_debug_id_ref(struct wlan_objmgr_peer *peer,
-				      wlan_objmgr_ref_dbgid id)
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc_debug(
+					struct wlan_peer_list *peer_list,
+					uint8_t hash_index,
+					struct wlan_objmgr_peer *peer,
+					wlan_objmgr_ref_dbgid dbg_id,
+					const char *func, int line)
 {
-	if (!qdf_atomic_read(&peer->peer_objmgr.ref_id_dbg[id])) {
-		uint8_t *macaddr;
+	struct wlan_objmgr_peer *peer_next = NULL;
+	qdf_list_node_t *psoc_node = NULL;
+	qdf_list_node_t *prev_psoc_node = NULL;
+	qdf_list_t *obj_list;
 
-		macaddr = wlan_peer_get_macaddr(peer);
-		obj_mgr_err(
-		"peer(%02x:%02x:%02x:%02x:%02x:%02x) ref was not taken by %d",
-			macaddr[0], macaddr[1], macaddr[2],
-			macaddr[3], macaddr[4], macaddr[5], id);
-		wlan_objmgr_print_ref_ids(peer->peer_objmgr.ref_id_dbg,
-					  QDF_TRACE_LEVEL_FATAL);
-		WLAN_OBJMGR_BUG(0);
-		return QDF_STATUS_E_FAILURE;
+	qdf_spin_lock_bh(&peer_list->peer_list_lock);
+	obj_list = &peer_list->peer_hash[hash_index];
+
+	prev_psoc_node = &peer->psoc_peer;
+	while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) ==
+						QDF_STATUS_SUCCESS) {
+		peer_next = qdf_container_of(psoc_node, struct wlan_objmgr_peer,
+					     psoc_peer);
+
+		if (wlan_objmgr_peer_try_get_ref_debug(peer_next, dbg_id,
+						       func, line) ==
+				QDF_STATUS_SUCCESS) {
+			qdf_spin_unlock_bh(&peer_list->peer_list_lock);
+			return peer_next;
+		}
+
+		prev_psoc_node = psoc_node;
 	}
 
-	qdf_atomic_dec(&peer->peer_objmgr.ref_id_dbg[id]);
-	return QDF_STATUS_SUCCESS;
+	qdf_spin_unlock_bh(&peer_list->peer_list_lock);
+
+	return NULL;
 }
 #else
-static QDF_STATUS
-wlan_objmgr_peer_release_debug_id_ref(struct wlan_objmgr_peer *peer,
-				      wlan_objmgr_ref_dbgid id)
+struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc(
+					struct wlan_peer_list *peer_list,
+					uint8_t hash_index,
+					struct wlan_objmgr_peer *peer,
+					wlan_objmgr_ref_dbgid dbg_id)
 {
-	return QDF_STATUS_SUCCESS;
+	struct wlan_objmgr_peer *peer_next = NULL;
+	qdf_list_node_t *psoc_node = NULL;
+	qdf_list_node_t *prev_psoc_node = NULL;
+	qdf_list_t *obj_list;
+
+	qdf_spin_lock_bh(&peer_list->peer_list_lock);
+	obj_list = &peer_list->peer_hash[hash_index];
+
+	prev_psoc_node = &peer->psoc_peer;
+	while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) ==
+						QDF_STATUS_SUCCESS) {
+		peer_next = qdf_container_of(psoc_node, struct wlan_objmgr_peer,
+					     psoc_peer);
+
+		if (wlan_objmgr_peer_try_get_ref(peer_next, dbg_id) ==
+				QDF_STATUS_SUCCESS) {
+			qdf_spin_unlock_bh(&peer_list->peer_list_lock);
+			return peer_next;
+		}
+
+		prev_psoc_node = psoc_node;
+	}
+
+	qdf_spin_unlock_bh(&peer_list->peer_list_lock);
+
+	return NULL;
 }
 #endif
 
-void wlan_objmgr_peer_release_ref(struct wlan_objmgr_peer *peer,
-				  wlan_objmgr_ref_dbgid id)
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head_debug(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_list_t *peer_list,
+				wlan_objmgr_ref_dbgid dbg_id,
+				const char *func, int line)
 {
-	QDF_STATUS status;
+	struct wlan_objmgr_peer *peer;
+	qdf_list_node_t *vdev_node = NULL;
+	qdf_list_node_t *prev_vdev_node = NULL;
 
-	if (!peer) {
-		obj_mgr_err("peer obj is NULL for %d", id);
-		QDF_ASSERT(0);
-		return;
+	wlan_vdev_obj_lock(vdev);
+
+	if (qdf_list_peek_front(peer_list, &vdev_node) != QDF_STATUS_SUCCESS) {
+		wlan_vdev_obj_unlock(vdev);
+		return NULL;
 	}
 
-	if (!qdf_atomic_read(&peer->peer_objmgr.ref_cnt)) {
-		uint8_t *macaddr;
+	do {
+		peer = qdf_container_of(vdev_node, struct wlan_objmgr_peer,
+					vdev_peer);
 
-		macaddr = wlan_peer_get_macaddr(peer);
-		obj_mgr_err("peer(%02x:%02x:%02x:%02x:%02x:%02x) ref cnt is 0",
-				macaddr[0], macaddr[1], macaddr[2],
-				macaddr[3], macaddr[4], macaddr[5]);
-		WLAN_OBJMGR_BUG(0);
-		return;
-	}
+		if (wlan_objmgr_peer_try_get_ref_debug(peer, dbg_id,
+						       func, line) ==
+				QDF_STATUS_SUCCESS) {
+			wlan_vdev_obj_unlock(vdev);
+			return peer;
+		}
 
-	status = wlan_objmgr_peer_release_debug_id_ref(peer, id);
-	if (QDF_IS_STATUS_ERROR(status))
-		return;
+		prev_vdev_node = vdev_node;
+	} while (qdf_list_peek_next(peer_list, prev_vdev_node, &vdev_node) ==
+							QDF_STATUS_SUCCESS);
 
-	/* Provide synchronization from the access to add peer
-	 * to logically deleted peer list.
-	 */
-	wlan_peer_obj_lock(peer);
-	/* Decrement ref count, free peer object, if ref count == 0 */
-	if (qdf_atomic_dec_and_test(&peer->peer_objmgr.ref_cnt)) {
-		wlan_peer_obj_unlock(peer);
-		wlan_objmgr_peer_obj_destroy(peer);
-	} else {
-		wlan_peer_obj_unlock(peer);
-	}
+	wlan_vdev_obj_unlock(vdev);
 
-	return;
+	return NULL;
 }
-qdf_export_symbol(wlan_objmgr_peer_release_ref);
-
+#else
 struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head(
 				struct wlan_objmgr_vdev *vdev,
 				qdf_list_t *peer_list,
@@ -759,7 +900,46 @@ struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head(
 
 	return NULL;
 }
+#endif
 
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev_debug(
+					struct wlan_objmgr_vdev *vdev,
+					qdf_list_t *peer_list,
+					struct wlan_objmgr_peer *peer,
+					wlan_objmgr_ref_dbgid dbg_id,
+					const char *func, int line)
+{
+	struct wlan_objmgr_peer *peer_next;
+	qdf_list_node_t *vdev_node = NULL;
+	qdf_list_node_t *prev_vdev_node = NULL;
+
+	if (!peer)
+		return NULL;
+
+	wlan_vdev_obj_lock(vdev);
+
+	prev_vdev_node = &peer->vdev_peer;
+	while (qdf_list_peek_next(peer_list, prev_vdev_node, &vdev_node) ==
+						QDF_STATUS_SUCCESS) {
+		peer_next = qdf_container_of(vdev_node, struct wlan_objmgr_peer,
+					     vdev_peer);
+
+		if (wlan_objmgr_peer_try_get_ref_debug(peer_next, dbg_id,
+						       func, line) ==
+				QDF_STATUS_SUCCESS) {
+			wlan_vdev_obj_unlock(vdev);
+			return peer_next;
+		}
+
+		prev_vdev_node = vdev_node;
+	}
+
+	wlan_vdev_obj_unlock(vdev);
+
+	return NULL;
+}
+#else
 struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev(
 					struct wlan_objmgr_vdev *vdev,
 					qdf_list_t *peer_list,
@@ -794,14 +974,16 @@ struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev(
 
 	return NULL;
 }
+#endif
 
-struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc(
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head_debug(
 					struct wlan_peer_list *peer_list,
 					uint8_t hash_index,
-					struct wlan_objmgr_peer *peer,
-					wlan_objmgr_ref_dbgid dbg_id)
+					wlan_objmgr_ref_dbgid dbg_id,
+					const char *func, int line)
 {
-	struct wlan_objmgr_peer *peer_next = NULL;
+	struct wlan_objmgr_peer *peer;
 	qdf_list_node_t *psoc_node = NULL;
 	qdf_list_node_t *prev_psoc_node = NULL;
 	qdf_list_t *obj_list;
@@ -809,26 +991,29 @@ struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc(
 	qdf_spin_lock_bh(&peer_list->peer_list_lock);
 	obj_list = &peer_list->peer_hash[hash_index];
 
-	prev_psoc_node = &peer->psoc_peer;
-	while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) ==
-						QDF_STATUS_SUCCESS) {
-		peer_next = qdf_container_of(psoc_node, struct wlan_objmgr_peer,
-						psoc_peer);
+	if (qdf_list_peek_front(obj_list, &psoc_node) != QDF_STATUS_SUCCESS) {
+		qdf_spin_unlock_bh(&peer_list->peer_list_lock);
+		return NULL;
+	}
 
-		if (wlan_objmgr_peer_try_get_ref(peer_next, dbg_id) ==
+	do {
+		peer = qdf_container_of(psoc_node, struct wlan_objmgr_peer,
+					psoc_peer);
+		if (wlan_objmgr_peer_try_get_ref_debug(peer, dbg_id,
+						       func, line) ==
 				QDF_STATUS_SUCCESS) {
 			qdf_spin_unlock_bh(&peer_list->peer_list_lock);
-			return peer_next;
+			return peer;
 		}
 
 		prev_psoc_node = psoc_node;
-	}
+	} while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) ==
+						QDF_STATUS_SUCCESS);
 
 	qdf_spin_unlock_bh(&peer_list->peer_list_lock);
-
 	return NULL;
 }
-
+#else
 struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head(
 					struct wlan_peer_list *peer_list,
 					uint8_t hash_index,
@@ -863,7 +1048,35 @@ struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head(
 	qdf_spin_unlock_bh(&peer_list->peer_list_lock);
 	return NULL;
 }
+#endif
+
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref_debug(
+					struct wlan_peer_list *peer_list,
+					uint8_t hash_index,
+					wlan_objmgr_ref_dbgid dbg_id,
+					const char *func, int line)
+{
+	struct wlan_objmgr_peer *peer;
+	qdf_list_t *obj_list;
 
+	qdf_spin_lock_bh(&peer_list->peer_list_lock);
+	obj_list = &peer_list->peer_hash[hash_index];
+
+	peer = wlan_psoc_peer_list_peek_head(obj_list);
+
+	/* This API is invoked by caller, only when caller need to access the
+	 * peer object, though object is not in active state, this API should be
+	 * used carefully, where multiple object frees are not triggered
+	 */
+	if (peer)
+		wlan_objmgr_peer_get_ref_debug(peer, dbg_id, func, line);
+
+	qdf_spin_unlock_bh(&peer_list->peer_list_lock);
+
+	return peer;
+}
+#else
 struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref(
 					struct wlan_peer_list *peer_list,
 					uint8_t hash_index,
@@ -877,8 +1090,7 @@ struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref(
 
 	peer = wlan_psoc_peer_list_peek_head(obj_list);
 
-	/**
-	 * This API is invoked by caller, only when caller need to access the
+	/* This API is invoked by caller, only when caller need to access the
 	 * peer object, though object is not in active state, this API should be
 	 * used carefully, where multiple object frees are not triggered
 	 */
@@ -889,7 +1101,34 @@ struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref(
 
 	return peer;
 }
+#endif
+
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref_debug(
+			struct wlan_peer_list *peer_list, uint8_t hash_index,
+			struct wlan_objmgr_peer *peer,
+			wlan_objmgr_ref_dbgid dbg_id,
+			const char *func, int line)
+{
+	qdf_list_t *obj_list;
+	struct wlan_objmgr_peer *peer_next;
+
+	qdf_spin_lock_bh(&peer_list->peer_list_lock);
+	obj_list = &peer_list->peer_hash[hash_index];
+
+	peer_next = wlan_peer_get_next_peer_of_psoc(obj_list, peer);
+	/* This API is invoked by caller, only when caller need to access the
+	 * peer object, though object is not in active state, this API should be
+	 * used carefully, where multiple free on object are not triggered
+	 */
+	if (peer_next)
+		wlan_objmgr_peer_get_ref_debug(peer_next, dbg_id, func, line);
+
+	qdf_spin_unlock_bh(&peer_list->peer_list_lock);
 
+	return peer_next;
+}
+#else
 struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref(
 			struct wlan_peer_list *peer_list, uint8_t hash_index,
 			struct wlan_objmgr_peer *peer,
@@ -902,8 +1141,7 @@ struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref(
 	obj_list = &peer_list->peer_hash[hash_index];
 
 	peer_next = wlan_peer_get_next_peer_of_psoc(obj_list, peer);
-	/**
-	 * This API is invoked by caller, only when caller need to access the
+	/* This API is invoked by caller, only when caller need to access the
 	 * peer object, though object is not in active state, this API should be
 	 * used carefully, where multiple free on object are not triggered
 	 */
@@ -914,6 +1152,95 @@ struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref(
 
 	return peer_next;
 }
+#endif
+
+#ifdef WLAN_OBJMGR_REF_ID_TRACE
+void wlan_objmgr_peer_release_ref_debug(struct wlan_objmgr_peer *peer,
+					wlan_objmgr_ref_dbgid id,
+					const char *func, int line)
+{
+	QDF_STATUS status;
+
+	if (!peer) {
+		obj_mgr_err("peer obj is NULL for %d", id);
+		QDF_ASSERT(0);
+		return;
+	}
+
+	if (!qdf_atomic_read(&peer->peer_objmgr.ref_cnt)) {
+		uint8_t *macaddr;
+
+		macaddr = wlan_peer_get_macaddr(peer);
+		obj_mgr_err("peer(%02x:%02x:%02x:%02x:%02x:%02x) ref cnt is 0",
+				macaddr[0], macaddr[1], macaddr[2],
+				macaddr[3], macaddr[4], macaddr[5]);
+		WLAN_OBJMGR_BUG(0);
+		return;
+	}
+
+	status = wlan_objmgr_peer_release_debug_id_ref(peer, id);
+	if (QDF_IS_STATUS_ERROR(status))
+		return;
+
+	wlan_objmgr_peer_deref_trace(peer, id, func, line);
+	/* Provide synchronization from the access to add peer
+	 * to logically deleted peer list.
+	 */
+	wlan_peer_obj_lock(peer);
+	/* Decrement ref count, free peer object, if ref count == 0 */
+	if (qdf_atomic_dec_and_test(&peer->peer_objmgr.ref_cnt)) {
+		wlan_peer_obj_unlock(peer);
+		wlan_objmgr_peer_obj_destroy(peer);
+	} else {
+		wlan_peer_obj_unlock(peer);
+	}
+
+	return;
+}
+
+qdf_export_symbol(wlan_objmgr_peer_release_ref_debug);
+#else
+void wlan_objmgr_peer_release_ref(struct wlan_objmgr_peer *peer,
+				  wlan_objmgr_ref_dbgid id)
+{
+	QDF_STATUS status;
+
+	if (!peer) {
+		obj_mgr_err("peer obj is NULL for %d", id);
+		QDF_ASSERT(0);
+		return;
+	}
+
+	if (!qdf_atomic_read(&peer->peer_objmgr.ref_cnt)) {
+		uint8_t *macaddr;
+
+		macaddr = wlan_peer_get_macaddr(peer);
+		obj_mgr_err("peer(%02x:%02x:%02x:%02x:%02x:%02x) ref cnt is 0",
+			    macaddr[0], macaddr[1], macaddr[2],
+			    macaddr[3], macaddr[4], macaddr[5]);
+		WLAN_OBJMGR_BUG(0);
+		return;
+	}
+
+	status = wlan_objmgr_peer_release_debug_id_ref(peer, id);
+	if (QDF_IS_STATUS_ERROR(status))
+		return;
+
+	/* Provide synchronization from the access to add peer
+	 * to logically deleted peer list.
+	 */
+	wlan_peer_obj_lock(peer);
+	/* Decrement ref count, free peer object, if ref count == 0 */
+	if (qdf_atomic_dec_and_test(&peer->peer_objmgr.ref_cnt)) {
+		wlan_peer_obj_unlock(peer);
+		wlan_objmgr_peer_obj_destroy(peer);
+	} else {
+		wlan_peer_obj_unlock(peer);
+	}
+}
+
+qdf_export_symbol(wlan_objmgr_peer_release_ref);
+#endif
 
 #ifdef WLAN_OBJMGR_REF_ID_DEBUG
 void