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

#include <linux/time.h>
#include <linux/ktime.h>

#include "log2us.h"
#include "dev.h"
#include "debug.h"
#include "mgt.h"
#include "nl80211_vendor.h"
#include "mib.h"
#include "mlme.h"

#define MACSTR_NOMASK "%02x:%02x:%02x:%02x:%02x:%02x"
#define MAC2STR_LOG(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]

#ifdef CONFIG_SCSC_WLAN_LOG_2_USER_SP
enum slsi_wlan_vendor_attr_conn_log_event {
	SLSI_WLAN_VENDOR_ATTR_CONN_LOG_EVENT = 1,
	SLSI_WLAN_VENDOR_ATTR_CONN_LOG_BUFF_COUNT,
	SLSI_WLAN_VENDOR_ATTR_CONN_LOG_EVENT_MAX
};


static void delete_node(struct slsi_dev *sdev)
{
	struct buff_list *curr = NULL;

	curr = sdev->conn_log2us_ctx.list;
	if (curr) {
		sdev->conn_log2us_ctx.list = sdev->conn_log2us_ctx.list->next;
		kfree(curr);
	}
}

static int slsi_send_conn_log_event(struct slsi_dev *sdev)
{
	struct sk_buff *skb;
	int res;
	u32 buf_count = 0;
	struct buff_list *curr;
	struct nlattr *nla = NULL;
	u32 *count_p;

	while (!(__ratelimit(&sdev->conn_log2us_ctx.rs)))
		msleep(50);

	skb = cfg80211_vendor_event_alloc(sdev->wiphy, NULL, NLMSG_DEFAULT_SIZE,
					  SLSI_NL80211_VENDOR_CONNECTIVITY_LOG_EVENT,
					  GFP_KERNEL);
	if (!skb) {
		SLSI_ERR_NODEV("Failed to allocate SKB for vendor conn_log_event event\n");
		return -ENOMEM;
	}

	nla = nla_reserve(skb, SLSI_WLAN_VENDOR_ATTR_CONN_LOG_BUFF_COUNT, sizeof(buf_count));
	if (!nla) {
		SLSI_ERR_NODEV("failed in nla_reserve\n");
		kfree_skb(skb);
		return -1;
	}

	count_p = nla_data(nla);

	spin_lock(&sdev->conn_log2us_ctx.conn_lock);
	curr = sdev->conn_log2us_ctx.list;

	while (curr && (buf_count < 100)) {
		res = nla_put(skb, SLSI_WLAN_VENDOR_ATTR_CONN_LOG_EVENT, curr->len,
			      curr->str);
		if (res) {
			SLSI_ERR_NODEV("failed in nla_put for buffer no = %d, res = %d\n",
				       buf_count + 1, res);
			break;
		}

		buf_count++;
		delete_node(sdev);
		curr = sdev->conn_log2us_ctx.list;
	}

	spin_unlock(&sdev->conn_log2us_ctx.conn_lock);
	if (buf_count == 0) {
		SLSI_ERR_NODEV("Buffer count is 0\n");
		kfree_skb(skb);
		return -1;
	}

	*count_p = buf_count;
	cfg80211_vendor_event(skb, GFP_KERNEL);

	return 0;
}

static void enqueue_log_buffer_for_roam_cand(struct buff_list *new_node, struct conn_log2us *ctx)
{
	struct buff_list *list;

	list = ctx->list_roam_cand;

	if (!list) {
		ctx->list_roam_cand = new_node;
		return;
	}
	while (list->next != NULL)
		list = list->next;

	list->next = new_node;
}

static void enqueue_log_buffer(struct buff_list *new_node, struct conn_log2us *ctx)
{
	struct buff_list *list;

	spin_lock(&ctx->conn_lock);
	list = ctx->list;

	if (!list) {
		ctx->list = new_node;
		spin_unlock(&ctx->conn_lock);
		return;
	}
	while (list->next != NULL)
		list = list->next;

	list->next = new_node;

	spin_unlock(&ctx->conn_lock);
}

static void conn_log_worker(struct work_struct *work)
{
	struct conn_log2us *p = container_of(work, struct conn_log2us, log2us_work);
	struct slsi_dev *sdev = container_of(p, struct slsi_dev, conn_log2us_ctx);
	int status = 0;

	while (p->list && (!(p->stop))) {
		rtnl_lock();
		status = slsi_send_conn_log_event(sdev);
		if (status)
			SLSI_ERR_NODEV("slsi_send_conn_log_event failed status = %d\n", status);
		rtnl_unlock();
	}
}

void slsi_conn_log2us_init(struct slsi_dev *sdev)
{
	spin_lock_init(&sdev->conn_log2us_ctx.conn_lock);

	sdev->conn_log2us_ctx.log2us_workq = create_workqueue("conn_logger");

	INIT_WORK(&sdev->conn_log2us_ctx.log2us_work, conn_log_worker);

	sdev->conn_log2us_ctx.list = NULL;
	sdev->conn_log2us_ctx.list_roam_cand = NULL;
	ratelimit_state_init(&sdev->conn_log2us_ctx.rs, 1 * HZ, SLSI_LOG2US_BURST);
	sdev->conn_log2us_ctx.stop = false;
}

