From: Guenter Roeck <linux@roeck-us.net>
To: Neelesh Gupta <neelegup@linux.vnet.ibm.com>,
linuxppc-dev@lists.ozlabs.org, jdelvare@suse.de,
lm-sensors@lm-sensors.org
Cc: sbhat@linux.vnet.ibm.com
Subject: Re: [lm-sensors] [PATCH v2] powerpc/powernv: hwmon driver for power values, fan rpm and temperature
Date: Wed, 28 May 2014 07:23:46 +0000 [thread overview]
Message-ID: <53858F02.2020808@roeck-us.net> (raw)
In-Reply-To: <20140519141931.9248.11356.stgit@neelegup-tp-t420.in.ibm.com>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WARNING: multiple messages have this Message-ID (diff)
From: Guenter Roeck <linux@roeck-us.net>
To: Neelesh Gupta <neelegup@linux.vnet.ibm.com>,
linuxppc-dev@lists.ozlabs.org, jdelvare@suse.de,
lm-sensors@lm-sensors.org
Cc: sbhat@linux.vnet.ibm.com
Subject: Re: [PATCH v2] powerpc/powernv: hwmon driver for power values, fan rpm and temperature
Date: Wed, 28 May 2014 00:23:46 -0700 [thread overview]
Message-ID: <53858F02.2020808@roeck-us.net> (raw)
In-Reply-To: <20140519141931.9248.11356.stgit@neelegup-tp-t420.in.ibm.com>
On 05/19/2014 07:26 AM, Neelesh Gupta wrote:
> This patch adds basic kernel enablement for reading power values, fan
> speed rpm and temperature values on powernv platforms which will
> be exported to user space through sysfs interface.
>
> Test results:
> -------------
> [root@tul163p1 ~]# sensors
> ibmpowernv-isa-0000
> Adapter: ISA adapter
> fan1: 5487 RPM (min = 0 RPM)
> fan2: 5152 RPM (min = 0 RPM)
> fan3: 5590 RPM (min = 0 RPM)
> fan4: 4963 RPM (min = 0 RPM)
> fan5: 0 RPM (min = 0 RPM)
> fan6: 0 RPM (min = 0 RPM)
> fan7: 7488 RPM (min = 0 RPM)
> fan8: 7944 RPM (min = 0 RPM)
> temp1: +39.0°C (high = +0.0°C)
> power1: 192.00 W
>
> [root@tul163p1 ~]# ls /sys/devices/platform/
> alarmtimer ibmpowernv.0 rtc-generic serial8250 uevent
> [root@tul163p1 ~]# ls /sys/devices/platform/ibmpowernv.0/
> driver/ hwmon/ modalias subsystem/ uevent
> [root@tul163p1 ~]# ls /sys/devices/platform/ibmpowernv.0/hwmon/hwmon0/
> device fan2_min fan4_min fan6_min fan8_min power1_input
> fan1_fault fan3_fault fan5_fault fan7_fault in1_fault subsystem
> fan1_input fan3_input fan5_input fan7_input in2_fault temp1_input
> fan1_min fan3_min fan5_min fan7_min in3_fault temp1_max
> fan2_fault fan4_fault fan6_fault fan8_fault in4_fault uevent
> fan2_input fan4_input fan6_input fan8_input name
> [root@tul163p1 ~]#
> [root@tul163p1 ~]# ls /sys/class/hwmon/hwmon0/
> device fan2_min fan4_min fan6_min fan8_min power1_input
> fan1_fault fan3_fault fan5_fault fan7_fault in1_fault subsystem
> fan1_input fan3_input fan5_input fan7_input in2_fault temp1_input
> fan1_min fan3_min fan5_min fan7_min in3_fault temp1_max
> fan2_fault fan4_fault fan6_fault fan8_fault in4_fault uevent
> fan2_input fan4_input fan6_input fan8_input name
> [root@tul163p1 ~]#
>
The inX_fault attributes don't really make much sense. _fault attributes without
_input attributes don't have any value and are, as you noticed, not displayed
with the sensors command. Is this a problem in teh devicetree data or do you
really have voltage faults without voltages ?
> Signed-off-by: Neelesh Gupta <neelegup@linux.vnet.ibm.com>
> ---
>
Checkpatch says:
total: 8 errors, 11 warnings, 389 lines checked
NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or
scripts/cleanfile
which should really not happen at this point.
Please make sure you follow CodingStyle. checkpatch --strict points to a number
of additional violations.
More comments inline.
> Changes in v2
> =============
> - Generic use of devm_* functions in hwmon like using devm_kzalloc() for dynamic
> memory request, avoiding the need to explicit free of memory.
> Adding 'struct attribute_group' as member of platform data structure to be
> populated and then passed to devm_hwmon_device_register_with_groups().
>
> Note: Having an array of pointers of 'attribute_group' and each group
> corresponds to 'enum sensors' type. Not completely sure, if it's ideal or
> could have just one group populated with attributes of sensor types?
>
Your call, really; whatever is easier for you. I won't dictate one or the other.
Question though is what happens if one group is not populated. If I understand
the code correctly this will result in the remaining groups to be 'dropped',
ie not displayed at all.
> - 'ibmpowernv' is not hot-pluggable device so moving 'platform_driver' callback
> function (probe) as part of __init code.
> - Fixed issues related to coding style.
> - Other general comments in v1.
>
> drivers/hwmon/Kconfig | 8 +
> drivers/hwmon/Makefile | 1
> drivers/hwmon/ibmpowernv.c | 368 ++++++++++++++++++++++++++++++++++++++++++++
You'll also need Documentation/hwmon/ibmpowernv and
Documentation/devicetree/bindings/hwmon/ibmpowernv.
The latter will need to get an Ack from the devicetree maintainers.
> 3 files changed, 377 insertions(+)
> create mode 100644 drivers/hwmon/ibmpowernv.c
>
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index bc196f4..3e308fa 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -554,6 +554,14 @@ config SENSORS_IBMPEX
> This driver can also be built as a module. If so, the module
> will be called ibmpex.
>
> +config SENSORS_IBMPOWERNV
> + tristate "IBM POWERNV platform sensors"
> + depends on PPC_POWERNV
> + default y
> + help
> + If you say yes here you get support for the temperature/fan/power
> + sensors on your platform.
> +
> config SENSORS_IIO_HWMON
> tristate "Hwmon driver that uses channels specified via iio maps"
> depends on IIO
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index c48f987..199c401 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -71,6 +71,7 @@ obj-$(CONFIG_SENSORS_ULTRA45) += ultra45_env.o
> obj-$(CONFIG_SENSORS_I5K_AMB) += i5k_amb.o
> obj-$(CONFIG_SENSORS_IBMAEM) += ibmaem.o
> obj-$(CONFIG_SENSORS_IBMPEX) += ibmpex.o
> +obj-$(CONFIG_SENSORS_IBMPOWERNV)+= ibmpowernv.o
> obj-$(CONFIG_SENSORS_IIO_HWMON) += iio_hwmon.o
> obj-$(CONFIG_SENSORS_INA209) += ina209.o
> obj-$(CONFIG_SENSORS_INA2XX) += ina2xx.o
> diff --git a/drivers/hwmon/ibmpowernv.c b/drivers/hwmon/ibmpowernv.c
> new file mode 100644
> index 0000000..afce620
> --- /dev/null
> +++ b/drivers/hwmon/ibmpowernv.c
> @@ -0,0 +1,368 @@
> +/*
> + * IBM PowerNV platform sensors for temperature/fan/power
> + * Copyright (C) 2014 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.
> + */
> +
> +#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/platform_device.h>
> +#include <asm/opal.h>
> +#include <linux/err.h>
> +
> +#define DRVNAME "ibmpowernv"
> +#define MAX_ATTR_LEN 32
> +
> +/* Sensor suffix name from DT */
> +#define DT_FAULT_ATTR_SUFFIX "faulted"
> +#define DT_DATA_ATTR_SUFFIX "data"
> +#define DT_THRESHOLD_ATTR_SUFFIX "thrs"
> +
> +/*
> + * Enumerates all the types of sensors in the POWERNV platform and does index
> + * into 'struct sensor_group'
> + */
> +enum sensors {
> + FAN,
> + AMBIENT_TEMP,
> + POWER_SUPPLY,
> + POWER_INPUT,
> + MAX_SENSOR_TYPE,
> +};
> +
> +static struct sensor_group {
> + const char *name;
> + const char *compatible;
> + struct attribute_group group;
> + u32 attr_count;
> +} sensor_groups[] = {
> + {"fan", "ibm,opal-sensor-cooling-fan", {0}, 0},
> + {"temp", "ibm,opal-sensor-amb-temp", {0}, 0},
> + {"in", "ibm,opal-sensor-power-supply", {0}, 0},
> + {"power", "ibm,opal-sensor-power", {0}, 0}
> +};
> +
The '0' initializations should not be necessary.
> +struct sensor_data {
> + u32 id; /* An opaque id of the firmware for each sensor */
> + enum sensors type;
> + char name[MAX_ATTR_LEN];
> + struct device_attribute dev_attr;
> +};
> +
> +struct platform_data {
> + const struct attribute_group *attr_groups[MAX_SENSOR_TYPE + 1];
> + u32 sensors_count; /* Total count of sensors from each group */
> +};
> +
> +/* Platform device representing all the ibmpowernv sensors */
> +static struct platform_device *pdevice;
> +
> +static ssize_t show_sensor(struct device *dev, struct device_attribute *devattr,
> + char *buf)
> +{
> + struct sensor_data *sdata = container_of(devattr, struct sensor_data,
> + dev_attr);
> + ssize_t ret;
> + u32 x;
> +
> + ret = opal_get_sensor_data(sdata->id, &x);
> + if (ret) {
> + pr_err("%s: Failed to get opal sensor data\n", __func__);
> + return ret;
> + }
> +
> + /* Convert temperature to milli-degrees */
> + if (sdata->type == AMBIENT_TEMP)
> + x *= 1000;
> + /* Convert power to micro-watts */
> + else if (sdata->type == POWER_INPUT)
> + x *= 1000000;
> +
> + return sprintf(buf, "%d\n", x);
x is unsigned, so %u.
> +}
> +
> +static void __init get_sensor_index_attr(const char *name, u32 *index, char *attr)
> +{
> + char *hash_pos = strchr(name, '#');
> + char *dash_pos;
> + u32 copy_len;
> + char buf[8];
> +
> + memset(buf, 0, sizeof(buf));
> + *index = 0;
> + *attr = '\0';
> +
> + if (hash_pos) {
> + dash_pos = strchr(hash_pos, '-');
> + if (dash_pos) {
> + copy_len = dash_pos - hash_pos - 1;
> + if (copy_len < sizeof(buf)) {
> + strncpy(buf, hash_pos + 1, copy_len);
> + sscanf(buf, "%d", index);
What if sscanf fails ? Might be an interesting exercise to try and create
multiple sensors with index 0 (or, for that matter, with the same index value).
Do you have any protection against bad input data ? Guess not; did you test
what happens if you pass bad data to the driver (such as duplicate sensor
entries) ?
> + }
> +
> + strncpy(attr, dash_pos + 1, MAX_ATTR_LEN);
> + }
> + }
> +}
> +
> +/*
> + * This function translates the DT node name into the 'hwmon' attribute name.
> + * IBMPOWERNV device node appear like cooling-fan#2-data, amb-temp#1-thrs etc.
> + * which need to be mapped as fan2_input, temp1_max respectively before
> + * populating them inside hwmon device class..
> + */
> +static int __init create_hwmon_attr_name(enum sensors type, const char *node_name,
> + char *hwmon_attr_name)
> +{
> + char attr_suffix[MAX_ATTR_LEN];
> + char *attr_name;
> + u32 index;
> +
> + get_sensor_index_attr(node_name, &index, attr_suffix);
> + if (!index || !strlen(attr_suffix)) {
> + pr_info("%s: Sensor device node name is invalid, name: %s\n",
> + __func__, node_name);
> + return -EINVAL;
> + }
> +
> + if (!strcmp(attr_suffix, DT_FAULT_ATTR_SUFFIX))
> + attr_name = "fault";
> + else if(!strcmp(attr_suffix, DT_DATA_ATTR_SUFFIX))
> + attr_name = "input";
> + else if (!strcmp(attr_suffix, DT_THRESHOLD_ATTR_SUFFIX)) {
> + if (type == AMBIENT_TEMP)
> + attr_name = "max";
> + else if (type == FAN)
> + attr_name = "min";
> + else
> + return -ENOENT;
> + } else
> + return -ENOENT;
> +
> + snprintf(hwmon_attr_name, MAX_ATTR_LEN, "%s%d_%s",
> + sensor_groups[type].name, index, attr_name);
> + return 0;
> +}
> +
> +static int __init populate_attr_groups(struct platform_device *pdev)
> +{
> + struct platform_data *pdata = platform_get_drvdata(pdev);
> + const struct attribute_group **pgroups = pdata->attr_groups;
> + struct device_node *opal, *np;
> + enum sensors type;
> + int err = 0;
> +
> + opal = of_find_node_by_path("/ibm,opal/sensors");
> + if (!opal) {
An obvious whitespace error here.
> + pr_err("%s: Opal 'sensors' node not found\n", __func__);
> + return -ENODEV;
> + }
> +
> + 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_groups[type].compatible)) {
> + sensor_groups[type].attr_count++;
> + break;
> + }
> + }
You should be able to do
of_node_put(opal);
here. Then you can return immediately on error below.
> +
> + for (type = 0; type < MAX_SENSOR_TYPE; type++) {
> + if (!sensor_groups[type].attr_count)
> + continue;
> +
> + sensor_groups[type].group.attrs = devm_kzalloc(&pdev->dev,
> + sizeof(struct attribute*) *
> + (sensor_groups[type].attr_count + 1),
> + GFP_KERNEL);
> + if (!sensor_groups[type].group.attrs) {
> + pr_err("%s: Failed to allocate memory for attribute"
> + "array\n", __func__);
devm_kzalloc() already dumps an error message. Same for all other memory error messages.
> + err = -ENOMEM;
> + goto exit_put_node;
> + }
> +
> + pgroups[type] = &sensor_groups[type].group;
> + pdata->sensors_count += sensor_groups[type].attr_count;
> + sensor_groups[type].attr_count = 0;
> + }
> +
> +exit_put_node:
> + of_node_put(opal);
> + return err;
> +}
> +
> +/*
> + * Iterate through the device tree for each child of sensor node, create
> + * a sysfs attribute file, the file is named by translating the DT node name
> + * to the name required by the higher 'hwmon' driver like fan1_input, temp1_max
> + * etc..
> + */
> +static int __init create_device_attrs(struct platform_device *pdev)
> +{
> + struct platform_data *pdata = platform_get_drvdata(pdev);
> + const struct attribute_group **pgroups = pdata->attr_groups;
> + struct device_node *opal, *np;
> + struct sensor_data *sdata;
> + const u32 *sensor_id;
> + enum sensors type;
> + u32 count = 0;
> + int err = 0;
> +
> + opal = of_find_node_by_path("/ibm,opal/sensors");
> + if (!opal) {
> + pr_err("%s: Opal 'sensors' node not found\n", __func__);
> + return -ENODEV;
> + }
> +
> + sdata = devm_kzalloc(&pdev->dev, (pdata->sensors_count) *
> + sizeof(*sdata), GFP_KERNEL);
> + if (!sdata) {
> + pr_err("%s: Failed to allocate memory for the sensor_data",
> + __func__);
> + err = -ENOMEM;
> + goto exit_put_node;
> + }
> +
> + 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_groups[type].compatible))
> + break;
> +
> + if (type == MAX_SENSOR_TYPE)
> + 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;
> + }
> +
Consider using of_property_read_u32().
> + sdata[count].id = *sensor_id;
> + sdata[count].type = type;
> + err = create_hwmon_attr_name(type, np->name, sdata[count].name);
> + if (err)
> + goto exit_put_node;
> +
> + sysfs_attr_init(&sdata[count].dev_attr.attr);
> + sdata[count].dev_attr.attr.name = sdata[count].name;
> + sdata[count].dev_attr.attr.mode = S_IRUGO;
> + sdata[count].dev_attr.show = show_sensor;
> +
> + pgroups[type]->attrs[sensor_groups[type].attr_count++] =
> + &sdata[count++].dev_attr.attr;
> + }
> +
> +exit_put_node:
> + of_node_put(opal);
> + return err;
> +}
> +
> +static int __init ibmpowernv_probe(struct platform_device *pdev)
> +{
> + struct platform_data *pdata;
> + struct device *hwmon_dev;
> + int err;
> +
> + pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
> + if (!pdata)
> + return -ENOMEM;
> +
> + platform_set_drvdata(pdev, pdata);
> + pdata->sensors_count = 0;
> + err = populate_attr_groups(pdev);
> + if (err)
> + return err;
> +
> + /* Create sysfs attribute file for each sensor found in the DT */
Attribute data, not file
> + err = create_device_attrs(pdev);
> + if (err)
> + return err;
> +
> + /* Finally, register with hwmon */
> + hwmon_dev = devm_hwmon_device_register_with_groups(&pdev->dev, DRVNAME,
> + pdata,
> + pdata->attr_groups);
> +
> + return PTR_ERR_OR_ZERO(hwmon_dev);
> +}
> +
> +static struct platform_driver ibmpowernv_driver = {
> + .driver = {
> + .owner = THIS_MODULE,
> + .name = DRVNAME,
> + },
> +};
> +
> +static int __init ibmpowernv_init(void)
> +{
> + int err;
> +
> + pdevice = platform_device_alloc(DRVNAME, 0);
> + if (!pdevice) {
> + pr_err("%s: Device allocation failed\n", __func__);
> + err = -ENOMEM;
> + goto exit;
> + }
> +
> + err = platform_device_add(pdevice);
> + if (err) {
> + pr_err("%s: Device addition failed (%d)\n", __func__, err);
> + goto exit_device_put;
> + }
> +
> + err = platform_driver_probe(&ibmpowernv_driver, ibmpowernv_probe);
> + if (err) {
> + pr_err("%s: Platfrom driver probe failed\n", __func__);
> + goto exit_device_del;
> + }
> +
> + return 0;
> +
> +exit_device_del:
> + platform_device_del(pdevice);
> +exit_device_put:
> + platform_device_put(pdevice);
> +exit:
> + return err;
> +}
> +
> +static void __exit ibmpowernv_exit(void)
> +{
> + platform_driver_unregister(&ibmpowernv_driver);
> + platform_device_unregister(pdevice);
> +}
> +
> +MODULE_AUTHOR("Neelesh Gupta <neelegup@linux.vnet.ibm.com>");
> +MODULE_DESCRIPTION("IBM POWERNV platform sensors");
> +MODULE_LICENSE("GPL");
> +
> +module_init(ibmpowernv_init);
> +module_exit(ibmpowernv_exit);
>
>
>
next prev parent reply other threads:[~2014-05-28 7:23 UTC|newest]
Thread overview: 18+ messages / expand[flat|nested] mbox.gz Atom feed top
2014-05-19 14:26 [PATCH v2] powerpc/powernv: hwmon driver for power values, fan rpm and temperature Neelesh Gupta
2014-05-19 14:38 ` [lm-sensors] " Neelesh Gupta
2014-05-26 6:22 ` Neelesh Gupta
2014-05-26 6:34 ` [lm-sensors] " Neelesh Gupta
2014-05-26 14:12 ` Guenter Roeck
2014-05-26 14:12 ` Guenter Roeck
2014-05-28 7:23 ` Guenter Roeck [this message]
2014-05-28 7:23 ` Guenter Roeck
2014-05-28 7:41 ` [lm-sensors] " Benjamin Herrenschmidt
2014-05-28 7:41 ` Benjamin Herrenschmidt
2014-05-30 14:05 ` Neelesh Gupta
2014-05-30 14:17 ` [lm-sensors] " Neelesh Gupta
2014-06-09 8:15 ` Neelesh Gupta
2014-06-09 8:27 ` [lm-sensors] " Neelesh Gupta
2014-06-18 8:43 ` Neelesh Gupta
2014-06-18 8:55 ` [lm-sensors] " Neelesh Gupta
2014-06-18 13:05 ` Guenter Roeck
2014-06-18 13:05 ` Guenter Roeck
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=53858F02.2020808@roeck-us.net \
--to=linux@roeck-us.net \
--cc=jdelvare@suse.de \
--cc=linuxppc-dev@lists.ozlabs.org \
--cc=lm-sensors@lm-sensors.org \
--cc=neelegup@linux.vnet.ibm.com \
--cc=sbhat@linux.vnet.ibm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.