xref: /OK3568_Linux_fs/external/rkwifibt/drivers/bcmdhd/dhd_linux_sock_qos.c (revision 4882a59341e53eb6f0b4789bf948001014eff981)

/*
 * Source file for DHD QOS on Socket Flow.
 *
 * Defines a socket flow and maintains a table of socket flows
 * for further analysis in order to upgrade the QOS of the flow.

 * Copyright (C) 2020, Broadcom.
 *
 *      Unless you and Broadcom execute a separate written software license
 * agreement governing use of this software, this software is licensed to you
 * under the terms of the GNU General Public License version 2 (the "GPL"),
 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
 * following added to such license:
 *
 *      As a special exception, the copyright holders of this software give you
 * permission to link this software with independent modules, and to copy and
 * distribute the resulting executable under terms of your choice, provided that
 * you also meet, for each linked independent module, the terms and conditions of
 * the license of that module.  An independent module is a module which is not
 * derived from this software.  The special exception does not apply to any
 * modifications of the software.
 *
 *
 * <<Broadcom-WL-IPTag/Open:>>
 *
 * $Id$
 *
 */

#include <dhd_linux_priv.h>
#include <dhd_dbg.h>
#include <bcmstdlib_s.h>
#include <bcmendian.h>
#include <dhd_linux_sock_qos.h>
#include <dhd_qos_algo.h>
#include <dhd.h>

#include <net/sock.h>
#include <linux/sock_diag.h>
#include <linux/netlink.h>
#include <linux/list.h>
#include <linux/sched.h>
#include <linux/math64.h>
#include <linux/pkt_sched.h>
#include <linux_pkt.h>
#include <net/tcp.h>

/* Maximum number of Socket Flows supported */
#define MAX_SOCK_FLOW	(1024UL)

#define SOCK_FLOW_UPGRADE_THRESHOLD	(3)
/*
 * Mark a Socket Flow as inactive and free the resources
 * if there is no packet receied for SOCK_IDLE_THREASHOLD_MS
 * of time. Note that this parameter is in milli seconds.
 */
#define SOCK_IDLE_THRESHOLD_MS	(2000UL)

#define DSCP_TOS_CS7 0XE0u

extern uint dhd_watchdog_ms;

/* Defines Socket Flow */
struct dhd_sock_flow_info
{
	/* Unique identifiers */
	struct sock *sk;
	unsigned long ino;

	/* statistics */
	qos_stat_t stats;
	u64 last_pkt_ns;
	kuid_t uid;

	/* Elements related to upgrade management */

	/* 0 - No upgrade
	 * 1 - Upgrade
	 */
	unsigned int cur_up_state;
	unsigned int rcm_up_state;
	unsigned int bus_flow_id;

	/* TODO:
	 * Handling Out Of Order during upgrade
	 * Once an upgrade is decided we cannot handover the skb to
	 * FW in the upgraded Flow Ring ... it will create Out of Order Packets.
	 * Instead we can have a output_q per socket flow. Once the upgrade is
	 * decided, we can start adding skbs to the output_q. The last 'skb' given
	 * to the actual Flow ring should be remembered in 'last_skb_orig_fl'.
	 * Once we get a  Tx completion for last_skb_orig_fl we can flush the
	 * contents of output_q to the 'upgraded flowring'. In this solution,
	 * we should also handle the case where output_q hits the watermark
	 * before the completion for 'last_skb_orig_fl' is received. If this condition
	 * happens, not to worry about OOO and flush the contents of output_q.
	 * Probably the last_skb_orig_fl is not sent out due latency in the
	 * existing flow ... the actual problem we are trying to solve.
	 */

	/* Management elements */
	struct list_head list;
	unsigned int in_use;
};

typedef enum _frameburst_state
{
	FRMBRST_DISABLED = 0,
	FRMBRST_ENABLED = 1
} frameburst_state_t;

/* Sock QOS Module Structure */
typedef struct dhd_sock_qos_info
{
	/* Table of Socket Flows */
	struct dhd_sock_flow_info *sk_fl;
	/* maximum number for socket flows supported */
	uint32 max_sock_fl;

	/* TODO: need to make it per flow later on */
	/* global qos algo parameters */
	qos_algo_params_t qos_params;
	/* List in which active Socket Flows live */
	struct list_head sk_fl_list_head;
	void *list_lock;

	/* Time interval a socket flow resource is moved out of the active list */
	uint32 sock_idle_thresh;
	/*
	 * Keep track of number of flows upgraded.
	 * If it reaches a threshold we should stop ugrading
	 * This is to avoid the problem where we overwhelm
	 * the Dongle with upgraded traffic.
	 */
	int num_skfl_upgraded;
	int skfl_upgrade_thresh;

	/* flag that is set to true when the first flow is upgraded
	 * so that FW frameburst is disabled, and set to false
	 * when no more flows are in upgraded state, so that
	 * FW frameburst is re-enabled
	 */
	bool upgrade_active;
	/* fw frameburst state */
	frameburst_state_t frmbrst_state;

	atomic_t on_off;
	atomic_t force_upgrade;

	/* required for enabling/disabling watchdog timer at runtime */
	uint watchdog_ms;
} dhd_sock_qos_info_t;