void slsi_conn_log2us_deinit(struct slsi_dev *sdev)
{
	struct buff_list *tmp;

	sdev->conn_log2us_ctx.stop = true;
	cancel_work_sync(&sdev->conn_log2us_ctx.log2us_work);
	destroy_workqueue(sdev->conn_log2us_ctx.log2us_workq);
	spin_lock(&sdev->conn_log2us_ctx.conn_lock);
	while (sdev->conn_log2us_ctx.list) {
		tmp = sdev->conn_log2us_ctx.list;
		sdev->conn_log2us_ctx.list = sdev->conn_log2us_ctx.list->next;
		kfree(tmp);
	}
	while (sdev->conn_log2us_ctx.list_roam_cand) {
		tmp = sdev->conn_log2us_ctx.list_roam_cand;
		sdev->conn_log2us_ctx.list_roam_cand = sdev->conn_log2us_ctx.list_roam_cand->next;
		kfree(tmp);
	}
	spin_unlock(&sdev->conn_log2us_ctx.conn_lock);
}

u8 *get_eap_type_from_val(int val, u8 *str)
{
	switch (val) {
	case SLSI_EAP_TYPE_IDENTITY:
		memcpy(str, "IDENTITY", strlen("IDENTITY") + 1);
		return str;
	case SLSI_EAP_TYPE_NOTIFICATION:
		memcpy(str, "NOTIFICATION", strlen("NOTIFICATION") + 1);
		return str;
	case SLSI_EAP_TYPE_NAK:
		memcpy(str, "NAK", strlen("NAK") + 1);
		return str;
	case SLSI_EAP_TYPE_MD5:
		memcpy(str, "MD5", strlen("MD5") + 1);
		return str;
	case SLSI_EAP_TYPE_OTP:
		memcpy(str, "OTP", strlen("OTP") + 1);
		return str;
	case SLSI_EAP_TYPE_GTC:
		memcpy(str, "GTC", strlen("GTC") + 1);
		return str;
	case SLSI_EAP_TYPE_TLS:
		memcpy(str, "TLS", strlen("TLS") + 1);
		return str;
	case SLSI_EAP_TYPE_LEAP:
		memcpy(str, "LEAP", strlen("LEAP") + 1);
		return str;
	case SLSI_EAP_TYPE_SIM:
		memcpy(str, "SIM", strlen("SIM") + 1);
		return str;
	case SLSI_EAP_TYPE_TTLS:
		memcpy(str, "TTLS", strlen("TTLS") + 1);
		return str;
	case SLSI_EAP_TYPE_AKA:
		memcpy(str, "AKA", strlen("AKA") + 1);
		return str;
	case SLSI_EAP_TYPE_PEAP:
		memcpy(str, "PEAP", strlen("PEAP") + 1);
		return str;
	case SLSI_EAP_TYPE_MSCHAPV2:
		memcpy(str, "MSCHAPV2", strlen("MSCHAPV2") + 1);
		return str;
	case SLSI_EAP_TYPE_TLV:
		memcpy(str, "TLV", strlen("TLV") + 1);
		return str;
	case SLSI_EAP_TYPE_TNC:
		memcpy(str, "TNC", strlen("TNC") + 1);
		return str;
	case SLSI_EAP_TYPE_FAST:
		memcpy(str, "FAST", strlen("FAST") + 1);
		return str;
	case SLSI_EAP_TYPE_PAX:
		memcpy(str, "PAX", strlen("PAX") + 1);
		return str;
	case SLSI_EAP_TYPE_PSK:
		memcpy(str, "PSK", strlen("PSK") + 1);
		return str;
	case SLSI_EAP_TYPE_SAKE:
		memcpy(str, "SAKE", strlen("SAKE") + 1);
		return str;
	case SLSI_EAP_TYPE_IKEV2:
		memcpy(str, "IKEV2", strlen("IKEV2") + 1);
		return str;
	case SLSI_EAP_TYPE_AKA_PRIME:
		memcpy(str, "AKA PRIME", strlen("AKA PRIME") + 1);
		return str;
	case SLSI_EAP_TYPE_GPSK:
		memcpy(str, "GPSK", strlen("GPSK") + 1);
		return str;
	case SLSI_EAP_TYPE_PWD:
		memcpy(str, "PWD", strlen("PWD") + 1);
		return str;
	case SLSI_EAP_TYPE_EKE:
		memcpy(str, "EKE", strlen("EKE") + 1);
		return str;
	case SLSI_EAP_TYPE_EXPANDED:
		memcpy(str, "EXPANDED", strlen("EXPANDED") + 1);
		return str;
	default:
		memcpy(str, "UNKNOWN", strlen("UNKNOWN") + 1);
		return str;
	}
}

static int slsi_get_roam_reason_for_fw_reason(int roam_reason)
{
	switch (roam_reason) {
	case SLSI_WIFI_ROAMING_SEARCH_REASON_LOW_RSSI:
		return 1;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_LINK_LOSS:
		return 3;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_BTM_REQ:
		return 5;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_CU_TRIGGER:
		return 2;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_EMERGENCY:
		return 4;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_IDLE:
		return 6;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_SCAN_TIMER1_EXPIRY:
		return 9;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_SCAN_TIMER2_EXPIRY:
		return 9;
	case SLSI_WIFI_ROAMING_SEARCH_REASON_INACTIVE_TIMER_EXPIRY:
		return 8;
	default:
		return 0;
	}
}

