// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Platform energy and frequency attributes driver
 *
 * This driver creates a sys file at /sys/firmware/papr/ which encapsulates a
 * directory structure containing files in keyword - value pairs that specify
 * energy and frequency configuration of the system.
 *
 * The format of exposing the sysfs information is as follows:
 * /sys/firmware/papr/energy_scale_info/
 *  |-- <id>/
 *    |-- desc
 *    |-- value
 *    |-- value_desc (if exists)
 *  |-- <id>/
 *    |-- desc
 *    |-- value
 *    |-- value_desc (if exists)
 *
 * Copyright 2022 IBM Corp.
 */

#include <asm/hvcall.h>
#include <asm/machdep.h>
#include <asm/firmware.h>

#include "pseries.h"

/*
 * Flag attributes to fetch either all or one attribute from the HCALL
 * flag = BE(0) => fetch all attributes with firstAttributeId = 0
 * flag = BE(1) => fetch a single attribute with firstAttributeId = id
 */
#define ESI_FLAGS_ALL		0
#define ESI_FLAGS_SINGLE	(1ull << 63)

#define KOBJ_MAX_ATTRS		3

#define ESI_HDR_SIZE		sizeof(struct h_energy_scale_info_hdr)
#define ESI_ATTR_SIZE		sizeof(struct energy_scale_attribute)
#define CURR_MAX_ESI_ATTRS	8

struct energy_scale_attribute {
	__be64 id;
	__be64 val;
	u8 desc[64];
	u8 value_desc[64];
} __packed;

struct h_energy_scale_info_hdr {
	__be64 num_attrs;
	__be64 array_offset;
	u8 data_header_version;
} __packed;

struct papr_attr {
	u64 id;
	struct kobj_attribute kobj_attr;
};

struct papr_group {
	struct attribute_group pg;
	struct papr_attr pgattrs[KOBJ_MAX_ATTRS];
};

static struct papr_group *papr_groups;
/* /sys/firmware/papr */
static struct kobject *papr_kobj;
/* /sys/firmware/papr/energy_scale_info */
static struct kobject *esi_kobj;

/*
 * Energy modes can change dynamically hence making a new hcall each time the
 * information needs to be retrieved
 */
static int papr_get_attr(u64 id, struct energy_scale_attribute *esi)
{
	int esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * ESI_ATTR_SIZE);
	int ret, max_esi_attrs = CURR_MAX_ESI_ATTRS;
	struct energy_scale_attribute *curr_esi;
	struct h_energy_scale_info_hdr *hdr;
	char *buf;

	buf = kmalloc(esi_buf_size, GFP_KERNEL);
	if (buf == NULL)
		return -ENOMEM;

retry:
	ret = plpar_hcall_norets(H_GET_ENERGY_SCALE_INFO, ESI_FLAGS_SINGLE,
				 id, virt_to_phys(buf),
				 esi_buf_size);

	/*
	 * If the hcall fails with not enough memory for either the
	 * header or data, attempt to allocate more
	 */
	if (ret == H_PARTIAL || ret == H_P4) {
		char *temp_buf;

		max_esi_attrs += 4;
		esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * max_esi_attrs);

		temp_buf = krealloc(buf, esi_buf_size, GFP_KERNEL);
		if (temp_buf) {
			buf = temp_buf;
		} else {
			ret = -ENOMEM;
			goto out_buf;
		}

		goto retry;
	}

	if (ret != H_SUCCESS) {
		pr_warn("hcall failed: H_GET_ENERGY_SCALE_INFO");
		ret = -EIO;
		goto out_buf;
	}

	hdr = (struct h_energy_scale_info_hdr *) buf;
	curr_esi = (struct energy_scale_attribute *)
		(buf + be64_to_cpu(hdr->array_offset));

	if (esi_buf_size <
	    be64_to_cpu(hdr->array_offset) + (be64_to_cpu(hdr->num_attrs)
	    * sizeof(struct energy_scale_attribute))) {
		ret = -EIO;
		goto out_buf;
	}

	*esi = *curr_esi;

