/*
 * Copyright (C) 2016-2018 Spreadtrum Communications Inc.
 * 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 <wcn_bus.h>

#include "edma_engine.h"
#include "mchn.h"
#include "pcie.h"

#define TX_CHN (0)
#define RX_CHN (1)

struct cfg_e {
	int pool_size;
	int buf_size;
	int num;
	int chn[8][2];
};

struct test_link {
	struct mbuf_t  *head;
	struct mbuf_t  *tail;
	int      num;
	int      chn;
};

struct loopback {
	struct cfg_e  cfg;
	int    seq;
	int    loop;
	struct mchn_ops_t ops[16];
	struct test_link link[8][2];

};
struct loopback g_lo;

int cfg[] = {3, 1024, 2, 0, 1, 2, 3};

static struct mchn_ops_t *lo_ops(int chn)
{
	struct loopback *lo = &g_lo;

	return &lo->ops[chn];
}

static int lo_index(int chn)
{
	int i;
	struct loopback *lo = &g_lo;

	for (i = 0; i < lo->cfg.num; i++) {
		if ((chn == lo->link[i][TX_CHN].chn) ||
		   (chn == lo->link[i][RX_CHN].chn))
			return i;

	}
	PCIE_INFO("%s(%d) err\n", __func__, chn);
	while (1)
		;

	return -1;
}

static int lo_buf_alloc(int chn, int size, int num)
{
	int ret, i;
	struct dma_buf dm = {0};
	struct mbuf_t *mbuf, *head, *tail;
	struct edma_info *edma = edma_info();

	ret = mbuf_link_alloc(chn, &head, &tail, &num);
	if (ret != 0)
		return -1;
	for (i = 0, mbuf = head; i < num; i++) {
		ret = dmalloc(edma->pcie_info, &dm, size);
		if (ret != 0)
			return -1;
		mbuf->buf = (unsigned char *)(dm.vir);
		mbuf->phy = (unsigned long)(dm.phy);
		mbuf->len = dm.size;
		memset(mbuf->buf, (unsigned char)(i+1), mbuf->len);
		mbuf = mbuf->next;
	}
	ret = mbuf_link_free(chn, head, tail, num);

	return ret;
}

static int lo_tx_pop(int chn, struct mbuf_t *head, struct mbuf_t *tail,
		     int num)
{
	struct loopback *lo = &g_lo;
	struct test_link *tx_link = &(lo->link[lo_index(chn)][TX_CHN]);

	if (tx_link->num == 0) {
		tx_link->head = head;
		tx_link->tail = tail;
		tx_link->num  = num;
	} else {
		tx_link->tail->next = head;
		tx_link->tail = tail;
		tx_link->num += num;
	}

	return 0;
}

static int lo_push(int chn)
{
	int num, ret, i, j;
	struct mchn_ops_t *ops = lo_ops(chn);
	struct mbuf_t *head, *tail, *mbuf;
	struct loopback *lo = &g_lo;

	num = ops->pool_size;
	ret = mbuf_link_alloc(chn, &head, &tail, &num);
	for (i = 0, mbuf = head; i < num; i++) {
		for (j = 0; j < mbuf->len/4; j++)
			*(int *)(mbuf->buf + j * 4) = lo->seq;

		lo->seq++;
		mbuf = mbuf->next;
	}
	ret = mchn_push_link(chn, head, tail, num);

	return ret;
}

static int lo_rx_push(int chn, struct mbuf_t **head, struct mbuf_t **tail,
		      int *num)
{
	int ret = mbuf_link_alloc(chn, head, tail, num);

	return ret;
}

static int lo_rx_pop(int chn, struct mbuf_t *head, struct mbuf_t *tail,
		     int num)
{
	int i, pos = 0;
	unsigned char string[128];
	struct mbuf_t *tx_mbuf, *rx_mbuf;
	struct loopback *lo = &g_lo;
	struct mchn_ops_t *ops = lo_ops(chn);
	struct test_link *tx_link = &(lo->link[lo_index(chn)][TX_CHN]);
	struct test_link *rx_link = &(lo->link[lo_index(chn)][RX_CHN]);

	if (rx_link->num == 0) {
		rx_link->head = head;
		rx_link->tail = tail;
		rx_link->num  = num;
		rx_link->chn  = chn;
	} else {
		rx_link->tail->next = head;
		rx_link->tail = (void *)tail;
		rx_link->num += num;
	}
	if (rx_link->num == ops->pool_size) {
		if (tx_link->num != rx_link->num) {
			PCIE_ERR("%s line:%d err\n", __func__, __LINE__);
			while (1)
				;

			return -1;
		}
		pos = sprintf(string + pos, "lo(%d,%d){",
			      tx_link->chn, rx_link->chn);
		for (i = 0, tx_mbuf = tx_link->head, rx_mbuf = rx_link->head;
		    i < tx_link->num; i++) {
			if (memcmp(tx_mbuf->buf, rx_mbuf->buf, 1024) != 0) {
				PCIE_ERR("%s line:%d err\n", __func__,
					 __LINE__);
				while (1)
					;
			}
			pos += sprintf(string+pos, "%d ",
				       *(int *)(tx_mbuf->buf));
			tx_mbuf = tx_mbuf->next;
			rx_mbuf = rx_mbuf->next;
		}
		PCIE_INFO("%s}\n", string);
		mbuf_link_free(rx_link->chn, rx_link->head, rx_link->tail,
			       rx_link->num);
		mbuf_link_free(tx_link->chn, tx_link->head, tx_link->tail,
			       tx_link->num);

		rx_link->num = 0;
		rx_link->head = rx_link->tail = NULL;

		tx_link->num = 0;
		tx_link->head = tx_link->tail = NULL;

		if (lo->loop)
			lo_push(tx_link->chn);
	}

	return 0;
}

static int lo_tx_complete(int chn, int timeout)
{
	return 0;
}

int lo_init(void)
{
	int i, tx_chn, rx_chn;
	struct mchn_ops_t *ops;
	struct loopback *lo = &g_lo;

	PCIE_INFO("[+]%s\n", __func__);
	memset(lo, 0x00, sizeof(struct loopback));
	for (i = 0; i < 8; i++) {
		lo->link[i][0].chn = -1;
		lo->link[i][1].chn = -1;
	}
	memcpy((unsigned char *)(&lo->cfg), (unsigned char *)(&cfg),
		sizeof(cfg));
	for (i = 0; i < lo->cfg.num; i++) {
		tx_chn = lo->cfg.chn[i][TX_CHN];
		rx_chn = lo->cfg.chn[i][RX_CHN];

		ops = lo_ops(tx_chn);
		ops->channel = tx_chn;
		ops->inout = 1;
		ops->hif_type = HW_TYPE_PCIE;
		ops->buf_size = lo->cfg.buf_size;
		ops->pool_size = lo->cfg.pool_size;
		ops->cb_in_irq = 0;
		ops->pop_link = lo_tx_pop;
		ops->tx_complete = lo_tx_complete;
		mchn_init(ops);
		lo_buf_alloc(ops->channel, ops->buf_size, ops->pool_size);

		ops = lo_ops(rx_chn);
		ops->channel = rx_chn;
		ops->inout = 0;
		ops->hif_type = HW_TYPE_PCIE;
		ops->buf_size = lo->cfg.buf_size;
		ops->pool_size = lo->cfg.pool_size;
		ops->cb_in_irq = 0;
		ops->pop_link = lo_rx_pop;
		ops->push_link = lo_rx_push;
		mchn_init(ops);
		lo_buf_alloc(ops->channel, ops->buf_size, ops->pool_size);

		lo->link[i][TX_CHN].chn = tx_chn;
		lo->link[i][RX_CHN].chn = rx_chn;
	}
	PCIE_INFO("[-]%s\n", __func__);

	return 0;
}

int lo_start(int mode)
{
	static int lo_init_state;
	int i, tx_chn;
	struct loopback *lo = &g_lo;

	PCIE_INFO("[+]%s\n", __func__);
	if (lo_init_state == 0) {
		lo_init();
		lo_init_state = 1;
	}
	lo->loop = mode;
	lo->seq = 0;
	for (i = 0; i < lo->cfg.num; i++) {
		tx_chn = lo->link[i][TX_CHN].chn;
		lo_push(tx_chn);
	}
	PCIE_INFO("[-]%s\n", __func__);

	return 0;
}

int lo_stop(void)
{
	struct loopback *lo = &g_lo;

	lo->loop = 0;

	return 0;
}