/*
 * Copyright (C) 2017 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 "wcn_integrate.h"
#include "wcn_sipc.h"
#include "wcn_txrx.h"

#define SIPC_WCN_DST 3

#define SIPC_TYPE_SBUF 0
#define SIPC_TYPE_SBLOCK 1

#define SIPC_CHN_ATCMD 4
#define SIPC_CHN_LOOPCHECK 11
#define SIPC_CHN_ASSERT 12
#define SIPC_CHN_LOG 5
#define SIPC_CHN_BT 4
#define SIPC_CHN_FM 4
#define SIPC_CHN_WIFI_CMD 7
#define SIPC_CHN_WIFI_DATA0 8
#define SIPC_CHN_WIFI_DATA1 9

#define INIT_SIPC_CHN_SBUF(idx, channel, bid,\
		 blen, bnum, tbsize, rbsize)\
{.index = idx, .chntype = SIPC_TYPE_SBUF,\
.chn = channel, .dst = SIPC_WCN_DST, .sbuf.bufid = bid,\
.sbuf.len = blen, .sbuf.bufnum = bnum,\
.sbuf.txbufsize = tbsize, .sbuf.rxbufsize = rbsize}

#define INIT_SIPC_CHN_SBLOCK(idx, channel,\
		 tbnum, tbsize, rbnum, rbsize)\
{.index = idx, .chntype = SIPC_TYPE_SBLOCK,\
.chn = channel, .dst = SIPC_WCN_DST,\
.sblk.txblocknum = tbnum, .sblk.txblocksize = tbsize,\
.sblk.rxblocknum = rbnum, .sblk.rxblocksize = rbsize}

static struct wcn_sipc_info_t g_sipc_info = {0};

/* sipc channel info */
static struct sipc_chn_info g_sipc_chn[SIPC_CHN_NUM] = {
	INIT_SIPC_CHN_SBUF(SIPC_ATCMD_TX, SIPC_CHN_ATCMD,
		5, 128, 0, 0x2400, 0x2400),
	INIT_SIPC_CHN_SBUF(SIPC_ATCMD_RX, SIPC_CHN_ATCMD,
		5, 128, 0, 0x2400, 0x2400),
	INIT_SIPC_CHN_SBUF(SIPC_LOOPCHECK_RX, SIPC_CHN_LOOPCHECK,
		0, 128, 1, 0x400, 0x400),
	INIT_SIPC_CHN_SBUF(SIPC_ASSERT_RX, SIPC_CHN_ASSERT,
		0, 1024, 1, 0x400, 0x400),
	INIT_SIPC_CHN_SBUF(SIPC_LOG_RX, SIPC_CHN_LOG,
		0, 8*1024, 1, 0x8000, 0x30000),
	INIT_SIPC_CHN_SBUF(SIPC_BT_TX, SIPC_CHN_BT,
		11, 4096, 0, 0x2400, 0x2400),
	INIT_SIPC_CHN_SBUF(SIPC_BT_RX, SIPC_CHN_BT,
		10, 4096, 0, 0x2400, 0x2400),
	INIT_SIPC_CHN_SBUF(SIPC_FM_TX, SIPC_CHN_FM,
		14, 128, 0, 0x2400, 0x2400),
	INIT_SIPC_CHN_SBUF(SIPC_FM_RX, SIPC_CHN_FM,
		13, 128, 0, 0x2400, 0x2400),
	INIT_SIPC_CHN_SBLOCK(SIPC_WIFI_CMD_TX, SIPC_CHN_WIFI_CMD,
		4, 2048, 16, 2048),
	INIT_SIPC_CHN_SBLOCK(SIPC_WIFI_CMD_RX, SIPC_CHN_WIFI_CMD,
		4, 2048, 16, 2048),
	INIT_SIPC_CHN_SBLOCK(SIPC_WIFI_DATA0_TX, SIPC_CHN_WIFI_DATA0,
		64, 1664, 256, 1664),
	INIT_SIPC_CHN_SBLOCK(SIPC_WIFI_DATA0_RX, SIPC_CHN_WIFI_DATA0,
		64, 1664, 256, 1664),
	INIT_SIPC_CHN_SBLOCK(SIPC_WIFI_DATA1_TX, SIPC_CHN_WIFI_DATA1,
		64, 1664, 0, 0),
	INIT_SIPC_CHN_SBLOCK(SIPC_WIFI_DATA1_RX, SIPC_CHN_WIFI_DATA1,
		64, 1664, 0, 0),
};

