/*
 * Copyright (C) 2016 Spreadtrum Communications Inc.
 *
 * Authors	:
 * star.liu <star.liu@spreadtrum.com>
 * yifei.li <yifei.li@spreadtrum.com>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/ip.h>
#include "sprdwl.h"
#include "wl_intf.h"
#include "intf_ops.h"
#include "mm.h"
#include "tx_msg.h"
#include "rx_msg.h"
#include "work.h"
#include "tcp_ack.h"

#define INIT_INTF(num, type, out, interval, bsize, psize, max,\
			 threshold, time, pop, push, complete, suspend) \
{ .channel = num, .hif_type = type, .inout = out, .intr_interval = interval,\
.buf_size = bsize, .pool_size = psize, .once_max_trans = max,\
.rx_threshold = threshold, .timeout = time, .pop_link = pop,\
.push_link = push, .tx_complete = complete, .power_notify = suspend }

struct sprdwl_intf_ops g_intf_ops;

static inline struct sprdwl_intf *get_intf(void)
{
	return (struct sprdwl_intf *)g_intf_ops.intf;
}

#define INTF_IS_PCIE \
	(get_intf()->priv->hw_type == SPRDWL_HW_PCIE)

void sprdwl_hex_dump(unsigned char *name,
		     unsigned char *data, unsigned short len)
{
	int i, p = 0, ret;
	unsigned char buf[255] = {0};

	if ((NULL == data) || (0 == len) || (NULL == name))
		return;

	sprintf(buf, "sprdwl %s hex dump(len = %d)", name, len);
	wl_info("%s\n", buf);

	if (len > 1024)
		len = 1024;
	memset(buf, 0x00, 255);
	for (i = 0; i < len ; i++) {
		ret = sprintf((buf + p), "%02x ", *(data + i));
		if ((i != 0) && ((i + 1)%16 == 0)) {
			wl_info("%s\n", buf);
			p = 0;
			memset(buf, 0x00, 255);
		} else {
			p = p + ret;
		}
	}
	if (p != 0)
		wl_info("%s\n", buf);
}

enum sprdwl_hw_type get_hwintf_type(void)
{
	int hif = 0;
	enum sprdwl_hw_type hw_type;

	hif = sprdwcn_bus_get_hif_type();
	switch (hif) {
	case HW_TYPE_SDIO:
		hw_type = SPRDWL_HW_SDIO;
		break;
	case HW_TYPE_PCIE:
		hw_type = SPRDWL_HW_PCIE;
		break;
	case HW_TYPE_SIPC:
		hw_type = SPRDWL_HW_SIPC;
		break;
	case HW_TYPE_USB:
		hw_type = SPRDWL_HW_USB;
		break;
	default:
		hw_type = SPRDWL_HW_SDIO;
		break;
	}
	return hw_type;
}

#if defined(MORE_DEBUG)
void sprdwl_dump_stats(struct sprdwl_intf *intf)
{
	wl_err("++print txrx statistics++\n");
	wl_err("tx packets: %lu, tx bytes: %lu\n",  intf->stats.tx_packets,
	       intf->stats.tx_bytes);
	wl_err("tx filter num: %lu\n",  intf->stats.tx_filter_num);
	wl_err("tx errors: %lu, tx dropped: %lu\n",  intf->stats.tx_errors,
	       intf->stats.tx_dropped);
	wl_err("tx avg time: %lu\n",  intf->stats.tx_avg_time);
	wl_err("tx realloc: %lu\n",  intf->stats.tx_realloc);
	wl_err("tx arp num: %lu\n",  intf->stats.tx_arp_num);
	wl_err("rx packets: %lu, rx bytes: %lu\n",  intf->stats.rx_packets,
	       intf->stats.rx_bytes);
	wl_err("rx errors: %lu, rx dropped: %lu\n",  intf->stats.rx_errors,
	       intf->stats.rx_dropped);
	wl_err("rx multicast: %lu, tx multicast: %lu\n",
	       intf->stats.rx_multicast, intf->stats.tx_multicast);
	wl_err("--print txrx statistics--\n");
}

void sprdwl_clear_stats(struct sprdwl_intf *intf)
{
	memset(&intf->stats, 0x0, sizeof(struct txrx_stats));
}

/*calculate packets  average sent time from received
*from network stack to freed by HIF every STATS_COUNT packets
*/
void sprdwl_get_tx_avg_time(struct sprdwl_intf *intf,
			    unsigned long tx_start_time)
{
	struct timespec tx_end;

	getnstimeofday(&tx_end);
	intf->stats.tx_cost_time +=
	timespec_to_ns(&tx_end) - tx_start_time;
	if (intf->stats.gap_num >= STATS_COUNT) {
		intf->stats.tx_avg_time =
		intf->stats.tx_cost_time / intf->stats.gap_num;
		sprdwl_dump_stats(intf);
		intf->stats.gap_num = 0;
		intf->stats.tx_cost_time = 0;
		wl_info("%s:%d packets avg cost time: %lu\n",
			__func__, __LINE__, intf->stats.tx_avg_time);
	}
}
#endif

void set_coex_bt_on_off(u8 action)
{
	struct sprdwl_intf *intf = get_intf();

	intf->coex_bt_on = action;
}

unsigned long mbufalloc;
unsigned long mbufpop;
int if_tx_one(struct sprdwl_intf *intf, unsigned char *data,
	      int len, int chn)
{
	int ret;
	struct mbuf_t *head = NULL, *tail = NULL, *mbuf = NULL;
	int num = 1;

	ret = sprdwcn_bus_list_alloc(chn, &head, &tail, &num);
	if (ret || head == NULL || tail == NULL) {
		wl_err("%s:%d sprdwcn_bus_list_alloc fail\n",
		       __func__, __LINE__);
		return -1;
	}
	mbufalloc += num;
	mbuf = head;
	mbuf->buf = data;

	mbuf->len = len;
	mbuf->next = NULL;
	if (sprdwl_debug_level >= L_DBG)
		sprdwl_hex_dump("tx to cp2 cmd data dump", data + 4, len);
	if (intf->priv->hw_type == SPRDWL_HW_PCIE) {
		mbuf->phy = mm_virt_to_phys(&intf->pdev->dev, mbuf->buf,
					    mbuf->len, DMA_TO_DEVICE);
	}

	ret = sprdwcn_bus_push_list(chn, head, tail, num);
	if (ret) {
		mbuf = head;
		if (intf->priv->hw_type == SPRDWL_HW_PCIE) {
			mm_phys_to_virt(&intf->pdev->dev, mbuf->phy, mbuf->len,
					DMA_TO_DEVICE, false);
			mbuf->phy = 0;
		}
		kfree(mbuf->buf);
		mbuf->buf = NULL;

		sprdwcn_bus_list_free(chn, head, tail, num);
		mbufalloc -= num;
	}

	return ret;
}

inline int if_tx_cmd(struct sprdwl_intf *intf, unsigned char *data, int len)
{
	return if_tx_one(intf, data, len, intf->tx_cmd_port);
}

inline int if_tx_addr_trans(struct sprdwl_intf *intf,
			    unsigned char *data, int len)
{
	/* FIXME: Which port is used to send ADDR TRNAS*/
	return if_tx_one(intf, data, len, intf->tx_data_port);
}

static inline struct pcie_addr_buffer
*sprdwl_alloc_pcie_addr_buf(int tx_count)
{
	struct pcie_addr_buffer *addr_buffer;
#define ADDR_OFFSET 5

	addr_buffer =
		kzalloc(sizeof(struct pcie_addr_buffer) +
		tx_count * SPRDWL_PHYS_LEN, GFP_KERNEL);
	if (addr_buffer == NULL) {
		wl_err("%s:%d alloc pcie addr buf fail\n", __func__, __LINE__);
		return NULL;
	}
	addr_buffer->common.type = SPRDWL_TYPE_DATA_PCIE_ADDR;
	addr_buffer->common.direction_ind = 0;
	addr_buffer->number = tx_count;
	addr_buffer->offset = ADDR_OFFSET;
	addr_buffer->buffer_ctrl.buffer_inuse = 1;
	addr_buffer->buffer_ctrl.buffer_type = 1;

	return addr_buffer;
}

static inline struct pcie_addr_buffer
*sprdwl_set_pcie_addr_to_mbuf(struct sprdwl_tx_msg *tx_msg, struct mbuf_t *mbuf,
				   int tx_count)
{
#define ADDR_OFFSET 5
	struct pcie_addr_buffer *addr_buffer;
	struct sprdwl_intf *intf = tx_msg->intf;

	addr_buffer = sprdwl_alloc_pcie_addr_buf(tx_count);
	if (addr_buffer == NULL)
		return NULL;
	mbuf->len = ADDR_OFFSET + tx_count * SPRDWL_PHYS_LEN;
	mbuf->buf = (unsigned char *)addr_buffer;
	mbuf->phy = mm_virt_to_phys(&intf->pdev->dev, mbuf->buf,
				    mbuf->len, DMA_TO_DEVICE);

	return addr_buffer;
}

