// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright 2022-23 IBM Corp.
 */

#define pr_fmt(fmt) "vas: " fmt

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/miscdevice.h>
#include <linux/kobject.h>
#include <linux/slab.h>
#include <linux/mm.h>

#include "vas.h"

#ifdef CONFIG_SYSFS
static struct kobject *pseries_vas_kobj;
static struct kobject *gzip_caps_kobj;

struct vas_caps_entry {
	struct kobject kobj;
	struct vas_cop_feat_caps *caps;
};

#define to_caps_entry(entry) container_of(entry, struct vas_caps_entry, kobj)

/*
 * This function is used to get the notification from the drmgr when
 * QoS credits are changed.
 */
static ssize_t update_total_credits_store(struct vas_cop_feat_caps *caps,
						const char *buf, size_t count)
{
	int err;
	u16 creds;

	err = kstrtou16(buf, 0, &creds);
	/*
	 * The user space interface from the management console
	 * notifies OS with the new QoS credits and then the
	 * hypervisor. So OS has to use this new credits value
	 * and reconfigure VAS windows (close or reopen depends
	 * on the credits available) instead of depending on VAS
	 * QoS capabilities from the hypervisor.
	 */
	if (!err)
		err = vas_reconfig_capabilties(caps->win_type, creds);

	if (err)
		return -EINVAL;

	pr_info("Set QoS total credits %u\n", creds);

	return count;
}

#define sysfs_caps_entry_read(_name)					\
static ssize_t _name##_show(struct vas_cop_feat_caps *caps, char *buf) 	\
{									\
	return sprintf(buf, "%d\n", atomic_read(&caps->_name));	\
}

struct vas_sysfs_entry {
	struct attribute attr;
	ssize_t (*show)(struct vas_cop_feat_caps *, char *);
	ssize_t (*store)(struct vas_cop_feat_caps *, const char *, size_t);
};

#define VAS_ATTR_RO(_name)	\
	sysfs_caps_entry_read(_name);		\
	static struct vas_sysfs_entry _name##_attribute = __ATTR(_name,	\
				0444, _name##_show, NULL);

/*
 * Create sysfs interface:
 * /sys/devices/virtual/misc/vas/vas0/gzip/default_capabilities
 *	This directory contains the following VAS GZIP capabilities
 *	for the default credit type.
 * /sys/devices/virtual/misc/vas/vas0/gzip/default_capabilities/nr_total_credits
 *	Total number of default credits assigned to the LPAR which
 *	can be changed with DLPAR operation.
 * /sys/devices/virtual/misc/vas/vas0/gzip/default_capabilities/nr_used_credits
 *	Number of credits used by the user space. One credit will
 *	be assigned for each window open.
 *
 * /sys/devices/virtual/misc/vas/vas0/gzip/qos_capabilities
 *	This directory contains the following VAS GZIP capabilities
 *	for the Quality of Service (QoS) credit type.
 * /sys/devices/virtual/misc/vas/vas0/gzip/qos_capabilities/nr_total_credits
 *	Total number of QoS credits assigned to the LPAR. The user
 *	has to define this value using HMC interface. It can be
 *	changed dynamically by the user.
 * /sys/devices/virtual/misc/vas/vas0/gzip/qos_capabilities/nr_used_credits
 *	Number of credits used by the user space.
 * /sys/devices/virtual/misc/vas/vas0/gzip/qos_capabilities/update_total_credits
 *	Update total QoS credits dynamically
 */

VAS_ATTR_RO(nr_total_credits);
VAS_ATTR_RO(nr_used_credits);

static struct vas_sysfs_entry update_total_credits_attribute =
	__ATTR(update_total_credits, 0200, NULL, update_total_credits_store);

static struct attribute *vas_def_capab_attrs[] = {
	&nr_total_credits_attribute.attr,
	&nr_used_credits_attribute.attr,
	NULL,
};
ATTRIBUTE_GROUPS(vas_def_capab);

static struct attribute *vas_qos_capab_attrs[] = {
	&nr_total_credits_attribute.attr,
	&nr_used_credits_attribute.attr,
	&update_total_credits_attribute.attr,
	NULL,
};
ATTRIBUTE_GROUPS(vas_qos_capab);

static ssize_t vas_type_show(struct kobject *kobj, struct attribute *attr,
			     char *buf)
{
	struct vas_caps_entry *centry;
	struct vas_cop_feat_caps *caps;
	struct vas_sysfs_entry *entry;

	centry = to_caps_entry(kobj);
	caps = centry->caps;
	entry = container_of(attr, struct vas_sysfs_entry, attr);

	if (!entry->show)
		return -EIO;

	return entry->show(caps, buf);
}

