/*
 * drivers/amlogic/memory_ext/ram_dump.c
 *
 * Copyright (C) 2017 Amlogic, Inc. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 <linux/version.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/reboot.h>
#include <linux/memblock.h>
#include <linux/amlogic/ramdump.h>
#include <linux/amlogic/reboot.h>
#include <linux/arm-smccc.h>
#include <linux/of.h>
#include <linux/highmem.h>
#include <asm/cacheflush.h>

static unsigned long ramdump_base	__initdata;
static unsigned long ramdump_size	__initdata;
static bool ramdump_disable		__initdata;

struct ramdump {
	unsigned long		mem_base;
	unsigned long		mem_size;
	struct mutex		lock;
	struct kobject		*kobj;
	struct work_struct	clear_work;
	int			disable;
};

static struct ramdump *ram;

static void meson_set_reboot_reason(int reboot_reason)
{
	struct arm_smccc_res smccc;

	arm_smccc_smc(SET_REBOOT_REASON,
		      reboot_reason, 0, 0, 0, 0, 0, 0, &smccc);
	return;
}

static int __init early_ramdump_para(char *buf)
{
	int ret;

	if (!buf)
		return -EINVAL;

	pr_info("%s:%s\n", __func__, buf);
	if (strcmp(buf, "disabled") == 0) {
		ramdump_disable = 1;
	} else {
		ret = sscanf(buf, "%lx,%lx", &ramdump_base, &ramdump_size);
		if (ret != 2) {
			pr_err("invalid boot args\n");
			ramdump_disable = 1;
		}
		pr_info("%s, base:%lx, size:%lx\n",
			__func__, ramdump_base, ramdump_size);
		ret = memblock_reserve(ramdump_base, PAGE_ALIGN(ramdump_size));
		if (ret < 0) {
			pr_info("reserve memblock %lx - %lx failed\n",
				ramdump_base,
				ramdump_base + PAGE_ALIGN(ramdump_size));
			ramdump_disable = 1;
		}
	}
	if (ramdump_disable)
		meson_set_reboot_reason(MESON_NORMAL_BOOT);

	return 0;
}
early_param("ramdump", early_ramdump_para);

static ssize_t ramdump_bin_read(struct file *filp, struct kobject *kobj,
				struct bin_attribute *attr,
				char *buf, loff_t off, size_t count)
{
	void *p = NULL;
#ifndef CONFIG_64BIT
	struct page *page, *pages[1];
#endif

	if (!ram->mem_base || off >= ram->mem_size)
		return 0;

#ifndef CONFIG_64BIT
	page = phys_to_page(ram->mem_base + off);
	pages[0] = page;
	p = vmap(pages, 1, VM_MAP, PAGE_KERNEL);
	if (!p) {
		pr_info("%s, map %lx, %d failed, page:%p, pfn:%lx\n",
			__func__, (unsigned long)(ram->mem_base + off),
			count, page, page_to_pfn(page));
		return -EINVAL;
	}
#else
	p = (void *)(ram->mem_base + off);
#endif
	if (off + count > ram->mem_size)
		count = ram->mem_size - off;
	mutex_lock(&ram->lock);
	memcpy(buf, p, count);
	mutex_unlock(&ram->lock);

	/* debug when read end */
	if (off + count >= ram->mem_size)
		pr_info("%s, p=%p %p, off:%lli, c:%zi\n",
			__func__, buf, p, off, count);
#ifndef CONFIG_64BIT
	vunmap(p);
#endif
	return count;
}

int ramdump_disabled(void)
{
	if (ram)
		return ram->disable;
	return 0;
}
EXPORT_SYMBOL(ramdump_disabled);

static ssize_t ramdump_bin_write(struct file *filp,
				 struct kobject *kobj,
				 struct bin_attribute *bin_attr,
				 char *buf, loff_t off, size_t count)
{
	if (!ram->mem_size)
		return -EINVAL;

	if (ram->mem_base && !strncmp("reboot", buf, 6))
		kernel_restart("RAM-DUMP finished\n");

	if (!strncmp("disable", buf, 7)) {
		ram->disable = 1;
		meson_set_reboot_reason(MESON_NORMAL_BOOT);
	}
	if (!strncmp("enable", buf, 6)) {
		ram->disable = 0;
		meson_set_reboot_reason(MESON_KERNEL_PANIC);
	}

	return count;
}