#define SK_FL_LIST_LOCK(lock, flags)	(flags) = osl_spin_lock(lock)
#define SK_FL_LIST_UNLOCK(lock, flags)	osl_spin_unlock((lock), (flags))

int
dhd_init_sock_flows_buf(dhd_info_t *dhd, uint watchdog_ms)
{
	unsigned long sz;
	unsigned int i;
	struct dhd_sock_flow_info *sk_fl = NULL;
	int val = 0, ret = 0;

	if (dhd == NULL)
		return BCME_BADARG;

	dhd->psk_qos = MALLOCZ(dhd->pub.osh, sizeof(dhd_sock_qos_info_t));
	if (dhd->psk_qos == NULL) {
		DHD_ERROR(("%s(): Failed to alloc psk_qos ! \n", __FUNCTION__));
		return BCME_NOMEM;
	}
	dhd->psk_qos->max_sock_fl = MAX_SOCK_FLOW;
	sz = sizeof(struct dhd_sock_flow_info) * MAX_SOCK_FLOW;
	dhd->psk_qos->sk_fl = MALLOCZ(dhd->pub.osh, sz);
	if (dhd->psk_qos->sk_fl == NULL) {
		DHD_ERROR(("%s(): Failed to allocated sk_fl \r\n", __FUNCTION__));
		return BCME_NOMEM;
	}

	sk_fl = dhd->psk_qos->sk_fl;
	for (i = 0; i < MAX_SOCK_FLOW; i++, sk_fl++) {
		sk_fl->in_use = 0;
	}

	dhd->psk_qos->sock_idle_thresh = SOCK_IDLE_THRESHOLD_MS;

	dhd->psk_qos->skfl_upgrade_thresh = SOCK_FLOW_UPGRADE_THRESHOLD;

	INIT_LIST_HEAD(&dhd->psk_qos->sk_fl_list_head);
	dhd->psk_qos->list_lock = osl_spin_lock_init(dhd->pub.osh);

	dhd->psk_qos->watchdog_ms = watchdog_ms;
	/* feature is DISABLED by default */
	dhd_sock_qos_set_status(dhd, 0);

	qos_algo_params_init(&dhd->psk_qos->qos_params);

	dhd->psk_qos->frmbrst_state = FRMBRST_ENABLED;
	/* read the initial state of frameburst from FW, cannot
	 * assume that it will always be in enabled state by default.
	 * We will cache the FW frameburst state in host and change
	 * it everytime we change it from host during QoS upgrade.
	 * This decision is taken, because firing an iovar everytime
	 * to query FW frameburst state before deciding whether to
	 * changing the frameburst state or not from host, is sub-optimal,
	 * especially in the Tx path.
	 */
	ret = dhd_wl_ioctl_cmd(&dhd->pub, WLC_SET_FAKEFRAG, (char *)&val,
		sizeof(val), FALSE, 0);
	if (ret != BCME_OK) {
		DHD_ERROR(("%s: get fw frameburst failed,"
			" err=%d\n", __FUNCTION__, ret));
	} else {
		DHD_INFO(("%s:fw frameburst = %d", __FUNCTION__, val));
		dhd->psk_qos->frmbrst_state =
			(val == 1) ? FRMBRST_ENABLED : FRMBRST_DISABLED;
	}
	return BCME_OK;
}

int
dhd_deinit_sock_flows_buf(dhd_info_t *dhd)
{
	if (dhd == NULL)
		return BCME_BADARG;

	if (dhd->psk_qos->sk_fl) {
		MFREE(dhd->pub.osh, dhd->psk_qos->sk_fl,
			sizeof(struct dhd_sock_flow_info) * MAX_SOCK_FLOW);
		dhd->psk_qos->sk_fl = NULL;
	}

	osl_spin_lock_deinit(dhd->pub.osh, dhd->psk_qos->list_lock);
	MFREE(dhd->pub.osh, dhd->psk_qos, sizeof(dhd_sock_qos_info_t));
	dhd->psk_qos = NULL;

	return BCME_OK;
}

