/* SPDX-License-Identifier: GPL-2.0 */
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/wait.h>

#include "rdc_debug.h"
#include "wcn_glb.h"
#include "wcn_misc.h"

#define MDBG_WRITE_SIZE			(64)
#define WCN_LOG_MAJOR 255
static int wcn_log_major = WCN_LOG_MAJOR;
static struct class		*wcnlog_class;

struct wcnlog_dev {
	struct cdev cdev;
	int			major;
	int			minor;
};

struct mdbg_device_t *mdbg_dev;
wait_queue_head_t	mdbg_wait;

int wake_up_log_wait(void)
{
	if (!mdbg_dev->exit_flag) {
		wake_up_interruptible(&mdbg_dev->rxwait);
		wake_up_interruptible(&mdbg_wait);
	}

	return 0;
}

void wcnlog_clear_log(void)
{
	if (mdbg_dev->ring_dev->ring->rp
		!= mdbg_dev->ring_dev->ring->wp) {
		WCN_INFO("log:%ld left in ringbuf not read\n",
			(long int)(mdbg_dev->ring_dev->ring->wp -
			mdbg_dev->ring_dev->ring->rp));
		mdbg_ring_clear(mdbg_dev->ring_dev->ring);
	}
}

static int wcnlog_open(struct inode *inode, struct file *filp)
{
	struct wcnlog_dev *dev;

	int minor = iminor(filp->f_path.dentry->d_inode);
	int minor1 = iminor(inode);
	int major = imajor(inode);

	WCN_INFO("minor=%d,minor1=%d,major=%d\n", minor, minor1, major);

	if (mdbg_dev->exit_flag) {
		WCN_INFO("wcnlog_open exit!\n");
		return -EIO;
	}

	dev = container_of(inode->i_cdev, struct wcnlog_dev, cdev);
	filp->private_data = dev;

	WCN_DEBUG("wcnlog_open z=%d,major=%d,minor = %d\n",
		dev->cdev.dev, MAJOR(dev->cdev.dev), MINOR(dev->cdev.dev));

	if (mdbg_dev->open_count != 0)
		MDBG_ERR("open count %d\n", mdbg_dev->open_count);

	mdbg_dev->open_count++;

	return 0;
}

static int wcnlog_release(struct inode *inode, struct file *filp)
{
	struct wcnlog_dev *dev = filp->private_data;

	WCN_INFO("wcnlog_release z=%d,major=%d,minor = %d\n",
		dev->cdev.dev, MAJOR(dev->cdev.dev), MINOR(dev->cdev.dev));
	mdbg_dev->open_count--;

	return 0;
}

static ssize_t wcnlog_read(struct file *filp,
		char __user *buf, size_t count, loff_t *ppos)
{
	long int read_size;
	int timeout = -1;
	int rval = 0;
	static unsigned int dum_send_size;
	struct wcnlog_dev *dev = filp->private_data;

	if (mdbg_dev->exit_flag) {
		WCN_INFO("wcnlog_read exit!\n");
		return -EIO;
	}

	if (filp->f_flags & O_NONBLOCK)
		timeout = 0;

	WCN_DEBUG("wcnlog_read timeout=%d,major=%d, minor=%d\n",
		timeout, dev->major, dev->minor);

	WCN_DEBUG("wcnlog_read z=%d,major=%d,minor = %d\n", dev->cdev.dev,
		MAJOR(dev->cdev.dev), MINOR(dev->cdev.dev));
	/* count :100K-log, 32K-mem ;cat :4096 */
	WCN_DEBUG("wcnlog_read len = %ld\n", (long int)count);
	if ((functionmask[7] & CP2_FLAG_YLOG) == 1)
		return -EIO;

	if (MINOR(dev->cdev.dev) == 1) {
		WCN_INFO("unsupported to read slog_wcn1: BT audio data\n");
		return -EPERM;
	}

	if (filp->f_flags & O_NONBLOCK)
		timeout = 0;

	if (count > MDBG_RX_RING_SIZE)
		count = MDBG_RX_RING_SIZE;

	if (timeout < 0) {
		/* when kernel go to sleep, it return -512 */
		rval = wait_event_interruptible(mdbg_wait,
				(mdbg_content_len() > 0));
		if (rval < 0)
			WCN_INFO("wait interrupted=%d\n", rval);
	}

	mutex_lock(&mdbg_dev->mdbg_lock);
	read_size = mdbg_receive((void *)buf, (long int)count);
	if (sprdwcn_bus_get_carddump_status() == 1) {
		dum_send_size += read_size;
		WCN_INFO("read_size = %ld dum_total_size= %d,remainder =%ld\n",
				read_size, dum_send_size, mdbg_content_len());
	}
	/* read_size = log1040 or mem32K, 1024 */
	if (read_size > 0) {
		WCN_DEBUG("Show %ld bytes data.", read_size);
		rval = read_size;
	} else if (read_size == 0)
		rval = -EAGAIN;
	else {
		rval = read_size;
		WCN_DEBUG("log read error %d\n", rval);
	}
	mutex_unlock(&mdbg_dev->mdbg_lock);

	return rval;

}

static ssize_t wcnlog_write(struct file *filp,
		const char __user *buf, size_t count, loff_t *ppos)
{
	long int sent_size = 0;
	char *p_data = NULL;

	if (mdbg_dev->exit_flag) {
		WCN_INFO("wcnlog_write exit!\n");
		return -EIO;
	}

	WCN_INFO("wcnlog_write count=%ld\n", (long int)count);
	if (count > MDBG_WRITE_SIZE) {
		WCN_ERR("mdbg_write count > MDBG_WRITE_SIZE\n");
		return -ENOMEM;
	}

	if (NULL == buf || 0 == count) {
		WCN_ERR("Param Error!");
		return count;
	}

	p_data = memdup_user(buf, count);
	mutex_lock(&mdbg_dev->mdbg_lock);
	sent_size = mdbg_send_atcmd(p_data, count, WCN_ATCMD_LOG);
	mutex_unlock(&mdbg_dev->mdbg_lock);
	kfree(p_data);

	WCN_DEBUG("sent_size = %ld", sent_size);

	return sent_size;
}