#define SIPC_INVALID_CHN(index) ((index >= SIPC_CHN_NUM) ? 1 : 0)
#define SIPC_TYPE(index) (g_sipc_chn[index].chntype)
#define SIPC_CHN(index) (&g_sipc_chn[index])

static inline char *sipc_chn_tostr(int chn, int bufid)
{
	switch (chn) {
	case SIPC_CHN_ATCMD:
		if (bufid == 5)
			return "ATCMD";
		else if (bufid == 10 || bufid == 11)
			return "BT";
		else if (bufid == 13 || bufid == 14)
			return "FM";
	case SIPC_CHN_LOG:
		return "LOG";
	case SIPC_CHN_LOOPCHECK:
		return "LOOPCHECK";
	case SIPC_CHN_ASSERT:
		return "ASSERT";
	case SIPC_CHN_WIFI_CMD:
		return "WIFICMD";
	case SIPC_CHN_WIFI_DATA0:
		return "WIFIDATA0";
	case SIPC_CHN_WIFI_DATA1:
		return "WIFIDATA1";
	default:
		return "Unknown Channel";
	}
}

static inline int wcn_sipc_buf_list_alloc(int chn,
	struct mbuf_t **head, struct mbuf_t **tail, int *num)
{
	return buf_list_alloc(chn, head, tail, num);
}

static inline int wcn_sipc_buf_list_free(int chn,
	struct mbuf_t *head, struct mbuf_t *tail, int num)
{
	return buf_list_free(chn, head, tail, num);
}

static int wcn_sipc_recv(struct sipc_chn_info *sipc_chn, void *buf, int len)
{
	struct mbuf_t *head, *tail;
	struct mchn_ops_t *wcn_sipc_ops = NULL;

	wcn_sipc_ops = chn_ops(sipc_chn->index);
	if (unlikely(!wcn_sipc_ops))
		return -E_NULLPOINT;

	head = kzalloc(sizeof(struct mbuf_t), GFP_KERNEL);
	if (unlikely(!head))
		return -E_NOMEM;

	head->buf = buf;
	head->len = len;
	head->next = NULL;
	tail = head;
	wcn_sipc_ops->pop_link(sipc_chn->index, head, tail, 1);

	return 0;
}

static int wcn_sipc_sbuf_write(u8 index, void *buf, int len)
{
	int cnt = -1;
	struct sipc_chn_info *sipc_chn;

	if (SIPC_INVALID_CHN(index))
		return -E_INVALIDPARA;
	sipc_chn = SIPC_CHN(index);
	cnt = sbuf_write(sipc_chn->dst, sipc_chn->chn,
			sipc_chn->sbuf.bufid, buf + PUB_HEAD_RSV, len, -1);
	WCN_INFO("sbuf chn[%s] write cnt=%d\n",
		sipc_chn_tostr(sipc_chn->chn, sipc_chn->sbuf.bufid), cnt);

	return cnt;
}

