[linux-2.6-block.git] / drivers / hwmon / scpi-hwmon.c

/*
 * System Control and Power Interface(SCPI) based hwmon sensor driver
 *
 * Copyright (C) 2015 ARM Ltd.
 * Punit Agrawal <punit.agrawal@arm.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

#include <linux/hwmon.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/scpi_protocol.h>
#include <linux/slab.h>
#include <linux/sysfs.h>

struct sensor_data {
	struct scpi_sensor_info info;
	struct device_attribute dev_attr_input;
	struct device_attribute dev_attr_label;
	char input[20];
	char label[20];
};

struct scpi_sensors {
	struct scpi_ops *scpi_ops;
	struct sensor_data *data;
	struct attribute **attrs;
	struct attribute_group group;
	const struct attribute_group *groups[2];
};

/* hwmon callback functions */
static ssize_t
scpi_show_sensor(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct scpi_sensors *scpi_sensors = dev_get_drvdata(dev);
	struct scpi_ops *scpi_ops = scpi_sensors->scpi_ops;
	struct sensor_data *sensor;
	u32 value;
	int ret;

	sensor = container_of(attr, struct sensor_data, dev_attr_input);

	ret = scpi_ops->sensor_get_value(sensor->info.sensor_id, &value);
	if (ret)
		return ret;

	return sprintf(buf, "%u\n", value);
}

static ssize_t
scpi_show_label(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct sensor_data *sensor;

	sensor = container_of(attr, struct sensor_data, dev_attr_label);

	return sprintf(buf, "%s\n", sensor->info.name);
}

static int scpi_hwmon_probe(struct platform_device *pdev)
{
	u16 nr_sensors, i;
	int num_temp = 0, num_volt = 0, num_current = 0, num_power = 0;
	struct scpi_ops *scpi_ops;
	struct device *hwdev, *dev = &pdev->dev;
	struct scpi_sensors *scpi_sensors;
	int ret;

	scpi_ops = get_scpi_ops();
	if (!scpi_ops)
		return -EPROBE_DEFER;

	ret = scpi_ops->sensor_get_capability(&nr_sensors);
	if (ret)
		return ret;

	if (!nr_sensors)
		return -ENODEV;

	scpi_sensors = devm_kzalloc(dev, sizeof(*scpi_sensors), GFP_KERNEL);
	if (!scpi_sensors)
		return -ENOMEM;

	scpi_sensors->data = devm_kcalloc(dev, nr_sensors,
				   sizeof(*scpi_sensors->data), GFP_KERNEL);
	if (!scpi_sensors->data)
		return -ENOMEM;

	scpi_sensors->attrs = devm_kcalloc(dev, (nr_sensors * 2) + 1,
				   sizeof(*scpi_sensors->attrs), GFP_KERNEL);
	if (!scpi_sensors->attrs)
		return -ENOMEM;

	scpi_sensors->scpi_ops = scpi_ops;

	for (i = 0; i < nr_sensors; i++) {
		struct sensor_data *sensor = &scpi_sensors->data[i];

		ret = scpi_ops->sensor_get_info(i, &sensor->info);
		if (ret)
			return ret;

		switch (sensor->info.class) {
		case TEMPERATURE:
			snprintf(sensor->input, sizeof(sensor->input),
				 "temp%d_input", num_temp + 1);
			snprintf(sensor->label, sizeof(sensor->input),
				 "temp%d_label", num_temp + 1);
			num_temp++;
			break;
		case VOLTAGE:
			snprintf(sensor->input, sizeof(sensor->input),
				 "in%d_input", num_volt);
			snprintf(sensor->label, sizeof(sensor->input),
				 "in%d_label", num_volt);
			num_volt++;
			break;
		case CURRENT:
			snprintf(sensor->input, sizeof(sensor->input),
				 "curr%d_input", num_current + 1);
			snprintf(sensor->label, sizeof(sensor->input),
				 "curr%d_label", num_current + 1);
			num_current++;
			break;
		case POWER:
			snprintf(sensor->input, sizeof(sensor->input),
				 "power%d_input", num_power + 1);
			snprintf(sensor->label, sizeof(sensor->input),
				 "power%d_label", num_power + 1);
			num_power++;
			break;
		default:
			break;
		}

		sensor->dev_attr_input.attr.mode = S_IRUGO;
		sensor->dev_attr_input.show = scpi_show_sensor;
		sensor->dev_attr_input.attr.name = sensor->input;

		sensor->dev_attr_label.attr.mode = S_IRUGO;
		sensor->dev_attr_label.show = scpi_show_label;
		sensor->dev_attr_label.attr.name = sensor->label;

		scpi_sensors->attrs[i << 1] = &sensor->dev_attr_input.attr;
		scpi_sensors->attrs[(i << 1) + 1] = &sensor->dev_attr_label.attr;

		sysfs_attr_init(scpi_sensors->attrs[i << 1]);
		sysfs_attr_init(scpi_sensors->attrs[(i << 1) + 1]);
	}

	scpi_sensors->group.attrs = scpi_sensors->attrs;
	scpi_sensors->groups[0] = &scpi_sensors->group;

	hwdev = devm_hwmon_device_register_with_groups(dev,
			"scpi_sensors", scpi_sensors, scpi_sensors->groups);

	return PTR_ERR_OR_ZERO(hwdev);
}

