1/*
  2 *  MEN 14F021P00 Board Management Controller (BMC) hwmon driver.
  3 *
  4 *  This is the core hwmon driver of the MEN 14F021P00 BMC.
  5 *  The BMC monitors the board voltages which can be access with this
  6 *  driver through sysfs.
  7 *
  8 *  Copyright (C) 2014 MEN Mikro Elektronik Nuernberg GmbH
  9 *
 10 *  This program is free software; you can redistribute  it and/or modify it
 11 *  under  the terms of  the GNU General  Public License as published by the
 12 *  Free Software Foundation;  either version 2 of the  License, or (at your
 13 *  option) any later version.
 14 */
 15
 16#include <linux/module.h>
 17#include <linux/kernel.h>
 18#include <linux/platform_device.h>
 19#include <linux/hwmon.h>
 20#include <linux/hwmon-sysfs.h>
 21#include <linux/jiffies.h>
 22#include <linux/slab.h>
 23#include <linux/i2c.h>
 24#include <linux/err.h>
 25
 26#define DRV_NAME  "menf21bmc_hwmon"
 27
 28#define BMC_VOLT_COUNT	5
 29#define MENF21BMC_V33	0
 30#define MENF21BMC_V5	1
 31#define MENF21BMC_V12	2
 32#define MENF21BMC_V5_SB	3
 33#define MENF21BMC_VBAT	4
 34
 35#define IDX_TO_VOLT_MIN_CMD(idx) (0x40 + idx)
 36#define IDX_TO_VOLT_MAX_CMD(idx) (0x50 + idx)
 37#define IDX_TO_VOLT_INP_CMD(idx) (0x60 + idx)
 38
 39struct menf21bmc_hwmon {
 40	bool valid;
 41	struct i2c_client *i2c_client;
 42	unsigned long last_update;
 43	int in_val[BMC_VOLT_COUNT];
 44	int in_min[BMC_VOLT_COUNT];
 45	int in_max[BMC_VOLT_COUNT];
 46};
 47
 48static const char *const input_names[] = {
 49	[MENF21BMC_V33]		= "MON_3_3V",
 50	[MENF21BMC_V5]		= "MON_5V",
 51	[MENF21BMC_V12]		= "MON_12V",
 52	[MENF21BMC_V5_SB]	= "5V_STANDBY",
 53	[MENF21BMC_VBAT]	= "VBAT"
 54};
 55
 56static struct menf21bmc_hwmon *menf21bmc_hwmon_update(struct device *dev)
 57{
 58	int i;
 59	int val;
 60	struct menf21bmc_hwmon *drv_data = dev_get_drvdata(dev);
 61	struct menf21bmc_hwmon *data_ret = drv_data;
 62
 63	if (time_after(jiffies, drv_data->last_update + HZ)
 64	    || !drv_data->valid) {
 65		for (i = 0; i < BMC_VOLT_COUNT; i++) {
 66			val = i2c_smbus_read_word_data(drv_data->i2c_client,
 67						       IDX_TO_VOLT_INP_CMD(i));
 68			if (val < 0) {
 69				data_ret = ERR_PTR(val);
 70				goto abort;
 71			}
 72			drv_data->in_val[i] = val;
 73		}
 74		drv_data->last_update = jiffies;
 75		drv_data->valid = true;
 76	}
 77abort:
 78	return data_ret;
 79}
 80
 81static int menf21bmc_hwmon_get_volt_limits(struct menf21bmc_hwmon *drv_data)
 82{
 83	int i, val;
 84
 85	for (i = 0; i < BMC_VOLT_COUNT; i++) {
 86		val = i2c_smbus_read_word_data(drv_data->i2c_client,
 87					       IDX_TO_VOLT_MIN_CMD(i));
 88		if (val < 0)
 89			return val;
 90
 91		drv_data->in_min[i] = val;
 92
 93		val = i2c_smbus_read_word_data(drv_data->i2c_client,
 94					       IDX_TO_VOLT_MAX_CMD(i));
 95		if (val < 0)
 96			return val;
 97
 98		drv_data->in_max[i] = val;
 99	}
100	return 0;
101}
102
103static ssize_t
104show_label(struct device *dev, struct device_attribute *devattr, char *buf)
105{
106	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
107
108	return sprintf(buf, "%s\n", input_names[attr->index]);
109}
110
111static ssize_t
112show_in(struct device *dev, struct device_attribute *devattr, char *buf)
113{
114	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
115	struct menf21bmc_hwmon *drv_data = menf21bmc_hwmon_update(dev);
116
117	if (IS_ERR(drv_data))
118		return PTR_ERR(drv_data);
119
120	return sprintf(buf, "%d\n", drv_data->in_val[attr->index]);
121}
122
123static ssize_t
124show_min(struct device *dev, struct device_attribute *devattr, char *buf)
125{
126	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
127	struct menf21bmc_hwmon *drv_data = dev_get_drvdata(dev);
128
129	return sprintf(buf, "%d\n", drv_data->in_min[attr->index]);
130}
131
132static ssize_t
133show_max(struct device *dev, struct device_attribute *devattr, char *buf)
134{
135	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
136	struct menf21bmc_hwmon *drv_data = dev_get_drvdata(dev);
137
138	return sprintf(buf, "%d\n", drv_data->in_max[attr->index]);
139}
140
141#define create_voltage_sysfs(idx)			\
142static SENSOR_DEVICE_ATTR(in##idx##_input, S_IRUGO,	\
143			show_in, NULL, idx);		\
144static SENSOR_DEVICE_ATTR(in##idx##_min, S_IRUGO,	\
145			show_min, NULL, idx);		\
146static SENSOR_DEVICE_ATTR(in##idx##_max, S_IRUGO,	\
147			show_max, NULL, idx);		\
148static SENSOR_DEVICE_ATTR(in##idx##_label, S_IRUGO,	\
149			show_label, NULL, idx);
150
151create_voltage_sysfs(0);
152create_voltage_sysfs(1);
153create_voltage_sysfs(2);
154create_voltage_sysfs(3);
155create_voltage_sysfs(4);
156
157static struct attribute *menf21bmc_hwmon_attrs[] = {
158	&sensor_dev_attr_in0_input.dev_attr.attr,
159	&sensor_dev_attr_in0_min.dev_attr.attr,
160	&sensor_dev_attr_in0_max.dev_attr.attr,
161	&sensor_dev_attr_in0_label.dev_attr.attr,
162
163	&sensor_dev_attr_in1_input.dev_attr.attr,
164	&sensor_dev_attr_in1_min.dev_attr.attr,
165	&sensor_dev_attr_in1_max.dev_attr.attr,
166	&sensor_dev_attr_in1_label.dev_attr.attr,
167
168	&sensor_dev_attr_in2_input.dev_attr.attr,
169	&sensor_dev_attr_in2_min.dev_attr.attr,
170	&sensor_dev_attr_in2_max.dev_attr.attr,
171	&sensor_dev_attr_in2_label.dev_attr.attr,
172
173	&sensor_dev_attr_in3_input.dev_attr.attr,
174	&sensor_dev_attr_in3_min.dev_attr.attr,
175	&sensor_dev_attr_in3_max.dev_attr.attr,
176	&sensor_dev_attr_in3_label.dev_attr.attr,
177
178	&sensor_dev_attr_in4_input.dev_attr.attr,
179	&sensor_dev_attr_in4_min.dev_attr.attr,
180	&sensor_dev_attr_in4_max.dev_attr.attr,
181	&sensor_dev_attr_in4_label.dev_attr.attr,
182	NULL
183};
184
185ATTRIBUTE_GROUPS(menf21bmc_hwmon);
186
187static int menf21bmc_hwmon_probe(struct platform_device *pdev)
188{
189	int ret;
190	struct menf21bmc_hwmon *drv_data;
191	struct i2c_client *i2c_client = to_i2c_client(pdev->dev.parent);
192	struct device *hwmon_dev;
193
194	drv_data = devm_kzalloc(&pdev->dev, sizeof(struct menf21bmc_hwmon),
195				GFP_KERNEL);
196	if (!drv_data)
197		return -ENOMEM;
198
199	drv_data->i2c_client = i2c_client;
200
201	ret = menf21bmc_hwmon_get_volt_limits(drv_data);
202	if (ret) {
203		dev_err(&pdev->dev, "failed to read sensor limits");
204		return ret;
205	}
206
207	hwmon_dev = devm_hwmon_device_register_with_groups(&pdev->dev,
208						   "menf21bmc", drv_data,
209						   menf21bmc_hwmon_groups);
210	if (IS_ERR(hwmon_dev))
211		return PTR_ERR(hwmon_dev);
212
213	dev_info(&pdev->dev, "MEN 14F021P00 BMC hwmon device enabled");
214
215	return 0;
216}
217
218static struct platform_driver menf21bmc_hwmon = {
219	.probe		= menf21bmc_hwmon_probe,
220	.driver		= {
221		.name		= DRV_NAME,
222	},
223};
224
225module_platform_driver(menf21bmc_hwmon);
226
227MODULE_AUTHOR("Andreas Werner <andreas.werner@men.de>");
228MODULE_DESCRIPTION("MEN 14F021P00 BMC hwmon");
229MODULE_LICENSE("GPL v2");
230MODULE_ALIAS("platform:menf21bmc_hwmon");