void slsi_eapol_eap_handle_tx_status(struct slsi_dev *sdev, struct netdev_vif *ndev_vif,
				     u16 host_tag, u16 tx_status)
{
	char *tx_status_str;

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	if (tx_status == FAPI_TRANSMISSIONSTATUS_SUCCESSFUL)
		tx_status_str = "ACK";
	else
		tx_status_str = "TX_FAIL";

	if (host_tag == sdev->conn_log2us_ctx.host_tag_eap) {
		slsi_conn_log2us_eap_tx(sdev, ndev_vif, sdev->conn_log2us_ctx.eap_resp_len,
					sdev->conn_log2us_ctx.eap_str_type, tx_status_str);
		sdev->conn_log2us_ctx.host_tag_eap = 0;
	}
}

static int slsi_log2us_get_rssi(struct slsi_dev *sdev, struct net_device *dev,
				int *mib_value, u16 psid)
{
	struct slsi_mib_data mibrsp = { 0, NULL };
	struct slsi_mib_value     *values = NULL;
	struct slsi_mib_get_entry get_values[] = { { psid, { 0, 0 } } };

	mibrsp.dataLength = 64;
	mibrsp.data = kmalloc(mibrsp.dataLength, GFP_KERNEL);
	if (!mibrsp.data) {
		SLSI_ERR(sdev, "Cannot kmalloc %d bytes\n", mibrsp.dataLength);
		kfree(mibrsp.data);
		return -ENOMEM;
	}

	values = slsi_read_mibs(sdev, dev, get_values, 1, &mibrsp);
	if (!values) {
		kfree(mibrsp.data);
		return -EINVAL;
	}

	if (values[0].type == SLSI_MIB_TYPE_INT)
		*mib_value = (int)(values->u.intValue);
	else if (values[0].type == SLSI_MIB_TYPE_UINT)
		*mib_value = (int)(values->u.uintValue);
	else
		SLSI_ERR(sdev, "Invalid type (%d) for SLSI_PSID_UNIFI_LAST_BSS_RSSI\n",
			 values[0].type);
	kfree(values);
	kfree(mibrsp.data);
	return 0;
}

static struct buff_list *slsi_conn_log2us_alloc_new_node(void)
{

	struct buff_list *new_node;

	new_node = kmalloc(sizeof(struct buff_list), GFP_KERNEL);
	if (!new_node) {
		SLSI_ERR_NODEV("Memory is not available\n");
		return NULL;
	}
	new_node->next = NULL;
	return new_node;
}

static struct buff_list *slsi_conn_log2us_alloc_atomic_new_node(void)
{
	struct buff_list *new_node;

	new_node = kmalloc(sizeof(*new_node), GFP_ATOMIC);
	if (!new_node) {
		SLSI_ERR_NODEV("Memory is not available\n");
		return NULL;
	}
	new_node->next = NULL;
	return new_node;
}

void slsi_conn_log2us_connecting(struct slsi_dev *sdev, struct net_device *dev, struct cfg80211_connect_params *sme)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	int btcoex = 0;
	const u8 *rsn;
	int rsn_pos = 0;
	u8 pmf = 0;
	u32 group_mgmt = 0;
	int rsn_len = 0;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);
	int pairwise = 0, group = 0, freq = 0, freq_hint = 0, akm_suite = 0;

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;

	log_buffer = new_node->str;
	get_kernel_timestamp(time);
	if (sdev->conn_log2us_ctx.btcoex_sco || sdev->conn_log2us_ctx.btcoex_scan ||
	    sdev->conn_log2us_ctx.btcoex_hid)
		btcoex = 1;

	rsn = cfg80211_find_ie(WLAN_EID_RSN, sme->ie, sme->ie_len);

	if (rsn) {
		/* element_id(1) + length(1) + version(2) + Group Data Cipher Suite(4)+ */
		/* Pairwise Cipher Suite Count(2) + Pairwise Cipher Suite List(count * 4) */
		if ((sme->ie_len - (rsn - sme->ie)) >= 10)
			rsn_pos = 7 + 2 + (rsn[8] * 4);
		/* AKM Suite Count(2) + AKM Suite List(count * 4) */
		if ((sme->ie_len - (rsn - sme->ie)) >= rsn[1] + 2) {
			rsn_pos = rsn_pos + 2 + (rsn[rsn_pos] * 4);
			rsn_len = rsn[1];
		}
		/* check for pmf which are RSN caps MFPR and MFPC */
		if ((rsn_pos + 2) <= rsn_len)
			pmf = pmf | (rsn[rsn_pos] << 7) | (rsn[rsn_pos] << 6);

		if (pmf) {
			rsn_pos = rsn_pos + 2; /* RSN caps(2) */
			rsn_pos = 2 + (rsn[rsn_pos] * 16); /* PMKID Count(2) + PMKID List(count * 16) */
			if ((rsn_pos + 4) <= rsn_len)
				memcpy(&group_mgmt, (rsn + rsn_pos), 4); /* last 4 octets are group_mgmt field. */
		}
	}

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d][CONN] CONNECTING ssid=\"%.*s\"",
			 time[0], time[1], (int)sme->ssid_len, sme->ssid);
	if (sme->bssid)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " bssid=" MACSTR_NOMASK,
				 MAC2STR_LOG(sme->bssid));
	if (sme->bssid_hint)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " bssid_hint=" MACSTR_NOMASK,
				 MAC2STR_LOG(sme->bssid_hint));
	freq = sme->channel ? sme->channel->center_freq : 0;
	if (freq)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " freq=%d", freq);
	freq_hint = sme->channel_hint ? sme->channel_hint->center_freq : 0;
	if (freq_hint)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " freq_hint=%d", freq_hint);

	if (sme->crypto.n_ciphers_pairwise)
                pairwise = sme->crypto.ciphers_pairwise[0];
        group = sme->crypto.cipher_group;
        if (sme->crypto.n_akm_suites)
                akm_suite = sme->crypto.akm_suites[0];

	pos += scnprintf(log_buffer + pos, buf_size - pos, " pairwise=0x%x group=0x%x ",
			 pairwise, group);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "akm=0x%x auth_type=%d ",
			 akm_suite, (sme->auth_type == NL80211_AUTHTYPE_SAE) ? FAPI_AUTHENTICATIONTYPE_SAE : sme->auth_type);

	if (pmf)
		pos += scnprintf(log_buffer + pos, buf_size - pos, "group_mgmt=0x%x btcoex=%d", group_mgmt, btcoex);
	else
		pos += scnprintf(log_buffer + pos, buf_size - pos, "btcoex=%d", btcoex);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_connecting_fail(struct slsi_dev *sdev, struct net_device *dev,
				      const unsigned char *bssid,
				      int freq, int reason)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	char *str;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	if (1 == reason)
		str = "no probe response";
	else
		str = "unknown";

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d][CONN] CONNECTING FAIL", time[0], time[1]);
	if (bssid)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " bssid=" MACSTR_NOMASK, MAC2STR_LOG(bssid));
	pos += scnprintf(log_buffer + pos, buf_size - pos, " freq=%d [reason=%d %s]", freq, reason, str);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_disconnect(struct slsi_dev *sdev, struct net_device *dev,
				 const unsigned char *bssid,
				 int reason)
{

	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	int rssi = 100;
	int status;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	sdev->conn_log2us_ctx.conn_flag = false;
	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	status = slsi_log2us_get_rssi(sdev, dev, &rssi, SLSI_PSID_UNIFI_LAST_BSS_RSSI);
	if (status)
		SLSI_ERR(sdev, "Could not get rssi status = %d\n", status);

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [CONN] DISCONN bssid="
			 MACSTR_NOMASK " rssi=%d "
			 "reason=%d", time[0], time[1], MAC2STR_LOG(bssid), rssi, reason);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);

}