/* Caller should hold list_lock */
static inline struct dhd_sock_flow_info *
__dhd_find_sock_stream_info(dhd_sock_qos_info_t *psk_qos, unsigned long ino)
{
	struct dhd_sock_flow_info *sk_fl = NULL;
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif
	list_for_each_entry(sk_fl, &psk_qos->sk_fl_list_head,
			list)  {
		if (sk_fl && (sk_fl->ino == ino)) {
			return sk_fl;
		}
	} /* end of list iteration */
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
	/* If control comes here, the ino is not found */
	DHD_INFO(("%s(): ino:%lu not found \r\n", __FUNCTION__, ino));

	return NULL;
}

static struct dhd_sock_flow_info *
dhd_alloc_sock_stream_info(dhd_sock_qos_info_t *psk_qos)
{
	struct dhd_sock_flow_info *sk_fl = psk_qos->sk_fl;
	int i;

	for (i = 0; i < psk_qos->max_sock_fl; i++, sk_fl++) {
		if (sk_fl->in_use == 0) {
			DHD_ERROR(("%s: Use sk_fl %p \r\n", __FUNCTION__, sk_fl));
			return sk_fl;
		}
	}
	DHD_INFO(("No Free Socket Stream info \r\n"));
	return NULL;
}

/* Caller should hold list_lock */
static inline void
__dhd_free_sock_stream_info(dhd_sock_qos_info_t *psk_qos,
	struct dhd_sock_flow_info *sk_fl)
{
	/*
	 * If the socket flow getting freed is an upgraded socket flow,
	 * we can upgrade one more flow.
	 */
	if (sk_fl->cur_up_state == 1) {
		--psk_qos->num_skfl_upgraded;
		ASSERT(psk_qos->num_skfl_upgraded >= 0);
	}

	/* Remove the flow from active list */
	list_del(&sk_fl->list);

	DHD_ERROR(("%s(): Cleaning Socket Flow ino:%lu psk_qos->num_skfl_upgraded=%d\r\n",
		__FUNCTION__, sk_fl->ino, psk_qos->num_skfl_upgraded));

	/* Clear its content */
	memset_s(sk_fl, sizeof(*sk_fl), 0, sizeof(*sk_fl));

	return;
}

static void
dhd_clean_idle_sock_streams(dhd_sock_qos_info_t *psk_qos)
{
	struct dhd_sock_flow_info *sk_fl = NULL, *next = NULL;
	u64 now;
	u64 diff;
	unsigned long flags = 0;
	now = local_clock();

	SK_FL_LIST_LOCK(psk_qos->list_lock, flags);

#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif
	list_for_each_entry_safe(sk_fl, next, &psk_qos->sk_fl_list_head, list)  {
		if (sk_fl) {

			if (sk_fl->in_use == 0) {
				DHD_ERROR_RLMT(("%s:Something wrong,"
					" a free sk_fl living in active stream\n",
					__FUNCTION__));
				DHD_ERROR_RLMT(("sk_fl:%p sk:%p ino:%lu \r\n",
					sk_fl, sk_fl->sk, sk_fl->ino));
				continue;
			}

			/* XXX: TODO: need to investigate properly in future.
			 * it is observed that in some hosts (FC25), the
			 * current timestamp is lesser than previous timestamp
			 * leading to false cleanups
			 */
			if (now <= sk_fl->last_pkt_ns)
				continue;

			diff = now - sk_fl->last_pkt_ns;

			/* Convert diff which is in ns to ms */
			diff = div64_u64(diff, 1000000UL);
			if (diff >= psk_qos->sock_idle_thresh) {
				DHD_ERROR(("sk_fl->sk:%p sk_fl->i_no:%lu \r\n",
					sk_fl->sk, sk_fl->ino));
				if (sk_fl->cur_up_state == 1 &&
					psk_qos->num_skfl_upgraded == 1) {
					psk_qos->upgrade_active = FALSE;
				}
				__dhd_free_sock_stream_info(psk_qos, sk_fl);
			}
		}
	} /* end of list iteration */
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
	SK_FL_LIST_UNLOCK(psk_qos->list_lock, flags);

}

static inline int
__dhd_upgrade_sock_flow(dhd_info_t *dhd,
	struct dhd_sock_flow_info *sk_fl,
	struct sk_buff *skb)
{
	dhd_sock_qos_info_t *psk_qos = dhd->psk_qos;
#ifdef DHD_HP2P
	dhd_pub_t *dhdp = &dhd->pub;
#endif
	uint8 *pktdat = NULL;
	struct ether_header *eh = NULL;
	struct iphdr *iph = NULL;