void sprdwl_add_tx_list_head(struct list_head *tx_fail_list,
			     struct list_head *tx_list,
			     int ac_index,
			     int tx_count)
{
	struct sprdwl_msg_buf *msg_buf = NULL;
	struct list_head *xmit_free_list;
	struct list_head *head, *tail;
	spinlock_t *lock;
	spinlock_t *free_lock;

	if (tx_fail_list == NULL)
		return;
	msg_buf = list_first_entry(tx_fail_list, struct sprdwl_msg_buf, list);
	xmit_free_list = &msg_buf->xmit_msg_list->to_free_list;
	free_lock = &msg_buf->xmit_msg_list->free_lock;
	if (msg_buf->msg_type != SPRDWL_TYPE_DATA) {
		lock = &msg_buf->msglist->busylock;
	} else {
		if (SPRDWL_AC_MAX != ac_index)
			lock = &msg_buf->data_list->p_lock;
		else
			lock = &msg_buf->xmit_msg_list->send_lock;
	}
	spin_lock_bh(free_lock);
	head = tx_fail_list->next;
	tail = tx_fail_list->prev;
	head->prev->next = tail->next;
	tail->next->prev = head->prev;
	head->prev = tx_fail_list;
	tail->next = tx_fail_list;
	spin_unlock_bh(free_lock);

	spin_lock_bh(lock);
	list_splice(tx_fail_list, tx_list);
	spin_unlock_bh(lock);
	INIT_LIST_HEAD(tx_fail_list);
}

static inline void
sprdwl_add_to_free_list(struct sprdwl_tx_msg *tx_msg,
			struct list_head *tx_list_head,
			int tx_count)
{
	spin_lock_bh(&tx_msg->xmit_msg_list.free_lock);
	list_splice_tail(tx_list_head, &tx_msg->xmit_msg_list.to_free_list);
	spin_unlock_bh(&tx_msg->xmit_msg_list.free_lock);
}

/*cut data list from tx data list*/
static inline void
sprdwl_list_cut_position(struct list_head *tx_list_head,
			 struct list_head *tx_list,
			 struct list_head *tail_entry, int ac_index)
{
	spinlock_t *lock;
	struct sprdwl_msg_buf *msg_buf = NULL;

	if (tail_entry == NULL)
		return;
	msg_buf = list_first_entry(tx_list, struct sprdwl_msg_buf, list);
	if (msg_buf->msg_type != SPRDWL_TYPE_DATA) {
		lock = &msg_buf->msglist->busylock;
	} else {
		if (SPRDWL_AC_MAX != ac_index)
			lock = &msg_buf->data_list->p_lock;
		else
			lock = &msg_buf->xmit_msg_list->send_lock;
	}
	spin_lock_bh(lock);
	list_cut_position(tx_list_head, tx_list, tail_entry);
	spin_unlock_bh(lock);
}

int sprdwl_add_topop_list(int chn, struct mbuf_t *head,
			   struct mbuf_t *tail, int num)
{
	struct sprdwl_intf *intf = get_intf();
	struct sprdwl_work *misc_work;
	struct sprdwl_pop_work pop_work;

	pop_work.chn = chn;
	pop_work.head = (void *)head;
	pop_work.tail = (void *)tail;
	pop_work.num = num;

	misc_work = sprdwl_alloc_work(sizeof(struct sprdwl_pop_work));
	if (!misc_work) {
		wl_err("%s out of memory\n", __func__);
		return -1;
	}
	misc_work->vif = NULL;
	misc_work->id = SPRDWL_POP_MBUF;
	memcpy(misc_work->data, &pop_work, sizeof(struct sprdwl_pop_work));

	sprdwl_queue_work(intf->priv, misc_work);
	return 0;
}

void sprdwl_count_tx_tp(struct sprdwl_tx_msg *tx_msg, int num)
{
	long long timeus = 0;
	struct sprdwl_intf *intf = get_intf();

	tx_msg->tx_data_num += num;
	if (tx_msg->tx_data_num == num) {
		tx_msg->txtimebegin = ktime_get();
		return;
	}

	tx_msg->txtimeend = ktime_get();
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)
	timeus = div_u64(tx_msg->txtimeend.tv64 - tx_msg->txtimebegin.tv64, NSEC_PER_USEC);
#else
	timeus = div_u64(tx_msg->txtimeend - tx_msg->txtimebegin, NSEC_PER_USEC);
#endif

	if(!timeus) {
		return;
	}

	if (div_u64((tx_msg->tx_data_num * 1000), timeus) >= intf->txnum_level &&
		tx_msg->tx_data_num >= 1000) {
		tx_msg->tx_data_num = 0;
#ifdef CPUFREQ_UPDATE_SUPPORT
		sprdwl_boost();
#endif /* CPUFREQ_UPDATE_SUPPORT */
	} else if (timeus >= USEC_PER_SEC) {
		tx_msg->tx_data_num = 0;
	}
}

unsigned long tx_packets;
int sprdwl_intf_tx_list(struct sprdwl_intf *dev,
			struct list_head *tx_list,
			struct list_head *tx_list_head,
			int tx_count,
			int ac_index,
			u8 coex_bt_on)
{
#define PCIE_TX_NUM 96
	int ret, i = 0, j = PCIE_TX_NUM, pcie_count = 0, cnt = 0, num = 0;
	struct sprdwl_msg_buf *msg_pos, *msg_temp;
	struct pcie_addr_buffer *addr_buffer = NULL;
	struct sprdwl_tx_msg *tx_msg;
	struct mbuf_t *head = NULL, *tail = NULL, *mbuf_pos;
	unsigned long pcie_addr = 0;
	/*struct sprdwl_data_hdr *hdr; *//*temp for test*/
	struct list_head *pos, *tx_list_tail, *n_list;
	unsigned long *msg_ptr;
	unsigned char *data_ptr;
	struct tx_msdu_dscr *dscr;
#if defined(MORE_DEBUG)
	unsigned long tx_bytes = 0;
#endif
	int tx_count_saved = tx_count;
	int list_num;

	if(dev->cp_asserted ==1)
		return 0;

	wl_debug("%s:%d tx_count is %d\n", __func__, __LINE__, tx_count);
	list_num = get_list_num(tx_list);
	if (list_num < tx_count) {
		wl_err("%s, %d, error!, tx_count:%d, list_num:%d\n",
				__func__, __LINE__, tx_count, list_num);
		WARN_ON(1);
	}
	tx_msg = (struct sprdwl_tx_msg *)dev->sprdwl_tx;
	sprdwl_count_tx_tp(tx_msg, tx_count);
	if (dev->priv->hw_type == SPRDWL_HW_PCIE) {
		if (tx_count <= PCIE_TX_NUM) {
			pcie_count = 1;
		} else {
			cnt = tx_count;
			while (cnt > PCIE_TX_NUM) {
				++num;
				cnt -= PCIE_TX_NUM;
			}
			pcie_count = num + 1;
		}
		ret = sprdwcn_bus_list_alloc(dev->tx_data_port, &head,
				      &tail, &pcie_count);
	} else {
		ret = sprdwcn_bus_list_alloc(dev->tx_data_port, &head,
				      &tail, &tx_count);
	}
	if (ret != 0 || head == NULL || tail == NULL) {
		wl_err("%s, %d, mbuf alloc fail\n",
		       __func__, __LINE__);
		sprdwcn_bus_list_free(dev->tx_data_port, head, tail, tx_count);
		return -ENOMEM;
	}
	if (tx_count_saved != tx_count) {
		wl_err("%s, %d error!mbuf not enough%d\n",
		       __func__, __LINE__, (tx_count_saved - tx_count));
		tx_msg->mbuf_short += (tx_count_saved - tx_count);
		sprdwcn_bus_list_free(dev->tx_data_port, head, tail, tx_count);
		return -ENOMEM;
	}
	mbufalloc += tx_count;

	mbuf_pos = head;
	if (dev->priv->hw_type == SPRDWL_HW_PCIE) {
		if (pcie_count > 1) {
			addr_buffer =
			sprdwl_set_pcie_addr_to_mbuf(tx_msg,
						     mbuf_pos, PCIE_TX_NUM);
		} else {
			addr_buffer =
			sprdwl_set_pcie_addr_to_mbuf(tx_msg,
						     mbuf_pos, tx_count);
		}
		if (addr_buffer == NULL) {
			wl_err("%s:%d alloc pcie addr buf fail\n",
			       __func__, __LINE__);
			return -1;
		}
	}
	list_for_each_safe(pos, n_list, tx_list) {
		msg_pos = list_entry(pos, struct sprdwl_msg_buf, list);
		sprdwl_move_tcpack_msg(dev->priv, msg_pos);
		data_ptr = (unsigned char *)(msg_pos->tran_data) -
			dev->hif_offset;
#ifdef OTT_UWE
		dscr = (struct tx_msdu_dscr *)(msg_pos->tran_data + FOUR_BYTES_ALIGN_OFFSET);
#else
		dscr = (struct tx_msdu_dscr *)(msg_pos->tran_data);
#endif
		dscr->color_bit = sprdwl_fc_set_clor_bit(tx_msg, i + 1);
/*TODO*/
		if (sprdwl_debug_level >= L_DBG) {
			int print_len = msg_pos->len;

			if (print_len > 200)
				print_len = 200;
			sprdwl_hex_dump("tx to cp2 data",
					(unsigned char *)(msg_pos->tran_data),
					print_len);
		}
#if defined(MORE_DEBUG)
		tx_bytes += msg_pos->skb->len;
#endif
		msg_ptr =
		(unsigned long *)(data_ptr - sizeof(unsigned long *));
		/*store msg_buf ptr to skb header room
		*for call back func free
		*/
		*msg_ptr = (unsigned long)msg_pos;
		if (dev->priv->hw_type == SPRDWL_HW_PCIE) {
			if (pcie_count > 1 && num > 0 && i >= j) {
				if (--num == 0) {
					if (cnt > 0)
						addr_buffer =
						sprdwl_set_pcie_addr_to_mbuf(
						tx_msg, mbuf_pos, cnt);
				} else {
					/*if data num greater than PCIE_TX_NUM,
					*alloc another pcie addr buf
					*/
					j += PCIE_TX_NUM;
						addr_buffer =
						sprdwl_set_pcie_addr_to_mbuf(
						tx_msg, mbuf_pos, PCIE_TX_NUM);
				}
				if (addr_buffer == NULL) {
					wl_err("%s:%d alloc pcie addr buf fail\n",
					       __func__, __LINE__);
					return -1;
				}
			}

			pcie_addr =
				mm_virt_to_phys(&dev->pdev->dev,
						msg_pos->tran_data,
						msg_pos->len, DMA_TO_DEVICE);
			memcpy(&addr_buffer->pcie_addr[i],
			       &pcie_addr, SPRDWL_PHYS_LEN);
		} else {
			mbuf_pos->buf = data_ptr;
			mbuf_pos->len = msg_pos->len;
			/*TODO, to check msgbuf before list push*/
			msg_temp = GET_MSG_BUF(mbuf_pos);
			if (!virt_addr_valid(msg_temp) ||
			    !virt_addr_valid(msg_temp->skb))
				BUG_ON(1);
		}
		mbuf_pos = mbuf_pos->next;
		if (++i == tx_count)
			break;
	}

	tx_list_tail = pos;
	sprdwl_list_cut_position(tx_list_head, tx_list, tx_list_tail,
				 ac_index);
	sprdwl_add_to_free_list(tx_msg, tx_list_head, tx_count);

	if (dev->priv->hw_type == SPRDWL_HW_PCIE) {
		/*ret = sprdwcn_bus_push_list(dev->tx_data_port, head, tail,*/
		/*pcie_count);*/
		/*edma sync function*/
		ret = sprdwcn_bus_push_link_wait_complete(dev->tx_data_port, head,
						   tail, pcie_count, 50000);
		if (ret != 0) {
			for (mbuf_pos = head; mbuf_pos != NULL;
				mbuf_pos = mbuf_pos->next) {
				kfree(mbuf_pos->buf);
				mbuf_pos->buf = NULL;
				if (--pcie_count == 0)
					break;
			}
			sprdwcn_bus_list_free(dev->tx_data_port, head, tail,
				       pcie_count);
			/*add data list to tx list header if tx fail*/
			sprdwl_add_tx_list_head(tx_list_head,
						tx_list, ac_index, tx_count);
			wl_err("%s:%d Tx pcie addr buf fail\n",
			       __func__, __LINE__);
		} else {
#if defined(MORE_DEBUG)
			UPDATE_TX_PACKETS(dev, tx_count, tx_bytes);
#endif
			INIT_LIST_HEAD(tx_list_head);
		}
		return ret;
	}

	/*BT is on: call sdiohal_txthread to send data.*/
	if (dev->priv->hw_type == SPRDWL_HW_SDIO) {
		if (coex_bt_on)
			ret = sprdwcn_bus_push_list(dev->tx_data_port,
						    head, tail, tx_count);
		else
			ret = sprdwcn_bus_push_list_direct(dev->tx_data_port,
							   head, tail, tx_count);
	} else {
		ret = sprdwcn_bus_push_list(dev->tx_data_port,
					    head, tail, tx_count);
	}

	if (ret != 0) {
		sprdwcn_bus_list_free(dev->tx_data_port, head, tail, tx_count);
		sprdwl_add_tx_list_head(tx_list_head, tx_list,
					ac_index, tx_count);
		wl_err("%s:%d err Tx data fail\n", __func__, __LINE__);
		mbufalloc -= tx_count;
	} else {
#if defined(MORE_DEBUG)
		UPDATE_TX_PACKETS(dev, tx_count, tx_bytes);
#endif
		INIT_LIST_HEAD(tx_list_head);
		tx_packets += tx_count;
		wl_info("%s, %d, tx_count=%d, total=%lu, mbufalloc=%lu, mbufpop=%lu\n",
			__func__, __LINE__, tx_count, tx_packets,
			mbufalloc, mbufpop);/*TODO*/
		if (dev->priv->hw_type == SPRDWL_HW_SDIO) {
			if (!coex_bt_on)
				sprdwl_add_topop_list(dev->tx_data_port,
						      head, tail, tx_count);
		}
	}

	return ret;
}