static struct bin_attribute ramdump_attr = {
	.attr = {
		.name = "compmsg",
		.mode = S_IRUGO | S_IWUSR,
	},
	.read  = ramdump_bin_read,
	.write = ramdump_bin_write,
};

/*
 * clear memory to avoid large amount of memory not used.
 * for ramdom data, it's hard to compress
 */
static void lazy_clear_work(struct work_struct *work)
{
	struct page *page;
	struct list_head head, *pos, *next;
	void *virt;
	int order;
	gfp_t flags = __GFP_NORETRY   |
		      __GFP_NOWARN    |
		      __GFP_MOVABLE;
	unsigned long clear = 0, size = 0, free = 0, tick;

	INIT_LIST_HEAD(&head);
	order = MAX_ORDER - 1;
	tick = sched_clock();
	do {
		page = alloc_pages(flags, order);
		if (page) {
			list_add(&page->lru, &head);
			virt = page_address(page);
			size = (1 << order) * PAGE_SIZE;
			memset(virt, 0, size);
			clear += size;
		}
	} while (page);
	tick = sched_clock() - tick;

	list_for_each_safe(pos, next, &head) {
		page = list_entry(pos, struct page, lru);
		list_del(&page->lru);
		__free_pages(page, order);
		free += size;
	}
	pr_info("clear:%lx, free:%lx, tick:%ld us\n",
		clear, free, tick / 1000);
}

#ifdef CONFIG_ARM64
void ramdump_sync_data(void)
{
	/*
	 * back port from old kernel verion for function
	 * flush_cache_all(), we need it for ram dump
	 */
	asm volatile (
		"mov	x12, x30			\n"
		"dsb	sy				\n"
		"mrs	x0, clidr_el1			\n"
		"and	x3, x0, #0x7000000		\n"
		"lsr	x3, x3, #23			\n"
		"cbz	x3, finished			\n"
		"mov	x10, #0				\n"
	"loop1:						\n"
		"add	x2, x10, x10, lsr #1		\n"
		"lsr	x1, x0, x2			\n"
		"and	x1, x1, #7			\n"
		"cmp	x1, #2				\n"
		"b.lt	skip				\n"
		"mrs	x9, daif			\n"
		"msr    daifset, #2 			\n"
		"msr	csselr_el1, x10			\n"
		"isb					\n"
		"mrs	x1, ccsidr_el1			\n"
		"msr    daif, x9			\n"
		"and	x2, x1, #7			\n"
		"add	x2, x2, #4			\n"
		"mov	x4, #0x3ff			\n"
		"and	x4, x4, x1, lsr #3		\n"
		"clz	w5, w4				\n"
		"mov	x7, #0x7fff			\n"
		"and	x7, x7, x1, lsr #13		\n"
	"loop2:						\n"
		"mov	x9, x4				\n"
	"loop3:						\n"
		"lsl	x6, x9, x5			\n"
		"orr	x11, x10, x6			\n"
		"lsl	x6, x7, x2			\n"
		"orr	x11, x11, x6			\n"
		"dc	cisw, x11			\n"
		"subs	x9, x9, #1			\n"
		"b.ge	loop3				\n"
		"subs	x7, x7, #1			\n"
		"b.ge	loop2				\n"
	"skip:						\n"
		"add	x10, x10, #2			\n"
		"cmp	x3, x10				\n"
		"b.gt	loop1				\n"
	"finished:					\n"
		"mov	x10, #0				\n"
		"msr	csselr_el1, x10			\n"
		"dsb	sy				\n"
		"isb					\n"
		"mov	x0, #0				\n"
		"ic	ialluis				\n"
		"ret	x12				\n"
	);
}
#else
void ramdump_sync_data(void)
{
	flush_cache_all();
}
#endif