	/* Before upgrading a flow,
	 * Check the bound to control the number of flows getting upgraded
	 */
	if ((sk_fl->rcm_up_state == 1) && (sk_fl->cur_up_state == 0)) {
		if (psk_qos->num_skfl_upgraded >= psk_qos->skfl_upgrade_thresh) {
			DHD_ERROR_RLMT(("%s(): Thresh hit num_skfl_upgraded:%d"
				"skfl_upgrade_thresh:%d \r\n",
				__FUNCTION__, psk_qos->num_skfl_upgraded,
				psk_qos->skfl_upgrade_thresh));
			return BCME_ERROR;
		} else {
			if (psk_qos->num_skfl_upgraded == 0) {
				/* if no flows upgraded till now, and this is the
				 * first flow to be upgraded,
				 * then disable frameburst in FW.
				 * The actual iovar to disable frameburst cannot
				 * be fired here because Tx can happen in atomic context
				 * and dhd_iovar can sleep due to proto_block lock being
				 * held. Instead the flag is checked from
				 * 'dhd_analyze_sock_flows' which execs in non-atomic context
				 * and the iovar is fired from there
				 */
				DHD_TRACE(("%s: disable frameburst ..", __FUNCTION__));
				psk_qos->upgrade_active = TRUE;
			}
			++psk_qos->num_skfl_upgraded;
			DHD_ERROR_RLMT(("%s(): upgrade flow sk_fl %p,"
				"num_skfl_upgraded:%d skfl_upgrade_thresh:%d \r\n",
				__FUNCTION__, sk_fl, psk_qos->num_skfl_upgraded,
				psk_qos->skfl_upgrade_thresh));
		}
	}

	/* Upgrade the skb */
#ifdef DHD_HP2P
	if (dhdp->hp2p_capable)
		skb->priority = TC_PRIO_CONTROL;
	else
		skb->priority = TC_PRIO_INTERACTIVE;
#else
	skb->priority = TC_PRIO_INTERACTIVE;
#endif /* DHD_HP2P  */

	pktdat = PKTDATA(dhd->pub.osh, skb);
	eh = (struct ether_header *) pktdat;
	if (pktdat && (eh->ether_type == hton16(ETHER_TYPE_IP))) {
		/* 'upgrade' DSCP also, else it is observed that on
		 * AP side if DSCP value is not in sync with L2 prio
		 * then out of order packets are observed
		 */
		iph = (struct iphdr *)(pktdat + sizeof(struct ether_header));
		iph->tos = DSCP_TOS_CS7;
		/* re-compute ip hdr checksum
		 * NOTE: this takes around 1us, need to profile more
		 * accurately to get the number of cpu cycles it takes
		 * in order to get a better idea of the impact of
		 * re computing ip hdr chksum in data path
		 */
		ip_send_check(iph);
	 }

	/* Mark the Flow as 'upgraded' */
	if (sk_fl->cur_up_state == 0)
		sk_fl->cur_up_state = 1;

	return BCME_OK;
}

static inline int
__dhd_downgrade_sock_flow(dhd_info_t *dhd,
	struct dhd_sock_flow_info *sk_fl,
	struct sk_buff *skb)
{
	dhd_sock_qos_info_t *psk_qos = dhd->psk_qos;

	if ((sk_fl->rcm_up_state == 0) && (sk_fl->cur_up_state == 1)) {
		/* sanity check */
		ASSERT(psk_qos->num_skfl_upgraded > 0);
		if (psk_qos->num_skfl_upgraded <= 0) {
			DHD_ERROR_RLMT(("%s(): FATAL ! no upgraded flows !\n",
					__FUNCTION__));
			return BCME_ERROR;
		}

		if (psk_qos->num_skfl_upgraded == 1) {
			/* if this is the
			 * last flow to be downgraded,
			 * then re-enable frameburst in FW.
			 * The actual iovar to enable frameburst cannot
			 * be fired here because Tx can happen in atomic context
			 * and dhd_iovar can sleep due to proto_block lock being
			 * held. Instead the flag is checked from
			 * 'dhd_analyze_sock_flows' which execs in non-atomic context
			 * and the iovar is fired from there
			 */
			DHD_TRACE(("%s: enable frameburst ..", __FUNCTION__));
			psk_qos->upgrade_active = FALSE;
		}
		--psk_qos->num_skfl_upgraded;
		DHD_ERROR_RLMT(("%s(): downgrade flow sk_fl %p,"
			"num_skfl_upgraded:%d \r\n",
			__FUNCTION__, sk_fl, psk_qos->num_skfl_upgraded));
	}

	/* Mark the Flow as 'downgraded' */
	if (sk_fl->cur_up_state == 1)
		sk_fl->cur_up_state = 0;

	return BCME_OK;
}

/*
 * Update the stats of a Socket flow.
 * Create a new flow if need be.
 * If a socket flow has been recommended for upgrade, do so.
 */
