[mirror_ubuntu-eoan-kernel.git] / arch / powerpc / platforms / powernv / opal-psr.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * PowerNV OPAL Power-Shift-Ratio interface
 *
 * Copyright 2017 IBM Corp.
 */

#define pr_fmt(fmt)     "opal-psr: " fmt

#include <linux/of.h>
#include <linux/kobject.h>
#include <linux/slab.h>

#include <asm/opal.h>

DEFINE_MUTEX(psr_mutex);

static struct kobject *psr_kobj;

struct psr_attr {
	u32 handle;
	struct kobj_attribute attr;
} *psr_attrs;

static ssize_t psr_show(struct kobject *kobj, struct kobj_attribute *attr,
			char *buf)
{
	struct psr_attr *psr_attr = container_of(attr, struct psr_attr, attr);
	struct opal_msg msg;
	int psr, ret, token;

	token = opal_async_get_token_interruptible();
	if (token < 0) {
		pr_devel("Failed to get token\n");
		return token;
	}

	ret = mutex_lock_interruptible(&psr_mutex);
	if (ret)
		goto out_token;

	ret = opal_get_power_shift_ratio(psr_attr->handle, token,
					    (u32 *)__pa(&psr));
	switch (ret) {
	case OPAL_ASYNC_COMPLETION:
		ret = opal_async_wait_response(token, &msg);
		if (ret) {
			pr_devel("Failed to wait for the async response\n");
			ret = -EIO;
			goto out;
		}
		ret = opal_error_code(opal_get_async_rc(msg));
		if (!ret) {
			ret = sprintf(buf, "%u\n", be32_to_cpu(psr));
			if (ret < 0)
				ret = -EIO;
		}
		break;
	case OPAL_SUCCESS:
		ret = sprintf(buf, "%u\n", be32_to_cpu(psr));
		if (ret < 0)
			ret = -EIO;
		break;
	default:
		ret = opal_error_code(ret);
	}

out:
	mutex_unlock(&psr_mutex);
out_token:
	opal_async_release_token(token);
	return ret;
}

static ssize_t psr_store(struct kobject *kobj, struct kobj_attribute *attr,
			 const char *buf, size_t count)
{
	struct psr_attr *psr_attr = container_of(attr, struct psr_attr, attr);
	struct opal_msg msg;
	int psr, ret, token;

	ret = kstrtoint(buf, 0, &psr);
	if (ret)
		return ret;

	token = opal_async_get_token_interruptible();
	if (token < 0) {
		pr_devel("Failed to get token\n");
		return token;
	}

	ret = mutex_lock_interruptible(&psr_mutex);
	if (ret)
		goto out_token;

	ret = opal_set_power_shift_ratio(psr_attr->handle, token, psr);
	switch (ret) {
	case OPAL_ASYNC_COMPLETION:
		ret = opal_async_wait_response(token, &msg);
		if (ret) {
			pr_devel("Failed to wait for the async response\n");
			ret = -EIO;
			goto out;
		}
		ret = opal_error_code(opal_get_async_rc(msg));
		if (!ret)
			ret = count;
		break;
	case OPAL_SUCCESS:
		ret = count;
		break;
	default:
		ret = opal_error_code(ret);
	}

out:
	mutex_unlock(&psr_mutex);
out_token:
	opal_async_release_token(token);
	return ret;
}

