/*
 * Copyright (C) 2015 Spreadtrum Communications Inc.
 *
 * Authors	:
 * Keguang Zhang <keguang.zhang@spreadtrum.com>
 * Jingxiang Li <Jingxiang.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/skbuff.h>

#include "sprdwl.h"
#include "txrx.h"
#include "cfg80211.h"
#include "cmdevt.h"
#include "intf_ops.h"
#include "work.h"
#if defined(UWE5621_FTR)
#include "wl_intf.h"
#endif
#include "rx_msg.h"
#include "tcp_ack.h"
#include "wl_core.h"

/* if err, the caller judge the skb if need free,
 * here just free the msg buf to the freelist
 */
int sprdwl_send_data(struct sprdwl_vif *vif, struct sprdwl_msg_buf *msg,
		     struct sk_buff *skb, u8 offset)
{
	int ret;
	int delta;
	unsigned long align_addr;
	unsigned char *buf = NULL;
/*TODO temp for MARLIN2*/
#ifndef UWE5621_FTR
	struct sprdwl_data_hdr *hdr;
#endif
	struct sprdwl_intf *intf;
	unsigned int plen = cpu_to_le16(skb->len);

	intf = (struct sprdwl_intf *)vif->priv->hw_priv;
	buf = skb->data;
/*TODO temp for MARLIN2*/
#ifndef UWE5621_FTR
	skb_push(skb, sizeof(*hdr) + offset);
	hdr = (struct sprdwl_data_hdr *)skb->data;
	memset(hdr, 0, sizeof(*hdr));
	hdr->common.type = SPRDWL_TYPE_DATA;
	hdr->common.ctx_id = vif->ctx_id;
	hdr->plen = cpu_to_le16(skb->len);
#else
	if (sprdwl_intf_fill_msdu_dscr(vif, skb, SPRDWL_TYPE_DATA, offset))
		return -EPERM;
#endif /* UWE5621_FTR */
#ifdef OTT_UWE
	skb_push(skb, 3);
	if ((unsigned long)skb->data & 0x3) {
		if (!skb_pad(skb, 8)) {
			align_addr = roundup((unsigned long)skb->data, 4);
			delta = align_addr - (unsigned long)skb->data;
			memmove((void *)align_addr, skb->data, skb->len);
			skb_pull(skb, delta);
			skb_put(skb, delta);
		} else {
			wl_err("addr not aligned\n");
			return -1;
		}
	}
#endif
	sprdwl_fill_msg(msg, skb, skb->data, skb->len);

	if (sprdwl_filter_send_tcp_ack(vif->priv, msg, buf, plen))
		return 0;

	ret = sprdwl_intf_tx(vif->priv, msg);
	if (ret)
		wl_err("%s TX data Err: %d\n", __func__, ret);

	if (intf->tdls_flow_count_enable == 1 &&
		vif->sm_state == SPRDWL_CONNECTED)
		count_tdls_flow(vif,
				skb->data + offset + intf->hif_offset,
				skb->len - offset - intf->hif_offset);

	return ret;
}

#if defined FPGA_LOOPBACK_TEST
int sprdwl_send_data_fpga_test(struct sprdwl_priv *priv,
				struct sprdwl_msg_buf *msg,
				struct sk_buff *skb, u8 type, u8 offset)
{
	int ret = 0;

	sprdwl_intf_fill_msdu_dscr_test(priv, skb, type, offset);
	msg->type = type;

	sprdwl_fill_msg(msg, skb, skb->data, skb->len);
	ret = sprdwl_intf_tx(priv, msg);

	return ret;
}
#endif

int sprdwl_send_cmd(struct sprdwl_priv *priv, struct sprdwl_msg_buf *msg)
{
	int ret;
	struct sk_buff *skb;

	skb = msg->skb;
	ret = sprdwl_intf_tx(priv, msg);
	if (ret) {
		wl_err("%s TX cmd Err: %d\n", __func__, ret);
		/* now cmd msg droped */
#if !defined(UWE5621_FTR)
		dev_kfree_skb(skb);
#endif
	}

	return ret;
}

void sprdwl_rx_send_cmd_process(struct sprdwl_priv *priv, void *data, int len,
				unsigned char id, unsigned char ctx_id)
{
	struct sprdwl_vif *vif;
	struct sprdwl_work *misc_work = NULL;

	if (unlikely(!priv)) {
		wl_err("%s priv not init.\n", __func__);
	} else if (ctx_id > STAP_MODE_P2P_DEVICE) {
		wl_err("%s [ctx_id %d]RX err\n", __func__, ctx_id);
	} else {
		vif = ctx_id_to_vif(priv, ctx_id);
		if (!vif) {
			wl_err("%s cant't get vif from ctx_id%d\n",
			       __func__, ctx_id);
		} else {
			misc_work = sprdwl_alloc_work(len);
			if (!misc_work) {
				wl_err("%s out of memory", __func__);
			} else {
				misc_work->vif = vif;
				misc_work->id = id;
				memcpy(misc_work->data, data, len);
				sprdwl_queue_work(vif->priv, misc_work);
			}
			sprdwl_put_vif(vif);
		}
	}
}