void
dhd_update_sock_flows(dhd_info_t *dhd, struct sk_buff *skb)
{
	struct sock *sk = NULL;
	unsigned long ino = 0;
	struct dhd_sock_flow_info *sk_fl = NULL;
	dhd_sock_qos_info_t *psk_qos = NULL;
	unsigned long flags = 0;
	uint8 prio;

	BCM_REFERENCE(prio);

	if ((dhd == NULL) || (skb == NULL)) {
		DHD_ERROR_RLMT(("%s: Invalid args \n", __FUNCTION__));
		return;
	}

	/* If the Feature is disabled, return */
	if (dhd_sock_qos_get_status(dhd) == 0)
		return;

	psk_qos = dhd->psk_qos;
	sk = (struct sock *)PKTSOCK(dhd->pub.osh, skb);

	/* TODO:
	 * Some times sk is NULL, what does that mean ...
	 * is it a broadcast packet generated by Network Stack ????
	 */
	if (sk == NULL) {
		return;
	}
	ino = sock_i_ino(sk);

	/* TODO:
	 * List Lock need not be held for allocating sock stream .. optimize
	 */
	SK_FL_LIST_LOCK(psk_qos->list_lock, flags);

	sk_fl = __dhd_find_sock_stream_info(psk_qos, ino);
	if (sk_fl == NULL) {
		/* Allocate new sock stream */
		sk_fl = dhd_alloc_sock_stream_info(psk_qos);
		if (sk_fl == NULL) {
			SK_FL_LIST_UNLOCK(psk_qos->list_lock, flags);
			goto done;
		}
		else {
			/* SK Flow elements updated first time */
			sk_fl->in_use = 1;
			sk_fl->sk = sk;
			sk_fl->ino = ino;
			/* TODO: Seeing a Kernel Warning ... check */
			/* sk_fl->uid = sock_i_uid(sk); */
			sk_fl->cur_up_state = 0;
			list_add_tail(&sk_fl->list, &psk_qos->sk_fl_list_head);
			DHD_ERROR(("%s(): skb %p sk %p sk_fl %p ino %lu"
				" prio 0x%x \r\n", __FUNCTION__, skb,
				sk, sk_fl, ino, skb->priority));
		} /* end of new sk flow allocation */
	} /* end of case when sk flow is found */

	sk_fl->stats.tx_pkts++;
	sk_fl->stats.tx_bytes += skb->len;
	sk_fl->last_pkt_ns = local_clock();

	SK_FL_LIST_UNLOCK(psk_qos->list_lock, flags);

	if (sk_fl->rcm_up_state == 1) {
		__dhd_upgrade_sock_flow(dhd, sk_fl, skb);
	} else {
		__dhd_downgrade_sock_flow(dhd, sk_fl, skb);
	}

	prio = PKTPRIO(skb);
	DHD_INFO(("%s(): skb:%p skb->priority 0x%x prio %d sk_fl %p\r\n", __FUNCTION__, skb,
		skb->priority, prio, sk_fl));
done:
	return;
}

static int
dhd_change_frameburst_state(frameburst_state_t newstate, dhd_info_t *dhd)
{
	int ret = 0, val = 0;
	dhd_sock_qos_info_t *psk_qos = NULL;

	if (!dhd)
		return BCME_BADARG;
	if (!dhd->psk_qos)
		return BCME_BADARG;

	psk_qos = dhd->psk_qos;

	/* Check with the cached frameburst state on host
	 * instead of querying FW frameburst state.
	 * This decision is taken, because firing an iovar everytime
	 * to query FW frameburst state before deciding whether to
	 * changing the frameburst state or not is sub-optimal,
	 * especially in the Tx path.
	 */
	if (psk_qos->frmbrst_state == newstate)
		return BCME_BADOPTION;

	val = (newstate == FRMBRST_ENABLED) ? 1 : 0;
	ret = dhd_wl_ioctl_cmd(&dhd->pub, WLC_SET_FAKEFRAG, (char *)&val,
		sizeof(val), TRUE, 0);
	if (ret != BCME_OK) {
		DHD_ERROR_RLMT(("%s: set frameburst=%d failed,"
			" err=%d\n", __FUNCTION__, val, ret));
	} else {
		/* change the state */
		DHD_INFO(("%s: set frameburst=%d\n", __FUNCTION__, val));
		psk_qos->frmbrst_state = newstate;
	}

	return ret;
}

