// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (c) 2016, Fuzhou Rockchip Electronics Co., Ltd
 */

#include <linux/device.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/kobject.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/panic_notifier.h>
#include <linux/reboot.h>
#include <linux/reboot-mode.h>
#include <linux/sysfs.h>

#define PREFIX "mode-"

struct mode_info {
	const char *mode;
	u32 magic;
	struct list_head list;
};

static const char *boot_mode = "coldboot";

static ssize_t boot_mode_show(struct kobject *kobj, struct kobj_attribute *attr,
			      char *buf)
{
	return scnprintf(buf, PAGE_SIZE, "%s\n", boot_mode);
}

static struct kobj_attribute kobj_boot_mode = __ATTR_RO(boot_mode);

static int get_reboot_mode_magic(struct reboot_mode_driver *reboot,
				 const char *cmd)
{
	const char *normal = "normal";
	int magic = 0;
	struct mode_info *info;

	if (!cmd || !cmd[0])
		cmd = normal;

	list_for_each_entry(info, &reboot->head, list) {
		if (!strcmp(info->mode, cmd)) {
			magic = info->magic;
			break;
		}
	}

	return magic;
}

static int last_magic;

static void reboot_mode_write(struct reboot_mode_driver *reboot,
			      const void *cmd)
{
	int magic;

	magic = get_reboot_mode_magic(reboot, cmd);
	if (!magic)
		magic = get_reboot_mode_magic(reboot, NULL);
	if (magic) {
		reboot->write(reboot, magic);
		last_magic = magic;
	}
}

static int reboot_mode_notify(struct notifier_block *this,
			      unsigned long mode, void *cmd)
{
	struct reboot_mode_driver *reboot;

	reboot = container_of(this, struct reboot_mode_driver, reboot_notifier);
	reboot_mode_write(reboot, cmd);

	return NOTIFY_DONE;
}

static int reboot_mode_pre_restart_notify(struct notifier_block *this,
			      unsigned long mode, void *cmd)
{
	struct reboot_mode_driver *reboot;

	reboot = container_of(this, struct reboot_mode_driver, pre_restart_notifier);
	if (cmd || !last_magic)
		reboot_mode_write(reboot, cmd);

	return NOTIFY_DONE;
}

static int reboot_mode_panic_notify(struct notifier_block *this,
				      unsigned long ev, void *ptr)
{
	struct reboot_mode_driver *reboot;
	const char *cmd = "panic";

	reboot = container_of(this, struct reboot_mode_driver, panic_notifier);
	reboot_mode_write(reboot, cmd);

	return NOTIFY_DONE;
}

static int boot_mode_parse(struct reboot_mode_driver *reboot)
{
	struct mode_info *info;
	unsigned int magic = reboot->read(reboot);

	list_for_each_entry(info, &reboot->head, list) {
		if (info->magic == magic) {
			boot_mode = info->mode;
			break;
		}
	}

	return 0;
}

/**
 * reboot_mode_register - register a reboot mode driver
 * @reboot: reboot mode driver
 *
 * Returns: 0 on success or a negative error code on failure.
 */
int reboot_mode_register(struct reboot_mode_driver *reboot)
{
	struct mode_info *info;
	struct property *prop;
	struct device_node *np = reboot->dev->of_node;
	size_t len = strlen(PREFIX);
	int ret;

	INIT_LIST_HEAD(&reboot->head);

	for_each_property_of_node(np, prop) {
		if (strncmp(prop->name, PREFIX, len))
			continue;

		info = devm_kzalloc(reboot->dev, sizeof(*info), GFP_KERNEL);
		if (!info) {
			ret = -ENOMEM;
			goto error;
		}

		if (of_property_read_u32(np, prop->name, &info->magic)) {
			dev_err(reboot->dev, "reboot mode %s without magic number\n",
				info->mode);
			devm_kfree(reboot->dev, info);
			continue;
		}

		info->mode = kstrdup_const(prop->name + len, GFP_KERNEL);
		if (!info->mode) {
			ret =  -ENOMEM;
			goto error;
		} else if (info->mode[0] == '\0') {
			kfree_const(info->mode);
			ret = -EINVAL;
			dev_err(reboot->dev, "invalid mode name(%s): too short!\n",
				prop->name);
			goto error;
		}

		list_add_tail(&info->list, &reboot->head);
	}

	boot_mode_parse(reboot);
	reboot->reboot_notifier.notifier_call = reboot_mode_notify;
	reboot->pre_restart_notifier.notifier_call = reboot_mode_pre_restart_notify;
	reboot->pre_restart_notifier.priority = 254;
	reboot->panic_notifier.notifier_call = reboot_mode_panic_notify;
	register_reboot_notifier(&reboot->reboot_notifier);
	register_restart_handler(&reboot->pre_restart_notifier);
	atomic_notifier_chain_register(&panic_notifier_list,
				       &reboot->panic_notifier);
	ret = sysfs_create_file(kernel_kobj, &kobj_boot_mode.attr);

	return ret;

error:
	list_for_each_entry(info, &reboot->head, list)
		kfree_const(info->mode);

	return ret;
}
EXPORT_SYMBOL_GPL(reboot_mode_register);

/**
 * reboot_mode_unregister - unregister a reboot mode driver
 * @reboot: reboot mode driver
 */
int reboot_mode_unregister(struct reboot_mode_driver *reboot)
{
	struct mode_info *info;

	unregister_reboot_notifier(&reboot->reboot_notifier);

	list_for_each_entry(info, &reboot->head, list)
		kfree_const(info->mode);

	return 0;
}
EXPORT_SYMBOL_GPL(reboot_mode_unregister);

static void devm_reboot_mode_release(struct device *dev, void *res)
{
	reboot_mode_unregister(*(struct reboot_mode_driver **)res);
}

/**
 * devm_reboot_mode_register() - resource managed reboot_mode_register()
 * @dev: device to associate this resource with
 * @reboot: reboot mode driver
 *
 * Returns: 0 on success or a negative error code on failure.
 */
int devm_reboot_mode_register(struct device *dev,
			      struct reboot_mode_driver *reboot)
{
	struct reboot_mode_driver **dr;
	int rc;

	dr = devres_alloc(devm_reboot_mode_release, sizeof(*dr), GFP_KERNEL);
	if (!dr)
		return -ENOMEM;

	rc = reboot_mode_register(reboot);
	if (rc) {
		devres_free(dr);
		return rc;
	}

	*dr = reboot;
	devres_add(dev, dr);

	return 0;
}
EXPORT_SYMBOL_GPL(devm_reboot_mode_register);

static int devm_reboot_mode_match(struct device *dev, void *res, void *data)
{
	struct reboot_mode_driver **p = res;

	if (WARN_ON(!p || !*p))
		return 0;

	return *p == data;
}

/**
 * devm_reboot_mode_unregister() - resource managed reboot_mode_unregister()
 * @dev: device to associate this resource with
 * @reboot: reboot mode driver
 */
void devm_reboot_mode_unregister(struct device *dev,
				 struct reboot_mode_driver *reboot)
{
	WARN_ON(devres_release(dev,
			       devm_reboot_mode_release,
			       devm_reboot_mode_match, reboot));
}
EXPORT_SYMBOL_GPL(devm_reboot_mode_unregister);

MODULE_AUTHOR("Andy Yan <andy.yan@rock-chips.com>");
MODULE_DESCRIPTION("System reboot mode core library");
MODULE_LICENSE("GPL v2");