struct sprdwl_peer_entry
*sprdwl_find_peer_entry_using_addr(struct sprdwl_vif *vif, u8 *addr)
{
	struct sprdwl_intf *intf;
	struct sprdwl_peer_entry *peer_entry = NULL;
	u8 i;

	intf = (struct sprdwl_intf *)vif->priv->hw_priv;
	for (i = 0; i < MAX_LUT_NUM; i++) {
		if (ether_addr_equal(intf->peer_entry[i].tx.da, addr)) {
			peer_entry = &intf->peer_entry[i];
			break;
		}
	}
	if (!peer_entry)
		wl_err("not find peer_entry at :%s\n", __func__);

	return peer_entry;
}

/* It is tx private function, just use in sprdwl_intf_fill_msdu_dscr()  */
unsigned char sprdwl_find_lut_index(struct sprdwl_intf *intf,
				    struct sprdwl_vif *vif)
{
	u8 ret;
	unsigned char i;

	if (intf->skb_da == NULL)/*TODO*/
		goto out;

	wl_debug("%s,bssid: %02x:%02x:%02x:%02x:%02x:%02x\n", __func__,
		 intf->skb_da[0], intf->skb_da[1], intf->skb_da[2],
		 intf->skb_da[3], intf->skb_da[4], intf->skb_da[5]);
	if (sprdwl_is_group(intf->skb_da) &&
	    (vif->mode == SPRDWL_MODE_AP || vif->mode == SPRDWL_MODE_P2P_GO)) {
		for (i = 0; i < MAX_LUT_NUM; i++) {
			if ((sprdwl_is_group(intf->peer_entry[i].tx.da)) &&
			    (intf->peer_entry[i].ctx_id == vif->ctx_id)) {
				wl_info("%s, %d, group lut_index=%d\n",
					__func__, __LINE__,
					intf->peer_entry[i].lut_index);
				return intf->peer_entry[i].lut_index;
			}
		}
		if (vif->mode == SPRDWL_MODE_AP) {
			wl_info("%s,AP mode, group bssid,\n"
				"lut not found, ctx_id:%d, return lut:4\n",
				__func__, vif->ctx_id);
			return 4;
		}
		if (vif->mode == SPRDWL_MODE_P2P_GO) {
			wl_info("%s,GO mode, group bssid,\n"
				"lut not found, ctx_id:%d, return lut:5\n",
				__func__, vif->ctx_id);
			return 5;
		}
	}

	for (i = 0; i < MAX_LUT_NUM; i++) {
		if ((0 == memcmp(intf->peer_entry[i].tx.da,
				 intf->skb_da, ETH_ALEN)) &&
		    (intf->peer_entry[i].ctx_id == vif->ctx_id)) {
			wl_debug("%s, %d, lut_index=%d\n",
				 __func__, __LINE__,
				 intf->peer_entry[i].lut_index);
			return intf->peer_entry[i].lut_index;
		}
	}

	for (i = 0; i < MAX_LUT_NUM; i++) {
		if ((vif->mode == SPRDWL_MODE_STATION ||
		     vif->mode == SPRDWL_MODE_P2P_CLIENT) &&
		    (intf->peer_entry[i].ctx_id == vif->ctx_id)) {
			wl_debug("%s, %d, lut_index=%d\n",
				 __func__, __LINE__,
				 intf->peer_entry[i].lut_index);
			return intf->peer_entry[i].lut_index;
		}
	}

out:
	switch (vif->mode) {
	case SPRDWL_MODE_AP:
		ret = 4;
		break;

	case SPRDWL_MODE_P2P_GO:
		ret = 5;
		break;

	default:
		ret = 0;
		break;
	}

	wl_err("ctx_id = %d, sm_state = %d, bssid =%pM\n",
			vif->ctx_id, vif->sm_state, intf->skb_da);

	return ret;
}