out_buf:
	kfree(buf);

	return ret;
}

/*
 * Extract and export the description of the energy scale attributes
 */
static ssize_t desc_show(struct kobject *kobj,
			  struct kobj_attribute *kobj_attr,
			  char *buf)
{
	struct papr_attr *pattr = container_of(kobj_attr, struct papr_attr,
					       kobj_attr);
	struct energy_scale_attribute esi;
	int ret;

	ret = papr_get_attr(pattr->id, &esi);
	if (ret)
		return ret;

	return sysfs_emit(buf, "%s\n", esi.desc);
}

/*
 * Extract and export the numeric value of the energy scale attributes
 */
static ssize_t val_show(struct kobject *kobj,
			 struct kobj_attribute *kobj_attr,
			 char *buf)
{
	struct papr_attr *pattr = container_of(kobj_attr, struct papr_attr,
					       kobj_attr);
	struct energy_scale_attribute esi;
	int ret;

	ret = papr_get_attr(pattr->id, &esi);
	if (ret)
		return ret;

	return sysfs_emit(buf, "%llu\n", be64_to_cpu(esi.val));
}

/*
 * Extract and export the value description in string format of the energy
 * scale attributes
 */
static ssize_t val_desc_show(struct kobject *kobj,
			      struct kobj_attribute *kobj_attr,
			      char *buf)
{
	struct papr_attr *pattr = container_of(kobj_attr, struct papr_attr,
					       kobj_attr);
	struct energy_scale_attribute esi;
	int ret;

	ret = papr_get_attr(pattr->id, &esi);
	if (ret)
		return ret;

	return sysfs_emit(buf, "%s\n", esi.value_desc);
}

static struct papr_ops_info {
	const char *attr_name;
	ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *kobj_attr,
			char *buf);
} ops_info[KOBJ_MAX_ATTRS] = {
	{ "desc", desc_show },
	{ "value", val_show },
	{ "value_desc", val_desc_show },
};

static void add_attr(u64 id, int index, struct papr_attr *attr)
{
	attr->id = id;
	sysfs_attr_init(&attr->kobj_attr.attr);
	attr->kobj_attr.attr.name = ops_info[index].attr_name;
	attr->kobj_attr.attr.mode = 0444;
	attr->kobj_attr.show = ops_info[index].show;
}

static int add_attr_group(u64 id, struct papr_group *pg, bool show_val_desc)
{
	int i;

	for (i = 0; i < KOBJ_MAX_ATTRS; i++) {
		if (!strcmp(ops_info[i].attr_name, "value_desc") &&
		    !show_val_desc) {
			continue;
		}
		add_attr(id, i, &pg->pgattrs[i]);
		pg->pg.attrs[i] = &pg->pgattrs[i].kobj_attr.attr;
	}

	return sysfs_create_group(esi_kobj, &pg->pg);
}


static int __init papr_init(void)
{
	int esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * ESI_ATTR_SIZE);
	int ret, idx, i, max_esi_attrs = CURR_MAX_ESI_ATTRS;
	struct h_energy_scale_info_hdr *esi_hdr;
	struct energy_scale_attribute *esi_attrs;
	uint64_t num_attrs;
	char *esi_buf;

	if (!firmware_has_feature(FW_FEATURE_LPAR) ||
	    !firmware_has_feature(FW_FEATURE_ENERGY_SCALE_INFO)) {
		return -ENXIO;
	}

	esi_buf = kmalloc(esi_buf_size, GFP_KERNEL);
	if (esi_buf == NULL)
		return -ENOMEM;
	/*
	 * hcall(
	 * uint64 H_GET_ENERGY_SCALE_INFO,  // Get energy scale info
	 * uint64 flags,            // Per the flag request
	 * uint64 firstAttributeId, // The attribute id
	 * uint64 bufferAddress,    // Guest physical address of the output buffer
	 * uint64 bufferSize);      // The size in bytes of the output buffer
	 */
