/*****************************************************************************
 *
 * Copyright (c) 2012 - 2017 Samsung Electronics Co., Ltd. All rights reserved
 *
 ****************************************************************************/

#include "dev.h"          /* sdev access */
#include "src_sink.h"
#include "debug.h"
#include "fapi.h"
#include "mlme.h"
#include "mgt.h"

static int slsi_src_sink_fake_sta_start(struct slsi_dev *sdev, struct net_device *dev)
{
	struct netdev_vif *ndev_vif = netdev_priv(dev);
	struct slsi_peer *peer;
	u8 device_address[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
	u8 fake_peer_mac[ETH_ALEN] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};

	SLSI_MUTEX_LOCK(ndev_vif->vif_mutex);

	ndev_vif->iftype = NL80211_IFTYPE_STATION;
	dev->ieee80211_ptr->iftype = NL80211_IFTYPE_STATION;
	ndev_vif->vif_type = FAPI_VIFTYPE_STATION;

	if (WARN(slsi_mlme_add_vif(sdev, dev, dev->dev_addr, device_address) != 0, "add VIF failed")) {
		SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
		return -EFAULT;
	}

	if (WARN(slsi_vif_activated(sdev, dev) != 0, "activate VIF failed")) {
		if (slsi_mlme_del_vif(sdev, dev) != 0)
			SLSI_NET_ERR(dev, "slsi_mlme_del_vif failed\n");
		SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
		return -EFAULT;
	}

	peer = slsi_peer_add(sdev, dev, fake_peer_mac, SLSI_STA_PEER_QUEUESET + 1);
	if (WARN(!peer, "add fake peer failed")) {
		slsi_vif_deactivated(sdev, dev);
		if (slsi_mlme_del_vif(sdev, dev) != 0)
			SLSI_NET_ERR(dev, "slsi_mlme_del_vif failed\n");
		SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
		return -EFAULT;
	}
	peer->qos_enabled = true;
	slsi_ps_port_control(sdev, dev, peer, SLSI_STA_CONN_STATE_CONNECTED);
	netif_carrier_on(dev);
	SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
	return 0;
}

static void slsi_src_sink_fake_sta_stop(struct slsi_dev *sdev, struct net_device *dev)
{
	struct netdev_vif *ndev_vif = netdev_priv(dev);
	struct slsi_peer  *peer = slsi_get_peer_from_qs(sdev, dev, SLSI_STA_PEER_QUEUESET);

	SLSI_MUTEX_LOCK(ndev_vif->vif_mutex);

	SLSI_NET_DBG1(dev, SLSI_SRC_SINK, "station stop(vif:%d)\n", ndev_vif->ifnum);

	if (WARN(!ndev_vif->activated, "not activated")) {
		SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
		return;
	}

	netif_carrier_off(dev);
	if (peer) {
		slsi_spinlock_lock(&ndev_vif->peer_lock);
		slsi_peer_remove(sdev, dev, peer);
		slsi_spinlock_unlock(&ndev_vif->peer_lock);
	}
	slsi_vif_deactivated(sdev, dev);
	if (slsi_mlme_del_vif(sdev, dev) != 0)
			SLSI_NET_ERR(dev, "slsi_mlme_del_vif failed\n");
	SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
}