int sprdwl_intf_fill_msdu_dscr(struct sprdwl_vif *vif,
			       struct sk_buff *skb,
				   u8 type,
			       u8 offset)
{
	u8 protocol;
	struct tx_msdu_dscr *dscr;
	struct sprdwl_intf *dev;
	u8 lut_index;
	struct sk_buff *temp_skb;
	unsigned char dscr_rsvd = 0;
	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
	u8 is_special_data = 0;
	bool is_vowifi2cmd = false;
#define DSCR_LEN	11
#define MSG_PTR_LEN 8

	if (ethhdr->h_proto == htons(ETH_P_ARP) ||
		ethhdr->h_proto == htons(ETH_P_TDLS) ||
		ethhdr->h_proto == htons(ETH_P_PREAUTH))
		is_special_data = 1;
	else if ((type == SPRDWL_TYPE_CMD) &&
		 is_vowifi_pkt(skb, &is_vowifi2cmd))
		is_special_data = 1;

	dev = (struct sprdwl_intf *)(vif->priv->hw_priv);
	dscr_rsvd = INTF_IS_PCIE ? MSDU_DSCR_RSVD : 0;
	if (skb_headroom(skb) < (DSCR_LEN + dev->hif_offset +
		MSG_PTR_LEN + dscr_rsvd)) {
		temp_skb = skb;

		skb = skb_realloc_headroom(skb, (DSCR_LEN + dev->hif_offset +
						 MSG_PTR_LEN + dscr_rsvd));
		kfree_skb(temp_skb);
		if (skb == NULL) {
			wl_err("%s:%d failed to unshare skbuff: NULL\n",
			       __func__, __LINE__);
			return -EPERM;
		}
#if defined(MORE_DEBUG)
		dev->stats.tx_realloc++;
#endif
	}

	dev->skb_da = skb->data;

	lut_index = sprdwl_find_lut_index(dev, vif);
	if ((lut_index < 6) && (!sprdwl_is_group(dev->skb_da))) {
		wl_err("%s, %d, sta disconn, no data tx!", __func__, __LINE__);
		return -EPERM;
	}
	skb_push(skb, sizeof(struct tx_msdu_dscr) + offset + dscr_rsvd);
	dscr = (struct tx_msdu_dscr *)(skb->data);
	memset(dscr, 0x00, sizeof(struct tx_msdu_dscr));
	dscr->common.type = (type == SPRDWL_TYPE_CMD ?
		SPRDWL_TYPE_CMD : SPRDWL_TYPE_DATA);
	dscr->common.direction_ind = 0;
	dscr->common.need_rsp = 0;/*TODO*/
	dscr->common.interface = vif->ctx_id;
	dscr->pkt_len = cpu_to_le16(skb->len - DSCR_LEN - dscr_rsvd);
	dscr->offset = DSCR_LEN;
/*TODO*/
	dscr->tx_ctrl.sw_rate = (is_special_data == 1 ? 1 : 0);
	dscr->tx_ctrl.wds = 0; /*TBD*/
	dscr->tx_ctrl.swq_flag = 0; /*TBD*/
	dscr->tx_ctrl.rsvd = 0; /*TBD*/
	dscr->tx_ctrl.next_buffer_type = 0;
	dscr->tx_ctrl.pcie_mh_readcomp = 0;
	dscr->buffer_info.msdu_tid = 0;
	dscr->buffer_info.mac_data_offset = 0;
	dscr->sta_lut_index = lut_index;

	if (skb->ip_summed == CHECKSUM_PARTIAL) {
		dscr->tx_ctrl.checksum_offload = 1;
		if (ethhdr->h_proto == htons(ETH_P_IPV6))
			protocol = ipv6_hdr(skb)->nexthdr;
		else
			protocol = ip_hdr(skb)->protocol;

		dscr->tx_ctrl.checksum_type =
			protocol == IPPROTO_TCP ? 1 : 0;
		dscr->tcp_udp_header_offset =
			skb->transport_header - skb->mac_header;
		wl_debug("%s: offload: offset: %d, protocol: %d\n",
			 __func__, dscr->tcp_udp_header_offset, protocol);
	}

	return 0;
}

#if defined FPGA_LOOPBACK_TEST
unsigned char tx_ipv4_udp[] = {
0x02, 0x04, 0x00, 0x01, 0x00, 0x06, 0x40, 0x45,
0xda, 0xf0, 0xff, 0x7e, 0x08, 0x00, 0x45, 0x00,
0x00, 0xe4, 0xc8, 0xc0, 0x40, 0x00, 0x40, 0x11,
0x8d, 0xb2, 0xc0, 0xa8, 0x31, 0x01, 0xc0, 0xa8,
0x31, 0x44, 0x67, 0x62, 0x3c, 0xbe, 0x00, 0xd0,
0xa0, 0x26, 0x80, 0x21, 0x81, 0x4b, 0x03, 0x68,
0x2b, 0x37, 0xde, 0xad, 0xbe, 0xef, 0x47, 0x10,
0x11, 0x35, 0xb1, 0x00, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00,
0x00, 0x00, 0xAA, 0xBB};

unsigned char tx_arp[] = {
0x02, 0x00, 0x00, 0x01, 0x00, 0x06, 0x74, 0x27,
0xea, 0xc8, 0x3e, 0x69, 0x08, 0x06, 0x00, 0x01,
0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0x74, 0x27,
0xea, 0xc8, 0x3e, 0x69, 0xc0, 0xa8, 0x01, 0x14,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8,
0x01, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xaa, 0xbb};

int sprdwl_intf_tx_data_fpga_test(struct sprdwl_intf *intf,
				  unsigned char *data, int len)
{
	struct sprdwl_msg_buf *msg;
	struct sk_buff *skb;
	int ret;

	wl_debug("%s: #%d start\n", __func__,  intf->loopback_n);
	msg = sprdwl_get_msg_buf(intf, SPRDWL_TYPE_DATA,
				 SPRDWL_MODE_STATION, 1);
	if (!msg) {
		wl_err("%s:%d get msg buf failed\n", __func__, __LINE__);
		return -1;
	}
	if (data == NULL) {
		skb = dev_alloc_skb(244 + NET_IP_ALIGN);
		skb_reserve(skb, NET_IP_ALIGN);
		memcpy(skb->data, tx_ipv4_udp, 244);
		skb_put(skb, 244);
	} else {
		skb = dev_alloc_skb(len + NET_IP_ALIGN);
		skb_reserve(skb, NET_IP_ALIGN);
		memcpy(skb->data, data, len);
		skb_put(skb, len);
	}
	ret = sprdwl_send_data_fpga_test(intf->priv,
					 msg, skb, SPRDWL_TYPE_DATA, 0);
	wl_debug("%s:%d loopback_n#%d end ret=%d\n", __func__, __LINE__,
		 intf->loopback_n, ret);
	intf->loopback_n++;
	return ret;
}

int sprdwl_intf_fill_msdu_dscr_test(struct sprdwl_priv *priv,
				    struct sk_buff *skb,
				    u8 type,
				    u8 offset)
{
	struct tx_msdu_dscr *dscr;
	struct sprdwl_intf *dev;
	u8 lut_index;
	struct sk_buff *temp_skb;
#define DSCR_LEN	11
#define MSG_PTR_LEN 8

	if (skb_headroom(skb) < (DSCR_LEN + intf->hif_offset + MSG_PTR_LEN)) {
		temp_skb = skb;

		skb = skb_realloc_headroom(skb, (DSCR_LEN + intf->hif_offset +
						 MSG_PTR_LEN));
		kfree_skb(temp_skb);
		if (skb == NULL) {
			wl_err("%s:%d failed to realloc skbuff: NULL\n",
			       __func__, __LINE__);
			return 0;
		}
	}
	dev = (struct sprdwl_intf *)(priv->hw_priv);
	dev->skb_da = skb->data;
	lut_index = sprdwl_find_index_using_addr(dev);
	skb_push(skb, sizeof(struct tx_msdu_dscr) + offset);
	dscr = (struct tx_msdu_dscr *)(skb->data);
	dscr->common.type = type;
	dscr->pkt_len = cpu_to_le16(skb->len - (DSCR_LEN));
	dscr->offset = DSCR_LEN;
	dscr->tx_ctrl.checksum_offload = 1;
	dscr->tx_ctrl.checksum_type =
		ip_hdr(skb)->protocol == IPPROTO_TCP ? 1 : 0;
	dscr->tx_ctrl.sw_rate = (type == SPRDWL_TYPE_DATA ? 0 : 1);
	dscr->tx_ctrl.wds = 0;
	dscr->sta_lut_index = lut_index;
	dscr->tcp_udp_header_offset = 34;
	return 1;
}
#endif

int sprdwl_rx_fill_mbuf(struct mbuf_t *head, struct mbuf_t *tail, int num, int len)
{
	struct sprdwl_intf *intf = get_intf();
	int ret = 0, count = 0;
	struct mbuf_t *pos = NULL;

	for (pos = head, count = 0; count < num; count++) {
		pos->len = ALIGN(len, SMP_CACHE_BYTES);
		pos->buf = netdev_alloc_frag(pos->len);
		pos->phy = mm_virt_to_phys(&intf->pdev->dev, pos->buf,
					   pos->len, DMA_FROM_DEVICE);
		if (unlikely(!pos->buf)) {
			ret = -ENOMEM;
			break;
		}
		pos = pos->next;
	}

	if (ret) {
		pos = head;
		while (count--) {
			sprdwl_free_data(pos->buf, SPRDWL_DEFRAG_MEM);
			pos = pos->next;
		}
	}

	return ret;
}

int sprdwl_rx_common_push(int chn, struct mbuf_t **head, struct mbuf_t **tail,
			  int *num, int len)
{
	int ret = 0;

	ret = sprdwcn_bus_list_alloc(chn, head, tail, num);
	if (ret || head == NULL) {
		wl_err("%s:%d sprdwcn_bus_list_alloc fail\n", __func__, __LINE__);
		ret = -ENOMEM;
	} else {
		ret = sprdwl_rx_fill_mbuf(*head, *tail, *num, len);
		if (ret) {
			wl_err("%s: alloc buf fail\n", __func__);
			sprdwcn_bus_list_free(chn, *head, *tail, *num);
			*head = NULL;
			*tail = NULL;
			*num = 0;
		}
	}

	return ret;
}

inline void *sprdwl_get_rx_data(struct sprdwl_intf *intf,
				void *pos, void **data,
				void **tran_data, int *len, int offset)
{
	struct mbuf_t *mbuf = (struct mbuf_t *)pos;

	if (intf->priv->hw_type == SPRDWL_HW_PCIE) {
		mm_phys_to_virt(&intf->pdev->dev, mbuf->phy, mbuf->len,
				DMA_FROM_DEVICE, false);
		mbuf->phy = 0;
	}

	*tran_data = mbuf->buf;
	*data = (*tran_data) + offset;
	*len = mbuf->len;
	mbuf->buf = NULL;

	return (void *)mbuf->next;
}

inline void sprdwl_free_rx_data(struct sprdwl_intf *intf,
				int chn, void *head, void *tail, int num)
{
	int len = 0, ret = 0;

	/* We should refill mbuf in pcie mode */
	if (intf->priv->hw_type == SPRDWL_HW_PCIE) {
		if (intf->rx_cmd_port == chn)
			len = SPRDWL_MAX_CMD_RXLEN;
		else
			len = SPRDWL_MAX_DATA_RXLEN;

		ret = sprdwl_rx_fill_mbuf(head, tail, num, len);
		if (ret) {
			wl_err("%s: alloc buf fail\n", __func__);
			sprdwcn_bus_list_free(chn, (struct mbuf_t *)head,
				       (struct mbuf_t *)tail, num);
			head = NULL;
			tail = NULL;
			num = 0;
		}
	}

	if (!ret)
		sprdwcn_bus_push_list(chn, (struct mbuf_t *)head, (struct mbuf_t *)tail, num);
}