static const struct of_device_id scpi_of_match[] = {
	{.compatible = "arm,scpi-sensors"},
	{},
};

static struct platform_driver scpi_hwmon_platdrv = {
	.driver = {
		.name	= "scpi-hwmon",
		.owner	= THIS_MODULE,
		.of_match_table = scpi_of_match,
	},
	.probe		= scpi_hwmon_probe,
};
module_platform_driver(scpi_hwmon_platdrv);

MODULE_AUTHOR("Punit Agrawal <punit.agrawal@arm.com>");
MODULE_DESCRIPTION("ARM SCPI HWMON interface driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
ea98b29a PA	1	/*
	2	* System Control and Power Interface(SCPI) based hwmon sensor driver
	3	*
	4	* Copyright (C) 2015 ARM Ltd.
	5	* Punit Agrawal <punit.agrawal@arm.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	12	* kind, whether express or implied; without even the implied warranty
	13	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/hwmon.h>
	18	#include <linux/module.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/scpi_protocol.h>
	21	#include <linux/slab.h>
	22	#include <linux/sysfs.h>
	23
	24	struct sensor_data {
	25	struct scpi_sensor_info info;
	26	struct device_attribute dev_attr_input;
	27	struct device_attribute dev_attr_label;
	28	char input[20];
	29	char label[20];
	30	};
	31
	32	struct scpi_sensors {
	33	struct scpi_ops *scpi_ops;
	34	struct sensor_data *data;
	35	struct attribute **attrs;
	36	struct attribute_group group;
	37	const struct attribute_group *groups[2];
	38	};
	39
	40	/* hwmon callback functions */
	41	static ssize_t
	42	scpi_show_sensor(struct device dev, struct device_attribute attr, char *buf)
	43	{
	44	struct scpi_sensors *scpi_sensors = dev_get_drvdata(dev);
	45	struct scpi_ops *scpi_ops = scpi_sensors->scpi_ops;
	46	struct sensor_data *sensor;
	47	u32 value;
	48	int ret;
	49
	50	sensor = container_of(attr, struct sensor_data, dev_attr_input);
	51
	52	ret = scpi_ops->sensor_get_value(sensor->info.sensor_id, &value);
	53	if (ret)
	54	return ret;
	55
	56	return sprintf(buf, "%u\n", value);
	57	}
	58
	59	static ssize_t
	60	scpi_show_label(struct device dev, struct device_attribute attr, char *buf)
	61	{
	62	struct sensor_data *sensor;
	63
	64	sensor = container_of(attr, struct sensor_data, dev_attr_label);
65
66	return sprintf(buf, "%s\n", sensor->info.name);
67	}
68
69	static int scpi_hwmon_probe(struct platform_device *pdev)
70	{
71	u16 nr_sensors, i;
72	int num_temp = 0, num_volt = 0, num_current = 0, num_power = 0;
73	struct scpi_ops *scpi_ops;
74	struct device hwdev, dev = &pdev->dev;
75	struct scpi_sensors *scpi_sensors;
76	int ret;
77
78	scpi_ops = get_scpi_ops();
79	if (!scpi_ops)
80	return -EPROBE_DEFER;
81
82	ret = scpi_ops->sensor_get_capability(&nr_sensors);
83	if (ret)
84	return ret;
85
86	if (!nr_sensors)
87	return -ENODEV;
88
89	scpi_sensors = devm_kzalloc(dev, sizeof(*scpi_sensors), GFP_KERNEL);
90	if (!scpi_sensors)
91	return -ENOMEM;
92
93	scpi_sensors->data = devm_kcalloc(dev, nr_sensors,
94	sizeof(*scpi_sensors->data), GFP_KERNEL);
95	if (!scpi_sensors->data)
96	return -ENOMEM;
97
98	scpi_sensors->attrs = devm_kcalloc(dev, (nr_sensors * 2) + 1,
99	sizeof(*scpi_sensors->attrs), GFP_KERNEL);
100	if (!scpi_sensors->attrs)
101	return -ENOMEM;
102
103	scpi_sensors->scpi_ops = scpi_ops;
104
105	for (i = 0; i < nr_sensors; i++) {
106	struct sensor_data *sensor = &scpi_sensors->data[i];
107
108	ret = scpi_ops->sensor_get_info(i, &sensor->info);
109	if (ret)
110	return ret;
111
112	switch (sensor->info.class) {
113	case TEMPERATURE:
114	snprintf(sensor->input, sizeof(sensor->input),
115	"temp%d_input", num_temp + 1);
116	snprintf(sensor->label, sizeof(sensor->input),
117	"temp%d_label", num_temp + 1);
118	num_temp++;
119	break;
120	case VOLTAGE:
121	snprintf(sensor->input, sizeof(sensor->input),
122	"in%d_input", num_volt);
123	snprintf(sensor->label, sizeof(sensor->input),
124	"in%d_label", num_volt);
125	num_volt++;
126	break;
127	case CURRENT:
128	snprintf(sensor->input, sizeof(sensor->input),
129	"curr%d_input", num_current + 1);
130	snprintf(sensor->label, sizeof(sensor->input),
131	"curr%d_label", num_current + 1);
132	num_current++;
133	break;
134	case POWER:
135	snprintf(sensor->input, sizeof(sensor->input),
136	"power%d_input", num_power + 1);
137	snprintf(sensor->label, sizeof(sensor->input),
138	"power%d_label", num_power + 1);
139	num_power++;
140	break;
141	default:
142	break;
143	}
144
145	sensor->dev_attr_input.attr.mode = S_IRUGO;
146	sensor->dev_attr_input.show = scpi_show_sensor;
147	sensor->dev_attr_input.attr.name = sensor->input;
148
149	sensor->dev_attr_label.attr.mode = S_IRUGO;
150	sensor->dev_attr_label.show = scpi_show_label;
151	sensor->dev_attr_label.attr.name = sensor->label;
152
153	scpi_sensors->attrs[i << 1] = &sensor->dev_attr_input.attr;
154	scpi_sensors->attrs[(i << 1) + 1] = &sensor->dev_attr_label.attr;
155
156	sysfs_attr_init(scpi_sensors->attrs[i << 1]);
157	sysfs_attr_init(scpi_sensors->attrs[(i << 1) + 1]);
158	}
159
160	scpi_sensors->group.attrs = scpi_sensors->attrs;
161	scpi_sensors->groups[0] = &scpi_sensors->group;
162
163	hwdev = devm_hwmon_device_register_with_groups(dev,
164	"scpi_sensors", scpi_sensors, scpi_sensors->groups);
165
166	return PTR_ERR_OR_ZERO(hwdev);
167	}
168
169	static const struct of_device_id scpi_of_match[] = {
170	{.compatible = "arm,scpi-sensors"},
171	{},
172	};
173
174	static struct platform_driver scpi_hwmon_platdrv = {
175	.driver = {
176	.name = "scpi-hwmon",
177	.owner = THIS_MODULE,
178	.of_match_table = scpi_of_match,
179	},
180	.probe = scpi_hwmon_probe,
181	};
182	module_platform_driver(scpi_hwmon_platdrv);
183
184	MODULE_AUTHOR("Punit Agrawal <punit.agrawal@arm.com>");
185	MODULE_DESCRIPTION("ARM SCPI HWMON interface driver");
186	MODULE_LICENSE("GPL v2");