static void wcn_sipc_sbuf_notifer(int event, void *data)
{
	int cnt = -1;
	int ret = -1;
	u8 *buf;
	struct bus_puh_t *puh = NULL;
	struct sipc_chn_info *sipc_chn = (struct sipc_chn_info *)data;

	if (unlikely(!sipc_chn))
		return;

	switch (event) {
	case SBUF_NOTIFY_WRITE:
		break;
	case SBUF_NOTIFY_READ:
		buf = kzalloc(sipc_chn->sbuf.len + PUB_HEAD_RSV, GFP_KERNEL);
		if (unlikely(!buf)) {
			WCN_ERR("[%s]:mem alloc fail!\n", __func__);
			return;
		}
		cnt = sbuf_read(sipc_chn->dst,
				sipc_chn->chn,
				sipc_chn->sbuf.bufid,
				(void *)(buf + PUB_HEAD_RSV),
				sipc_chn->sbuf.len, 0);
		puh = (struct bus_puh_t *)buf;
		puh->len = cnt;
		WCN_DEBUG("sbuf chn[%s] read cnt=%d\n",
				sipc_chn_tostr(sipc_chn->chn, 0), cnt);
		if (cnt < 0) {
			WCN_ERR("sbuf read cnt[%d] invalid\n", cnt);
			kfree(buf);
			return;
		}
		ret = wcn_sipc_recv(sipc_chn, buf, cnt);
		if (ret < 0) {
			WCN_ERR("sbuf recv fail[%d]\n", ret);
			kfree(buf);
			return;
		}
		break;
	default:
		WCN_ERR("sbuf read event[%d] invalid\n", event);
	}
}

static int wcn_sipc_sblk_write(u8 index, void *buf, int len)
{
	int ret = -1;
	u8 *addr = NULL;
	struct sblock blk;
	struct sipc_chn_info *sipc_chn;

	if (SIPC_INVALID_CHN(index))
		return -E_INVALIDPARA;
	sipc_chn = SIPC_CHN(index);
	/* Get a free swcnblk. */
	ret = sblock_get(sipc_chn->dst, sipc_chn->chn, &blk, 0);
	if (ret) {
		WCN_ERR("[%s]:Failed to get free swcnblk(%d)!\n",
		       sipc_chn_tostr(sipc_chn->chn, 0), ret);
		return -ENOMEM;
	}
	if (blk.length < len) {
		WCN_ERR("[%s]:The size of swcnblk is so tiny!\n",
		       sipc_chn_tostr(sipc_chn->chn, 0));
		sblock_put(sipc_chn->dst, sipc_chn->chn, &blk);
		return E_INVALIDPARA;
	}
	addr = (u8 *)blk.addr + SIPC_SBLOCK_HEAD_RESERV;
	blk.length = len + SIPC_SBLOCK_HEAD_RESERV;
	memcpy(((u8 *)addr), buf, len);
	ret = sblock_send(sipc_chn->dst, sipc_chn->chn, &blk);
	if (ret) {
		WCN_ERR("[%s]:err:%d\n",
		       sipc_chn_tostr(sipc_chn->chn, 0), ret);
		sblock_put(sipc_chn->dst, sipc_chn->chn, &blk);
	}

	return ret;
}

static void wcn_sipc_sblk_recv(struct sipc_chn_info *sipc_chn)
{
	u32 length = 0;
	int ret = -1;
	struct sblock blk;

	WCN_DEBUG("[%s]:recv sblock msg",
		       sipc_chn_tostr(sipc_chn->chn, 0));

	while (!sblock_receive(sipc_chn->dst, sipc_chn->chn, &blk, 0)) {
		length = blk.length - SIPC_SBLOCK_HEAD_RESERV;
		WCN_DEBUG("sblk length %d", length);
		wcn_sipc_recv(sipc_chn,
			(u8 *)blk.addr + SIPC_SBLOCK_HEAD_RESERV, length);
		ret = sblock_release(sipc_chn->dst, sipc_chn->chn, &blk);
		if (ret)
			WCN_ERR("release swcnblk[%d] err:%d\n",
			       sipc_chn->chn, ret);
	}
}