void dhd_analyze_sock_flows(dhd_info_t *dhd, uint32 watchdog_ms)
{
	struct dhd_sock_flow_info *sk_fl = NULL;
	dhd_sock_qos_info_t *psk_qos = NULL;
	unsigned long flags = 0;

	if (dhd == NULL) {
		DHD_ERROR_RLMT(("%s: Bad argument \r\n", __FUNCTION__));
		return;
	}

	/* Check whether the feature is disabled */
	if (dhd_sock_qos_get_status(dhd) == 0)
		return;

	psk_qos = dhd->psk_qos;

	dhd_clean_idle_sock_streams(dhd->psk_qos);

	/* TODO: Plug in the QoS Algorithm here */
	SK_FL_LIST_LOCK(psk_qos->list_lock, flags);
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif
	list_for_each_entry(sk_fl, &psk_qos->sk_fl_list_head, list)  {

		sk_fl->rcm_up_state = dhd_qos_algo(dhd, &sk_fl->stats, &psk_qos->qos_params);

		/* TODO: Handle downgrades */

		/* update sk_flow previous elements on every sampling interval */
		sk_fl->stats.tx_pkts_prev = sk_fl->stats.tx_pkts;
		sk_fl->stats.tx_bytes_prev = sk_fl->stats.tx_bytes;

		/* TODO: Handle the condition where num_skfl_upgraded reaches the threshold */

		/* TODO: Handle the condition where we upgrade all the socket flows
		 * of the uid on which one flow is detected to be upgraded.
		 */

	} /* end of list iteration */
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
	SK_FL_LIST_UNLOCK(psk_qos->list_lock, flags);

	/* disable frameburst in FW on the first flow upgraded */
	if (psk_qos->upgrade_active) {
		dhd_change_frameburst_state(FRMBRST_DISABLED, dhd);
	} else {
		/* if no upgraded flows remain, either after cleanup,
		 * or after a downgrade,
		 * then re-enable frameburst in FW
		 */
		dhd_change_frameburst_state(FRMBRST_ENABLED, dhd);
	}

	return;
}

void dhd_sock_qos_update_bus_flowid(dhd_info_t *dhd, void *pktbuf,
	uint32 bus_flow_id)
{
	BCM_REFERENCE(dhd);
	BCM_REFERENCE(pktbuf);
	BCM_REFERENCE(bus_flow_id);
	return;
}

/* ================= Sysfs interfce support functions ======================== */

unsigned long dhd_sock_qos_get_status(dhd_info_t *dhd)
{
	if (dhd == NULL)
		return 0;

	return (atomic_read(&dhd->psk_qos->on_off));
}

void dhd_sock_qos_set_status(dhd_info_t *dhd, unsigned long on_off)
{
	if (dhd == NULL)
		return;

	atomic_set(&dhd->psk_qos->on_off, on_off);
	if (on_off) {
		dhd_watchdog_ms = QOS_SAMPLING_INTVL_MS;
		/* enable watchdog to monitor the socket flows */
		dhd_os_wd_timer(&dhd->pub, QOS_SAMPLING_INTVL_MS);
	} else {
		dhd_watchdog_ms = dhd->psk_qos->watchdog_ms;
		/* disable watchdog or set it back to the original value */
		dhd_os_wd_timer(&dhd->pub, dhd->psk_qos->watchdog_ms);
	}
	return;
}

ssize_t dhd_sock_qos_show_stats(dhd_info_t *dhd, char *buf,
	ssize_t sz)
{
	dhd_sock_qos_info_t *psk_qos = NULL;
	struct dhd_sock_flow_info *sk_fl = NULL;
	unsigned long flags = 0;
	ssize_t	ret = 0;
	char *p = buf;

	/* TODO: Should be actual record length */
	unsigned long rec_len = 100;

	if (dhd == NULL)
		return -1;

	psk_qos = dhd->psk_qos;

	ret += scnprintf(p, sz-ret-1, "\nino\t sk\t\t\t tx_pkts\t tx_bytes\t"
		"last_pkt_ns\r\n");
	p += ret;

	SK_FL_LIST_LOCK(psk_qos->list_lock, flags);
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif
	list_for_each_entry(sk_fl, &psk_qos->sk_fl_list_head, list)  {
		/* Protect the buffer from over run */
		if (ret + rec_len >= sz)
			break;

		ret += scnprintf(p, sz-ret-1, "%lu\t %p\t %lu\t %lu\t %llu\t \r\n",
			sk_fl->ino, sk_fl->sk, sk_fl->stats.tx_pkts, sk_fl->stats.tx_bytes,
			sk_fl->last_pkt_ns);

		p += ret;

	}
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
	SK_FL_LIST_UNLOCK(psk_qos->list_lock, flags);

	return ret + 1;
}