void sprdwl_count_rx_tp(struct sprdwl_rx_if *rx_if, int num)
{
	long long timeus = 0;
	struct sprdwl_intf *intf = get_intf();

	rx_if->rx_data_num += num;
	if (rx_if->rx_data_num == num) {
		rx_if->rxtimebegin = ktime_get();
		return;
	}

	rx_if->rxtimeend = ktime_get();
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)
	timeus = div_u64(rx_if->rxtimeend.tv64 - rx_if->rxtimebegin.tv64, NSEC_PER_USEC);
#else
	timeus = div_u64(rx_if->rxtimeend - rx_if->rxtimebegin, NSEC_PER_USEC);
#endif

	if(!timeus) {
		return;
	}

	if (div_u64((rx_if->rx_data_num * 1000), timeus) >= intf->rxnum_level &&
		rx_if->rx_data_num >= 1000) {
		rx_if->rx_data_num = 0;
#ifdef CPUFREQ_UPDATE_SUPPORT
		sprdwl_boost();
#endif /* CPUFREQ_UPDATE_SUPPORT */
	} else if (timeus >= USEC_PER_SEC) {
		rx_if->rx_data_num = 0;
	}
}

static int check_msdu_early(struct sprdwl_intf *intf, struct mbuf_t *mbuf)
{
	struct rx_msdu_desc *msdu_desc =
		(struct rx_msdu_desc *)(mbuf->buf + intf->hif_offset);

	if (mbuf->len < msdu_desc->msdu_len ||
	    msdu_desc->msdu_len > 1600) {
		wl_err("%s, %d, %d, %d\n", __func__, __LINE__, mbuf->len, msdu_desc->msdu_len);
		return -1;
	}
	return 0;
}

static int intf_rx_handle(int chn, struct mbuf_t *head,
				   struct mbuf_t *tail, int num)
{
	struct sprdwl_intf *intf = get_intf();
	struct sprdwl_rx_if *rx_if = (struct sprdwl_rx_if *)intf->sprdwl_rx;
	struct sprdwl_msg_buf *msg = NULL;

	wl_debug("%s: channel:%d head:%p tail:%p num:%d\n",
		__func__, chn, head, tail, num);
	if ((intf->priv->hw_type == SPRDWL_HW_SDIO && chn == SDIO_RX_DATA_PORT) ||
		(intf->priv->hw_type == SPRDWL_HW_USB && chn == USB_RX_DATA_PORT))
		sprdwl_count_rx_tp(rx_if, num);

	/*To process credit earlier*/
	if (intf->priv->hw_type == SPRDWL_HW_SDIO ||
		intf->priv->hw_type == SPRDWL_HW_USB) {
		unsigned int i = 0;
		struct mbuf_t *mbuf = NULL;

		mbuf = head;
		for (i = num; i > 0; i--) {
			sprdwl_sdio_process_credit(intf,
				(void *)(mbuf->buf + intf->hif_offset));
			if (intf->priv->hw_type == SPRDWL_HW_USB &&
			    chn == USB_RX_DATA_PORT &&
			    check_msdu_early(intf, mbuf)) {
				sprdwcn_bus_push_list(chn, head, tail, num);
				return 0;
			}

			mbuf = mbuf->next;
		}
	}

	/* FIXME: Should we use replace msg? */
	msg = sprdwl_alloc_msg_buf(&rx_if->rx_list);
	if (!msg) {
		wl_err("%s: no msgbuf\n", __func__);
		sprdwcn_bus_push_list(chn, head, tail, num);
		return 0;
	}

	sprdwl_fill_msg(msg, NULL, (void *)head, num);
	msg->fifo_id = chn;
	msg->buffer_type = SPRDWL_DEFRAG_MEM;
	msg->data = (void *)tail;

	sprdwl_queue_msg_buf(msg, &rx_if->rx_list);
#ifdef SPRD_RX_THREAD
	rx_up(rx_if);
#else
	queue_work(rx_if->rx_queue, &rx_if->rx_work);
#endif
	return 0;
}

void sprdwl_handle_pop_list(void *data)
{
	int i;
	struct sprdwl_msg_buf *msg_pos;
	struct mbuf_t *mbuf_pos = NULL;
	struct sprdwl_pop_work *pop = (struct sprdwl_pop_work *)data;
	struct sprdwl_tx_msg *tx_msg;
	struct sprdwl_intf *intf = get_intf();
	struct list_head tmp_list;
	struct sprdwl_msg_buf *msg_head, *msg_tail;

	tx_msg = (struct sprdwl_tx_msg *)intf->sprdwl_tx;
	mbuf_pos = (struct mbuf_t *)pop->head;
	msg_pos = GET_MSG_BUF(mbuf_pos);

	msg_head = GET_MSG_BUF((struct mbuf_t *)pop->head);
	msg_tail = GET_MSG_BUF((struct mbuf_t *)pop->tail);

	spin_lock_bh(&tx_msg->xmit_msg_list.free_lock);
	list_cut_position(&tmp_list, msg_head->list.prev, &msg_tail->list);
	spin_unlock_bh(&tx_msg->xmit_msg_list.free_lock);

	for (i = 0; i < pop->num; i++) {
		msg_pos = GET_MSG_BUF(mbuf_pos);
		dev_kfree_skb(msg_pos->skb);
		mbuf_pos = mbuf_pos->next;
	}

	spin_lock_bh(&tx_msg->tx_list_qos_pool.freelock);
	list_splice_tail(&tmp_list, &msg_pos->msglist->freelist);
	spin_unlock_bh(&tx_msg->tx_list_qos_pool.freelock);
	sprdwcn_bus_list_free(pop->chn,
			      pop->head,
			      pop->tail,
			      pop->num);
	mbufpop += pop->num;
}

/*call back func for HIF pop_link*/
int sprdwl_tx_data_pop_list(int channel, struct mbuf_t *head, struct mbuf_t *tail, int num)
{
	struct mbuf_t *mbuf_pos = NULL;
#if defined(MORE_DEBUG)
	struct sprdwl_msg_buf *msg_head;
#endif
	struct sprdwl_intf *intf = get_intf();

	wl_debug("%s channel: %d, head: %p, tail: %p num: %d\n",
		__func__, channel, head, tail, num);

	if (intf->priv->hw_type == SPRDWL_HW_PCIE) {
		/* FIXME: Temp solution, addr node pos hard to sync dma */
		for (mbuf_pos = head; mbuf_pos != NULL;
		mbuf_pos = mbuf_pos->next) {
			mm_phys_to_virt(&intf->pdev->dev, mbuf_pos->phy,
					mbuf_pos->len, DMA_TO_DEVICE, false);
			mbuf_pos->phy = 0;
			kfree(mbuf_pos->buf);
			mbuf_pos->buf = NULL;
			if (--num == 0)
				break;
		}
		sprdwcn_bus_list_free(channel, head, tail, num);
		wl_info("%s:%d free : %d msg buf\n", __func__, __LINE__, num);
		return 0;
	}
#if defined(MORE_DEBUG)
	msg_head = GET_MSG_BUF(head);
	/*show packet average sent time, unit: ns*/
	sprdwl_get_tx_avg_time(intf, msg_head->tx_start_time);
#endif

	sprdwl_add_topop_list(channel, head, tail, num);
	wl_debug("%s:%d free : %d msg buf\n", __func__, __LINE__, num);

	return 0;
}

/*free PCIe data when receive txc event from cp*/
int sprdwl_tx_free_pcie_data(struct sprdwl_intf *dev, unsigned char *data,
			     unsigned short len)
{
	int i;
	struct sprdwl_tx_msg *tx_msg;
	unsigned char *data_addr_ptr;
	unsigned long pcie_addr, timeout;
	unsigned short  data_num;
	struct list_head *free_list;
	struct txc_addr_buff *txc_addr;
	unsigned char (*pos)[5];
	struct sprdwl_msg_buf *msg_buf, *pos_buf, *temp_buf;
#if defined(MORE_DEBUG)
	unsigned long tx_start_time = 0;
#endif

	txc_addr = (struct txc_addr_buff *)data;
	data_num = txc_addr->number;
	pos = (unsigned char (*)[5])(txc_addr + 1);
	for (i = 0; i < data_num; i++, pos++) {
		memcpy(&pcie_addr, pos, SPRDWL_PHYS_LEN);
		data_addr_ptr = (unsigned char *)
		mm_phys_to_virt(&dev->pdev->dev, pcie_addr,
				SPRDWL_MAX_DATA_TXLEN, DMA_TO_DEVICE, true);
		msg_buf = (struct sprdwl_msg_buf *)
		(data_addr_ptr - (sizeof(unsigned long *) + dev->hif_offset));
#if defined(MORE_DEBUG)
		if (i == 0)
			tx_start_time = msg_buf->tx_start_time;
#endif
		dev_kfree_skb(msg_buf->skb);
		sprdwl_dequeue_data_buf(msg_buf);
	}
#if defined(MORE_DEBUG)
	sprdwl_get_tx_avg_time(dev, tx_start_time);
#endif
	tx_msg = (struct sprdwl_tx_msg *)dev->sprdwl_tx;
	free_list = &tx_msg->xmit_msg_list.to_free_list;
	/*if cp fail to sent txc event, data will be freed timeout*/
	if (!list_empty(free_list)) {
		timeout = msecs_to_jiffies(SPRDWL_TX_DATA_TIMEOUT);
		list_for_each_entry_safe(pos_buf,
					 temp_buf, free_list, list) {
			if (time_after(jiffies, pos_buf->timeout + timeout)) {
				dev_kfree_skb(pos_buf->skb);
				sprdwl_dequeue_data_buf(pos_buf);
			} else {
				return 0;
			}
		}
	}
	return 0;
}