static ssize_t vas_type_store(struct kobject *kobj, struct attribute *attr,
			      const char *buf, size_t count)
{
	struct vas_caps_entry *centry;
	struct vas_cop_feat_caps *caps;
	struct vas_sysfs_entry *entry;

	centry = to_caps_entry(kobj);
	caps = centry->caps;
	entry = container_of(attr, struct vas_sysfs_entry, attr);
	if (!entry->store)
		return -EIO;

	return entry->store(caps, buf, count);
}

static void vas_type_release(struct kobject *kobj)
{
	struct vas_caps_entry *centry = to_caps_entry(kobj);
	kfree(centry);
}

static const struct sysfs_ops vas_sysfs_ops = {
	.show	=	vas_type_show,
	.store	=	vas_type_store,
};

static const struct kobj_type vas_def_attr_type = {
		.release	=	vas_type_release,
		.sysfs_ops      =       &vas_sysfs_ops,
		.default_groups	=	vas_def_capab_groups,
};

static const struct kobj_type vas_qos_attr_type = {
		.release	=	vas_type_release,
		.sysfs_ops	=	&vas_sysfs_ops,
		.default_groups	=	vas_qos_capab_groups,
};

static char *vas_caps_kobj_name(struct vas_caps_entry *centry,
				struct kobject **kobj)
{
	struct vas_cop_feat_caps *caps = centry->caps;

	if (caps->descriptor == VAS_GZIP_QOS_CAPABILITIES) {
		kobject_init(&centry->kobj, &vas_qos_attr_type);
		*kobj = gzip_caps_kobj;
		return "qos_capabilities";
	} else if (caps->descriptor == VAS_GZIP_DEFAULT_CAPABILITIES) {
		kobject_init(&centry->kobj, &vas_def_attr_type);
		*kobj = gzip_caps_kobj;
		return "default_capabilities";
	} else
		return "Unknown";
}

/*
 * Add feature specific capability dir entry.
 * Ex: VDefGzip or VQosGzip
 */
int sysfs_add_vas_caps(struct vas_cop_feat_caps *caps)
{
	struct vas_caps_entry *centry;
	struct kobject *kobj = NULL;
	int ret = 0;
	char *name;

	centry = kzalloc(sizeof(*centry), GFP_KERNEL);
	if (!centry)
		return -ENOMEM;

	centry->caps = caps;
	name  = vas_caps_kobj_name(centry, &kobj);

	if (kobj) {
		ret = kobject_add(&centry->kobj, kobj, "%s", name);

		if (ret) {
			pr_err("VAS: sysfs kobject add / event failed %d\n",
					ret);
			kobject_put(&centry->kobj);
		}
	}

	return ret;
}

static struct miscdevice vas_miscdev = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "vas",
};

/*
 * Add VAS and VasCaps (overall capabilities) dir entries.
 */
int __init sysfs_pseries_vas_init(struct vas_all_caps *vas_caps)
{
	int ret;

	ret = misc_register(&vas_miscdev);
	if (ret < 0) {
		pr_err("%s: register vas misc device failed\n", __func__);
		return ret;
	}

	/*
	 * The hypervisor does not expose multiple VAS instances, but can
	 * see multiple VAS instances on PowerNV. So create 'vas0' directory
	 * on pseries.
	 */
	pseries_vas_kobj = kobject_create_and_add("vas0",
					&vas_miscdev.this_device->kobj);
	if (!pseries_vas_kobj) {
		misc_deregister(&vas_miscdev);
		pr_err("Failed to create VAS sysfs entry\n");
		return -ENOMEM;
	}

	if ((vas_caps->feat_type & VAS_GZIP_QOS_FEAT_BIT) ||
		(vas_caps->feat_type & VAS_GZIP_DEF_FEAT_BIT)) {
		gzip_caps_kobj = kobject_create_and_add("gzip",
						       pseries_vas_kobj);
		if (!gzip_caps_kobj) {
			pr_err("Failed to create VAS GZIP capability entry\n");
			kobject_put(pseries_vas_kobj);
			misc_deregister(&vas_miscdev);
			return -ENOMEM;
		}
	}

	return 0;
}

#else
int sysfs_add_vas_caps(struct vas_cop_feat_caps *caps)
{
	return 0;
}

int __init sysfs_pseries_vas_init(struct vas_all_caps *vas_caps)
{
	return 0;
}
#endif