static void wcn_sipc_sblk_notifer(int event, void *data)
{
	struct sipc_chn_info *sipc_chn = (struct sipc_chn_info *)data;

	if (unlikely(!sipc_chn))
		return;
	switch (event) {
	case SBLOCK_NOTIFY_RECV:
		wcn_sipc_sblk_recv(sipc_chn);
		break;
	/* SBLOCK_NOTIFY_GET cmd not need process it */
	case SBLOCK_NOTIFY_GET:
		break;
	default:
		WCN_ERR("Invalid event swcnblk notify:%d\n", event);
		break;
	}
}

struct wcn_sipc_data_ops  sipc_data_ops[] = {
	{
		.sipc_write = wcn_sipc_sbuf_write,
		.sipc_notifer = wcn_sipc_sbuf_notifer,
	},
	{
		.sipc_write = wcn_sipc_sblk_write,
		.sipc_notifer = wcn_sipc_sblk_notifer,
	},
};

static int wcn_sipc_buf_push(int index, struct mbuf_t *head,
			  struct mbuf_t *tail, int num)
{
	struct mchn_ops_t *wcn_sipc_ops = NULL;

	wcn_sipc_ops = chn_ops(index);
	if (unlikely(!wcn_sipc_ops))
		return -E_NULLPOINT;

	if (wcn_sipc_ops->inout == WCNBUS_TX) {
		sipc_data_ops[SIPC_TYPE(index)].sipc_write(
					index, (void *)(head->buf), head->len);
		wcn_sipc_ops->pop_link(index, head, tail, num);
	} else if (wcn_sipc_ops->inout == WCNBUS_RX) {
		/* free buf mem */
		if (SIPC_TYPE(index) == SIPC_TYPE_SBUF)
			kfree(head->buf);
		/* free buf head */
		kfree(head);
	} else
		return -E_INVALIDPARA;

	return 0;
}

static inline unsigned int wcn_sipc_get_status(void)
{
	return g_sipc_info.sipc_chn_status;
}

static inline void wcn_sipc_set_status(unsigned int flag)
{
	mutex_lock(&g_sipc_info.status_lock);
	g_sipc_info.sipc_chn_status = flag;
	mutex_unlock(&g_sipc_info.status_lock);
}

static unsigned long long wcn_sipc_get_rxcnt(void)
{
	return wcn_get_cp2_comm_rx_count();
}

static int wcn_sipc_chn_init(struct mchn_ops_t *ops)
{
	int ret = -1;
	u8 chntype = 0;
	struct sipc_chn_info *sipc_chn;

	if (SIPC_INVALID_CHN(ops->channel))
		return -E_INVALIDPARA;
	sipc_chn = SIPC_CHN(ops->channel);
	WCN_INFO("[%s]:index[%d] chn[%d]\n",
				__func__,
				ops->channel,
				sipc_chn->chn);

	chntype = sipc_chn->chntype;
	if (chntype == SIPC_TYPE_SBUF) {
		/* sbuf */
		WCN_DEBUG("bufid[%d] len[%d] bufnum[%d]\n",
				sipc_chn->sbuf.bufid,
				sipc_chn->sbuf.len,
				sipc_chn->sbuf.bufnum);
		if (sipc_chn->sbuf.bufnum) {
			ret = sbuf_create(sipc_chn->dst, sipc_chn->chn,
					sipc_chn->sbuf.bufnum,
					sipc_chn->sbuf.txbufsize,
					sipc_chn->sbuf.rxbufsize);
			if (ret < 0) {
				WCN_ERR("sbuf chn[%d] create fail!\n",
					ops->channel);
				return ret;
			}
		}
		if (ops->inout == WCNBUS_RX) {
			ret = sbuf_register_notifier(
					sipc_chn->dst,
					sipc_chn->chn,
					sipc_chn->sbuf.bufid,
					sipc_data_ops[chntype].sipc_notifer,
					sipc_chn);
			if (ret < 0) {
				WCN_ERR("sbuf chn[%d] registerfail!\n",
						ops->channel);
				return ret;
			}
		}
		WCN_INFO("sbuf chn[%d] create success!\n", ops->channel);
	} else if (chntype == SIPC_TYPE_SBLOCK) {
		WCN_DEBUG("tbnum[%d] tbsz[%d] rbnum[%d] rbsz[%d]\n",
					sipc_chn->sblk.txblocknum,
					sipc_chn->sblk.txblocksize,
					sipc_chn->sblk.rxblocknum,
					sipc_chn->sblk.rxblocksize);
		/* sblock */
		if (ops->inout == WCNBUS_TX) {
			ret = sblock_create(
					sipc_chn->dst,
					sipc_chn->chn,
					sipc_chn->sblk.txblocknum,
					sipc_chn->sblk.txblocksize,
					sipc_chn->sblk.rxblocknum,
					sipc_chn->sblk.rxblocksize);
			if (ret < 0) {
				WCN_ERR("sblock chn[%d] create fail!\n",
					ops->channel);
				return ret;
			}
		}
		if (ops->inout == WCNBUS_RX) {
			ret = sblock_register_notifier(
					sipc_chn->dst,
					sipc_chn->chn,
					sipc_data_ops[chntype].sipc_notifer,
					sipc_chn);
			if (ret < 0) {
				WCN_ERR("sblock chn[%d] register fail!\n",
					ops->channel);
				sblock_destroy(sipc_chn->dst, sipc_chn->chn);
				return ret;
			}
		}
		WCN_INFO("sblock chn[%d] create success!\n", ops->channel);
	} else {
		WCN_ERR("invalid sipc type!");
		return -E_INVALIDPARA;
	}

	bus_chn_init(ops, HW_TYPE_SIPC);

	return ret;
}