void slsi_conn_log2us_eapol_gtk(struct slsi_dev *sdev, struct net_device *dev,
				int eapol_msg_type)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [EAPOL] GTK M%d", time[0], time[1],
			 eapol_msg_type);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_eapol_gtk_tx(struct slsi_dev *sdev, u32 status_code)
{
	int pos = 0;
	char *log_buffer = NULL, *tx_status_str = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);

	if (status_code == FAPI_TRANSMISSIONSTATUS_SUCCESSFUL)
		tx_status_str = "ACK";
	else
		tx_status_str = "TX_FAIL";

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [EAPOL] GTK M2 tx_status=%s",
			 time[0], time[1],  tx_status_str);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_eapol_ptk(struct slsi_dev *sdev, struct net_device *dev,
				int eapol_msg_type)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [EAPOL] 4WAY M%d", time[0], time[1],
			 eapol_msg_type);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_eapol_ptk_tx(struct slsi_dev *sdev, u32 status_code)
{
	int pos = 0;
	char *log_buffer = NULL, *tx_status_str = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	if (status_code == FAPI_TRANSMISSIONSTATUS_SUCCESSFUL)
		tx_status_str = "ACK";
	else
		tx_status_str = "TX_FAIL";

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [EAPOL] 4WAY M%d tx_status=%s",
			 time[0], time[1], sdev->conn_log2us_ctx.eapol_ptk_msg_type, tx_status_str);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_eapol_tx(struct slsi_dev *sdev, struct net_device *dev, u32 status_code)
{
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	if (sdev->conn_log2us_ctx.is_eapol_ptk) {
		slsi_conn_log2us_eapol_ptk_tx(sdev, status_code);
		sdev->conn_log2us_ctx.is_eapol_ptk = false;
	} else if (sdev->conn_log2us_ctx.is_eapol_gtk) {
		slsi_conn_log2us_eapol_gtk_tx(sdev, status_code);
		sdev->conn_log2us_ctx.is_eapol_gtk = false;
	}
}
void slsi_conn_log2us_roam_scan_start(struct slsi_dev *sdev, struct net_device *dev,
				      int reason, int roam_rssi_val,
				      short chan_utilisation,
				      int rssi_thresh, u64 timestamp)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	sdev->conn_log2us_ctx.roam_ap_count = 0;
	sdev->conn_log2us_ctx.cand_number = 0;
	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	reason = slsi_get_roam_reason_for_fw_reason(reason);

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [ROAM] SCAN_START reason=%d ",
			 time[0], time[1], reason);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "rssi=%d cu=%d full_scan=%d rssi_thres=%d [fw_time=%llu]",
			 roam_rssi_val, chan_utilisation, sdev->conn_log2us_ctx.full_scan_roam, rssi_thresh, timestamp);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_roam_result(struct slsi_dev *sdev, struct net_device *dev,
				  char *bssid, u64 timestamp, bool roam_candidate)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	char *res = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	if (roam_candidate)
		res = "ROAM";
	else
		res = "NO_ROAM";
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [ROAM] RESULT %s bssid="
			 MACSTR_NOMASK "[fw_time=%llu status=%d]",
			 time[0], time[1], res, MAC2STR_LOG(bssid), timestamp, !roam_candidate);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_eap_with_len(struct slsi_dev *sdev, struct net_device *dev,
				   u8 *eap, int eap_length)
{
	int  pos         = 0;
	char *log_buffer = NULL;
	u32  time[2]     = { 0 };
	char *eap_type   = NULL;
	int buf_size = BUFF_SIZE;
	char str_type[15] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);

	switch (eap[SLSI_EAP_CODE_POS]) {
	case SLSI_EAP_PACKET_REQUEST:
		eap_type = "REQ";
		break;
	}

	sdev->conn_log2us_ctx.eap_str_type = eap[SLSI_EAP_TYPE_POS];
	get_eap_type_from_val(eap[SLSI_EAP_TYPE_POS], str_type);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [EAP] %s type=%s len=%d",
			 time[0], time[1], eap_type, str_type, eap_length);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_eap_tx(struct slsi_dev *sdev, struct netdev_vif *ndev_vif,
			     int eap_length, int eap_type,
			     char *tx_status_str)
{
	int  pos         = 0;
	char *log_buffer = NULL;
	u32  time[2]     = { 0 };
	int buf_size = BUFF_SIZE;
	struct buff_list *new_node = NULL;
	char eap_type_str[15] = {0};

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	get_eap_type_from_val(eap_type, eap_type_str);

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [EAP] RESP type=%s len=%d",
			 time[0], time[1], eap_type_str, eap_length);
	pos += scnprintf(log_buffer + pos, buf_size - pos, " tx_status=%s", tx_status_str);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_eap(struct slsi_dev *sdev, struct net_device *dev, u8 *eap)
{
	int  pos         = 0;
	char *log_buffer = NULL;
	char *eap_type   = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);

	switch (eap[SLSI_EAP_CODE_POS]) {
	case SLSI_EAP_PACKET_SUCCESS:
		eap_type = "SUCC";
		break;
	case SLSI_EAP_PACKET_FAILURE:
		eap_type = "FAIL";
		break;
	}

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [EAP] %s",
			 time[0], time[1], eap_type);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_dhcp(struct slsi_dev *sdev, struct net_device *dev, char *str)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [DHCP] %s", time[0], time[1], str);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_dhcp_tx(struct slsi_dev *sdev, struct net_device *dev,
			      char *str, char *tx_status)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_atomic_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [DHCP] %s tx_status=%s",
			 time[0], time[1], str, tx_status);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_auth_req(struct slsi_dev *sdev, struct net_device *dev, const unsigned char *bssid,
			       int auth_algo, int sae_type, int sn, int status, u32 tx_status, int is_roaming)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	char *tx_status_str;
	int rssi = 100;
	int res;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	if (tx_status == FAPI_RESULTCODE_AUTH_TX_FAIL)
		tx_status_str = "TX_FAIL";
	else if (tx_status == FAPI_RESULTCODE_AUTH_NO_ACK)
		tx_status_str = "NO_ACK";
	else
		tx_status_str = "ACK";
	get_kernel_timestamp(time);
	res = slsi_log2us_get_rssi(sdev, dev, &rssi, SLSI_PSID_UNIFI_RSSI);
	if (res)
		SLSI_ERR(sdev, "Could not get rssi status = %d\n", res);

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d][CONN] AUTH REQ bssid=" MACSTR_NOMASK,
			 time[0], time[1], MAC2STR_LOG(bssid));
	pos += scnprintf(log_buffer + pos, buf_size - pos, " rssi=%d auth_algo=%d type=%d sn=%d status=%d",
			 rssi, auth_algo, sae_type, sn, status);
	if (is_roaming)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " tx_status=%s [ROAM]", tx_status_str);
	else
		pos += scnprintf(log_buffer + pos, buf_size - pos, " tx_status=%s", tx_status_str);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_auth_resp(struct slsi_dev *sdev, struct net_device *dev,
				const unsigned char *bssid, int auth_algo,
				int sae_type,
				int sn, int status, int is_roaming)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d][CONN] AUTH RESP",
			 time[0], time[1]);
	if (is_roaming)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " bssid="
				 MACSTR_NOMASK " auth_algo=%d "
				 "type=%d sn=%d status=%d [ROAM]", MAC2STR_LOG(bssid),
				 auth_algo, sae_type, sn, status);
	else
		pos += scnprintf(log_buffer + pos, buf_size - pos, " bssid="
				 MACSTR_NOMASK " auth_algo=%d "
				 "type=%d sn=%d status=%d", MAC2STR_LOG(bssid),
				 auth_algo, sae_type, sn, status);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_assoc_req(struct slsi_dev *sdev, struct net_device *dev,
				const unsigned char *bssid, int sn, int tx_status,
				int mgmt_frame_subtype)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	char *tx_status_str;
	int rssi = 100;
	int status;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	if (tx_status == FAPI_RESULTCODE_ASSOC_TX_FAIL)
		tx_status_str = "TX_FAIL";
	else if (tx_status == FAPI_RESULTCODE_ASSOC_NO_ACK)
		tx_status_str = "NO_ACK";
	else
		tx_status_str = "ACK";
	status = slsi_log2us_get_rssi(sdev, dev, &rssi, SLSI_PSID_UNIFI_RSSI);
	if (status)
		SLSI_ERR(sdev, "Could not get rssi status = %d\n", status);
	if (mgmt_frame_subtype == SLSI_MGMT_FRAME_SUBTYPE_ASSOC_REQ)
		pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [CONN] ASSOC REQ ", time[0], time[1]);
	else if (mgmt_frame_subtype == SLSI_MGMT_FRAME_SUBTYPE_REASSOC_REQ)
		pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [CONN] REASSOC REQ ", time[0], time[1]);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "bssid="
			 MACSTR_NOMASK  " rssi=%d sn=%d "
			 "tx_status=%s", MAC2STR_LOG(bssid), rssi, sn,
			 tx_status_str);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_assoc_resp(struct slsi_dev *sdev, struct net_device *dev,
				 const unsigned char *bssid, int sn, int status,
				 int mgmt_frame_subtype)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	if (mgmt_frame_subtype == SLSI_MGMT_FRAME_SUBTYPE_ASSOC_RESP)
		pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [CONN] ASSOC RESP", time[0], time[1]);
	else if (mgmt_frame_subtype == SLSI_MGMT_FRAME_SUBTYPE_REASSOC_RESP)
		pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [CONN] REASSOC RESP", time[0], time[1]);
	pos += scnprintf(log_buffer + pos, buf_size - pos, " bssid="
			 MACSTR_NOMASK " sn=%d "
			 "status=%d", MAC2STR_LOG(bssid), sn, status);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_deauth(struct slsi_dev *sdev, struct net_device *dev, char *str_type,
			     const unsigned char *bssid,
			     int sn, int status)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	int rssi = 100;
	int res;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	sdev->conn_log2us_ctx.conn_flag = false;
	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	res = slsi_log2us_get_rssi(sdev, dev, &rssi, SLSI_PSID_UNIFI_LAST_BSS_RSSI);
	if (res)
		SLSI_ERR(sdev, "Could not get rssi status = %d\n", res);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [CONN] DEAUTH %s bssid="
			 MACSTR_NOMASK " rssi=%d sn=%d reason=%d", time[0], time[1],
			 str_type, MAC2STR_LOG(bssid), rssi, sn, status);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_disassoc(struct slsi_dev *sdev, struct net_device *dev, char *str_type,
			       const unsigned char *bssid,
			       int sn, int status)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	int rssi = 100;
	int res;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	sdev->conn_log2us_ctx.conn_flag = false;
	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	res = slsi_log2us_get_rssi(sdev, dev, &rssi, SLSI_PSID_UNIFI_LAST_BSS_RSSI);
	if (res)
		SLSI_ERR(sdev, "Could not get rssi status = %d\n", res);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [CONN] DISASSOC %s bssid="
			 MACSTR_NOMASK " rssi=%d sn=%d "
			 "reason=%d", time[0], time[1], str_type, MAC2STR_LOG(bssid),
			 rssi, sn, status);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_roam_scan_save(struct slsi_dev *sdev, struct net_device *dev,
				     int scan_type, int freq_count,
				     int *freq_list)
{
	int i;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	sdev->conn_log2us_ctx.roam_freq_count = freq_count;

	for (i = 0; i < freq_count; i++)
		sdev->conn_log2us_ctx.roam_freq_list[i] = *(freq_list + i);

	if (scan_type == FAPI_SCANTYPE_SOFT_CACHED_ROAMING_SCAN ||
	    scan_type == FAPI_SCANTYPE_HARD_CACHED_ROAMING_SCAN)
		sdev->conn_log2us_ctx.full_scan_roam = 0;
	else if (scan_type == FAPI_SCANTYPE_SOFT_FULL_ROAMING_SCAN ||
		 scan_type == FAPI_SCANTYPE_HARD_FULL_ROAMING_SCAN)
		sdev->conn_log2us_ctx.full_scan_roam = 1;
}