static int slsi_src_sink_loopback_start(struct slsi_dev *sdev)
{
	struct net_device *dev;
	struct netdev_vif *ndev_vif;
	u8 i, queue_idx;

	for (i = SLSI_NET_INDEX_WLAN; i <= SLSI_NET_INDEX_P2P; i++) {
		dev = slsi_get_netdev_locked(sdev, i);
		if (WARN(!dev, "no netdev (index:%d)", i))
			return -EFAULT;

		ndev_vif = netdev_priv(dev);
		SLSI_MUTEX_LOCK(ndev_vif->vif_mutex);

		/* for p2p0 interface the peer database is not created during init;
		 * peer database is needed for dataplane to be functional.
		 * so create the peer records for p2p0 now and undo it during loopback stop
		 */
		if (i == SLSI_NET_INDEX_P2P) {
			for (queue_idx = 0; queue_idx < SLSI_ADHOC_PEER_CONNECTIONS_MAX; queue_idx++) {
				ndev_vif->peer_sta_record[queue_idx] = kzalloc(sizeof(*ndev_vif->peer_sta_record[queue_idx]), GFP_KERNEL);
				if (!ndev_vif->peer_sta_record[queue_idx]) {
					int j;

					SLSI_NET_ERR(dev, "Could not allocate memory for peer entry (queue_idx:%d)\n", queue_idx);

					/* free previously allocated peer database memory till current queue_idx */
					for (j = 0; j < queue_idx; j++) {
						kfree(ndev_vif->peer_sta_record[j]);
						ndev_vif->peer_sta_record[j] = NULL;
					}
					SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
					return -EFAULT;
				}
			}
		}
		SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
		if (WARN(slsi_src_sink_fake_sta_start(sdev, dev) != 0, "fake STA setup failed (vif:%d)\n", i))
			return -EFAULT;
	}
	return 0;
}

static void slsi_src_sink_loopback_stop(struct slsi_dev *sdev)
{
	struct net_device *dev;
	struct netdev_vif *ndev_vif;
	u8 i, queue_idx;

	for (i = SLSI_NET_INDEX_WLAN; i <= SLSI_NET_INDEX_P2P; i++) {
		dev = slsi_get_netdev_locked(sdev, i);
		if (WARN(!dev, "no netdev (index:%d)", i))
			return;

		slsi_src_sink_fake_sta_stop(sdev, dev);

		ndev_vif = netdev_priv(dev);
		SLSI_MUTEX_LOCK(ndev_vif->vif_mutex);

		/* undo peer database creation for p2p0 interface on loopback stop */
		if (i == SLSI_NET_INDEX_P2P) {
			for (queue_idx = 0; queue_idx < SLSI_ADHOC_PEER_CONNECTIONS_MAX; queue_idx++) {
				kfree(ndev_vif->peer_sta_record[queue_idx]);
				ndev_vif->peer_sta_record[queue_idx] = NULL;
			}
		}
		SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
	}
}

