// SPDX-License-Identifier: (GPL-2.0+ OR MIT)

/* Copyright (c) 2023 Rockchip Electronics Co., Ltd. */

#include <linux/kernel.h>
#include <linux/debugfs.h>
#include <linux/dma-mapping.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/list.h>
#include <linux/io.h>
#include <linux/mempolicy.h>
#include <linux/miscdevice.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/of_reserved_mem.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/soc/rockchip/rk_vendor_storage.h>
#include <linux/uaccess.h>
#include <misc/rkflash_vendor_storage.h>

static struct vendor_info *g_vendor;

static int ram_vendor_read(u32 id, void *pbuf, u32 size)
{
	u32 i;

	if (!g_vendor)
		return -ENOMEM;

	for (i = 0; i < g_vendor->item_num; i++) {
		if (g_vendor->item[i].id == id) {
			if (size > g_vendor->item[i].size)
				size = g_vendor->item[i].size;
			memcpy(pbuf, &g_vendor->data[g_vendor->item[i].offset], size);
			return size;
		}
	}

	return (-1);
}

static int ram_vendor_storage_open(struct inode *inode, struct file *file)
{
	return 0;
}

static int ram_vendor_storage_release(struct inode *inode, struct file *file)
{
	return 0;
}

static long ram_vendor_storage_ioctl(struct file *file, unsigned int cmd,
				 unsigned long arg)
{
	long ret = -1;
	int size;
	struct RK_VENDOR_REQ *v_req;
	u32 *page_buf;

	page_buf = kmalloc(4096, GFP_KERNEL);
	if (!page_buf)
		return -ENOMEM;

	v_req = (struct RK_VENDOR_REQ *)page_buf;

	switch (cmd) {
	case VENDOR_READ_IO:
	{
		if (copy_from_user(page_buf, (void __user *)arg, 8)) {
			ret = -EFAULT;
			break;
		}
		if (v_req->tag == VENDOR_REQ_TAG && v_req->len <= 4096 - 8) {
			size = ram_vendor_read(v_req->id, v_req->data, v_req->len);
			if (size != -1) {
				v_req->len = size;
				ret = 0;
				if (copy_to_user((void __user *)arg,
						 page_buf,
						 v_req->len + 8))
					ret = -EFAULT;
			}
		}
	} break;

	case VENDOR_WRITE_IO:
	default:
		ret = -EINVAL;
		goto exit;
	}
exit:
	kfree(page_buf);
	return ret;
}

static const struct file_operations vendor_storage_fops = {
	.open = ram_vendor_storage_open,
	.compat_ioctl = ram_vendor_storage_ioctl,
	.unlocked_ioctl = ram_vendor_storage_ioctl,
	.release = ram_vendor_storage_release,
};

static struct miscdevice vender_storage_dev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name  = "vendor_storage",
	.fops  = &vendor_storage_fops,
};

static void *ram_vendor_stroage_map(phys_addr_t start, size_t len)
{
	int i;
	void *vaddr;
	pgprot_t pgprot = PAGE_KERNEL;
	phys_addr_t phys;
	int npages = PAGE_ALIGN(len) / PAGE_SIZE;
	struct page **p = vmalloc(sizeof(struct page *) * npages);

	if (!p)
		return NULL;

	phys = start;
	for (i = 0; i < npages; i++) {
		p[i] = phys_to_page(phys);
		phys += PAGE_SIZE;
	}

	vaddr = vmap(p, npages, VM_MAP, pgprot);
	vfree(p);

	return vaddr;
}

static int ram_vendor_storage_probe(struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;
	struct device_node *node;
	struct resource res;
	int ret;
	phys_addr_t size, start;

	if (g_vendor)
		return -EINVAL;

	node = of_parse_phandle(np, "memory-region", 0);
	if (!node)
		return -ENOMEM;

	ret = of_address_to_resource(node, 0, &res);
	if (ret)
		return ret;

	ret = -EINVAL;

	size = resource_size(&res);
	start = res.start;
	if (size != VENDOR_PART_SIZE << 9 || (start & (PAGE_SIZE - 1)))
		goto un_reserved;

	g_vendor = ram_vendor_stroage_map(start, size);
	if (IS_ERR(g_vendor))
		goto un_reserved;

	if (g_vendor->tag != VENDOR_HEAD_TAG)
		goto un_remap;

	misc_register(&vender_storage_dev);
	rk_vendor_register(ram_vendor_read, NULL);

	return 0;

un_remap:
	vunmap(g_vendor);
un_reserved:
#ifndef MODULE
	free_reserved_area(phys_to_virt(start), phys_to_virt(start) + size, -1, "memory-region");
#endif
	g_vendor = NULL;

	return ret;
}

static int ram_vendor_storage_remove(struct platform_device *pdev)
{
	if (g_vendor) {
		misc_deregister(&vender_storage_dev);
		vunmap(g_vendor);
		g_vendor = NULL;
	}

	return 0;
}

static const struct of_device_id dt_match[] = {
	{ .compatible = "rockchip,ram-vendor-storage" },
	{}
};

static struct platform_driver vendor_storage_driver = {
	.probe		= ram_vendor_storage_probe,
	.remove		= ram_vendor_storage_remove,
	.driver		= {
		.name		= "vendor-storage",
		.of_match_table	= dt_match,
	},
};

module_platform_driver(vendor_storage_driver);
MODULE_LICENSE("GPL");