void __init opal_psr_init(void)
{
	struct device_node *psr, *node;
	int i = 0;

	psr = of_find_compatible_node(NULL, NULL,
				      "ibm,opal-power-shift-ratio");
	if (!psr) {
		pr_devel("Power-shift-ratio node not found\n");
		return;
	}

	psr_attrs = kcalloc(of_get_child_count(psr), sizeof(*psr_attrs),
			    GFP_KERNEL);
	if (!psr_attrs)
		return;

	psr_kobj = kobject_create_and_add("psr", opal_kobj);
	if (!psr_kobj) {
		pr_warn("Failed to create psr kobject\n");
		goto out;
	}

	for_each_child_of_node(psr, node) {
		if (of_property_read_u32(node, "handle",
					 &psr_attrs[i].handle))
			goto out_kobj;

		sysfs_attr_init(&psr_attrs[i].attr.attr);
		if (of_property_read_string(node, "label",
					    &psr_attrs[i].attr.attr.name))
			goto out_kobj;
		psr_attrs[i].attr.attr.mode = 0664;
		psr_attrs[i].attr.show = psr_show;
		psr_attrs[i].attr.store = psr_store;
		if (sysfs_create_file(psr_kobj, &psr_attrs[i].attr.attr)) {
			pr_devel("Failed to create psr sysfs file %s\n",
				 psr_attrs[i].attr.attr.name);
			goto out_kobj;
		}
		i++;
	}

	return;
out_kobj:
	kobject_put(psr_kobj);
out:
	kfree(psr_attrs);
}
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
8e84b2d1 SB	2	/*
	3	* PowerNV OPAL Power-Shift-Ratio interface
	4	*
	5	* Copyright 2017 IBM Corp.
8e84b2d1 SB	6	*/
	7
	8	#define pr_fmt(fmt) "opal-psr: " fmt
	9
	10	#include <linux/of.h>
	11	#include <linux/kobject.h>
	12	#include <linux/slab.h>
	13
	14	#include <asm/opal.h>
	15
	16	DEFINE_MUTEX(psr_mutex);
	17
	18	static struct kobject *psr_kobj;
	19
	20	struct psr_attr {
	21	u32 handle;
	22	struct kobj_attribute attr;
	23	} *psr_attrs;
	24
	25	static ssize_t psr_show(struct kobject kobj, struct kobj_attribute attr,
	26	char *buf)
	27	{
	28	struct psr_attr *psr_attr = container_of(attr, struct psr_attr, attr);
	29	struct opal_msg msg;
	30	int psr, ret, token;
	31
	32	token = opal_async_get_token_interruptible();
	33	if (token < 0) {
	34	pr_devel("Failed to get token\n");
	35	return token;
	36	}
	37
	38	ret = mutex_lock_interruptible(&psr_mutex);
	39	if (ret)
	40	goto out_token;
	41
	42	ret = opal_get_power_shift_ratio(psr_attr->handle, token,
	43	(u32 *)__pa(&psr));
	44	switch (ret) {
	45	case OPAL_ASYNC_COMPLETION:
	46	ret = opal_async_wait_response(token, &msg);
	47	if (ret) {
	48	pr_devel("Failed to wait for the async response\n");
	49	ret = -EIO;
	50	goto out;
	51	}
	52	ret = opal_error_code(opal_get_async_rc(msg));
	53	if (!ret) {
	54	ret = sprintf(buf, "%u\n", be32_to_cpu(psr));
	55	if (ret < 0)
	56	ret = -EIO;
	57	}
	58	break;
	59	case OPAL_SUCCESS:
	60	ret = sprintf(buf, "%u\n", be32_to_cpu(psr));
	61	if (ret < 0)
	62	ret = -EIO;
	63	break;
	64	default:
	65	ret = opal_error_code(ret);
	66	}
	67
	68	out:
	69	mutex_unlock(&psr_mutex);
70	out_token:
71	opal_async_release_token(token);
72	return ret;
73	}
74
75	static ssize_t psr_store(struct kobject kobj, struct kobj_attribute attr,
76	const char *buf, size_t count)
77	{
78	struct psr_attr *psr_attr = container_of(attr, struct psr_attr, attr);
79	struct opal_msg msg;
80	int psr, ret, token;
81
82	ret = kstrtoint(buf, 0, &psr);
83	if (ret)
84	return ret;
85
86	token = opal_async_get_token_interruptible();
87	if (token < 0) {
88	pr_devel("Failed to get token\n");
89	return token;
90	}
91
92	ret = mutex_lock_interruptible(&psr_mutex);
93	if (ret)
94	goto out_token;
95
96	ret = opal_set_power_shift_ratio(psr_attr->handle, token, psr);
97	switch (ret) {
98	case OPAL_ASYNC_COMPLETION:
99	ret = opal_async_wait_response(token, &msg);
100	if (ret) {
101	pr_devel("Failed to wait for the async response\n");
102	ret = -EIO;
103	goto out;
104	}
105	ret = opal_error_code(opal_get_async_rc(msg));
106	if (!ret)
107	ret = count;
108	break;
109	case OPAL_SUCCESS:
110	ret = count;
111	break;
112	default:
113	ret = opal_error_code(ret);
114	}
115
116	out:
117	mutex_unlock(&psr_mutex);
118	out_token:
119	opal_async_release_token(token);
120	return ret;
121	}
122
123	void __init opal_psr_init(void)
124	{
125	struct device_node psr, node;
126	int i = 0;
127
128	psr = of_find_compatible_node(NULL, NULL,
129	"ibm,opal-power-shift-ratio");
130	if (!psr) {
131	pr_devel("Power-shift-ratio node not found\n");
132	return;
133	}
134
a0828cf5	135	psr_attrs = kcalloc(of_get_child_count(psr), sizeof(*psr_attrs),
8e84b2d1 SB	136	GFP_KERNEL);
	137	if (!psr_attrs)
	138	return;
	139
	140	psr_kobj = kobject_create_and_add("psr", opal_kobj);
	141	if (!psr_kobj) {
	142	pr_warn("Failed to create psr kobject\n");
	143	goto out;
	144	}
	145
	146	for_each_child_of_node(psr, node) {
	147	if (of_property_read_u32(node, "handle",
	148	&psr_attrs[i].handle))
	149	goto out_kobj;
	150
	151	sysfs_attr_init(&psr_attrs[i].attr.attr);
	152	if (of_property_read_string(node, "label",
	153	&psr_attrs[i].attr.attr.name))
	154	goto out_kobj;
	155	psr_attrs[i].attr.attr.mode = 0664;
	156	psr_attrs[i].attr.show = psr_show;
	157	psr_attrs[i].attr.store = psr_store;
	158	if (sysfs_create_file(psr_kobj, &psr_attrs[i].attr.attr)) {
	159	pr_devel("Failed to create psr sysfs file %s\n",
	160	psr_attrs[i].attr.attr.name);
	161	goto out_kobj;
	162	}
	163	i++;
	164	}
	165
	166	return;
	167	out_kobj:
	168	kobject_put(psr_kobj);
	169	out:
	170	kfree(psr_attrs);
	171	}