drivers/hwmon/ibmpowernv.c - kernel/msm-4.9 - Gitiles

 /*
  * 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);
	/*
	* 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);