int sprdwl_tx_cmd_pop_list(int channel, struct mbuf_t *head, struct mbuf_t *tail, int num)
{
	int count = 0;
	struct mbuf_t *pos = NULL;
	struct sprdwl_intf *intf = get_intf();
	struct sprdwl_tx_msg *tx_msg;
	struct sprdwl_msg_buf *pos_buf, *temp_buf;

	wl_debug("%s channel: %d, head: %p, tail: %p num: %d\n",
		 __func__, channel, head, tail, num);

	tx_msg = (struct sprdwl_tx_msg *)intf->sprdwl_tx;

	wl_debug("%s len: %d buf: %s\n", __func__, head->len, head->buf + 4);

	pos = head;

	list_for_each_entry_safe(pos_buf, temp_buf,
				 &tx_msg->tx_list_cmd.cmd_to_free, list) {
		if (pos_buf->tran_data == pos->buf) {
			wl_debug("move CMD node from to_free to free list\n");
			/*list msg_buf from to_free list  to free list*/
			sprdwl_free_cmd_buf(pos_buf, &tx_msg->tx_list_cmd);

			if (intf->priv->hw_type == SPRDWL_HW_PCIE) {
				mm_phys_to_virt(&intf->pdev->dev, pos->phy,
						pos->len, DMA_TO_DEVICE, false);
				pos->phy = 0;
			}
			/*free it*/
			kfree(pos->buf);
			pos->buf = NULL;
			pos = pos->next;
			count++;
		}
		if (count == num)
			break;
	}

	tx_msg->cmd_poped += num;
	mbufpop += num;
	wl_info("tx_cmd_pop add num: %d=cmd_poped%d, cmd_send%d\n",
		num, tx_msg->cmd_poped, tx_msg->cmd_send);
	sprdwcn_bus_list_free(channel, head, tail, num);

	return 0;
}

int sprdwl_rx_cmd_push(int chn, struct mbuf_t **head, struct mbuf_t **tail, int *num)
{
	return sprdwl_rx_common_push(chn, head, tail,
				     num, SPRDWL_MAX_CMD_RXLEN);
}

int sprdwl_rx_data_push(int chn, struct mbuf_t **head, struct mbuf_t **tail, int *num)
{
	return sprdwl_rx_common_push(chn, head, tail,
				     num, SPRDWL_MAX_DATA_RXLEN);
}

/*
 * mode:
 * 0 - suspend
 * 1 - resume
 */
int sprdwl_suspend_resume_handle(int chn, int mode)
{
	struct sprdwl_intf *intf = get_intf();
	struct sprdwl_priv *priv = intf->priv;
	struct sprdwl_tx_msg *tx_msg = (struct sprdwl_tx_msg *)intf->sprdwl_tx;
	int ret = -EBUSY;
	struct sprdwl_vif *vif;
	struct timespec time;
	enum sprdwl_mode sprdwl_mode = SPRDWL_MODE_STATION;
	u8 mode_found = 0;

	for (sprdwl_mode = SPRDWL_MODE_STATION; sprdwl_mode < SPRDWL_MODE_MAX; sprdwl_mode++) {
		if (priv->fw_stat[sprdwl_mode] == SPRDWL_INTF_OPEN) {
			mode_found = 1;
			break;
		}
	}

	if (0 == mode_found) {
		wl_err("%s suspend failed, mode not found\n", __func__);
		return -EBUSY;
	}

	vif = mode_to_vif(priv, sprdwl_mode);
	if (vif == NULL || intf->cp_asserted) {
		wl_err("%s, %d, error! NULL vif or assert\n", __func__, __LINE__);
		sprdwl_put_vif(vif);
		return -EBUSY;
	}

	if (mode == 0) {
		if (atomic_read(&tx_msg->tx_list_qos_pool.ref) > 0 ||
			atomic_read(&tx_msg->tx_list_cmd.ref) > 0 ||
			!list_empty(&tx_msg->xmit_msg_list.to_send_list) ||
			!list_empty(&tx_msg->xmit_msg_list.to_free_list)) {
			wl_info("%s, %d,Q not empty suspend not allowed\n",
				__func__, __LINE__);
			sprdwl_put_vif(vif);
			return -EBUSY;
		}
		priv->wakeup_tracer.resume_flag = 0;
		intf->suspend_mode = SPRDWL_PS_SUSPENDING;

		if ((vif->mode == SPRDWL_MODE_STATION) && (vif->sm_state == SPRDWL_CONNECTED)
			&& (sprdwcn_bus_get_wl_wake_host_en() == SPRDWL_NO_WAKE_HOST)) {
			vif->suspend_resume_connect.reconnect_flag = true;
			priv->is_suspending = 1;
			sprdwl_cfg80211_disconnect(NULL, vif->ndev, 0);
		}

		/* if cp2 is wakeup, send power_down firstly */
		if (intf->fw_power_down != 1) {
			priv->is_suspending = 1;
			sprdwl_fw_power_down_ack(vif->priv, vif->ctx_id);
		}

		getnstimeofday(&time);
		intf->sleep_time = timespec_to_ns(&time);
		priv->is_suspending = 1;
		ret = sprdwl_power_save(priv,
					vif->ctx_id,
					SPRDWL_SUSPEND_RESUME,
					0);
		if (ret == 0)
			intf->suspend_mode = SPRDWL_PS_SUSPENDED;
		else
			intf->suspend_mode = SPRDWL_PS_RESUMED;

		wl_info("%s, %d,suspend ret=%d\n", __func__, __LINE__, ret);
	} else if (mode == 1) {
		intf->suspend_mode = SPRDWL_PS_RESUMING;
		priv->wakeup_tracer.resume_flag = 1;

		complete(&intf->suspend_completed);

		getnstimeofday(&time);
		intf->sleep_time = timespec_to_ns(&time) - intf->sleep_time;
		ret = sprdwl_power_save(priv,
					vif->ctx_id,
					SPRDWL_SUSPEND_RESUME,
					1);
		wl_info("%s, %d,resume ret=%d, resume after %lu ms\n",
			__func__, __LINE__,
			ret, intf->sleep_time/1000000);

		if ((vif->mode == SPRDWL_MODE_STATION) && (vif->suspend_resume_connect.reconnect_flag == true)) {
			sprdwl_cfg80211_connect(priv->wiphy, vif->ndev, &vif->suspend_resume_connect.connect_params);
			vif->suspend_resume_connect.reconnect_flag = false;
		}
	}
	sprdwl_put_vif(vif);
	return ret;
}

/*  SDIO TX:
 *  Type 3:WIFI
 *  Subtype 0  --> port 8
 *  Subtype 1  --> port 9
 *  Subtype 2  --> port 10(fifolen=8)
 *  Subtype 3  --> port 11(fifolen=8)
 *  SDIO RX:
 *  Type 3:WIFI
 *  Subtype 0  --> port 10
 *  Subtype 1  --> port 11
 *  Subtype 2  --> port 12(fifolen=8)
 *  Subtype 3  --> port 13(fifolen=8)
 */
struct mchn_ops_t sdio_hif_ops[] = {
	/* RX INTF */
	/* NOTE: Requested by SDIO team, pool_size MUST be 1 in RX */
	INIT_INTF(SDIO_RX_CMD_PORT, 0, 0, 0,
		  SPRDWL_MAX_CMD_RXLEN, 1, 0, 0, 0,
		  intf_rx_handle, NULL, NULL, NULL),
	INIT_INTF(SDIO_RX_PKT_LOG_PORT, 0, 0, 0,
		  SPRDWL_MAX_DATA_RXLEN, 1, 0, 0, 0,
		  intf_rx_handle, NULL, NULL, NULL),
	INIT_INTF(SDIO_RX_DATA_PORT, 0, 0, 0,
		  SPRDWL_MAX_DATA_RXLEN, 1, 0, 0, 0,
		  intf_rx_handle, NULL, NULL, NULL),

	/* TX INTF */
	INIT_INTF(SDIO_TX_CMD_PORT, 0, 1, 0,
		  SPRDWL_MAX_CMD_TXLEN, 10, 0, 0, 0,
		  sprdwl_tx_cmd_pop_list, NULL, NULL,
		  sprdwl_suspend_resume_handle),
	INIT_INTF(SDIO_TX_DATA_PORT, 0, 1, 0,
		  SPRDWL_MAX_DATA_TXLEN, 800, 0, 0, 0,
		  sprdwl_tx_data_pop_list, NULL, NULL, NULL),
};

struct mchn_ops_t pcie_hif_ops[] = {
	/* RX INTF */
	INIT_INTF(PCIE_RX_CMD_PORT, 1, 0, 0,
		  SPRDWL_MAX_CMD_RXLEN, 1, 0, 0, 0,
		  intf_rx_handle,
		  sprdwl_rx_cmd_push, NULL, NULL),
	INIT_INTF(PCIE_RX_DATA_PORT, 1, 0, 0,
		  SPRDWL_MAX_DATA_RXLEN, 1, 0, 0, 0,
		  intf_rx_handle,
		  sprdwl_rx_data_push, NULL, NULL),
	/* TX INTF */
	INIT_INTF(SDIO_TX_CMD_PORT, 1, 1, 0,
		  SPRDWL_MAX_CMD_TXLEN, 10, 0, 0, 0,
		  sprdwl_tx_cmd_pop_list, NULL, NULL, NULL),
	INIT_INTF(SDIO_TX_DATA_PORT, 1, 1, 0,
		  SPRDWL_MAX_DATA_TXLEN, 300, 0, 0, 0,
		  sprdwl_tx_data_pop_list, NULL, NULL, NULL)
};