static unsigned int wcnlog_poll(struct file *filp, poll_table *wait)
{
	unsigned int mask = 0;

	MDBG_LOG("wcnlog_poll\n");
	if ((!mdbg_dev) || (mdbg_dev->exit_flag)) {
		WCN_INFO("wcnlog_poll exit!\n");
		mask |= POLLIN | POLLERR;
		return mask;
	}
	poll_wait(filp, &mdbg_dev->rxwait, wait);
	if (mdbg_content_len() > 0)
		mask |= POLLIN | POLLRDNORM;

	return mask;
}

static long wcnlog_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	if (mdbg_dev->exit_flag) {
		WCN_INFO("wcnlog_ioctl exit!\n");
		return -EIO;
	}

	return 0;
}

static const struct file_operations wcnlog_fops = {
	.open		= wcnlog_open,
	.release	= wcnlog_release,
	.read		= wcnlog_read,
	.write		= wcnlog_write,
	.poll		= wcnlog_poll,
	.unlocked_ioctl	= wcnlog_ioctl,
	.owner		= THIS_MODULE,
	.llseek		= default_llseek,
};

static int wcnlog_register_device(struct wcnlog_dev *dev, int index)
{
	dev_t devno;
	int ret;

	devno = MKDEV(wcn_log_major, index);
	dev->cdev.owner = THIS_MODULE;
	cdev_init(&dev->cdev, &wcnlog_fops);
	ret = cdev_add(&dev->cdev, devno, 1);
	if (ret != 0) {
		unregister_chrdev_region(devno, 1);
		WCN_ERR("Failed to add wcn log cdev\n");
		return ret;
	}
	dev->major = MAJOR(devno);
	dev->minor = MINOR(devno);
	WCN_DEBUG("log dev major=%d,minor=%d\n", dev->major, dev->minor);
	device_create(wcnlog_class, NULL,
			MKDEV(MAJOR(devno), MINOR(devno)),
			NULL, "%s%d", "slog_wcn", index);

	return 0;
}

int log_cdev_init(void)
{
	int ret = -1;
	int	i;
	int iflag = -1;
	dev_t devno;

	struct wcnlog_dev *dev[WCN_LOG_MAX_MINOR] = {NULL};

	WCN_DEBUG("log_cdev_init\n");
	wcnlog_class = class_create(THIS_MODULE, "slog_wcn");
	if (IS_ERR(wcnlog_class))
		return PTR_ERR(wcnlog_class);

	devno = MKDEV(wcn_log_major, 0);
	if (wcn_log_major)
		ret = register_chrdev_region(devno,
				WCN_LOG_MAX_MINOR, "wcnlog");
	if (ret < 0) {
		WCN_INFO("failed to apply for static device number");
		ret = alloc_chrdev_region(&devno, 0,
				WCN_LOG_MAX_MINOR, "wcnlog");
		wcn_log_major = MAJOR(devno);
	}

	if (ret < 0) {
		WCN_ERR("failed to apply for device number");
		return ret;
	}

	for (i = 0; i < WCN_LOG_MAX_MINOR; i++) {
		dev[i] = kmalloc(sizeof(struct wcnlog_dev), GFP_KERNEL);
		if (!dev[i]) {
			WCN_ERR("failed alloc mem!\n");
			continue;
		}
		iflag = 1;
		ret = wcnlog_register_device(dev[i], i);
		if (ret != 0) {
			kfree(dev[i]);
			dev[i] = NULL;
			continue;
		}
		mdbg_dev->dev[i] = dev[i];
	}
	/* kmalloc fail */
	if (iflag == -1) {
		unregister_chrdev_region(devno, 1);
		ret = -1;
	}

	return ret;
}

int log_cdev_exit(void)
{
	struct wcnlog_dev *dev[WCN_LOG_MAX_MINOR];
	int i;

	WCN_INFO("log_cdev_exit\n");

	for (i = 0; i < WCN_LOG_MAX_MINOR; i++) {
		dev[i] = mdbg_dev->dev[i];
		if (!dev[i])
			continue;
		device_destroy(wcnlog_class, (&(dev[i]->cdev))->dev);
		cdev_del(&(dev[i]->cdev));
		kfree(dev[i]);
		dev[i] = NULL;
	}

	class_destroy(wcnlog_class);

	unregister_chrdev_region(MKDEV(wcn_log_major, 0), WCN_LOG_MAX_MINOR);

	return 0;
}

int log_dev_init(void)
{
	int err;

	MDBG_FUNC_ENTERY;
	mdbg_dev = kzalloc(sizeof(struct mdbg_device_t), GFP_KERNEL);
	if (!mdbg_dev)
		return -ENOMEM;

	mdbg_dev->open_count = 0;
	mutex_init(&mdbg_dev->mdbg_lock);
	init_waitqueue_head(&mdbg_dev->rxwait);
	init_waitqueue_head(&mdbg_wait);
	err = mdbg_ring_init();
	if (err < 0)
		return -ENOMEM;

	log_cdev_init();
	mdbg_dev->exit_flag = 0;

	return 0;
}

int log_dev_exit(void)
{
	mdbg_dev->exit_flag = 1;
	log_cdev_exit();

	/* free for old mdbg_dev */
	mdbg_ring_remove();
	mutex_destroy(&mdbg_dev->mdbg_lock);
	kfree(mdbg_dev);

	return 0;
}