void dhd_sock_qos_clear_stats(dhd_info_t *dhd)
{
	dhd_sock_qos_info_t *psk_qos = NULL;
	struct dhd_sock_flow_info *sk_fl = NULL;
	unsigned long flags = 0;

	if (dhd == NULL)
		return;

	psk_qos = dhd->psk_qos;

	SK_FL_LIST_LOCK(psk_qos->list_lock, flags);
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
#endif
	list_for_each_entry(sk_fl, &psk_qos->sk_fl_list_head, list)  {
		sk_fl->stats.tx_pkts = 0;
		sk_fl->stats.tx_bytes = 0;
		sk_fl->stats.tx_pkts_prev = 0;
		sk_fl->stats.tx_bytes_prev = 0;
		sk_fl->last_pkt_ns = 0;
	}
#if defined(STRICT_GCC_WARNINGS) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
	SK_FL_LIST_UNLOCK(psk_qos->list_lock, flags);

	return;
}

unsigned long dhd_sock_qos_get_force_upgrade(dhd_info_t *dhd)
{
	if (dhd == NULL)
		return 0;

	return (atomic_read(&dhd->psk_qos->force_upgrade));
}

void dhd_sock_qos_set_force_upgrade(dhd_info_t *dhd, unsigned long force_upgrade)
{
	if (dhd == NULL)
		return;

	atomic_set(&dhd->psk_qos->force_upgrade, force_upgrade);
	return;
}

int dhd_sock_qos_get_numfl_upgrd_thresh(dhd_info_t *dhd)
{
	if (dhd == NULL)
		return 0;

	return dhd->psk_qos->skfl_upgrade_thresh;
}

void dhd_sock_qos_set_numfl_upgrd_thresh(dhd_info_t *dhd,
		int upgrade_thresh)
{
	if (dhd == NULL)
		return;

	dhd->psk_qos->skfl_upgrade_thresh = upgrade_thresh;
	return;
}

void dhd_sock_qos_get_avgpktsize_thresh(dhd_info_t *dhd,
		unsigned long *avgpktsize_low,
		unsigned long *avgpktsize_high)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL || avgpktsize_low == NULL ||
		avgpktsize_high == NULL) {
		return;
	}

	pqos_params = QOS_PARAMS(dhd);
	*avgpktsize_low = pqos_params->avg_pkt_size_low_thresh;
	*avgpktsize_high = pqos_params->avg_pkt_size_high_thresh;
	return;
}

void dhd_sock_qos_set_avgpktsize_thresh(dhd_info_t *dhd,
		unsigned long avgpktsize_low,
		unsigned long avgpktsize_high)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL)
		return;

	pqos_params = QOS_PARAMS(dhd);
	pqos_params->avg_pkt_size_low_thresh = avgpktsize_low;
	pqos_params->avg_pkt_size_high_thresh = avgpktsize_high;
	return;
}

void dhd_sock_qos_get_numpkts_thresh(dhd_info_t *dhd,
		unsigned long *numpkts_low,
		unsigned long *numpkts_high)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL || numpkts_low == NULL ||
		numpkts_high == NULL) {
		return;
	}

	pqos_params = QOS_PARAMS(dhd);
	*numpkts_low = pqos_params->num_pkts_low_thresh;
	*numpkts_high = pqos_params->num_pkts_high_thresh;
}

void dhd_sock_qos_set_numpkts_thresh(dhd_info_t *dhd,
		unsigned long numpkts_low,
		unsigned long numpkts_high)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL)
		return;
	pqos_params = QOS_PARAMS(dhd);
	pqos_params->num_pkts_low_thresh = numpkts_low;
	pqos_params->num_pkts_high_thresh = numpkts_high;
	return;
}

void dhd_sock_qos_get_detectcnt_thresh(dhd_info_t *dhd,
		unsigned char *detectcnt_inc,
		unsigned char *detectcnt_dec)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL || detectcnt_inc == NULL ||
		detectcnt_dec == NULL) {
		return;
	}

	pqos_params = QOS_PARAMS(dhd);
	*detectcnt_inc = pqos_params->detect_cnt_inc_thresh;
	*detectcnt_dec = pqos_params->detect_cnt_dec_thresh;
}

void dhd_sock_qos_set_detectcnt_thresh(dhd_info_t *dhd,
		unsigned char detectcnt_inc,
		unsigned char detectcnt_dec)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL)
		return;

	pqos_params = QOS_PARAMS(dhd);
	pqos_params->detect_cnt_inc_thresh = detectcnt_inc;
	pqos_params->detect_cnt_dec_thresh = detectcnt_dec;
	return;
}

int dhd_sock_qos_get_detectcnt_upgrd_thresh(dhd_info_t *dhd)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL)
		return 0;

	pqos_params = QOS_PARAMS(dhd);
	return pqos_params->detect_cnt_upgrade_thresh;
}

void dhd_sock_qos_set_detectcnt_upgrd_thresh(dhd_info_t *dhd,
		unsigned char detect_upgrd_thresh)
{
	qos_algo_params_t *pqos_params = NULL;

	if (dhd == NULL)
		return;

	pqos_params = QOS_PARAMS(dhd);
	pqos_params->detect_cnt_upgrade_thresh = detect_upgrd_thresh;
}