struct mchn_ops_t usb_hif_ops[] = {
	/* RX INTF */
	INIT_INTF(USB_RX_CMD_PORT, 3, 0, 0,
		  SPRDWL_MAX_CMD_RXLEN, 10, 0, 0, 0,
		  intf_rx_handle, NULL, NULL, NULL),
	INIT_INTF(USB_RX_PKT_LOG_PORT, 3, 0, 0,
		  SPRDWL_MAX_DATA_RXLEN, 50, 0, 0, 0,
		  intf_rx_handle, NULL, NULL, NULL),
	INIT_INTF(USB_RX_DATA_PORT, 3, 0, 0,
		  SPRDWL_MAX_DATA_RXLEN, 1000, 0, 0, 0,
		  intf_rx_handle, NULL, NULL, NULL),

	/* TX INTF */
	INIT_INTF(USB_TX_CMD_PORT, 3, 1, 0,
		  SPRDWL_MAX_CMD_TXLEN, 100, 0, 0, 0,
		  sprdwl_tx_cmd_pop_list, NULL, NULL,
		  sprdwl_suspend_resume_handle),
	INIT_INTF(USB_TX_DATA_PORT, 3, 1, 0,
		  SPRDWL_MAX_DATA_TXLEN, 300, 0, 0, 0,
		  sprdwl_tx_data_pop_list, NULL, NULL, NULL),
};

struct sprdwl_peer_entry
*sprdwl_find_peer_entry_using_lut_index(struct sprdwl_intf *intf,
					unsigned char sta_lut_index)
{
	int i = 0;
	struct sprdwl_peer_entry *peer_entry = NULL;

	for (i = 0; i < MAX_LUT_NUM; i++) {
		if (sta_lut_index == intf->peer_entry[i].lut_index) {
			peer_entry = &intf->peer_entry[i];
			break;
		}
	}

	return peer_entry;
}

/* update lut-inidex if event_sta_lut received
 * at CP side, lut_index range 0-31
 * but 0-3 were used to send non-assoc frame(only used by CP)
 * so for Ap-CP interface, there is only 4-31
*/
void sprdwl_event_sta_lut(struct sprdwl_vif *vif, u8 *data, u16 len)
{
	struct sprdwl_intf *intf;
	struct sprdwl_sta_lut_ind *sta_lut = NULL;
	u8 i;

	if (len < sizeof(*sta_lut)) {
		wl_err("%s, len:%d too short!\n", __func__, len);
		return;
	}
	intf = (struct sprdwl_intf *)vif->priv->hw_priv;
	sta_lut = (struct sprdwl_sta_lut_ind *)data;
	if (intf != get_intf()) {
		wl_err("%s, wrong intf!\n", __func__);
		return;
	}
	if (sta_lut == NULL) {
		wl_err("%s, NULL input data!\n", __func__);
		return;
	}

	i = sta_lut->sta_lut_index;

	wl_debug("ctx_id:%d,action:%d,lut:%d\n", sta_lut->ctx_id,
		sta_lut->action, sta_lut->sta_lut_index);
	switch (sta_lut->action) {
	case DEL_LUT_INDEX:
		if (intf->peer_entry[i].ba_tx_done_map != 0) {
			intf->peer_entry[i].ht_enable = 0;
			intf->peer_entry[i].ip_acquired = 0;
			intf->peer_entry[i].ba_tx_done_map = 0;
			/*sprdwl_tx_delba(intf, intf->peer_entry + i);*/
		}
		peer_entry_delba((void *)intf, i);
		memset(&intf->peer_entry[i], 0x00,
		       sizeof(struct sprdwl_peer_entry));
		intf->peer_entry[i].ctx_id = 0xFF;
		intf->tx_num[i] = 0;
		sprdwl_dis_flush_txlist(intf, i);
		break;
	case UPD_LUT_INDEX:
		peer_entry_delba((void *)intf, i);
		sprdwl_dis_flush_txlist(intf, i);
	case ADD_LUT_INDEX:
		intf->peer_entry[i].lut_index = i;
		intf->peer_entry[i].ctx_id = sta_lut->ctx_id;
		intf->peer_entry[i].ht_enable = sta_lut->is_ht_enable;
		intf->peer_entry[i].vht_enable = sta_lut->is_vht_enable;
		intf->peer_entry[i].ba_tx_done_map = 0;
		intf->tx_num[i] = 0;

		wl_debug("ctx_id%d,action%d,lut%d,%x:%x:%x:%x:%x:%x\n",
			sta_lut->ctx_id, sta_lut->action,
			sta_lut->sta_lut_index,
			sta_lut->ra[0], sta_lut->ra[1], sta_lut->ra[2],
			sta_lut->ra[3], sta_lut->ra[4], sta_lut->ra[5]);
		ether_addr_copy(intf->peer_entry[i].tx.da, sta_lut->ra);
		break;
	default:
		break;
	}
}

void sprdwl_tx_ba_mgmt(struct sprdwl_priv *priv, void *data, int len,
		       unsigned char cmd_id, unsigned char ctx_id)
{
	struct sprdwl_msg_buf *msg;
	unsigned char *data_ptr;
	u8 *rbuf;
	u16 rlen = (1 + sizeof(struct host_addba_param));

	msg = sprdwl_cmd_getbuf(priv, len, ctx_id, SPRDWL_HEAD_RSP,
				cmd_id);
	if (!msg) {
		wl_err("%s, %d, get msg err\n", __func__, __LINE__);
		return;
	}
	rbuf = kzalloc(rlen, GFP_KERNEL);
	if (!rbuf) {
		wl_err("%s, %d, alloc rbuf err\n", __func__, __LINE__);
		return;
	}
	memcpy(msg->data, data, len);
	data_ptr = (unsigned char *)data;

	if (sprdwl_debug_level >= L_DBG)
		sprdwl_hex_dump("sprdwl_tx_ba_mgmt", data_ptr, len);

	if (sprdwl_cmd_send_recv(priv, msg, CMD_WAIT_TIMEOUT, rbuf, &rlen))
		goto out;
	/*if tx ba req failed, need to clear txba map*/
	if (cmd_id == WIFI_CMD_ADDBA_REQ &&
		rbuf[0] != ADDBA_REQ_RESULT_SUCCESS) {
		struct host_addba_param *addba;
		struct sprdwl_peer_entry *peer_entry = NULL;
		struct sprdwl_intf *intf = get_intf();
		u16 tid = 0;

		addba = (struct host_addba_param *)(rbuf + 1);
		peer_entry = &intf->peer_entry[addba->lut_index];
		tid = addba->addba_param.tid;
		if (!test_and_clear_bit(tid, &peer_entry->ba_tx_done_map))
			goto out;
		wl_err("%s, %d, tx_addba failed, reason=%d, lut_index=%d, tid=%d, map=%lu\n",
		       __func__, __LINE__,
		       rbuf[0],
		       addba->lut_index,
		       tid,
		       peer_entry->ba_tx_done_map);
	}
out:
	kfree(rbuf);
}

void sprdwl_tx_send_addba(struct sprdwl_vif *vif, void *data, int len)
{
	sprdwl_tx_ba_mgmt(vif->priv, data, len, WIFI_CMD_ADDBA_REQ,
			  vif->ctx_id);
}

void sprdwl_tx_send_delba(struct sprdwl_vif *vif, void *data, int len)
{
	u8 i;
	struct host_delba_param *delba;

	delba = (struct host_delba_param *)data;
	for (i = 0; i < SPRDWL_AC_MAX; i++)
			sprdwl_tx_ba_mgmt(vif->priv, delba + i,
					  sizeof(struct host_delba_param),
					  WIFI_CMD_DELBA_REQ,
					  vif->ctx_id);
}

void sprdwl_tx_addba(struct sprdwl_intf *intf,
		     struct sprdwl_peer_entry *peer_entry, unsigned char tid)
{
#define WIN_SIZE 64
	struct host_addba_param addba;
	struct sprdwl_work *misc_work;
	struct sprdwl_vif *vif;

	vif = ctx_id_to_vif(intf->priv, peer_entry->ctx_id);
	if (!vif)
		return;
	memset(&addba, 0x0, sizeof(struct host_addba_param));

	addba.lut_index = peer_entry->lut_index;
	ether_addr_copy(addba.perr_mac_addr, peer_entry->tx.da);
	wl_debug("%s, lut_index is %d\n", __func__, peer_entry->lut_index);
	addba.dialog_token = 1;
	addba.addba_param.amsdu_permit = 0;
	addba.addba_param.ba_policy = DOT11_ADDBA_POLICY_IMMEDIATE;
	addba.addba_param.tid = tid;
	addba.addba_param.buffer_size = WIN_SIZE;
	misc_work = sprdwl_alloc_work(sizeof(struct host_addba_param));
	if (!misc_work) {
		wl_err("%s out of memory\n", __func__);
		sprdwl_put_vif(vif);
		return;
	}
	misc_work->vif = vif;
	misc_work->id = SPRDWL_WORK_ADDBA;
	memcpy(misc_work->data, &addba, sizeof(struct host_addba_param));

	sprdwl_queue_work(vif->priv, misc_work);
	sprdwl_put_vif(vif);
}

void sprdwl_tx_delba(struct sprdwl_intf *intf,
		     struct sprdwl_peer_entry *peer_entry,  unsigned int ac_index)
{
	struct host_delba_param delba[SPRDWL_AC_MAX];
	struct sprdwl_work *misc_work;
	struct sprdwl_vif *vif;

	vif = ctx_id_to_vif(intf->priv, peer_entry->ctx_id);
	if (!vif)
		return;
	memset(delba, 0x0, sizeof(delba));

