/*
* hwmon driver for temperature/power/fan on IBM PowerNV platform
* Copyright (C) 2013 IBM
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/of.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/platform_device.h>
#include <asm/opal.h>
#include <linux/err.h>
MODULE_DESCRIPTION("IBM PowerNV Platform power/temp/fan sensor hwmon module");
MODULE_LICENSE("GPL");
#define MAX_ATTR_LENGTH 32
/* Device tree sensor name prefixes. The device tree has the names in the
* format "cooling-fan#2-faulted" where the "cooling-fan" is the sensor type,
* 2 is the sensor count, and "faulted" is the sensor data attribute type.
*/
#define DT_FAULT_ATTR_SUFFIX "faulted"
#define DT_DATA_ATTR_SUFFIX "data"
#define DT_THRESHOLD_ATTR_SUFFIX "thrs"
enum sensors {
FAN,
TEMPERATURE,
POWERSUPPLY,
POWER,
MAX_SENSOR_TYPE,
};
enum attributes {
INPUT,
MINIMUM,
MAXIMUM,
FAULT,
MAX_ATTR_TYPES
};
static struct sensor_name {
char *name;
char *compaible;
} sensor_names[] = {
{"fan-sensor", "ibm,opal-sensor-cooling-fan"},
{"amb-temp-sensor", "ibm,opal-sensor-amb-temp"},
{"power-sensor", "ibm,opal-sensor-power-supply"},
{"power", "ibm,opal-sensor-power"}
};
static const char * const attribute_type_table[] = {
"input",
"min",
"max",
"fault",
NULL
};
struct pdev_entry {
struct list_head list;
struct platform_device *pdev;
enum sensors type;
};
static LIST_HEAD(pdev_list);
/* The sensors are categorised on type.
*
* The sensors of same type are categorised under a common platform device.
* So, The pdev is shared by all sensors of same type.
* Ex : temp1_input, temp1_max, temp2_input,temp2_max all share same platform
* device.
*
* "sensor_data" is the Platform device specific data.
* There is one hwmon_device instance for all the sensors of same type.
* This also holds the list of all sensors with same type but different
* attribute and index.
*/
struct sensor_specific_data {
u32 sensor_id; /* The hex value as in the device tree */
u32 sensor_index; /* The sensor instance index */
struct sensor_device_attribute sd_attr;
enum attributes attr_type;
char attr_name[64];
};
struct sensor_data {
struct device *hwmon_dev;
struct list_head sensor_list;
struct device_attribute name_attr;
};
struct sensor_entry {
struct list_head list;
struct sensor_specific_data *sensor_data;
};
static struct platform_device *powernv_sensor_get_pdev(enum sensors type)
{
struct pdev_entry *p;
list_for_each_entry(p, &pdev_list, list)
if (p->type == type)
return p->pdev;
return NULL;
}
static struct sensor_specific_data *powernv_sensor_get_sensor_data(
struct sensor_data *pdata,
int index, enum attributes attr_type)
{
struct sensor_entry *p;
list_for_each_entry(p, &pdata->sensor_list, list)
if ((p->sensor_data->sensor_index == index) &&
(attr_type == p->sensor_data->attr_type))
return p->sensor_data;
return NULL;
}
static ssize_t show_name(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
return sprintf(buf, "%s\n", pdev->name);
}
/* Note: Data from the sensors for each sensor type needs to be converted to
* the dimension appropriate.
*/
static ssize_t show_sensor(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *sd_attr = to_sensor_dev_attr(devattr);
struct platform_device *pdev = to_platform_device(dev);
struct sensor_data *pdata = platform_get_drvdata(pdev);
struct sensor_specific_data *tdata = NULL;
enum sensors sensor_type = pdev->id;
u32 x = -1;
int ret;
if (sd_attr && sd_attr->dev_attr.attr.name) {
char *pos = strchr(sd_attr->dev_attr.attr.name, '_');
int i;
for (i = 0; i < MAX_ATTR_TYPES; i++) {
if (strcmp(pos+1, attribute_type_table[i]) == 0) {
tdata = powernv_sensor_get_sensor_data(pdata,
sd_attr->index, i);
break;
}
}
}
if (tdata) {
ret = opal_get_sensor_data(tdata->sensor_id, &x);
if (ret)
x = -1;
}
if (sensor_type == TEMPERATURE && x > 0) {
/* Temperature comes in Degrees and convert it to
* milli-degrees.
*/
x = x*1000;
} else if (sensor_type == POWER && x > 0) {
/* Power value comes in watts, convert to micro-watts */
x = x * 1000000;
}
return sprintf(buf, "%d\n", x);
}
static u32 get_sensor_index_from_name(const char *name)
{
char *hash_position = strchr(name, '#');
u32 index = 0, copy_length;
char newbuf[8];
if (hash_position) {
copy_length = strchr(hash_position, '-') - hash_position - 1;
if (copy_length < sizeof(newbuf)) {
strncpy(newbuf, hash_position + 1, copy_length);
sscanf(newbuf, "%d", &index);
}
}
return index;
}
static inline void get_sensor_suffix_from_name(const char *name, char *suffix)
{
char *dash_position = strrchr(name, '-');
if (dash_position)
strncpy(suffix, dash_position+1, MAX_ATTR_LENGTH);
else
strcpy(suffix,"");
}
static int get_sensor_attr_properties(const char *sensor_name,
enum sensors sensor_type, enum attributes *attr_type,
u32 *sensor_index)
{
char suffix[MAX_ATTR_LENGTH];
*attr_type = MAX_ATTR_TYPES;
*sensor_index = get_sensor_index_from_name(sensor_name);
if (*sensor_index == 0)
return -EINVAL;
get_sensor_suffix_from_name(sensor_name, suffix);
if (strcmp(suffix, "") == 0)
return -EINVAL;
if (strcmp(suffix, DT_FAULT_ATTR_SUFFIX) == 0)
*attr_type = FAULT;
else if (strcmp(suffix, DT_DATA_ATTR_SUFFIX) == 0)
*attr_type = INPUT;
else if ((sensor_type == TEMPERATURE) &&
(strcmp(suffix, DT_THRESHOLD_ATTR_SUFFIX) == 0))
*attr_type = MAXIMUM;
else if ((sensor_type == FAN) &&
(strcmp(suffix, DT_THRESHOLD_ATTR_SUFFIX) == 0))
*attr_type = MINIMUM;
else
return -ENOENT;
if (((sensor_type == FAN) && ((*attr_type == INPUT) ||
(*attr_type == MINIMUM)))
|| ((sensor_type == TEMPERATURE) && ((*attr_type == INPUT) ||
(*attr_type == MAXIMUM)))
|| ((sensor_type == POWER) && ((*attr_type == INPUT))))
return 0;
return -ENOENT;
}
static int create_sensor_attr(struct sensor_specific_data *tdata,
struct device *dev, enum sensors sensor_type,
enum attributes attr_type)
{
int err = 0;
char temp_file_prefix[50];
static const char *const file_name_format = "%s%d_%s";
tdata->attr_type = attr_type;
if (sensor_type == FAN)
strcpy(temp_file_prefix, "fan");
else if (sensor_type == TEMPERATURE)
strcpy(temp_file_prefix, "temp");
else if (sensor_type == POWERSUPPLY)
strcpy(temp_file_prefix, "powersupply");
else if (sensor_type == POWER)
strcpy(temp_file_prefix, "power");
snprintf(tdata->attr_name, sizeof(tdata->attr_name), file_name_format,
temp_file_prefix, tdata->sensor_index,
attribute_type_table[tdata->attr_type]);
sysfs_attr_init(&tdata->sd_attr.dev_attr.attr);
tdata->sd_attr.dev_attr.attr.name = tdata->attr_name;
tdata->sd_attr.dev_attr.attr.mode = S_IRUGO;
tdata->sd_attr.dev_attr.show = show_sensor;
tdata->sd_attr.index = tdata->sensor_index;
err = device_create_file(dev, &tdata->sd_attr.dev_attr);
return err;
}
static int create_name_attr(struct sensor_data *pdata,
struct device *dev)
{
sysfs_attr_init(&pdata->name_attr.attr);
pdata->name_attr.attr.name = "name";
pdata->name_attr.attr.mode = S_IRUGO;
pdata->name_attr.show = show_name;
return device_create_file(dev, &pdata->name_attr);
}
static int create_platform_device(enum sensors sensor_type,
struct platform_device **pdev)
{
struct pdev_entry *pdev_entry = NULL;
int err;
*pdev = platform_device_alloc(sensor_names[sensor_type].name,
sensor_type);
if (!*pdev) {
pr_err("Device allocation failed\n");
err = -ENOMEM;
goto exit;
}
pdev_entry = kzalloc(sizeof(struct pdev_entry), GFP_KERNEL);
if (!pdev_entry) {
pr_err("Device allocation failed\n");
err = -ENOMEM;
goto exit_device_put;
}
err = platform_device_add(*pdev);
if (err) {
pr_err("Device addition failed (%d)\n", err);
goto exit_device_free;
}
pdev_entry->pdev = *pdev;
pdev_entry->type = (*pdev)->id;
list_add_tail(&pdev_entry->list, &pdev_list);
return 0;
exit_device_free:
kfree(pdev_entry);
exit_device_put:
platform_device_put(*pdev);
exit:
return err;
}
static int create_sensor_data(struct platform_device *pdev)
{
struct sensor_data *pdata = NULL;
int err = 0;
pdata = kzalloc(sizeof(struct sensor_data), GFP_KERNEL);
if (!pdata) {
err = -ENOMEM;
goto exit;
}
err = create_name_attr(pdata, &pdev->dev);
if (err)
goto exit_free;
pdata->hwmon_dev = hwmon_device_register(&pdev->dev);
if (IS_ERR(pdata->hwmon_dev)) {
err = PTR_ERR(pdata->hwmon_dev);
dev_err(&pdev->dev, "Class registration failed (%d)\n",
err);
goto exit_name;
}
INIT_LIST_HEAD(&pdata->sensor_list);
platform_set_drvdata(pdev, pdata);
return 0;
exit_name:
device_remove_file(&pdev->dev, &pdata->name_attr);
exit_free:
kfree(pdata);
exit:
return err;
}
static void delete_sensor_attr(struct sensor_data *pdata)
{
struct sensor_entry *s, *l;
list_for_each_entry_safe(s, l, &pdata->sensor_list, list) {
struct sensor_specific_data *tdata = s->sensor_data;
kfree(tdata);
list_del(&s->list);
kfree(s);
}
}
static int powernv_sensor_init(u32 sensor_id, const struct device_node *np,
enum sensors sensor_type, enum attributes attr_type,
u32 sensor_index)
{
struct platform_device *pdev = powernv_sensor_get_pdev(sensor_type);
struct sensor_specific_data *tdata;
struct sensor_entry *sensor_entry;
struct sensor_data *pdata;
int err = 0;
if (!pdev) {
err = create_platform_device(sensor_type, &pdev);
if (err)
goto exit;
err = create_sensor_data(pdev);
if (err)
goto exit;
}
pdata = platform_get_drvdata(pdev);
if (!pdata) {
err = -ENOMEM;
goto exit;
}
tdata = kzalloc(sizeof(struct sensor_specific_data), GFP_KERNEL);
if (!tdata) {
err = -ENOMEM;
goto exit;
}
tdata->sensor_id = sensor_id;
tdata->sensor_index = sensor_index;
err = create_sensor_attr(tdata, &pdev->dev, sensor_type, attr_type);
if (err)
goto exit_free;
sensor_entry = kzalloc(sizeof(struct sensor_entry), GFP_KERNEL);
if (!sensor_entry) {
err = -ENOMEM;
goto exit_attr;
}
sensor_entry->sensor_data = tdata;
list_add_tail(&sensor_entry->list, &pdata->sensor_list);
return 0;
exit_attr:
device_remove_file(&pdev->dev, &tdata->sd_attr.dev_attr);
exit_free:
kfree(tdata);
exit:
return err;
}
static void delete_unregister_sensors(void)
{
struct pdev_entry *p, *n;
list_for_each_entry_safe(p, n, &pdev_list, list) {
struct sensor_data *pdata = platform_get_drvdata(p->pdev);
if (pdata) {
delete_sensor_attr(pdata);
hwmon_device_unregister(pdata->hwmon_dev);
kfree(pdata);
}
platform_device_unregister(p->pdev);
list_del(&p->list);
kfree(p);
}
}
static int __init powernv_hwmon_init(void)
{
struct device_node *opal, *np = NULL;
enum attributes attr_type;
enum sensors type;
const u32 *sensor_id;
u32 sensor_index;
int err;
opal = of_find_node_by_path("/ibm,opal/sensors");
if (!opal) {
pr_err("%s: Opal 'sensors' node not found\n", __func__);
return -ENXIO;
}
for_each_child_of_node(opal, np) {
if (np->name == NULL)
continue;
for (type = 0; type < MAX_SENSOR_TYPE; type++)
if (of_device_is_compatible(np,
sensor_names[type].compaible))
break;
if (type == MAX_SENSOR_TYPE)
continue;
if (get_sensor_attr_properties(np->name, type, &attr_type,
&sensor_index))
continue;
sensor_id = of_get_property(np, "sensor-id", NULL);
if (!sensor_id) {
pr_info("%s: %s doesn't have sensor-id\n", __func__,
np->name);
continue;
}
err = powernv_sensor_init(*sensor_id, np, type, attr_type,
sensor_index);
if (err) {
of_node_put(opal);
goto exit;
}
}
of_node_put(opal);
return 0;
exit:
delete_unregister_sensors();
return err;
}
static void powernv_hwmon_exit(void)
{
delete_unregister_sensors();
}
module_init(powernv_hwmon_init);
module_exit(powernv_hwmon_exit);