void slsi_conn_log2us_roam_scan_done(struct slsi_dev *sdev, struct net_device *dev, u64 timestamp)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	int i;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [ROAM] SCAN_DONE ap_count=%d freq[%d]=",
			 time[0], time[1], sdev->conn_log2us_ctx.roam_ap_count,
			 sdev->conn_log2us_ctx.roam_freq_count);

	for (i = 0; i < sdev->conn_log2us_ctx.roam_freq_count; i++)
		pos += scnprintf(log_buffer + pos, buf_size - pos, "%d ",
				 sdev->conn_log2us_ctx.roam_freq_list[i]);

	pos += scnprintf(log_buffer + pos, buf_size - pos, "[fw_time=%llu]", timestamp);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	enqueue_log_buffer(sdev->conn_log2us_ctx.list_roam_cand, &sdev->conn_log2us_ctx);
	sdev->conn_log2us_ctx.list_roam_cand = NULL;
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_roam_scan_result(struct slsi_dev *sdev, struct net_device *dev,
				       bool curr, char *bssid, int freq,
				       int rssi, short cu,
				       int score, int tp_score, bool eligible)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	sdev->conn_log2us_ctx.roam_ap_count++;
	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	if (curr) {
		pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [ROAM] SCORE_CUR_AP bssid="
				 MACSTR_NOMASK " freq=%d rssi=%d cu=%d score=%d.%02d", time[0], time[1],
				 MAC2STR_LOG(bssid), freq / 2, rssi, cu, score / 100, score % 100);
	} else {
		pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [ROAM] SCORE_CANDI[%d] bssid="
				 MACSTR_NOMASK " freq=%d rssi=%d cu=%d score=%d.%02d tp=%dkbps [eligible=%s]",
				 time[0], time[1], sdev->conn_log2us_ctx.cand_number,
				 MAC2STR_LOG(bssid), freq / 2, rssi, cu, score / 100, score % 100,
				 tp_score, eligible ? "true" : "false");
		sdev->conn_log2us_ctx.cand_number++;
	}
	new_node->len = pos + 1;
	enqueue_log_buffer_for_roam_cand(new_node, &sdev->conn_log2us_ctx);
}