	wl_info("enter--at %s\n", __func__);
	ether_addr_copy(delba[ac_index].perr_mac_addr, peer_entry->tx.da);
	delba[ac_index].lut_index = peer_entry->lut_index;
	delba[ac_index].delba_param.initiator = 1;
	delba[ac_index].delba_param.tid = qos_index_2_tid(ac_index);
	delba[ac_index].reason_code = 0;


	misc_work =
	sprdwl_alloc_work(sizeof(struct host_delba_param) * SPRDWL_AC_MAX);
	if (!misc_work) {
		wl_err("%s out of memory\n", __func__);
		sprdwl_put_vif(vif);
		return;
	}
	misc_work->vif = vif;
	misc_work->id = SPRDWL_WORK_DELBA;
	memcpy(misc_work->data, delba,
	       sizeof(struct host_delba_param) * SPRDWL_AC_MAX);
	peer_entry->ht_enable = 0;
	peer_entry->ba_tx_done_map = 0;

	sprdwl_queue_work(vif->priv, misc_work);
	sprdwl_put_vif(vif);
}

#ifdef CPUFREQ_UPDATE_SUPPORT
int sprdwl_notifier_boost(struct notifier_block *nb, unsigned long event, void *data)
{
#if KERNEL_VERSION(5, 4, 19) <= LINUX_VERSION_CODE
	struct cpufreq_policy_data *policy = data;
#else
	struct cpufreq_policy *policy = data;
#endif
	unsigned long min_freq;
	unsigned long max_freq = policy->cpuinfo.max_freq;
	struct sprdwl_intf *intf = get_intf();
	u8 boost;

	if(NULL == intf)
		return NOTIFY_DONE;

	boost = intf->boost;

#if KERNEL_VERSION(5, 4, 0) <= LINUX_VERSION_CODE
	if (event != CPUFREQ_CREATE_POLICY)
#else
	if (event != CPUFREQ_ADJUST)
#endif
		return NOTIFY_DONE;

	min_freq = boost ? 1200000 : 400000;
	cpufreq_verify_within_limits(policy, min_freq, max_freq);

	return NOTIFY_OK;
}

void sprdwl_boost(void)
{
	struct sprdwl_intf *intf = get_intf();

	if (intf->boost == 0) {
		intf->boost = 1;
		cpufreq_update_policy(0);
	}
}

void sprdwl_unboost(void)
{
	struct sprdwl_intf *intf = get_intf();

	if (intf->boost == 1) {
		intf->boost = 0;
		cpufreq_update_policy(0);
	}
}
#endif /* CPUFREQ_UPDATE_SUPPORT */

void adjust_txnum_level(char *buf, unsigned char offset)
{
#define MAX_LEN 4
	unsigned int cnt = 0;
	unsigned int i = 0;
	struct sprdwl_intf *intf = get_intf();

	for (i = 0; i < MAX_LEN; (cnt *= 10), i++) {
		if ((buf[offset + i] >= '0') &&
		   (buf[offset + i] <= '9')) {
			cnt += (buf[offset + i] - '0');
		} else {
			cnt /= 10;
			break;
		}
	}

	if (cnt < 0 || cnt > 9999)
		cnt = BOOST_TXNUM_LEVEL;
	intf->txnum_level = cnt;
	wl_info("credit_level: %d\n", intf->txnum_level);
#undef MAX_LEN
}

void adjust_rxnum_level(char *buf, unsigned char offset)
{
#define MAX_LEN 2
	unsigned int cnt = 0;
	unsigned int i = 0;
	struct sprdwl_intf *intf = get_intf();

	for (i = 0; i < MAX_LEN; (cnt *= 10), i++) {
		if ((buf[offset + i] >= '0') &&
		   (buf[offset + i] <= '9')) {
			cnt += (buf[offset + i] - '0');
		} else {
			cnt /= 10;
			break;
		}
	}

	if (cnt < 0 || cnt > 99)
		cnt = BOOST_RXNUM_LEVEL;
	intf->rxnum_level = cnt;
	wl_info("rxnum_level: %d\n", intf->rxnum_level);
#undef MAX_LEN
}

void sprdwl_count_rx_tp_tcp_ack(struct sprdwl_intf *intf, u32 len)
{
	unsigned long long timeus = 0;
	struct sprdwl_rx_if *rx_if = (struct sprdwl_rx_if *)intf->sprdwl_rx;

	rx_if->rx_total_len += (unsigned long)len;
	if (rx_if->rx_total_len == (unsigned long)len) {
		rx_if->rxtimebegin = ktime_get();
		return;
	}

	rx_if->rxtimeend = ktime_get();
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)
	timeus = div_u64(rx_if->rxtimeend.tv64 - rx_if->rxtimebegin.tv64, NSEC_PER_USEC);
#else
	timeus = div_u64(rx_if->rxtimeend - rx_if->rxtimebegin, NSEC_PER_USEC);
#endif

	if(!timeus) {
		return;
	}

	if (div_u64(((unsigned long long)rx_if->rx_total_len * 8 ) , (u32)timeus) >= (unsigned long long)intf->tcpack_delay_th_in_mb &&
		timeus > (unsigned long long)intf->tcpack_time_in_ms * USEC_PER_MSEC) {
		rx_if->rx_total_len = 0;
		enable_tcp_ack_delay("tcpack_delay_en=1", strlen("tcpack_delay_en="));
	} else if (div_u64((rx_if->rx_total_len * 8 ) , (u32)timeus) < intf->tcpack_delay_th_in_mb &&
		timeus > intf->tcpack_time_in_ms * USEC_PER_MSEC) {
		rx_if->rx_total_len = 0;
		enable_tcp_ack_delay("tcpack_delay_en=0", strlen("tcpack_delay_en="));
	}
}

int sprdwl_bus_init(struct sprdwl_priv *priv)
{
	int ret = -EINVAL, chn = 0;

	if (priv->hw_type == SPRDWL_HW_SDIO) {
		g_intf_ops.hif_ops = sdio_hif_ops;
		g_intf_ops.max_num =
			sizeof(sdio_hif_ops)/sizeof(struct mchn_ops_t);
	} else if (priv->hw_type == SPRDWL_HW_PCIE) {
		g_intf_ops.hif_ops = pcie_hif_ops;
		g_intf_ops.max_num =
			sizeof(pcie_hif_ops)/sizeof(struct mchn_ops_t);
	} else if (priv->hw_type == SPRDWL_HW_USB) {
		g_intf_ops.hif_ops = usb_hif_ops;
		g_intf_ops.max_num =
			sizeof(usb_hif_ops)/sizeof(struct mchn_ops_t);
	}

	if (g_intf_ops.max_num < MAX_CHN_NUM) {
		wl_info("%s: register %d ops\n",
			__func__, g_intf_ops.max_num);

		for (chn = 0; chn < g_intf_ops.max_num; chn++) {
			ret = sprdwcn_bus_chn_init(&g_intf_ops.hif_ops[chn]);
			if (ret < 0)
				goto err;
		}
		return 0;
	}
err:
	wl_err("%s: unregister %d ops\n",
		     __func__, g_intf_ops.max_num);

	for (; chn > 0; chn--)
		sprdwcn_bus_chn_deinit(&g_intf_ops.hif_ops[chn]);

	g_intf_ops.hif_ops = NULL;
	g_intf_ops.max_num = 0;

	return ret;
}

void sprdwl_bus_deinit(void)
{
	int chn = 0;

	for (chn = 0; chn < g_intf_ops.max_num; chn++)
		sprdwcn_bus_chn_deinit(&g_intf_ops.hif_ops[chn]);
}

int sprdwl_intf_init(struct sprdwl_priv *priv, struct sprdwl_intf *intf)
{
	int ret = -EINVAL;

	ret = sprdwl_bus_init(priv);
	if (ret < 0)
		return ret;

	g_intf_ops.intf = (void *)intf;
	/* TODO: Need we reserve g_intf_ops? */
	intf->hw_intf = (void *)&g_intf_ops;

	priv->hw_priv = intf;
	priv->hw_offset = intf->hif_offset;
	intf->priv = priv;
	intf->fw_awake = 1;
	intf->fw_power_down = 0;
	intf->txnum_level = BOOST_TXNUM_LEVEL;
	intf->rxnum_level = BOOST_RXNUM_LEVEL;

#ifdef CPUFREQ_UPDATE_SUPPORT
	intf->boost = 0;
#endif /* CPUFREQ_UPDATE_SUPPORT */

	intf->tcpack_time_in_ms = RX_TP_COUNT_IN_MS;
	intf->tcpack_delay_th_in_mb = DROPACK_TP_TH_IN_M;

	init_completion(&intf->suspend_completed);

	return ret;
}

void sprdwl_intf_deinit(struct sprdwl_intf *dev)
{
	g_intf_ops.intf = NULL;
	g_intf_ops.max_num = 0;
	dev->hw_intf = NULL;
}

int sprdwl_dis_flush_txlist(struct sprdwl_intf *intf, u8 lut_index)
{
	struct sprdwl_tx_msg *tx_msg;
	int i, j;

	if (lut_index <= 5) {
		wl_err("err lut_index:%d, %s, %d\n",
				lut_index, __func__, __LINE__);
		return -1;
	}
	wl_debug("disconnect, flush qoslist, %s, %d\n", __func__, __LINE__);
	tx_msg = (struct sprdwl_tx_msg *)intf->sprdwl_tx;
	for (i = 0; i < SPRDWL_MODE_MAX; i++)
		for (j = 0; j < SPRDWL_AC_MAX; j++)
				sprdwl_flush_tx_qoslist(tx_msg, i, j, lut_index);
	return 0;
}