long slsi_src_sink_cdev_ioctl_cfg(struct slsi_dev *sdev, unsigned long arg)
{
	long                          r = 0;
	struct unifiio_src_sink_arg_t src_sink_arg;
	struct net_device             *dev;
	struct netdev_vif             *ndev_vif;
	struct sk_buff                *req = NULL;
	struct sk_buff                *ind = NULL;

	memset((void *)&src_sink_arg, 0, sizeof(struct unifiio_src_sink_arg_t));
	if (copy_from_user((void *)(&src_sink_arg), (void *)arg, sizeof(struct unifiio_src_sink_arg_t)))
		return -EFAULT;

	SLSI_DBG2(sdev, SLSI_SRC_SINK, "Source/Sink\n");
	SLSI_DBG2(sdev, SLSI_SRC_SINK, "====================================================\n");
	SLSI_DBG2(sdev, SLSI_SRC_SINK, "  #action    : [0x%04X]\n", src_sink_arg.common.action);
	SLSI_DBG2(sdev, SLSI_SRC_SINK, "  #direction : [0x%04X]\n", src_sink_arg.common.direction);
	SLSI_DBG2(sdev, SLSI_SRC_SINK, "  #vif       : [0x%04X]\n", src_sink_arg.common.vif);
	SLSI_DBG2(sdev, SLSI_SRC_SINK, "  #endpoint  : [0x%04X]\n", src_sink_arg.common.endpoint);
	SLSI_DBG2(sdev, SLSI_SRC_SINK, "====================================================\n");

	SLSI_MUTEX_LOCK(sdev->netdev_add_remove_mutex);
	dev = slsi_get_netdev_locked(sdev, src_sink_arg.common.vif);
	if (WARN_ON(!dev)) {
		SLSI_ERR(sdev, "netdev for input vif:%d is NULL\n", src_sink_arg.common.vif);
		r = -ENODEV;
		goto out_locked;
	}
	ndev_vif = netdev_priv(dev);

	switch (src_sink_arg.common.action) {
	case SRC_SINK_ACTION_SINK_START:
		if (WARN(slsi_src_sink_fake_sta_start(sdev, dev) != 0, "fake STA setup failed\n")) {
			r = -EFAULT;
			goto out_locked;
		}
		req = fapi_alloc(debug_pkt_sink_start_req, DEBUG_PKT_SINK_START_REQ, src_sink_arg.common.vif, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_sink_start_req.end_point, src_sink_arg.common.endpoint);
		fapi_set_u16(req, u.debug_pkt_sink_start_req.direction, src_sink_arg.common.direction);
		fapi_set_u32(req, u.debug_pkt_sink_start_req.interval, src_sink_arg.u.config.interval);
		fapi_set_u16(req, u.debug_pkt_sink_start_req.packets_per_interval, src_sink_arg.u.config.pkts_per_int);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_sink_start_req->\n");
		r = slsi_mlme_req(sdev, dev, req);
		break;
	case SRC_SINK_ACTION_SINK_STOP:
		req = fapi_alloc(debug_pkt_sink_stop_req, DEBUG_PKT_SINK_STOP_REQ, src_sink_arg.common.vif, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_sink_stop_req.direction, src_sink_arg.common.direction);
		fapi_set_u16(req, u.debug_pkt_sink_stop_req.end_point, src_sink_arg.common.endpoint);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_sink_stop_req->\n");
		r = slsi_mlme_req(sdev, dev, req);
		slsi_src_sink_fake_sta_stop(sdev, dev);
		break;
	case SRC_SINK_ACTION_GEN_START:
		if (WARN(slsi_src_sink_fake_sta_start(sdev, dev) != 0, "fake STA setup failed\n")) {
			r = -EFAULT;
			goto out_locked;
		}
		req = fapi_alloc(debug_pkt_gen_start_req, DEBUG_PKT_GEN_START_REQ, src_sink_arg.common.vif, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_gen_start_req.direction, src_sink_arg.common.direction);
		fapi_set_u16(req, u.debug_pkt_gen_start_req.end_point, src_sink_arg.common.endpoint);
		fapi_set_u32(req, u.debug_pkt_gen_start_req.interval, src_sink_arg.u.config.interval);
		fapi_set_u16(req, u.debug_pkt_gen_start_req.packets_per_interval, src_sink_arg.u.config.pkts_per_int);
		fapi_set_u16(req, u.debug_pkt_gen_start_req.size, src_sink_arg.u.config.u.gen.size);
		fapi_set_u16(req, u.debug_pkt_gen_start_req.use_streaming, src_sink_arg.u.config.u.gen.use_streaming);
		fapi_set_u32(req, u.debug_pkt_gen_start_req.ipv4destination_address, src_sink_arg.u.config.u.gen.ipv4_dest);
		fapi_set_u16(req, u.debug_pkt_gen_start_req.packets_per_interrupt, src_sink_arg.u.config.u.gen.pkts_per_intr);

		SLSI_DBG3(sdev, SLSI_SRC_SINK,
			  "int:%u, pkts_per_int:%u, vif:%u, size:%u, use_streaming:%u, ipv4_dest:0x%04X, pkts_per_intr:%u\n",
			  src_sink_arg.u.config.interval,
			  src_sink_arg.u.config.pkts_per_int,
			  src_sink_arg.common.vif,
			  src_sink_arg.u.config.u.gen.size,
			  src_sink_arg.u.config.u.gen.use_streaming,
			  src_sink_arg.u.config.u.gen.ipv4_dest,
			  src_sink_arg.u.config.u.gen.pkts_per_intr);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_gen_start_req->\n");
		r = slsi_mlme_req(sdev, dev, req);
		break;
	case SRC_SINK_ACTION_GEN_STOP:
		req = fapi_alloc(debug_pkt_gen_stop_req, DEBUG_PKT_GEN_STOP_REQ, src_sink_arg.common.vif, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_gen_stop_req.direction, src_sink_arg.common.direction);
		fapi_set_u16(req, u.debug_pkt_gen_stop_req.end_point, src_sink_arg.common.endpoint);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_gen_stop_req->\n");
		r = slsi_mlme_req(sdev, dev, req);
		slsi_src_sink_fake_sta_stop(sdev, dev);
		break;
	case SRC_SINK_ACTION_LOOPBACK_START:
		if (WARN(slsi_src_sink_loopback_start(sdev) != 0, "loopback setup failed\n")) {
			r = -EFAULT;
			goto out_locked;
		}
		req = fapi_alloc(debug_pkt_sink_start_req, DEBUG_PKT_SINK_START_REQ, 1, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_sink_start_req.end_point, SRC_SINK_ENDPOINT_HOSTIO);
		fapi_set_u16(req, u.debug_pkt_sink_start_req.direction, SRC_SINK_DIRECTION_RX);
		fapi_set_u32(req, u.debug_pkt_sink_start_req.interval, src_sink_arg.u.config.interval);
		fapi_set_u16(req, u.debug_pkt_sink_start_req.packets_per_interval, src_sink_arg.u.config.pkts_per_int);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_loopback_start_req->\n");
		r = slsi_mlme_req(sdev, dev, req);
		break;
	case SRC_SINK_ACTION_LOOPBACK_STOP:
		req = fapi_alloc(debug_pkt_sink_stop_req, DEBUG_PKT_SINK_STOP_REQ, 1, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_sink_stop_req.direction, SRC_SINK_DIRECTION_RX);
		fapi_set_u16(req, u.debug_pkt_sink_stop_req.end_point, SRC_SINK_ENDPOINT_HOSTIO);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_loopback_stop_req->\n");
		r = slsi_mlme_req(sdev, dev, req);
		slsi_src_sink_loopback_stop(sdev);
		break;
	case SRC_SINK_ACTION_SINK_REPORT:
		req = fapi_alloc(debug_pkt_sink_report_req, DEBUG_PKT_SINK_REPORT_REQ, src_sink_arg.common.vif, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_sink_report_req.end_point, src_sink_arg.common.endpoint);
		fapi_set_u16(req, u.debug_pkt_sink_report_req.direction, src_sink_arg.common.direction);
		fapi_set_u32(req, u.debug_pkt_sink_report_req.report_interval, src_sink_arg.u.report.interval);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_sink_report_req->\n");

		ind = slsi_mlme_req_ind(sdev, dev, req, DEBUG_PKT_SINK_REPORT_IND);
		if (!ind) {
			SLSI_ERR(sdev, "slsi_mlme_req_ind [SINK_REPORT] failed\n");
			r = -EIO;
			break;
		}

		src_sink_arg.u.report.duration            = fapi_get_u32(ind, u.debug_pkt_sink_report_ind.duration);
		src_sink_arg.u.report.count               = fapi_get_u32(ind, u.debug_pkt_sink_report_ind.received_packets);
		src_sink_arg.u.report.octet               = fapi_get_u32(ind, u.debug_pkt_sink_report_ind.received_octets);
		src_sink_arg.u.report.kbps                = fapi_get_u32(ind, u.debug_pkt_sink_report_ind.kbps);
		src_sink_arg.u.report.idle_ratio          = fapi_get_u16(ind, u.debug_pkt_sink_report_ind.idle_ratio);
		src_sink_arg.u.report.interrupt_latency   = fapi_get_u16(ind, u.debug_pkt_sink_report_ind.int_latency);
		src_sink_arg.u.report.free_kbytes         = fapi_get_u16(ind, u.debug_pkt_sink_report_ind.free_kbytes);
		src_sink_arg.u.report.timestamp           = jiffies_to_msecs(jiffies);

		memset(&ndev_vif->src_sink_params.sink_report, 0, sizeof(struct unifiio_src_sink_report));

		/* copy the report to userspace */
		if (copy_to_user((void *)arg, (void *)(&src_sink_arg), sizeof(struct unifiio_src_sink_arg_t)))
			r = -EFAULT;
		kfree_skb(ind);
		break;
	case SRC_SINK_ACTION_GEN_REPORT:
		req = fapi_alloc(debug_pkt_gen_report_req, DEBUG_PKT_GEN_REPORT_REQ, src_sink_arg.common.vif, 0);
		if (WARN_ON(!req)) {
			r = -ENODEV;
			goto out_locked;
		}
		fapi_set_u16(req, u.debug_pkt_gen_report_req.end_point, src_sink_arg.common.endpoint);
		fapi_set_u16(req, u.debug_pkt_gen_report_req.direction, src_sink_arg.common.direction);
		fapi_set_u32(req, u.debug_pkt_gen_report_req.report_interval, src_sink_arg.u.report.interval);
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "debug_pkt_gen_report_req->\n");

		ind = slsi_mlme_req_ind(sdev, dev, req, DEBUG_PKT_GEN_REPORT_IND);
		if (!ind) {
			SLSI_ERR(sdev, "slsi_mlme_req_ind [GEN_REPORT] failed\n");
			r = -EIO;
			break;
		}

		src_sink_arg.u.report.duration     = fapi_get_u32(ind, u.debug_pkt_gen_report_ind.duration);
		src_sink_arg.u.report.count        = fapi_get_u32(ind, u.debug_pkt_gen_report_ind.received_packets);
		src_sink_arg.u.report.failed_count = fapi_get_u32(ind, u.debug_pkt_gen_report_ind.failed_count);
		src_sink_arg.u.report.octet        = fapi_get_u32(ind, u.debug_pkt_gen_report_ind.received_octets);
		src_sink_arg.u.report.kbps         = fapi_get_u32(ind, u.debug_pkt_gen_report_ind.kbps);
		src_sink_arg.u.report.idle_ratio        = fapi_get_u16(ind, u.debug_pkt_gen_report_ind.idle_ratio);
		src_sink_arg.u.report.interrupt_latency = fapi_get_u16(ind, u.debug_pkt_gen_report_ind.int_latency);
		src_sink_arg.u.report.free_kbytes       = fapi_get_u16(ind, u.debug_pkt_gen_report_ind.free_kbytes);

		src_sink_arg.u.report.timestamp           = jiffies_to_msecs(jiffies);

		memset(&ndev_vif->src_sink_params.gen_report, 0, sizeof(struct unifiio_src_sink_report));

		/* copy the report to userspace */
		if (copy_to_user((void *)arg, (void *)(&src_sink_arg), sizeof(struct unifiio_src_sink_arg_t)))
			r = -EFAULT;
		kfree_skb(ind);
		break;
	case SRC_SINK_ACTION_SINK_REPORT_CACHED:
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "cached sink_report\n");
		memcpy(&src_sink_arg.u.report, &ndev_vif->src_sink_params.sink_report, sizeof(struct unifiio_src_sink_report));
		memset(&ndev_vif->src_sink_params.sink_report, 0, sizeof(struct unifiio_src_sink_report));

		if (copy_to_user((void *)arg, (void *)(&src_sink_arg), sizeof(struct unifiio_src_sink_arg_t)))
			r = -EFAULT;

		break;
	case SRC_SINK_ACTION_GEN_REPORT_CACHED:
		SLSI_DBG1(sdev, SLSI_SRC_SINK, "cached gen_report\n");
		memcpy(&src_sink_arg.u.report, &ndev_vif->src_sink_params.gen_report, sizeof(struct unifiio_src_sink_report));
		memset(&ndev_vif->src_sink_params.gen_report, 0, sizeof(struct unifiio_src_sink_report));

		if (copy_to_user((void *)arg, (void *)(&src_sink_arg), sizeof(struct unifiio_src_sink_arg_t)))
			r = -EFAULT;
		break;
	default:
		SLSI_ERR(sdev, "Invalid input for action: 0x%04X\n", src_sink_arg.common.action);
		r = -EINVAL;
		break;
	}