void slsi_conn_log2us_btm_query(struct slsi_dev *sdev, struct net_device *dev,
				int dialog, int reason)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [BTM] QUERY token=%d reason=%d",
			 time[0], time[1], dialog, reason);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_btm_req(struct slsi_dev *sdev, struct net_device *dev,
			      int dialog, int btm_mode, int disassoc_timer,
			      int validity_time, int candidate_count)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	sdev->conn_log2us_ctx.cand_count = 0;
	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [BTM] REQ token=%d mode=%d disassoc=%d"
			 " validity=%d candidate_list_cnt=%d", time[0], time[1], dialog, btm_mode,
			 disassoc_timer, validity_time, candidate_count);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_btm_resp(struct slsi_dev *sdev, struct net_device *dev, int dialog,
			       int btm_mode, int delay, char *bssid)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [BTM] RESP token=%d status=%d delay=%d",
			 time[0], time[1], dialog, btm_mode, delay);
	if (btm_mode == 0)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " target=" MACSTR_NOMASK, MAC2STR_LOG(bssid));
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_btm_cand(struct slsi_dev *sdev, struct net_device *dev,
			       char *bssid, int prefer)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [BTM] REQ_CANDI[%d] bssid="
			 MACSTR_NOMASK " preference=%d", time[0], time[1],
			 sdev->conn_log2us_ctx.cand_count, MAC2STR_LOG(bssid), prefer);
	sdev->conn_log2us_ctx.cand_count++;
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_nr_frame_req(struct slsi_dev *sdev, struct net_device *dev)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [NEIGHBOR_REPORT] REQ Sent from mobile",
			 time[0], time[1]);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_nr_frame_resp(struct slsi_dev *sdev, struct net_device *dev, char *string)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d] [NEIGHBOR_REPORT] RESP Channel list=%s",
			 time[0], time[1], string);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_beacon_report_request(struct slsi_dev *sdev, struct net_device *dev,
					    int dialog_token, int operating_class, char *string,
					    int measure_duration, char *measure_mode,
					    char *mac_addr, char *ssid)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d][BEACON_REPORT] REQ Token=%d Operating Class=%d "
			 "channel list=%s Measurement Duration=%d Measurement Mode=%s BSSID="MACSTR_NOMASK" SSID=%s",
			 time[0], time[1], dialog_token, operating_class, string, measure_duration, measure_mode,
			 MAC2STR_LOG(mac_addr), ssid);
	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_beacon_report_response(struct slsi_dev *sdev, struct net_device *dev, int dialog_token,
					     int ap_count, int reason_code)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos += scnprintf(log_buffer + pos, buf_size - pos, "[%d.%d][BEACON_REPORT] RESP Token=%d"
			 " Scanned AP Number=%d", time[0], time[1], dialog_token, ap_count);
	if (reason_code)
		pos += scnprintf(log_buffer + pos, buf_size - pos, " Reason=%d", reason_code);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

