qcacmn: Add WiFi Radar core utils

Add WiFi Radar core functions utils.

Change-Id: I74fd9e5f76d2a454a6de2f21a2080c17230f25ad

umac/wifi_radar/core/inc/wifi_radar_defs_i.h

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2021, Qualcomm Innovation Center, Inc. All rights reserved.
+
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _WIFI_RADAR_DEFS_I_H_
+#define _WIFI_RADAR_DEFS_I_H_
+
+#include <wlan_objmgr_cmn.h>
+#include <wlan_objmgr_global_obj.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_peer_obj.h>
+#include <qdf_list.h>
+#include <qdf_timer.h>
+#include <qdf_util.h>
+#include <qdf_types.h>
+#include <wlan_wifi_radar_utils_api.h>
+
+/**
+ * wlan_wifi_radar_psoc_obj_create_handler() -
+ * psoc object create handler for WiFi Radar
+ * @psoc - pointer to psoc object
+ * @args - void pointer in case it needs arguments
+ *
+ * Return: status of object creation
+ */
+QDF_STATUS
+wlan_wifi_radar_psoc_obj_create_handler(
+struct wlan_objmgr_psoc *psoc, void *arg);
+
+/**
+ * wlan_wifi_radar_psoc_obj_destroy_handler() -
+ * psoc object destroy handler for WiFi Radar
+ * @psoc - pointer to psoc object
+ * @args - void pointer in case it needs arguments
+ *
+ * Return: status of destroy object
+ */
+QDF_STATUS
+wlan_wifi_radar_psoc_obj_destroy_handler(
+struct wlan_objmgr_psoc *psoc, void *arg);
+
+/**
+ * wlan_wifi_radar_pdev_obj_create_handler() -
+ * pdev object create handler for WiFi Radar
+ * @pdev - pointer to pdev object
+ * @args - void pointer in case it needs arguments
+ *
+ * Return: status of object creation
+ */
+QDF_STATUS
+wlan_wifi_radar_pdev_obj_create_handler(
+struct wlan_objmgr_pdev *pdev, void *arg);
+
+/**
+ * wlan_wifi_radar_pdev_obj_destroy_handler() -
+ * pdev object destroy handler for WiFi Radar
+ * @pdev - pointer to pdev object
+ * @args - void pointer in case it needs arguments
+ *
+ * Return: status of destroy object
+ */
+QDF_STATUS
+wlan_wifi_radar_pdev_obj_destroy_handler(
+struct wlan_objmgr_pdev *pdev, void *arg);
+
+/**
+ * wlan_wifi_radar_peer_obj_create_handler() -
+ * peer object create handler for WiFi Radar
+ * @peer - pointer to peer object
+ * @args - void pointer in case it needs arguments
+ *
+ * Return: status of object creation
+ */
+QDF_STATUS
+wlan_wifi_radar_peer_obj_create_handler(
+struct wlan_objmgr_peer *peer, void *arg);
+
+/**
+ * wlan_wifi_radar_peer_obj_destroy_handler() -
+ * peer object destroy handler for WiFi radar
+ * @peer - pointer to peer object
+ * @args - void pointer in case it needs arguments
+ *
+ * Return: status ofi destry object
+ */
+QDF_STATUS
+wlan_wifi_radar_peer_obj_destroy_handler(
+struct wlan_objmgr_peer *peer, void *arg);
+
+/**
+ * wifi_radar_streamfs_init() - stream filesystem init
+ * @pdev - pointer to pdev object
+ *
+ * Return: status of fs init
+ */
+QDF_STATUS
+wifi_radar_streamfs_init(struct wlan_objmgr_pdev *pdev);
+
+/**
+ * wifi_radar_streamfs_remove() - stream filesystem remove
+ * @pdev - pointer to pdev object
+ *
+ * Return: status of fs remove
+ */
+QDF_STATUS
+wifi_radar_streamfs_remove(struct wlan_objmgr_pdev *pdev);
+
+/**
+ * wifi_radar_streamfs_write() - write to stream filesystem
+ * @pa - pointer to pdev_cfr object
+ * @write_data - Pointer to data
+ * @write_len - data len
+ *
+ * Return: status of fs write
+ */
+QDF_STATUS
+wifi_radar_streamfs_write(
+struct pdev_cfr *pa, const void *write_data,
+size_t write_len);
+
+/**
+ * wifi_radar_streamfs_flush() - flush the write to streamfs
+ * @pa - pointer to pdev_cfr object
+ *
+ * Return: status of fs flush
+ */
+QDF_STATUS
+wifi_radar_streamfs_flush(struct pdev_cfr *pa);
+#endif

umac/wifi_radar/core/src/wifi_radar_common.c