retry:

	ret = plpar_hcall_norets(H_GET_ENERGY_SCALE_INFO, ESI_FLAGS_ALL, 0,
				 virt_to_phys(esi_buf), esi_buf_size);

	/*
	 * If the hcall fails with not enough memory for either the
	 * header or data, attempt to allocate more
	 */
	if (ret == H_PARTIAL || ret == H_P4) {
		char *temp_esi_buf;

		max_esi_attrs += 4;
		esi_buf_size = ESI_HDR_SIZE + (CURR_MAX_ESI_ATTRS * max_esi_attrs);

		temp_esi_buf = krealloc(esi_buf, esi_buf_size, GFP_KERNEL);
		if (temp_esi_buf)
			esi_buf = temp_esi_buf;
		else
			return -ENOMEM;

		goto retry;
	}

	if (ret != H_SUCCESS) {
		pr_warn("hcall failed: H_GET_ENERGY_SCALE_INFO, ret: %d\n", ret);
		goto out_free_esi_buf;
	}

	esi_hdr = (struct h_energy_scale_info_hdr *) esi_buf;
	num_attrs = be64_to_cpu(esi_hdr->num_attrs);
	esi_attrs = (struct energy_scale_attribute *)
		    (esi_buf + be64_to_cpu(esi_hdr->array_offset));

	if (esi_buf_size <
	    be64_to_cpu(esi_hdr->array_offset) +
	    (num_attrs * sizeof(struct energy_scale_attribute))) {
		goto out_free_esi_buf;
	}

	papr_groups = kcalloc(num_attrs, sizeof(*papr_groups), GFP_KERNEL);
	if (!papr_groups)
		goto out_free_esi_buf;

	papr_kobj = kobject_create_and_add("papr", firmware_kobj);
	if (!papr_kobj) {
		pr_warn("kobject_create_and_add papr failed\n");
		goto out_papr_groups;
	}

	esi_kobj = kobject_create_and_add("energy_scale_info", papr_kobj);
	if (!esi_kobj) {
		pr_warn("kobject_create_and_add energy_scale_info failed\n");
		goto out_kobj;
	}

	/* Allocate the groups before registering */
	for (idx = 0; idx < num_attrs; idx++) {
		papr_groups[idx].pg.attrs = kcalloc(KOBJ_MAX_ATTRS + 1,
					    sizeof(*papr_groups[idx].pg.attrs),
					    GFP_KERNEL);
		if (!papr_groups[idx].pg.attrs)
			goto out_pgattrs;

		papr_groups[idx].pg.name = kasprintf(GFP_KERNEL, "%lld",
					     be64_to_cpu(esi_attrs[idx].id));
		if (papr_groups[idx].pg.name == NULL)
			goto out_pgattrs;
	}

	for (idx = 0; idx < num_attrs; idx++) {
		bool show_val_desc = true;

		/* Do not add the value desc attr if it does not exist */
		if (strnlen(esi_attrs[idx].value_desc,
			    sizeof(esi_attrs[idx].value_desc)) == 0)
			show_val_desc = false;

		if (add_attr_group(be64_to_cpu(esi_attrs[idx].id),
				   &papr_groups[idx],
				   show_val_desc)) {
			pr_warn("Failed to create papr attribute group %s\n",
				papr_groups[idx].pg.name);
			idx = num_attrs;
			goto out_pgattrs;
		}
	}

	kfree(esi_buf);
	return 0;
out_pgattrs:
	for (i = 0; i < idx ; i++) {
		kfree(papr_groups[i].pg.attrs);
		kfree(papr_groups[i].pg.name);
	}
	kobject_put(esi_kobj);
out_kobj:
	kobject_put(papr_kobj);
out_papr_groups:
	kfree(papr_groups);
out_free_esi_buf:
	kfree(esi_buf);

	return -ENOMEM;
}

machine_device_initcall(pseries, papr_init);