void slsi_conn_log2us_ncho_mode(struct slsi_dev *sdev, struct net_device *dev, int enable)
{
	int pos = 0;
	char *log_buffer = NULL;
	int buf_size = BUFF_SIZE;
	u32 time[2] = { 0 };
	struct buff_list *new_node = NULL;
	struct netdev_vif   *ndev_vif = netdev_priv(dev);

	if (ndev_vif->iftype != NL80211_IFTYPE_STATION)
		return;

	new_node = slsi_conn_log2us_alloc_new_node();
	if (!new_node)
		return;
	log_buffer = new_node->str;

	get_kernel_timestamp(time);
	pos = scnprintf(log_buffer, buf_size, "[%d.%d][NCHO] MODE enable=%d",
			 time[0], time[1], enable);

	new_node->len = pos + 1;
	enqueue_log_buffer(new_node, &sdev->conn_log2us_ctx);
	queue_work(sdev->conn_log2us_ctx.log2us_workq, &sdev->conn_log2us_ctx.log2us_work);
}

#else

void slsi_conn_log2us_init(struct slsi_dev *sdev)
{
}

void slsi_conn_log2us_deinit(struct slsi_dev *sdev)
{
}

void slsi_conn_log2us_connecting(struct slsi_dev *sdev, struct net_device *dev, struct cfg80211_connect_params *sme)
{
}

void slsi_conn_log2us_connecting_fail(struct slsi_dev *sdev, struct net_device *dev,
				      const unsigned char *bssid,
				      int freq, int reason)
{
}

void slsi_conn_log2us_disconnect(struct slsi_dev *sdev, struct net_device *dev,
				 const unsigned char *bssid, int reason)
{
}