@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <wifi_radar_defs_i.h>
+#include <qdf_types.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_peer_obj.h>
+#include <qdf_streamfs.h>
+#include <target_if.h>
+#include <target_if_direct_buf_rx_api.h>
+#include <wlan_osif_priv.h>
+
+QDF_STATUS
+wlan_wifi_radar_psoc_obj_create_handler(
+struct wlan_objmgr_psoc *psoc, void *arg)
+{
+	struct psoc_wifi_radar *wifi_radar_sc = NULL;
+
+	wifi_radar_sc =
+	(struct psoc_wifi_radar *)qdf_mem_malloc(sizeof(*wifi_radar_sc));
+	if (!wifi_radar_sc) {
+		wifi_radar_err("Failed to allocate wifi_radar_ctx object\n");
+		return QDF_STATUS_E_NOMEM;
+	}
+
+	wifi_radar_sc->psoc_obj = psoc;
+
+	wlan_objmgr_psoc_component_obj_attach(psoc, WLAN_UMAC_COMP_WIFI_RADAR,
+					      (void *)wifi_radar_sc,
+					      QDF_STATUS_SUCCESS);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_wifi_radar_psoc_obj_destroy_handler(
+struct wlan_objmgr_psoc *psoc, void *arg)
+{
+	struct psoc_wifi_radar *wifi_radar_sc = NULL;
+
+	wifi_radar_sc = wlan_objmgr_psoc_get_comp_private_obj(
+				    psoc, WLAN_UMAC_COMP_WIFI_RADAR);
+	if (wifi_radar_sc) {
+		wlan_objmgr_psoc_component_obj_detach(
+		psoc, WLAN_UMAC_COMP_WIFI_RADAR, (void *)wifi_radar_sc);
+		qdf_mem_free(wifi_radar_sc);
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_wifi_radar_pdev_obj_create_handler(
+struct wlan_objmgr_pdev *pdev, void *arg)
+{
+	struct pdev_wifi_radar *pa = NULL;
+
+	if (!pdev) {
+		wifi_radar_err("PDEV is NULL\n");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	wlan_pdev_nif_feat_ext_cap_set(pdev, WLAN_PDEV_FEXT_WIFI_RADAR_ENABLE);
+
+	pa = (struct pdev_wifi_radar *)
+		 qdf_mem_malloc(sizeof(struct pdev_wifi_radar));
+	if (!pa) {
+		wifi_radar_err("Failed to allocate pdev object\n");
+		return QDF_STATUS_E_NOMEM;
+	}
+	pa->pdev_obj = pdev;
+	wlan_objmgr_pdev_component_obj_attach(pdev, WLAN_UMAC_COMP_WIFI_RADAR,
+					      (void *)pa, QDF_STATUS_SUCCESS);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_wifi_radar_pdev_obj_destroy_handler(
+struct wlan_objmgr_pdev *pdev, void *arg)
+{
+	struct pdev_wifi_radar *pa = NULL;
+	uint32_t idx;
+
+	if (!pdev) {
+		wifi_radar_err("PDEV is NULL\n");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	pa =
+	wlan_objmgr_pdev_get_comp_private_obj(pdev, WLAN_UMAC_COMP_WIFI_RADAR);
+	if (pa) {
+		wlan_objmgr_pdev_component_obj_detach(
+		pdev, WLAN_UMAC_COMP_WIFI_RADAR, (void *)pa);
+		qdf_mem_free(pa);
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_wifi_radar_peer_obj_create_handler(
+struct wlan_objmgr_peer *peer, void *arg)
+{
+	struct peer_wifi_radar *pe = NULL;
+	struct wlan_objmgr_vdev *vdev;
+	struct wlan_objmgr_pdev *pdev = NULL;
+
+	if (!peer) {
+		wifi_radar_err("PEER is NULL\n");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	vdev = wlan_peer_get_vdev(peer);
+	if (vdev)
+		pdev = wlan_vdev_get_pdev(vdev);
+
+	if (!pdev) {
+		wifi_radar_err("PDEV is NULL\n");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	if (wlan_wifi_radar_is_feature_disabled(pdev)) {
+		wifi_radar_info("WiFi Radar is disabled");
+		return QDF_STATUS_E_NOSUPPORT;
+	}
+
+	pe = (struct peer_wifi_radar *)
+	qdf_mem_malloc(sizeof(struct peer_wifi_radar));
+	if (!pe) {
+		wifi_radar_err("Failed to allocate peer_wifi_radar object\n");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	pe->peer_obj = peer;
+
+	wlan_objmgr_peer_component_obj_attach(peer, WLAN_UMAC_COMP_WIFI_RADAR,
+					      (void *)pe, QDF_STATUS_SUCCESS);
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_wifi_radar_peer_obj_destroy_handler(
+struct wlan_objmgr_peer *peer, void *arg)
+{
+	struct peer_wifi_radar *pe = NULL;
+	struct wlan_objmgr_vdev *vdev;
+	struct wlan_objmgr_pdev *pdev = NULL;
+
+	if (!peer) {
+		wifi_radar_err("PEER is NULL\n");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	vdev = wlan_peer_get_vdev(peer);
+	if (vdev)
+		pdev = wlan_vdev_get_pdev(vdev);
+
+	if (wlan_wifi_radar_is_feature_disabled(pdev)) {
+		wifi_radar_info("WiFi Radar is disabled");
+		return QDF_STATUS_E_NOSUPPORT;
+	}
+
+	pe =
+	wlan_objmgr_peer_get_comp_private_obj(peer, WLAN_UMAC_COMP_WIFI_RADAR);
+	if (pe) {
+		wlan_objmgr_peer_component_obj_detach(
+		peer, WLAN_UMAC_COMP_WIFI_RADAR, (void *)pe);
+		qdf_mem_free(pe);
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * wifi_radar_get_dev_name() - Get net device name from pdev
+ *  @pdev: objmgr pdev
+ *
+ *  Return: netdev name
+ */
+static char *wifi_radar_get_dev_name(struct wlan_objmgr_pdev *pdev)
+{
+	struct pdev_osif_priv *pdev_ospriv;
+	struct qdf_net_if *nif;
+
+	pdev_ospriv = wlan_pdev_get_ospriv(pdev);
+	if (!pdev_ospriv) {
+		wifi_radar_err("pdev_ospriv is NULL\n");
+		return NULL;
+	}
+
+	nif = pdev_ospriv->nif;
+	if (!nif) {
+		wifi_radar_err("pdev nif is NULL\n");
+		return NULL;
+	}
+
+	return  qdf_net_if_get_devname(nif);
+}
+
+QDF_STATUS wifi_radar_streamfs_init(struct wlan_objmgr_pdev *pdev)
+{
+	struct pdev_wifi_radar *pa = NULL;
+	char *devname;
+	char folder[32];
+
+	if (!pdev) {
+		wifi_radar_err("PDEV is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	if (wlan_wifi_radar_is_feature_disabled(pdev)) {
+		wifi_radr_info("WiFi Radar is disabled");
+		return QDF_STATUS_COMP_DISABLED;
+	}
+
+	pa = wlan_objmgr_pdev_get_comp_private_obj(
+		pdev, WLAN_UMAC_COMP_WIFI_RADAR);
+
+	if (!pa) {
+		wifi_radar_err("pdev_wifi_radar is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	if (!pa->is_wifi_radar_capable) {
+		wifi_radar_err("WiFi Radar is not supported");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	devname = wifi_radar_get_dev_name(pdev);
+	if (!devname) {
+		wifi_radar_err("devname is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	snprintf(folder, sizeof(folder), "wifi-radar%s", devname);
+
+	pa->dir_ptr = qdf_streamfs_create_dir((const char *)folder, NULL);
+
+	if (!pa->dir_ptr) {
+		wifi_radar_err("Directory create failed");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	pa->chan_ptr = qdf_streamfs_open("wifi_radar_dump", pa->dir_ptr,
+					 pa->subbuf_size,
+					 pa->num_subbufs, NULL);
+
+	if (!pa->chan_ptr) {
+		wifi_radar_err("Chan create failed");
+		qdf_streamfs_remove_dir_recursive(pa->dir_ptr);
+		pa->dir_ptr = NULL;
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS wifi_radar_streamfs_remove(struct wlan_objmgr_pdev *pdev)
+{
+	struct pdev_wifi_radar *pa = NULL;
+
+	if (wlan_wifi_radar_is_feature_disabled(pdev)) {
+		wifi_radar_info("WiFi Radar is disabled");
+		return QDF_STATUS_COMP_DISABLED;
+	}
+
+	pa = wlan_objmgr_pdev_get_comp_private_obj(
+		 pdev, WLAN_UMAC_COMP_WIFI_RADAR);
+	if (pa) {
+		if (pa->chan_ptr) {
+			qdf_streamfs_close(pa->chan_ptr);
+			pa->chan_ptr = NULL;
+		}
+
+		if (pa->dir_ptr) {
+			qdf_streamfs_remove_dir_recursive(pa->dir_ptr);
+			pa->dir_ptr = NULL;
+		}
+
+	} else {
+		return QDF_STATUS_E_FAILURE;
+	}
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS wifi_radar_streamfs_write(
+struct pdev_wifi_radar *pa, const void *write_data,
+size_t write_len)
+{
+	if (pa->chan_ptr) {
+	/* write to channel buffer */
+		qdf_streamfs_write(pa->chan_ptr, (const void *)write_data,
+				   write_len);
+	} else {
+		return QDF_STATUS_E_FAILURE;
+	}
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS wifi_radar_streamfs_flush(struct pdev_wifi_radar *pa)
+{
+	if (pa->chan_ptr) {
+	/* Flush the data write to channel buffer */
+		qdf_streamfs_flush(pa->chan_ptr);
+	} else {
+		return QDF_STATUS_E_FAILURE;
+	}
+	return QDF_STATUS_SUCCESS;
+}