/* SPDX-License-Identifier: GPL-2.0 */
#include <linux/err.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/time.h>
#include <linux/kernel.h>

#include "sprdwl.h"
#include "edma_test.h"
#include "wl_intf.h"

#define PCIE_CHANNEL_PAIR (8)
#define RUN 1
#define STOP 0
#define RAW_DATA_LEN 10

#define WL_SEQ_NUM_MASK			0xfff /* allow 12 bit */
#define WL_SEQ_NUM_SHIFT		0
#define WL_SEQ_SET_NUM(x, val)	((x) = \
	((x) & ~(WL_SEQ_NUM_MASK << WL_SEQ_NUM_SHIFT)) | \
	(((val) & WL_SEQ_NUM_MASK) << WL_SEQ_NUM_SHIFT))
#define WL_SEQ_GET_NUM(x)	(((x) >> WL_SEQ_NUM_SHIFT) & \
	WL_SEQ_NUM_MASK)

extern struct sprdwl_intf_ops g_intf_ops;
extern int if_tx_one(struct sprdwl_intf *intf, unsigned char *data,
		     int len, int chn);

unsigned long loop;

static struct dentry *chn_tx_dentry[8];
static unsigned int chn_tx_num[8];
static unsigned int chn_tx_success[8];
static unsigned int chn_tx_fail[8];

struct edma_test_cmd_header {
	u16 subcmd;
	u16 len;
	u8 data[0];
} __packed;

struct task_struct *task_array[PCIE_CHANNEL_PAIR];
int task_status;

void edma_transceive_test_init(void)
{
	int i, err;

	wl_err("Enter %s\n", __func__);

	for (i = 0; i < PCIE_CHANNEL_PAIR; i++) {
		task_array[i] = kthread_create(edma_transceive_test_exec,
					NULL, "edma_transceive_task");
		if (IS_ERR(task_array[i])) {
			err = PTR_ERR(task_array[i]);
			wl_err("%s, Fail, thread_num=%d,error_num=%d.",
				__func__, i, err);
		}
	}

	wl_err("Exit %s\n", __func__);
}

void edma_transceive_test_deinit(void)
{
	int i;

	wl_err("Enter %s\n", __func__);

	for (i = 0; i < PCIE_CHANNEL_PAIR; i++) {
		if (!IS_ERR_OR_NULL(task_array[i])) {
			wl_err(" %s, Destory thread, thread_num=%d,\n",
			       __func__, i);
			kthread_stop(task_array[i]);
			task_array[i] = NULL;
		}
	}

	wl_err("Exit %s\n", __func__);
}

int do_tx(int channel)
{
	int ret = 0;
	struct sprdwl_msg_buf *msg;
	struct edma_test_cmd_header *p;
	unsigned char raw_data[RAW_DATA_LEN];
	struct sprdwl_intf *intf = (struct sprdwl_intf *)g_intf_ops.intf;
	struct sprdwl_priv *priv = intf->priv;

	memset(raw_data, channel, RAW_DATA_LEN);

	msg = sprdwl_cmd_getbuf(priv, sizeof(*p) + RAW_DATA_LEN,
				0, SPRDWL_HEAD_RSP,
				channel);
	if (!msg) {
		wl_err(" %s, No mem for msg,\n", __func__);
		return -ENOMEM;
	}

	p = (struct edma_test_cmd_header *)msg->data;
	p->subcmd = channel;
	p->len = RAW_DATA_LEN;
	memcpy(p->data, raw_data, RAW_DATA_LEN);

	sprdwl_queue_msg_buf(msg, msg->msglist);

	ret = if_tx_one(intf, msg->tran_data, msg->len, channel);

	if (ret) {
		wl_err("%s send cmd failed (ret=%d)\n", __func__, ret);
		kfree(msg->tran_data);
		msg->tran_data = NULL;
	}

	sprdwl_dequeue_msg_buf(msg, msg->msglist);

	return 0;
}