void slsi_conn_log2us_eapol_gtk(struct slsi_dev *sdev, struct net_device *dev,
				int eapol_msg_type)
{
}

void slsi_conn_log2us_eapol_ptk(struct slsi_dev *sdev, struct net_device *dev,
				int eapol_msg_type)
{
}

void slsi_conn_log2us_roam_scan_start(struct slsi_dev *sdev, struct net_device *dev,
				      int reason, int roam_rssi_val,
				      short chan_utilisation,
				      int rssi_thresh, u64 timestamp)
{
}

void slsi_conn_log2us_roam_result(struct slsi_dev *sdev, struct net_device *dev,
				  char *bssid, u64 timestamp, bool roam_candidate)
{
}

void slsi_conn_log2us_eap(struct slsi_dev *sdev, struct net_device *dev, u8 *eap_type)
{
}

void slsi_conn_log2us_dhcp(struct slsi_dev *sdev, struct net_device *dev, char *str)
{
}

void slsi_conn_log2us_dhcp_tx(struct slsi_dev *sdev, struct net_device *dev,
			      char *str, char *tx_status)
{
}

void slsi_conn_log2us_eap_with_len(struct slsi_dev *sdev, struct net_device *dev,
				   u8 *eap_type, int eap_length)
{
}

void slsi_conn_log2us_auth_req(struct slsi_dev *sdev, struct net_device *dev,
			       const unsigned char *bssid,
			       int auth_algo, int sae_type, int sn, int status, u32 tx_status, int is_roaming)
{
}

void slsi_conn_log2us_auth_resp(struct slsi_dev *sdev, struct net_device *dev,
				const unsigned char *bssid, int auth_algo,
				int sae_type,
				int sn, int status, int is_roaming)
{
}

void slsi_conn_log2us_assoc_req(struct slsi_dev *sdev, struct net_device *dev,
				const unsigned char *bssid, int sn, int tx_status,
				int mgmt_frame_subtype)
{
}

void slsi_conn_log2us_assoc_resp(struct slsi_dev *sdev, struct net_device *dev,
				 const unsigned char *bssid, int sn, int status,
				 int mgmt_frame_subtype)
{
}

void slsi_conn_log2us_deauth(struct slsi_dev *sdev, struct net_device *dev, char *str_type,
			     const unsigned char *bssid, int sn, int status)
{
}

void slsi_conn_log2us_disassoc(struct slsi_dev *sdev, struct net_device *dev, char *str_type,
			       const unsigned char *bssid,
			       int sn, int status)
{
}

void slsi_conn_log2us_roam_scan_done(struct slsi_dev *sdev, struct net_device *dev, u64 timestamp)
{
}

void slsi_conn_log2us_roam_scan_result(struct slsi_dev *sdev, struct net_device *dev,
				       bool curr, char *bssid, int freq,
				       int rssi, short cu,
				       int score, int tp_score, bool eligible)
{
}

void slsi_conn_log2us_btm_query(struct slsi_dev *sdev, struct net_device *dev,
				int dialog, int reason)
{
}

void slsi_conn_log2us_btm_req(struct slsi_dev *sdev, struct net_device *dev,
			      int dialog, int btm_mode, int disassoc_timer,
			      int validity_time, int candidate_count)
{
}

void slsi_conn_log2us_btm_resp(struct slsi_dev *sdev, struct net_device *dev,
			       int dialog, int btm_mode, int delay, char *bssid)
{
}

u8 *get_eap_type_from_val(int val, u8 *str)
{
	return NULL;
}

void slsi_conn_log2us_eapol_tx(struct slsi_dev *sdev, struct net_device *dev, u32 status_code)
{
}

void slsi_conn_log2us_eapol_ptk_tx(struct slsi_dev *sdev, u32 status_code)
{
}

void slsi_conn_log2us_eapol_gtk_tx(struct slsi_dev *sdev, u32 status_code)
{
}

void slsi_conn_log2us_eap_tx(struct slsi_dev *sdev, struct netdev_vif *ndev_vif,
			     int eap_length, int eap_type,
			     char *tx_status_str)
{
}

void slsi_conn_log2us_btm_cand(struct slsi_dev *sdev, struct net_device *dev,
			       char *bssid, int prefer)
{
}

void slsi_eapol_eap_handle_tx_status(struct slsi_dev *sdev, struct netdev_vif *ndev_vif,
				     u16 a, u16 b)
{
}

void slsi_conn_log2us_roam_scan_save(struct slsi_dev *sdev, struct net_device *dev,
				     int scan_type, int freq_count, int *freq_list)
{
}

void slsi_conn_log2us_nr_frame_req(struct slsi_dev *sdev, struct net_device *dev);
{
}

void slsi_conn_log2us_nr_frame_resp(struct slsi_dev *sdev, struct net_device *dev, char *string)
{
}

void slsi_conn_log2us_beacon_report_request(struct slsi_dev *sdev, struct net_device *dev,
					    int dialog_token, int operating_class, char *string,
					    int measure_duration, char *measure_mode,
					    char *mac_addr, char *ssid)
{
}

void slsi_conn_log2us_beacon_report_response(struct slsi_dev *sdev, struct net_device *dev, int dialog_token,
					     int ap_count, int reason_code)
{
}

void slsi_conn_log2us_ncho_mode(struct slsi_dev *sdev, struct net_device *dev, int enable)
{
}

#endif