static int __init ramdump_probe(struct platform_device *pdev)
{
	void __iomem *p = NULL;
	struct device_node *np;
	unsigned long dts_memory[2] = {0}, total_mem;
	struct resource *res;
	unsigned int dump_set;
	int ret;
	void __iomem *base;

	np = of_find_node_by_name(NULL, "memory");
	if (!np)
		return -EINVAL;

#ifdef CONFIG_64BIT
	ret = of_property_read_u64_array(np, "linux,usable-memory",
					 (u64 *)&dts_memory, 2);
	if (ret)
		ret = of_property_read_u64_array(np, "reg",
						 (u64 *)&dts_memory, 2);
#else
	ret = of_property_read_u32_array(np, "linux,usable-memory",
					 (u32 *)&dts_memory, 2);
	if (ret)
		ret = of_property_read_u32_array(np, "reg",
						 (u32 *)&dts_memory, 2);
#endif
	if (ret)
		pr_info("can't get dts memory\n");
	else
		pr_info("MEMORY:[%lx+%lx]\n", dts_memory[0], dts_memory[1]);
	of_node_put(np);

	/*
	 * memory in dts is [start_addr size] patten. For amlogic soc,
	 * ddr address range is started from 0x0, usually start_addr in
	 * dts should be started with 0x0, but some soc must reserve a
	 * small framgment of memory at 0x0 for start up code. So start_addr
	 * can be 0x100000/0x1000000. But we always using 0x0 to get real
	 * DDR size for ramdump. So we using following formula to get total
	 * DDR size.
	 */
	total_mem = dts_memory[0] + dts_memory[1];

	ram = kzalloc(sizeof(struct ramdump), GFP_KERNEL);
	if (!ram)
		return -ENOMEM;

	if (ramdump_disable)
		ram->disable = 1;

	if (!ramdump_base || !ramdump_size) {
		pr_info("NO valid ramdump args:%lx %lx\n",
			ramdump_base, ramdump_size);
	} else {
	#ifdef CONFIG_64BIT
		p = ioremap_cache(ramdump_base, ramdump_size);
		ram->mem_base = (unsigned long)p;
		ram->mem_size = ramdump_size;
	#else
		ram->mem_base = ramdump_base;
		ram->mem_size = ramdump_size;
	#endif
		pr_info("%s, mem_base:%p, %lx, size:%lx\n",
			__func__, p, ramdump_base, ramdump_size);
	}
	ram->kobj = kobject_create_and_add("mdump", kernel_kobj);
	if (!ram->kobj) {
		pr_err("%s, create sysfs failed\n", __func__);
		goto err;
	}
	ramdump_attr.size = ram->mem_size;
	if (sysfs_create_bin_file(ram->kobj, &ramdump_attr)) {
		pr_err("%s, create sysfs1 failed\n", __func__);
		goto err1;
	}
	mutex_init(&ram->lock);
	if (!ram->disable && !ram->mem_size) {
		INIT_WORK(&ram->clear_work, lazy_clear_work);
		schedule_work(&ram->clear_work);
	}
	res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
					   "PREG_STICKY_REG8");
	if (res) {
		base = devm_ioremap(&pdev->dev, res->start,
						res->end - res->start);
		if (!base) {
			pr_err("%s, map reg failed\n", __func__);
			goto err;
		}
		dump_set = readl(base);
		dump_set &= ~RAMDUMP_STICKY_DATA_MASK;
		dump_set |= ((total_mem >> 20) | AMLOGIC_KERNEL_BOOTED);
		writel(dump_set, base);
		pr_info("%s, set sticky to %x\n", __func__, dump_set);
	}
	return 0;

err1:
	kobject_put(ram->kobj);
err:
#ifdef CONFIG_64BIT
	iounmap((void *)ram->mem_base);
#endif
	kfree(ram);

	return -EINVAL;
}

static int ramdump_remove(struct platform_device *pdev)
{
	sysfs_remove_bin_file(ram->kobj, &ramdump_attr);
#ifdef CONFIG_64BIT
	iounmap((void *)ram->mem_base);
#endif
	kobject_put(ram->kobj);
	kfree(ram);
	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id ramdump_dt_match[] = {
	{
		.compatible = "amlogic, ram_dump",
	},
	{},
};
#endif

static struct platform_driver ramdump_driver = {
	.driver = {
		.name  = "mdump",
		.owner = THIS_MODULE,
	#ifdef CONFIG_OF
		.of_match_table = ramdump_dt_match,
	#endif
	},
	.remove = ramdump_remove,
};

static int __init ramdump_init(void)
{
	int ret;

	ret = platform_driver_probe(&ramdump_driver, ramdump_probe);

	return ret;
}

static void __exit ramdump_uninit(void)
{
	platform_driver_unregister(&ramdump_driver);
}

subsys_initcall(ramdump_init);
module_exit(ramdump_uninit);
MODULE_DESCRIPTION("AMLOGIC ramdump driver");
MODULE_LICENSE("GPL");