#define SPRDWL_SDIO_DEBUG_BUFLEN 128
static ssize_t pcie_read_info(struct file *file,
			      char __user *user_buf,
			      size_t count, loff_t *ppos)
{
	size_t ret = 0;
	unsigned int buflen, len;
	unsigned char *buf;
	unsigned long chn = (unsigned long)file->private_data;

	buflen = SPRDWL_SDIO_DEBUG_BUFLEN;
	buf = kzalloc(buflen, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	len = 0;
	len += scnprintf(buf, buflen, "chn: %d, num: %d, success: %d, fail: %d\n",
			 ((int)chn)*2, chn_tx_num[chn], chn_tx_success[chn], chn_tx_fail[chn]);
	if (len > buflen)
		len = buflen;

	ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
	kfree(buf);

	return ret;
}

static const struct file_operations pcie_debug_fops = {
	.read = pcie_read_info,
	.open = simple_open,
	.owner = THIS_MODULE,
	.llseek = default_llseek,
};

const unsigned char *tx_name[] = {
	"edma_transceive_0",
	"edma_transceive_2",
	"edma_transceive_4",
	"edma_transceive_6",
	"edma_transceive_8",
	"edma_transceive_10",
	"edma_transceive_12",
	"edma_transceive_14",
};

void edma_transceive_test_run(int pairs)
{
	int i, err;
	struct sprdwl_intf *intf = (struct sprdwl_intf *)g_intf_ops.intf;
	struct sprdwl_priv *priv = intf->priv;

	wl_info("Enter %s\n", __func__);

	memset(task_array, 0, sizeof(struct task_struct *)*PCIE_CHANNEL_PAIR);
	memset(chn_tx_dentry, 0, sizeof(struct dentry *)*PCIE_CHANNEL_PAIR);

	loop = 0;
	for (i = 0; i < pairs; i++) {
		chn_tx_num[i] = 0;
		chn_tx_success[i] = 0;
		chn_tx_fail[i] = 0;

		task_array[i] = kthread_create(edma_transceive_test_exec,
							    (unsigned long *)loop,
							    "edma_transceive_%d", i);
		chn_tx_dentry[i] = debugfs_create_file(tx_name[i], S_IRUSR, priv->debugfs, (unsigned long *)loop, &pcie_debug_fops);
		loop++;
		if (IS_ERR(task_array[i])) {
			err = PTR_ERR(task_array[i]);
			wl_err("%s, Fail, thread_num=%d,error_num=%d.",
			       __func__, i, err);
		} else {
			wl_info(" %s, Start thread, thread_num=%d,\n",
				__func__, i);
			wake_up_process(task_array[i]);
		}
	}

	wl_info("Exit %s\n", __func__);
}

void edma_transceive_test_stop(void)
{
	int i;

	wl_info("Enter %s\n", __func__);

	for (i = 0; i < PCIE_CHANNEL_PAIR; i++) {
		if (!IS_ERR_OR_NULL(task_array[i])) {
			wl_err(" %s, Stop thread, thread_num=%d,\n",
			       __func__, i);
			kthread_stop(task_array[i]);
			task_array[i] = NULL;
		}

		if (!IS_ERR_OR_NULL(chn_tx_dentry[i])) {
			wl_err(" %s, deinit tx dentry: %d\n", __func__, i);
			debugfs_remove(chn_tx_dentry[i]);
			chn_tx_dentry[i] = NULL;
		}
	}

	wl_info("Exit %s\n", __func__);
}

int edma_transceive_test_exec(void *args)
{
	unsigned long chn = (unsigned long)args;
	int ret = 0;
	//struct sched_param param;

	wl_err("Enter %s\n", __func__);

	while (1) {
		if (kthread_should_stop()) {
			wl_err(" %s, Exec thread, stopped.\n", __func__);
			break;
		}

		__set_current_state(TASK_RUNNING);
		wl_info(" %s, Exec thread, thread_num=%ld.\n", __func__, chn);
		/* do tx */
		chn_tx_num[chn]++;
		ret = do_tx((int)chn * 2);
		if (ret)
			chn_tx_fail[chn]++;
		else
			chn_tx_success[chn]++;
		msleep(1);
	}

	wl_err("Exit %s\n", __func__);

	return 0;
}

char *
__strtok(char **string, const char *delimiters, char *tokdelim)
{
	unsigned char *str;
	unsigned long map[8];
	int count;
	char *nextoken;

	if (tokdelim != NULL) {
		/* Prime the token delimiter */
		*tokdelim = '\0';
	}

	/* Clear control map */
	for (count = 0; count < 8; count++)
		map[count] = 0;

	/* Set bits in delimiter table */
	do {
		map[*delimiters >> 5] |= (1 << (*delimiters & 31));
	} while (*delimiters++);

	str = (unsigned char *)*string;

	/* Find beginning of token (skip over leading delimiters). Note that
	 * there is no token iff this loop sets str to point to the terminal
	 * null (*str == '\0')
	 */
	while (((map[*str >> 5] & (1 << (*str & 31))) &&
		*str) || (*str == ' '))
		str++;

	nextoken = (char *)str;

	/* Find the end of the token. If it is not the end of the string,
	 * put a null there.
	 */
	for (; *str; str++) {
		if (map[*str >> 5] & (1 << (*str & 31))) {
			if (tokdelim != NULL)
				*tokdelim = *str;

			*str++ = '\0';
			break;
		}
	}

	*string = (char *)str;

	/* Determine if a token has been found. */
	if (nextoken == (char *)str)
		return NULL;
	else
		return nextoken;
}

void edma_transceive_test_trigger(char *cmd)
{
	long oper, pairs;
	char *delim_1 = "=";
	char *delim_2 = ",";

	__strtok(&cmd, delim_1, 0);
	/* oper = (int)simple_strtol(cmd, NULL, 0); */
	if (kstrtol(cmd, 10, &oper) < 0) {
		wl_err("%s, %s is invalid\n", __func__, cmd);
		return;
	}


	__strtok(&cmd, delim_2, 0);
	/* pairs = (int)simple_strtol(cmd, NULL, 0); */
	if (kstrtol(cmd, 10, &pairs) < 0) {
		wl_err("%s, %s is invalid\n", __func__, cmd);
		return;
	}

	wl_err("Enter %s\n", __func__);

	if (pairs <= 0 || pairs > PCIE_CHANNEL_PAIR) {
		wl_err("%s, Invalid chn pairs(%ld), use default val(8)\n",
		       __func__, pairs);
		pairs = PCIE_CHANNEL_PAIR;
	}

	switch (oper) {
	case RUN:
		wl_err("%s, Run task\n", __func__);
		if (task_status == RUN) {
			wl_err("%s, Already running\n", __func__);
			return;
		}

		edma_transceive_test_run((int)pairs);
		task_status = RUN;
		break;
	case STOP:
		wl_err("%s, Stop task\n", __func__);
		if (task_status == STOP) {
			wl_err("%s, Already stopped\n", __func__);
			return;
		}

		edma_transceive_test_stop();
		task_status = STOP;
		break;
	default:
		wl_err("%s, Unknown trigger\n", __func__);
		break;
	}

	wl_err("Exit %s\n", __func__);
}