out_locked:
	SLSI_MUTEX_UNLOCK(sdev->netdev_add_remove_mutex);
	if (r)
		SLSI_ERR(sdev, "slsi_src_sink_cdev_ioctl_cfg(vif:%d) failed with %ld\n", src_sink_arg.common.vif, r);
	return r;
}

void slsi_rx_sink_report(struct slsi_dev *sdev, struct net_device *dev, struct sk_buff *skb)
{
	struct netdev_vif              *ndev_vif = netdev_priv(dev);
	struct unifiio_src_sink_report *report = &ndev_vif->src_sink_params.sink_report;

	SLSI_DBG3(sdev, SLSI_SRC_SINK, "RX debug_pkt_sink_report_ind\n");

	SLSI_MUTEX_LOCK(sdev->netdev_add_remove_mutex);
	memset(report, 0, sizeof(struct unifiio_src_sink_report));
	report->duration            = fapi_get_u32(skb, u.debug_pkt_sink_report_ind.duration);
	report->count               = fapi_get_u32(skb, u.debug_pkt_sink_report_ind.received_packets);
	report->octet               = fapi_get_u32(skb, u.debug_pkt_sink_report_ind.received_octets);
	report->kbps                = fapi_get_u32(skb, u.debug_pkt_sink_report_ind.kbps);
	report->idle_ratio          = fapi_get_u16(skb, u.debug_pkt_sink_report_ind.idle_ratio);
	report->interrupt_latency   = fapi_get_u16(skb, u.debug_pkt_sink_report_ind.int_latency);
	report->free_kbytes         = fapi_get_u16(skb, u.debug_pkt_sink_report_ind.free_kbytes);
	report->timestamp           = jiffies_to_msecs(jiffies);
	SLSI_MUTEX_UNLOCK(sdev->netdev_add_remove_mutex);
	kfree_skb(skb);
}