void sprdwl_rx_skb_process(struct sprdwl_priv *priv, struct sk_buff *skb)
{
	struct sprdwl_vif *vif = NULL;
	struct net_device *ndev = NULL;
	struct rx_msdu_desc *msdu_desc = NULL;
	struct sk_buff *tx_skb = NULL;
	struct sprdwl_intf *intf;
	struct ethhdr *eth;
	struct sprdwl_rx_if *rx_if;

	intf = (struct sprdwl_intf *)priv->hw_priv;
	rx_if = (struct sprdwl_rx_if *)intf->sprdwl_rx;

	if (unlikely(!priv)) {
		wl_err("%s priv not init.\n", __func__);
		goto err;
	}

	msdu_desc = (struct rx_msdu_desc *)skb->data;
	if (msdu_desc->ctx_id >= SPRDWL_MAC_INDEX_MAX) {
		wl_err("%s [ctx_id %d]RX err\n", __func__, msdu_desc->ctx_id);
		goto err;
	}

	if ((msdu_desc->amsdu_flag == 1) && (msdu_desc->snap_hdr_present == 0) &&
		(msdu_desc->first_msdu_of_mpdu == 1)) {
		rx_if->rx_snaphdr_flag = 1;
		rx_if->rx_snaphdr_seqnum = msdu_desc->seq_num;
		rx_if->rx_snaphdr_lut = msdu_desc->sta_lut_index;
		rx_if->rx_snaphdr_tid = msdu_desc->tid;
		wl_info("%s snaphdr attect flag %d %d %d\n", __func__, msdu_desc->seq_num,
					msdu_desc->sta_lut_index, msdu_desc->tid);
		if (msdu_desc->last_buff_of_mpdu == 1) {
			rx_if->rx_snaphdr_flag = 0;
			wl_info("%s snaphdr attect over %d last %d %d %d\n", __func__, msdu_desc->snap_hdr_present,
				msdu_desc->last_msdu_of_mpdu, msdu_desc->last_buff_of_mpdu, msdu_desc->last_msdu_of_buff);
		}
		goto err;
	}

	if(rx_if->rx_snaphdr_flag == 1) {
		if ((rx_if->rx_snaphdr_seqnum == msdu_desc->seq_num) &&
			(rx_if->rx_snaphdr_lut == msdu_desc->sta_lut_index) &&
			(rx_if->rx_snaphdr_tid == msdu_desc->tid)) {
			wl_err("%s snaphdr attect %d %d %d\n", __func__, msdu_desc->seq_num,
				msdu_desc->sta_lut_index, msdu_desc->tid);
			if (msdu_desc->last_buff_of_mpdu == 1) {
				rx_if->rx_snaphdr_flag = 0;
				wl_info("%s snaphdr attect over %d %d %d %d last %d %d %d\n", __func__, msdu_desc->snap_hdr_present,
					msdu_desc->seq_num, msdu_desc->sta_lut_index, msdu_desc->tid,
					msdu_desc->last_msdu_of_mpdu, msdu_desc->last_buff_of_mpdu, msdu_desc->last_msdu_of_buff);
			}
			goto err;
		}
	}

	vif = ctx_id_to_vif(priv, msdu_desc->ctx_id);
	if (!vif) {
		wl_err("%s cannot get vif, ctx_id: %d\n",
		       __func__, msdu_desc->ctx_id);
		goto err;
	}

	/* Sanity check for bug 846454 */
	if (vif->ndev == NULL) {
		wl_err("%s ndev is NULL, ctx_id = %d\n",
		       __func__, msdu_desc->ctx_id);
		BUG_ON(1);
	}

	ndev = vif->ndev;
	skb_reserve(skb, msdu_desc->msdu_offset);
	skb_put(skb, msdu_desc->msdu_len);

	eth = (struct ethhdr *)skb->data;
	if (eth->h_proto == htons(ETH_P_IPV6))
		if (ether_addr_equal(skb->data, skb->data + ETH_ALEN)) {
			wl_err("%s, drop loopback pkt, macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
				__func__, skb->data[0], skb->data[1], skb->data[2],
				skb->data[3], skb->data[4], skb->data[5]);
			goto err;
		}

	if (intf->tdls_flow_count_enable == 1)
		count_tdls_flow(vif,
				skb->data + ETH_ALEN,
				skb->len - ETH_ALEN);

	/* FIXME: We would remove mode in furture, how to modify? */
	if (((vif->mode == SPRDWL_MODE_AP) ||
	     (vif->mode == SPRDWL_MODE_P2P_GO)) && msdu_desc->uc_w2w_flag) {
		skb->dev = ndev;
		dev_queue_xmit(skb);
	} else {
		if (((vif->mode == SPRDWL_MODE_AP) ||
		     (vif->mode == SPRDWL_MODE_P2P_GO)) &&
		    msdu_desc->bc_mc_w2w_flag) {
			struct ethhdr *eth = (struct ethhdr *)skb->data;

			if (eth->h_proto != ETH_P_IP &&
			    eth->h_proto != ETH_P_IPV6) {
				tx_skb = pskb_copy(skb, GFP_ATOMIC);
				if (likely(tx_skb)) {
					tx_skb->dev = ndev;
					dev_queue_xmit(tx_skb);
				}
			}
		}

		/* skb->data MUST point to ETH HDR */
		sprdwl_filter_rx_tcp_ack(priv, skb->data, msdu_desc->msdu_len);
		/*adjust drop tcpack enable or not*/
#ifdef TCPACK_DROP_DYNAMIC
		sprdwl_count_rx_tp_tcp_ack(intf, msdu_desc->msdu_len);
#endif
		sprdwl_netif_rx(skb, ndev);
	}

	sprdwl_put_vif(vif);

	return;

err:
	dev_kfree_skb(skb);
#if defined(MORE_DEBUG)
	intf->stats.rx_errors++;
	intf->stats.rx_dropped++;
#endif
}
unsigned short sprdwl_rx_data_process(struct sprdwl_priv *priv,
				      unsigned char *msg)
{
	return 0;
}