static int wcn_sipc_chn_deinit(struct mchn_ops_t *ops)
{
	struct sipc_chn_info *sipc_chn;

	bus_chn_deinit(ops);

	if (SIPC_INVALID_CHN(ops->channel))
		return -E_INVALIDPARA;
	sipc_chn = SIPC_CHN(ops->channel);
	/* sbuf */
	if (sipc_chn->chntype == SIPC_TYPE_SBUF) {
		if (sipc_chn->sbuf.bufnum)
			sbuf_destroy(sipc_chn->dst, sipc_chn->chn);
	} else if (sipc_chn->chntype == SIPC_TYPE_SBLOCK) {
		if (ops->inout == WCNBUS_TX)
			sblock_destroy(sipc_chn->dst, sipc_chn->chn);
	}
	WCN_INFO("sipc chn[%d] deinit success!\n", ops->channel);

	return 0;
}

static void wcn_sipc_module_init(void)
{
	mutex_init(&g_sipc_info.status_lock);
	WCN_INFO("sipc module init success\n");
}

static void wcn_sipc_module_deinit(void)
{
	mutex_destroy(&g_sipc_info.status_lock);
	WCN_INFO("sipc module deinit success\n");
}

static struct sprdwcn_bus_ops sipc_bus_ops = {
	.chn_init = wcn_sipc_chn_init,
	.chn_deinit = wcn_sipc_chn_deinit,
	.list_alloc = wcn_sipc_buf_list_alloc,
	.list_free = wcn_sipc_buf_list_free,
	.push_list = wcn_sipc_buf_push,
	.get_carddump_status = wcn_sipc_get_status,
	.set_carddump_status = wcn_sipc_set_status,
	.get_rx_total_cnt = wcn_sipc_get_rxcnt,

};

void module_bus_init(void)
{
	wcn_sipc_module_init();
	module_ops_register(&sipc_bus_ops);
	WCN_INFO("sipc bus init success\n");
}
EXPORT_SYMBOL(module_bus_init);

void module_bus_deinit(void)
{
	module_ops_unregister();
	wcn_sipc_module_deinit();
	WCN_INFO("sipc bus deinit success\n");
}
EXPORT_SYMBOL(module_bus_deinit);