void slsi_rx_gen_report(struct slsi_dev *sdev, struct net_device *dev, struct sk_buff *skb)
{
	struct netdev_vif              *ndev_vif = netdev_priv(dev);
	struct unifiio_src_sink_report *report = &ndev_vif->src_sink_params.gen_report;

	SLSI_DBG3(sdev, SLSI_SRC_SINK, "RX debug_pkt_gen_report_ind\n");

	SLSI_MUTEX_LOCK(sdev->netdev_add_remove_mutex);
	memset(report, 0, sizeof(struct unifiio_src_sink_report));
	report->duration          = fapi_get_u32(skb, u.debug_pkt_gen_report_ind.duration);
	report->count             = fapi_get_u32(skb, u.debug_pkt_gen_report_ind.received_packets);
	report->failed_count      = fapi_get_u32(skb, u.debug_pkt_gen_report_ind.failed_count);
	report->octet             = fapi_get_u32(skb, u.debug_pkt_gen_report_ind.received_octets);
	report->kbps              = fapi_get_u32(skb, u.debug_pkt_gen_report_ind.kbps);
	report->idle_ratio        = fapi_get_u16(skb, u.debug_pkt_gen_report_ind.idle_ratio);
	report->interrupt_latency = fapi_get_u16(skb, u.debug_pkt_gen_report_ind.int_latency);
	report->free_kbytes       = fapi_get_u16(skb, u.debug_pkt_gen_report_ind.free_kbytes);
	report->timestamp         = jiffies_to_msecs(jiffies);
	SLSI_MUTEX_UNLOCK(sdev->netdev_add_remove_mutex);
	kfree_skb(skb);
}