int dhd_sock_qos_get_maxfl(dhd_info_t *dhd)
{
	if (dhd == NULL)
		return 0;

	return dhd->psk_qos->max_sock_fl;
}

void dhd_sock_qos_set_maxfl(dhd_info_t *dhd,
		unsigned int maxfl)
{
	if (dhd == NULL)
		return;

	dhd->psk_qos->max_sock_fl = maxfl;
}
/* ================= End of Sysfs interfce support functions ======================== */

/* ================= QOS Algorithm ======================== */

/*
 * Operates on a flow and returns 1 for upgrade and 0 for
 * no up-grade - Has the potential of moving into a separate file
 * Takes the dhd pointer too in case if it has to access any platform
 * functions like MALLOC that takes dhd->pub.osh as argument.
 */
int dhd_qos_algo(dhd_info_t *dhd, qos_stat_t *qos, qos_algo_params_t *pqos_params)
{
	unsigned long tx_bytes, tx_pkts, tx_avg_pkt_size;

	if (!dhd || !qos || !pqos_params) {
		return 0;
	}

	/* if the user has set the sysfs variable to force upgrade */
	if (atomic_read(&dhd->psk_qos->force_upgrade) == 1) {
		return 1;
	}

	DHD_TRACE(("%s(): avgpktsize_thrsh %lu:%lu; "
		"numpkts_thrs %lu:%lu; detectcnt_thrs %d:%d;"
		" detectcnt_upgrd_thrs %d\n", __FUNCTION__,
		pqos_params->avg_pkt_size_low_thresh,
		pqos_params->avg_pkt_size_high_thresh,
		pqos_params->num_pkts_low_thresh,
		pqos_params->num_pkts_high_thresh,
		pqos_params->detect_cnt_inc_thresh,
		pqos_params->detect_cnt_dec_thresh,
		pqos_params->detect_cnt_upgrade_thresh));

	tx_bytes = qos->tx_bytes - qos->tx_bytes_prev;
	tx_pkts = qos->tx_pkts - qos->tx_pkts_prev;
	if ((tx_bytes == 0) || (tx_pkts == 0)) {
		return 0;
	}

	tx_avg_pkt_size = tx_bytes / tx_pkts;

	if ((tx_avg_pkt_size > pqos_params->avg_pkt_size_low_thresh) &&
		(tx_avg_pkt_size < pqos_params->avg_pkt_size_high_thresh) &&
		(tx_pkts > pqos_params->num_pkts_low_thresh) &&
		(tx_pkts < pqos_params->num_pkts_high_thresh)) {
		if (qos->lowlat_detect_count < pqos_params->detect_cnt_inc_thresh) {
			qos->lowlat_detect_count++;
		}
	} else if (qos->lowlat_detect_count > pqos_params->detect_cnt_dec_thresh) {
		qos->lowlat_detect_count--;
	}

	if (qos->lowlat_detect_count > pqos_params->detect_cnt_upgrade_thresh) {
		qos->lowlat_flow = TRUE;
	} else if (qos->lowlat_detect_count == 0) {
		qos->lowlat_flow = FALSE;
	}

	DHD_TRACE(("%s(): TX:%lu:%lu:%lu, PUBG:%d::%d\n",
		__FUNCTION__, tx_avg_pkt_size, tx_bytes, tx_pkts,
		qos->lowlat_detect_count, qos->lowlat_flow));

	return (qos->lowlat_flow == TRUE) ? 1 : 0;
}

int qos_algo_params_init(qos_algo_params_t *pqos_params)
{
	if (!pqos_params)
		return BCME_BADARG;

	memset(pqos_params, 0, sizeof(*pqos_params));
	pqos_params->avg_pkt_size_low_thresh = LOWLAT_AVG_PKT_SIZE_LOW;
	pqos_params->avg_pkt_size_high_thresh = LOWLAT_AVG_PKT_SIZE_HIGH;
	pqos_params->num_pkts_low_thresh = LOWLAT_NUM_PKTS_LOW;
	pqos_params->num_pkts_high_thresh = LOWLAT_NUM_PKTS_HIGH;
	pqos_params->detect_cnt_inc_thresh = LOWLAT_DETECT_CNT_INC_THRESH;
	pqos_params->detect_cnt_dec_thresh = LOWLAT_DETECT_CNT_DEC_THRESH;
	pqos_params->detect_cnt_upgrade_thresh = LOWLAT_DETECT_CNT_UPGRADE_THRESH;

	return BCME_OK;
}
/* ================= End of QOS Algorithm ======================== */