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

/*
 * PowerNV OPAL Power-Shift-Ratio interface
 *
 * Copyright 2017 IBM Corp.
 *
 * 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.
 */

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