Skip to contentSkip to conversation

hwmon: PMBus device driver

PATCH Superseded Guenter Roeck 2 participants 19 messages Feb 17, 2011 – Feb 26, 2011

Subsystems (2)

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

v4 cover hwmon: PMBus device driver

This patchset adds support for hardware monitoring features of PMBus devices.

---
I did not get significant feedback from the previous submission, so here it is again with extended audience. Only change since v3 is a minor fix in Kconfig.

I understand this is a large patch set. Question is if it would make sense to create its own subdirectory for pmbus devices, and to split pmbus.c and pmbus_core.c into more files. I'd be more than happy to do that if it helps for the review process.

There is still some work to be done. Fan support is only rudimentary, and the PHASE command is still not supported. However, the driver is now stable enough to be useful, so it is worth going ahead.

v4 changes:
- Fixed PMBUS entry in Kconfig

v3 changes:
Tested with real hardware (bmr453, bmr454, ltc2978, max8688, max16064, max34441).
Changes are too numerous to count. Lots of bug fixes. Code was completely rearranged to permit addition of chips without having to modify the core pmbus driver. Split main driver into pmbus_core.c for core support and pmbus.c as front-end driver to support generic PMBus chips. Support for additional chips can now be added by writing small front-end drivers which basically describe chip capabilities.

v2 changes:
- Calculate maximum number of attributes / sensors / booleans / labels instead of using defines
- Increased maximum number of supported pages to the PMBus maximum of 32.
- Replaced most fixed size arrays with dynamically allocated arrays/structures.
- Added comments and clarifications
- Renamed local defines to start with PB_ or PMBUS_ prefix
- Removed pages module parameter. Replaced with code to auto-detect the number of supported pages.
- Split probe code into several functions to make it better readable
- Replaced _fault attributes with _lcrit_alarm and _crit_alarm attributes
- Several other minor changes to address review feedback
- PMBus emulator: Fixed fault status detection code. Also use more reasonable power limits (eg 200W instead of 2kW).

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

#1 lore raw

PATCH v4 1/5 hwmon: PMBus device driver

This driver adds support for hardware monitoring features of various PMBus devices.

---
 drivers/hwmon/Kconfig      |   25 +
 drivers/hwmon/Makefile     |    4 +
 drivers/hwmon/pmbus.c      |  234 +++++++
 drivers/hwmon/pmbus.h      |  307 +++++++++
 drivers/hwmon/pmbus_core.c | 1611 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/i2c/pmbus.h  |   45 ++
 6 files changed, 2226 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/pmbus.c
 create mode 100644 drivers/hwmon/pmbus.h
 create mode 100644 drivers/hwmon/pmbus_core.c
 create mode 100644 include/linux/i2c/pmbus.h
drivers/hwmon/Kconfig +25 -0
index 773e484..9f20e56 100644
@@ -734,6 +734,31 @@ config SENSORS_PCF8591
 	  These devices are hard to detect and rarely found on mainstream
 	  hardware.  If unsure, say N.
 
+config PMBUS
+	tristate "PMBus support"
+	depends on I2C && EXPERIMENTAL
+	default n
+	help
+	  Say yes here if you want to enable PMBus support.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called pmbus_core.
+
+if PMBUS
+
+config SENSORS_PMBUS
+	tristate "Generic PMBus devices"
+	default n
+	help
+	  If you say yes here you get hardware monitoring support for generic
+	  PMBus devices, including but not limited to BMR450, BMR451, BMR453,
+	  BMR454, and LTC2978.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called pmbus.
+
+endif # PMBUS
+
 config SENSORS_SHT15
 	tristate "Sensiron humidity and temperature sensors. SHT15 and compat."
 	depends on GENERIC_GPIO
drivers/hwmon/Makefile +4 -0
index dde02d9..f7f158b 100644
@@ -112,6 +112,10 @@ obj-$(CONFIG_SENSORS_W83L786NG)	+= w83l786ng.o
 obj-$(CONFIG_SENSORS_WM831X)	+= wm831x-hwmon.o
 obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 
+# PMBus drivers
+obj-$(CONFIG_PMBUS)		+= pmbus_core.o
+obj-$(CONFIG_SENSORS_PMBUS)	+= pmbus.o
+
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG
 endif
drivers/hwmon/pmbus.c new file +234 -0

234 lines not on this page · raw message

drivers/hwmon/pmbus.h new file +307 -0

307 lines not on this page · raw message

drivers/hwmon/pmbus_core.c new file +1607 -0

1,607 lines not on this page · raw message

include/linux/i2c/pmbus.h new file +45 -0

45 lines not on this page · raw message

Signature · 7 lines
1.7.3.1


_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
#2 lore raw
Quoted 2 lines · Guenter Roeck

This driver adds support for hardware monitoring features of various PMBus devices.

Hi Guenter, I'm afraid this isn't the most thorough review ever, but there are a few questions I'd like answered inline. These devices are pretty ugly.

I'm also a little unhappy with how often you clear faults without it being obvious why. Please have another look at this and add clarifying comments...

I've suggested use of some macros inline. Not sure whether it's actualy a good idea though. What do you think?

Other than request for a few more comments to explain bits that weren't immediately obvious, the only bit I'd really question is the necessity of the list of pmbus devices. I might have missed something there though...

Thanks,

Jonathan

Quoted 98 lines
---
 drivers/hwmon/Kconfig      |   25 +
 drivers/hwmon/Makefile     |    4 +
 drivers/hwmon/pmbus.c      |  234 +++++++
 drivers/hwmon/pmbus.h      |  307 +++++++++
 drivers/hwmon/pmbus_core.c | 1611 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/i2c/pmbus.h  |   45 ++
 6 files changed, 2226 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/pmbus.c
 create mode 100644 drivers/hwmon/pmbus.h
 create mode 100644 drivers/hwmon/pmbus_core.c
 create mode 100644 include/linux/i2c/pmbus.h
drivers/hwmon/Kconfig +25 -0
index 773e484..9f20e56 100644
@@ -734,6 +734,31 @@ config SENSORS_PCF8591
 	  These devices are hard to detect and rarely found on mainstream
 	  hardware.  If unsure, say N.
 
+config PMBUS
+	tristate "PMBus support"
+	depends on I2C && EXPERIMENTAL
+	default n
+	help
+	  Say yes here if you want to enable PMBus support.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called pmbus_core.
+
+if PMBUS
+
+config SENSORS_PMBUS
+	tristate "Generic PMBus devices"
+	default n
+	help
+	  If you say yes here you get hardware monitoring support for generic
+	  PMBus devices, including but not limited to BMR450, BMR451, BMR453,
+	  BMR454, and LTC2978.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called pmbus.
+
+endif # PMBUS
+
 config SENSORS_SHT15
 	tristate "Sensiron humidity and temperature sensors. SHT15 and compat."
 	depends on GENERIC_GPIO
drivers/hwmon/Makefile +4 -0
index dde02d9..f7f158b 100644
@@ -112,6 +112,10 @@ obj-$(CONFIG_SENSORS_W83L786NG)	+= w83l786ng.o
 obj-$(CONFIG_SENSORS_WM831X)	+= wm831x-hwmon.o
 obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 
+# PMBus drivers
+obj-$(CONFIG_PMBUS)		+= pmbus_core.o
+obj-$(CONFIG_SENSORS_PMBUS)	+= pmbus.o
+
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG
 endif
drivers/hwmon/pmbus.c new file +26 -0
new file mode 100644
index 0000000..e5c3527
@@ -0,0 +1,234 @@
+/*
+ * Hardware monitoring driver for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>

drivers/hwmon/pmbus.c line 36

Quoted 10 lines
drivers/hwmon/pmbus.c new file +10 -0
+#include <linux/list.h>
+#include <linux/i2c.h>
+#include "pmbus.h"
+
+struct pmbus_entry {
+	struct list_head list;
+	struct i2c_client *client;
+	struct pmbus_driver_info info;
+};
+

I'd like to see a comment to explain that (I think) this list only contains pmbus drivers directly managed by this driver. (and not say the max8688?)

Quoted 124 lines
drivers/hwmon/pmbus.c new file +124 -0
+static LIST_HEAD(pmbus_list);
+static DEFINE_MUTEX(pmbus_list_mutex);
+
+/*
+ * Find sensor groups and status registers on each page.
+ */
+static void pmbus_find_sensor_groups(struct i2c_client *client,
+				     struct pmbus_driver_info *info)
+{
+	int page;
+
+	/* Sensors detected on page 0 only */
+	if (pmbus_check_word_register(client, 0, PMBUS_READ_VIN))
+		info->func[0] |= PMBUS_HAVE_VIN;
+	if (pmbus_check_word_register(client, 0, PMBUS_READ_VCAP))
+		info->func[0] |= PMBUS_HAVE_VCAP;
+	if (pmbus_check_word_register(client, 0, PMBUS_READ_IIN))
+		info->func[0] |= PMBUS_HAVE_IIN;
+	if (pmbus_check_word_register(client, 0, PMBUS_READ_PIN))
+		info->func[0] |= PMBUS_HAVE_PIN;
+	if (info->func[0]
+	    && pmbus_check_byte_register(client, 0, PMBUS_STATUS_INPUT))
+		info->func[0] |= PMBUS_HAVE_STATUS_INPUT;
+	if (pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_1)) {
+		info->func[0] |= PMBUS_HAVE_FAN12;
+		if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_12))
+			info->func[0] |= PMBUS_HAVE_STATUS_FAN12;
+	}
+	if (pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_3)) {
+		info->func[0] |= PMBUS_HAVE_FAN34;
+		if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_34))
+			info->func[0] |= PMBUS_HAVE_STATUS_FAN34;
+	}
+	if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_1)) {
+		info->func[0] |= PMBUS_HAVE_TEMP;
+		if (pmbus_check_byte_register(client, 0,
+					      PMBUS_STATUS_TEMPERATURE))
+			info->func[0] |= PMBUS_HAVE_STATUS_TEMP;
+	}
+
+	/* Sensors detected on all pages */
+	for (page = 0; page < info->pages; page++) {
+		if (pmbus_check_word_register(client, page, PMBUS_READ_VOUT)) {
+			info->func[page] |= PMBUS_HAVE_VOUT;
+			if (pmbus_check_byte_register(client, page,
+						      PMBUS_STATUS_VOUT))
+				info->func[page] |= PMBUS_HAVE_STATUS_VOUT;
+		}
+		if (pmbus_check_word_register(client, page, PMBUS_READ_IOUT)) {
+			info->func[page] |= PMBUS_HAVE_IOUT;
+			if (pmbus_check_byte_register(client, 0,
+						      PMBUS_STATUS_IOUT))
+				info->func[page] |= PMBUS_HAVE_STATUS_IOUT;
+		}
+		if (pmbus_check_word_register(client, page, PMBUS_READ_POUT))
+			info->func[page] |= PMBUS_HAVE_POUT;
+	}
+}
+
+/*
+ * Identify chip parameters.
+ */
+static int pmbus_identify(struct i2c_client *client,
+			  struct pmbus_driver_info *info)
+{
+	if (!info->pages) {
+		/*
+		 * Check if the PAGE command is supported. If it is,
+		 * keep setting the page number until it fails or until the
+		 * maximum number of pages has been reached. Assume that
+		 * this is the number of pages supported by the chip.
+		 */
+		if (pmbus_check_byte_register(client, 0, PMBUS_PAGE)) {
+			int page;
+
+			for (page = 1; page < PMBUS_PAGES; page++) {
+				if (pmbus_set_page(client, page) < 0)
+					break;
+			}
+			pmbus_set_page(client, 0);
+			info->pages = page;
+		} else {
+			info->pages = 1;
+		}
+	}
+
+	/*
+	 * We should check if the COEFFICIENTS register is supported.
+	 * If it is, and the chip is configured for direct mode, we can read
+	 * the coefficients from the chip, one set per group of sensor
+	 * registers.
+	 *
+	 * To do this, we will need access to a chip which actually supports the
+	 * COEFFICIENTS command, since the command is too complex to implement
+	 * without testing it.
+	 */
+
+	/* Try to find sensor groups  */
+	pmbus_find_sensor_groups(client, info);
+
+	pmbus_clear_faults(client);
+
+	return 0;
+}
+
+static void pmbus_entry_remove(struct i2c_client *client)
+{
+	struct pmbus_entry *p;
+
+	mutex_lock(&pmbus_list_mutex);
+	list_for_each_entry(p, &pmbus_list, list) {
+		if (p->client == client) {
+			list_del(&p->list);
+			kfree(p);
+			break;
+		}
+	}
+	mutex_unlock(&pmbus_list_mutex);
+}
+
+static int pmbus_probe(struct i2c_client *client,
+		       const struct i2c_device_id *id)
+{
+	struct pmbus_entry *pe;

drivers/hwmon/pmbus.c line 170

Quoted 10 lines
drivers/hwmon/pmbus.c new file +10 -0
+	int ret;
+
+	pe = kzalloc(sizeof(struct pmbus_entry), GFP_KERNEL);
+	if (!pe)
+		return -ENOMEM;
+
+	pe->client = client;
+	mutex_lock(&pmbus_list_mutex);
+	list_add_tail(&pe->list, &pmbus_list);
+	mutex_unlock(&pmbus_list_mutex);

I'm a little unclear why the list is needed. Looks like it is used for cleanup purposes. i2c_set_clientdata gets called with a struct pmbus_data *data in pmbus_do_probe. That structure has a pointer to struct pmbus_driver_info info currently effectively stored in this list. Hence, if we don't have the list I think we can create a pmbus_driver_info struct directly here and get to it via ((struct pmbus_data *)(i2c_get_clientdata(client))->info to free the structure on remove.

Quoted 359 lines
drivers/hwmon/pmbus.c new file +64 -0
+
+	pe->info.pages = id->driver_data;
+	pe->info.identify = pmbus_identify;
+
+	ret = pmbus_do_probe(client, id, &pe->info);
+	if (ret < 0)
+		goto out;
+	return 0;
+
+out:
+	pmbus_entry_remove(client);
+	return ret;
+}
+
+static int pmbus_remove(struct i2c_client *client)
+{
+	int ret;
+
+	ret = pmbus_do_remove(client);
+	pmbus_entry_remove(client);
+
+	return ret;
+}
+
+/*
+ * Use driver_data to set the number of pages supported by the chip.
+ */
+static const struct i2c_device_id pmbus_id[] = {
+	{"bmr450", 1},
+	{"bmr451", 1},
+	{"bmr453", 1},
+	{"bmr454", 1},
+	{"ltc2978", 8},
+	{"pmbus", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, pmbus_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver pmbus_driver = {
+	.driver = {
+		   .name = "pmbus",
+		   },
+	.probe = pmbus_probe,
+	.remove = pmbus_remove,
+	.id_table = pmbus_id,
+};
+
+static int __init pmbus_init(void)
+{
+	return i2c_add_driver(&pmbus_driver);
+}
+
+static void __exit pmbus_exit(void)
+{
+	i2c_del_driver(&pmbus_driver);
+}
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("Generic PMBus driver");
+MODULE_LICENSE("GPL");
+module_init(pmbus_init);
+module_exit(pmbus_exit);
drivers/hwmon/pmbus.h new file +289 -0
new file mode 100644
index 0000000..2dc4e01
@@ -0,0 +1,307 @@
+/*
+ * pmbus.h - Common defines and structures for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef PMBUS_H
+#define PMBUS_H
+
+/*
+ * Registers
+ */
+#define PMBUS_PAGE			0x00
+#define PMBUS_OPERATION			0x01
+#define PMBUS_ON_OFF_CONFIG		0x02
+#define PMBUS_CLEAR_FAULTS		0x03
+#define PMBUS_PHASE			0x04
+
+#define PMBUS_CAPABILITY		0x19
+#define PMBUS_QUERY			0x1A
+
+#define PMBUS_VOUT_MODE			0x20
+#define PMBUS_VOUT_COMMAND		0x21
+#define PMBUS_VOUT_TRIM			0x22
+#define PMBUS_VOUT_CAL_OFFSET		0x23
+#define PMBUS_VOUT_MAX			0x24
+#define PMBUS_VOUT_MARGIN_HIGH		0x25
+#define PMBUS_VOUT_MARGIN_LOW		0x26
+#define PMBUS_VOUT_TRANSITION_RATE	0x27
+#define PMBUS_VOUT_DROOP		0x28
+#define PMBUS_VOUT_SCALE_LOOP		0x29
+#define PMBUS_VOUT_SCALE_MONITOR	0x2A
+
+#define PMBUS_COEFFICIENTS		0x30
+#define PMBUS_POUT_MAX			0x31
+
+#define PMBUS_FAN_CONFIG_12		0x3A
+#define PMBUS_FAN_COMMAND_1		0x3B
+#define PMBUS_FAN_COMMAND_2		0x3C
+#define PMBUS_FAN_CONFIG_34		0x3D
+#define PMBUS_FAN_COMMAND_3		0x3E
+#define PMBUS_FAN_COMMAND_4		0x3F
+
+#define PMBUS_VOUT_OV_FAULT_LIMIT	0x40
+#define PMBUS_VOUT_OV_FAULT_RESPONSE	0x41
+#define PMBUS_VOUT_OV_WARN_LIMIT	0x42
+#define PMBUS_VOUT_UV_WARN_LIMIT	0x43
+#define PMBUS_VOUT_UV_FAULT_LIMIT	0x44
+#define PMBUS_VOUT_UV_FAULT_RESPONSE	0x45
+#define PMBUS_IOUT_OC_FAULT_LIMIT	0x46
+#define PMBUS_IOUT_OC_FAULT_RESPONSE	0x47
+#define PMBUS_IOUT_OC_LV_FAULT_LIMIT	0x48
+#define PMBUS_IOUT_OC_LV_FAULT_RESPONSE	0x49
+#define PMBUS_IOUT_OC_WARN_LIMIT	0x4A
+#define PMBUS_IOUT_UC_FAULT_LIMIT	0x4B
+#define PMBUS_IOUT_UC_FAULT_RESPONSE	0x4C
+
+#define PMBUS_OT_FAULT_LIMIT		0x4F
+#define PMBUS_OT_FAULT_RESPONSE		0x50
+#define PMBUS_OT_WARN_LIMIT		0x51
+#define PMBUS_UT_WARN_LIMIT		0x52
+#define PMBUS_UT_FAULT_LIMIT		0x53
+#define PMBUS_UT_FAULT_RESPONSE		0x54
+#define PMBUS_VIN_OV_FAULT_LIMIT	0x55
+#define PMBUS_VIN_OV_FAULT_RESPONSE	0x56
+#define PMBUS_VIN_OV_WARN_LIMIT		0x57
+#define PMBUS_VIN_UV_WARN_LIMIT		0x58
+#define PMBUS_VIN_UV_FAULT_LIMIT	0x59
+
+#define PMBUS_IIN_OC_FAULT_LIMIT	0x5B
+#define PMBUS_IIN_OC_WARN_LIMIT		0x5D
+
+#define PMBUS_POUT_OP_FAULT_LIMIT	0x68
+#define PMBUS_POUT_OP_WARN_LIMIT	0x6A
+#define PMBUS_PIN_OP_WARN_LIMIT		0x6B
+
+#define PMBUS_STATUS_BYTE		0x78
+#define PMBUS_STATUS_WORD		0x79
+#define PMBUS_STATUS_VOUT		0x7A
+#define PMBUS_STATUS_IOUT		0x7B
+#define PMBUS_STATUS_INPUT		0x7C
+#define PMBUS_STATUS_TEMPERATURE	0x7D
+#define PMBUS_STATUS_CML		0x7E
+#define PMBUS_STATUS_OTHER		0x7F
+#define PMBUS_STATUS_MFR_SPECIFIC	0x80
+#define PMBUS_STATUS_FAN_12		0x81
+#define PMBUS_STATUS_FAN_34		0x82
+
+#define PMBUS_READ_VIN			0x88
+#define PMBUS_READ_IIN			0x89
+#define PMBUS_READ_VCAP			0x8A
+#define PMBUS_READ_VOUT			0x8B
+#define PMBUS_READ_IOUT			0x8C
+#define PMBUS_READ_TEMPERATURE_1	0x8D
+#define PMBUS_READ_TEMPERATURE_2	0x8E
+#define PMBUS_READ_TEMPERATURE_3	0x8F
+#define PMBUS_READ_FAN_SPEED_1		0x90
+#define PMBUS_READ_FAN_SPEED_2		0x91
+#define PMBUS_READ_FAN_SPEED_3		0x92
+#define PMBUS_READ_FAN_SPEED_4		0x93
+#define PMBUS_READ_DUTY_CYCLE		0x94
+#define PMBUS_READ_FREQUENCY		0x95
+#define PMBUS_READ_POUT			0x96
+#define PMBUS_READ_PIN			0x97
+
+#define PMBUS_REVISION			0x98
+#define PMBUS_MFR_ID			0x99
+#define PMBUS_MFR_MODEL			0x9A
+#define PMBUS_MFR_REVISION		0x9B
+#define PMBUS_MFR_LOCATION		0x9C
+#define PMBUS_MFR_DATE			0x9D
+#define PMBUS_MFR_SERIAL		0x9E
+
+/*
+ * CAPABILITY
+ */
+#define PB_CAPABILITY_SMBALERT		(1<<4)
+#define PB_CAPABILITY_ERROR_CHECK	(1<<7)
+
+/*
+ * VOUT_MODE
+ */
+#define PB_VOUT_MODE_MODE_MASK		0xe0
+#define PB_VOUT_MODE_PARAM_MASK		0x1f
+
+#define PB_VOUT_MODE_LINEAR		0x00
+#define PB_VOUT_MODE_VID		0x20
+#define PB_VOUT_MODE_DIRECT		0x40
+
+/*
+ * Fan configuration
+ */
+#define PB_FAN_2_PULSE_MASK		((1 << 0) | (1 << 1))
+#define PB_FAN_2_RPM			(1 << 2)
+#define PB_FAN_2_INSTALLED		(1 << 3)
+#define PB_FAN_1_PULSE_MASK		((1 << 4) | (1 << 5))
+#define PB_FAN_1_RPM			(1 << 6)
+#define PB_FAN_1_INSTALLED		(1 << 7)
+
+/*
+ * STATUS_BYTE, STATUS_WORD (lower)
+ */
+#define PB_STATUS_NONE_ABOVE		(1<<0)
+#define PB_STATUS_CML			(1<<1)
+#define PB_STATUS_TEMPERATURE		(1<<2)
+#define PB_STATUS_VIN_UV		(1<<3)
+#define PB_STATUS_IOUT_OC		(1<<4)
+#define PB_STATUS_VOUT_OV		(1<<5)
+#define PB_STATUS_OFF			(1<<6)
+#define PB_STATUS_BUSY			(1<<7)
+
+/*
+ * STATUS_WORD (upper)
+ */
+#define PB_STATUS_UNKNOWN		(1<<8)
+#define PB_STATUS_OTHER			(1<<9)
+#define PB_STATUS_FANS			(1<<10)
+#define PB_STATUS_POWER_GOOD_N		(1<<11)
+#define PB_STATUS_WORD_MFR		(1<<12)
+#define PB_STATUS_INPUT			(1<<13)
+#define PB_STATUS_IOUT_POUT		(1<<14)
+#define PB_STATUS_VOUT			(1<<15)
+
+/*
+ * STATUS_IOUT
+ */
+#define PB_POUT_OP_WARNING		(1<<0)
+#define PB_POUT_OP_FAULT		(1<<1)
+#define PB_POWER_LIMITING		(1<<2)
+#define PB_CURRENT_SHARE_FAULT		(1<<3)
+#define PB_IOUT_UC_FAULT		(1<<4)
+#define PB_IOUT_OC_WARNING		(1<<5)
+#define PB_IOUT_OC_LV_FAULT		(1<<6)
+#define PB_IOUT_OC_FAULT		(1<<7)
+
+/*
+ * STATUS_VOUT, STATUS_INPUT
+ */
+#define PB_VOLTAGE_UV_FAULT		(1<<4)
+#define PB_VOLTAGE_UV_WARNING		(1<<5)
+#define PB_VOLTAGE_OV_WARNING		(1<<6)
+#define PB_VOLTAGE_OV_FAULT		(1<<7)
+
+/*
+ * STATUS_INPUT
+ */
+#define PB_PIN_OP_WARNING		(1<<0)
+#define PB_IIN_OC_WARNING		(1<<1)
+#define PB_IIN_OC_FAULT			(1<<2)
+
+/*
+ * STATUS_TEMPERATURE
+ */
+#define PB_TEMP_UT_FAULT		(1<<4)
+#define PB_TEMP_UT_WARNING		(1<<5)
+#define PB_TEMP_OT_WARNING		(1<<6)
+#define PB_TEMP_OT_FAULT		(1<<7)
+
+/*
+ * STATUS_FAN
+ */
+#define PB_FAN_AIRFLOW_WARNING		(1<<0)
+#define PB_FAN_AIRFLOW_FAULT		(1<<1)
+#define PB_FAN_FAN2_SPEED_OVERRIDE	(1<<2)
+#define PB_FAN_FAN1_SPEED_OVERRIDE	(1<<3)
+#define PB_FAN_FAN2_WARNING		(1<<4)
+#define PB_FAN_FAN1_WARNING		(1<<5)
+#define PB_FAN_FAN2_FAULT		(1<<6)
+#define PB_FAN_FAN1_FAULT		(1<<7)
+
+/*
+ * CML_FAULT_STATUS
+ */
+#define PB_CML_FAULT_OTHER_MEM_LOGIC	(1<<0)
+#define PB_CML_FAULT_OTHER_COMM		(1<<1)
+#define PB_CML_FAULT_PROCESSOR		(1<<3)
+#define PB_CML_FAULT_MEMORY		(1<<4)
+#define PB_CML_FAULT_PACKET_ERROR	(1<<5)
+#define PB_CML_FAULT_INVALID_DATA	(1<<6)
+#define PB_CML_FAULT_INVALID_COMMAND	(1<<7)
+
+enum pmbus_sensor_classes {
+	PSC_VOLTAGE_IN = 0,
+	PSC_VOLTAGE_OUT,
+	PSC_CURRENT_IN,
+	PSC_CURRENT_OUT,
+	PSC_POWER,
+	PSC_TEMPERATURE,
+	PSC_FAN,
+	PSC_NUM_CLASSES		/* Number of power sensor classes */
+};
+
+#define PMBUS_PAGES	32	/* Per PMBus specification */
+
+/* Functionality bit mask */
+#define PMBUS_HAVE_VIN		(1 << 0)
+#define PMBUS_HAVE_VCAP		(1 << 1)
+#define PMBUS_HAVE_VOUT		(1 << 2)
+#define PMBUS_HAVE_IIN		(1 << 3)
+#define PMBUS_HAVE_IOUT		(1 << 4)
+#define PMBUS_HAVE_PIN		(1 << 5)
+#define PMBUS_HAVE_POUT		(1 << 6)
+#define PMBUS_HAVE_FAN12	(1 << 7)
+#define PMBUS_HAVE_FAN34	(1 << 8)
+#define PMBUS_HAVE_TEMP		(1 << 9)
+#define PMBUS_HAVE_TEMP2	(1 << 10)
+#define PMBUS_HAVE_TEMP3	(1 << 11)
+#define PMBUS_HAVE_STATUS_VOUT	(1 << 12)
+#define PMBUS_HAVE_STATUS_IOUT	(1 << 13)
+#define PMBUS_HAVE_STATUS_INPUT	(1 << 14)
+#define PMBUS_HAVE_STATUS_TEMP	(1 << 15)
+#define PMBUS_HAVE_STATUS_FAN12	(1 << 16)
+#define PMBUS_HAVE_STATUS_FAN34	(1 << 17)
+
+struct pmbus_driver_info {
+	int pages;		/* Total number of pages */
+	bool direct[PSC_NUM_CLASSES];
+				/* true if device uses direct data format
+				   for the given sensor class */
+	/*
+	 * Support one set of coefficients for each sensor type
+	 * Used for chips providing data in direct mode.
+	 */
+	int m[PSC_NUM_CLASSES];	/* mantissa for direct data format */
+	int b[PSC_NUM_CLASSES];	/* offset */
+	int R[PSC_NUM_CLASSES];	/* exponent */
+
+	u32 func[PMBUS_PAGES];	/* Functionality, per page */
+	/*
+	 * The get_status function maps manufacturing specific status values
+	 * into PMBus standard status values.
+	 */
+	int (*get_status)(struct i2c_client *client, int page, int reg);
+	/*
+	 * The identify function determines supported PMBus functionality.

drivers/hwmon/pmbus.h line 299

Quoted 10 lines
drivers/hwmon/pmbus.h new file +10 -0
+	 */
+	int (*identify)(struct i2c_client *client,
+			struct pmbus_driver_info *info);
+};
+
+/* Function declarations */
+
+int pmbus_set_page(struct i2c_client *client, u8 page);
+int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg);
+int pmbus_read_byte_data(struct i2c_client *client, u8 page, u8 reg);

I suppose this makes sense for completeness. But I don't think you currently use read_byte_data in any of the drivers so it needn't be here..

Quoted 260 lines
drivers/hwmon/pmbus.h new file +8 -0
+void pmbus_clear_faults(struct i2c_client *client);
+bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg);
+bool pmbus_check_word_register(struct i2c_client *client, int page, int reg);
+int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
+		   struct pmbus_driver_info *info);
+int pmbus_do_remove(struct i2c_client *client);
+
+#endif /* PB_H */
drivers/hwmon/pmbus_core.c new file +246 -0
new file mode 100644
index 0000000..fe18722
@@ -0,0 +1,1611 @@
+/*
+ * Hardware monitoring driver for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/delay.h>
+#include <linux/i2c/pmbus.h>
+#include "pmbus.h"
+
+/*
+ * Constants needed to determine number of sensors, booleans, and labels.
+ */
+#define PMBUS_MAX_INPUT_SENSORS		11	/* 6*volt, 3*curr, 2*power */
+#define PMBUS_VOUT_SENSORS_PER_PAGE	5	/* input, min, max, lcrit,
+						   crit */
+#define PMBUS_IOUT_SENSORS_PER_PAGE	4	/* input, min, max, crit */
+#define PMBUS_POUT_SENSORS_PER_PAGE	4	/* input, cap, max, crit */
+#define PMBUS_MAX_SENSORS_PER_FAN	1	/* input */
+#define PMBUS_MAX_SENSORS_PER_TEMP	5	/* input, min, max, lcrit,
+						   crit */
+
+#define PMBUS_MAX_INPUT_BOOLEANS	7	/* v: min_alarm, max_alarm,
+						   lcrit_alarm, crit_alarm;
+						   c: alarm, crit_alarm;
+						   p: crit_alarm */
+#define PMBUS_VOUT_BOOLEANS_PER_PAGE	4	/* min_alarm, max_alarm,
+						   lcrit_alarm, crit_alarm */
+#define PMBUS_IOUT_BOOLEANS_PER_PAGE	3	/* alarm, lcrit_alarm,
+						   crit_alarm */
+#define PMBUS_POUT_BOOLEANS_PER_PAGE	2	/* alarm, crit_alarm */
+#define PMBUS_MAX_BOOLEANS_PER_FAN	2	/* alarm, fault */
+#define PMBUS_MAX_BOOLEANS_PER_TEMP	4	/* min_alarm, max_alarm,
+						   lcrit_alarm, crit_alarm */
+
+#define PMBUS_MAX_INPUT_LABELS		4	/* vin, vcap, iin, pin */
+
+/*
+ * status, status_vout, status_iout, status_fans, and status_temp
+ * are paged. status_input and status_fan34 are unpaged.
+ * status_fan34 is a special case to handle a second set of fans
+ * on page 0.
+ */
+#define PB_NUM_STATUS_REG	(PMBUS_PAGES * 5 + 2)
+
+/*
+ * Index into status register array, per status register group
+ */
+#define PB_STATUS_BASE		0
+#define PB_STATUS_VOUT_BASE	(PB_STATUS_BASE + PMBUS_PAGES)
+#define PB_STATUS_IOUT_BASE	(PB_STATUS_VOUT_BASE + PMBUS_PAGES)
+#define PB_STATUS_FAN_BASE	(PB_STATUS_IOUT_BASE + PMBUS_PAGES)
+#define PB_STATUS_FAN34_BASE	(PB_STATUS_FAN_BASE + PMBUS_PAGES)
+#define PB_STATUS_INPUT_BASE	(PB_STATUS_FAN34_BASE + 1)
+#define PB_STATUS_TEMP_BASE	(PB_STATUS_INPUT_BASE + 1)
+
+struct pmbus_sensor {
+	char name[I2C_NAME_SIZE];	/* sysfs sensor name */
+	struct sensor_device_attribute attribute;
+	u8 page;		/* page number */
+	u8 reg;			/* register */
+	enum pmbus_sensor_classes class;	/* sensor class */
+	bool update;		/* runtime sensor update needed */
+	int data;		/* Sensor data.
+				   Negative if there was a read error */
+};
+
+struct pmbus_boolean {
+	char name[I2C_NAME_SIZE];	/* sysfs boolean name */
+	struct sensor_device_attribute attribute;
+};
+
+struct pmbus_label {
+	char name[I2C_NAME_SIZE];	/* sysfs label name */
+	struct sensor_device_attribute attribute;
+	char label[I2C_NAME_SIZE];	/* label */
+};
+
+struct pmbus_data {
+	struct device *hwmon_dev;
+
+	u32 flags;		/* from platform data */
+
+	int exponent;		/* linear mode: exponent for output voltages */
+
+	const struct pmbus_driver_info *info;
+
+	int max_attributes;
+	int num_attributes;
+	struct attribute **attributes;
+	struct attribute_group group;
+
+	/*
+	 * Sensors cover both sensor and limit registers.
+	 */
+	int max_sensors;
+	int num_sensors;
+	struct pmbus_sensor *sensors;
+	/*
+	 * Booleans are used for alarms.
+	 * Values are determined from status registers.
+	 */
+	int max_booleans;
+	int num_booleans;
+	struct pmbus_boolean *booleans;
+	/*
+	 * Labels are used to map generic names (e.g., "in1")
+	 * to PMBus specific names (e.g., "vin" or "vout1").
+	 */
+	int max_labels;
+	int num_labels;
+	struct pmbus_label *labels;
+
+	struct mutex update_lock;
+	bool valid;
+	unsigned long last_updated;	/* in jiffies */
+
+	/*
+	 * A single status register covers multiple attributes,
+	 * so we keep them all together.
+	 */
+	u8 status_bits;
+	u8 status[PB_NUM_STATUS_REG];
+
+	u8 currpage;
+};
+
+int pmbus_set_page(struct i2c_client *client, u8 page)
+{
+	struct pmbus_data *data = i2c_get_clientdata(client);
+	int rv = 0;
+	int newpage;
+
+	if (page != data->currpage) {
+		rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
+		newpage = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
+		if (newpage != page)
+			rv = -EINVAL;
+		else
+			data->currpage = page;
+	}
+	return rv;
+}
+EXPORT_SYMBOL_GPL(pmbus_set_page);
+
+static int pmbus_write_byte(struct i2c_client *client, u8 page, u8 value)
+{
+	int rv;
+
+	rv = pmbus_set_page(client, page);
+	if (rv < 0)
+		return rv;
+
+	return i2c_smbus_write_byte(client, value);
+}
+
+static int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg,
+				 u16 word)
+{
+	int rv;
+
+	rv = pmbus_set_page(client, page);
+	if (rv < 0)
+		return rv;
+
+	return i2c_smbus_write_word_data(client, reg, word);
+}
+
+int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg)
+{
+	int rv;
+
+	rv = pmbus_set_page(client, page);
+	if (rv < 0)
+		return rv;
+
+	return i2c_smbus_read_word_data(client, reg);
+}
+EXPORT_SYMBOL_GPL(pmbus_read_word_data);
+
+int pmbus_read_byte_data(struct i2c_client *client, u8 page, u8 reg)
+{
+	int rv;
+
+	rv = pmbus_set_page(client, page);
+	if (rv < 0)
+		return rv;
+
+	return i2c_smbus_read_byte_data(client, reg);
+}
+EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
+
+void pmbus_clear_faults(struct i2c_client *client)
+{
+	struct pmbus_data *data = i2c_get_clientdata(client);
+	int i;
+
+	for (i = 0; i < data->info->pages; i++)
+		pmbus_write_byte(client, i, PMBUS_CLEAR_FAULTS);
+}
+EXPORT_SYMBOL_GPL(pmbus_clear_faults);
+
+bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
+{
+	int rv, status;
+	struct pmbus_data *data = i2c_get_clientdata(client);
+
+	pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
+	rv = pmbus_read_byte_data(client, page, reg);
+	if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) {
+		status = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
+		if (status < 0 || (status & PB_STATUS_CML)) {
+			int status2 = pmbus_read_byte_data(client, page,
+							   PMBUS_STATUS_CML);
+			if (status2 < 0
+			    || (status2 & PB_CML_FAULT_INVALID_COMMAND)) {
+				dev_dbg(&client->dev,
+					"page %d reg 0x%x status 0x%x-0x%x\n",
+					page, reg, status, status2);
+				rv = -EINVAL;
+			}
+		}
+	}
+	pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);

drivers/hwmon/pmbus_core.c line 256

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+	return rv >= 0;
+}
+EXPORT_SYMBOL_GPL(pmbus_check_byte_register);
+
+bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
+{
+	int rv, status;
+	struct pmbus_data *data = i2c_get_clientdata(client);
+
+	pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);

If there have been faults, do we not want to have handled them? That is, should there be any circumstance under which we would want to clear one here?x

drivers/hwmon/pmbus_core.c line 257

Quoted 1 line
drivers/hwmon/pmbus_core.c new file +1 -0
+	rv = pmbus_read_word_data(client, page, reg);

I think this is idenical to the check code in the previous function. Worth pulling out to a utility function used by both?

Quoted 325 lines
drivers/hwmon/pmbus_core.c new file +325 -0
+	if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) {
+		status = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
+		if (status < 0 || (status & PB_STATUS_CML)) {
+			int status2 = pmbus_read_byte_data(client, page,
+							   PMBUS_STATUS_CML);
+			if (status2 < 0
+			    || (status2 & PB_CML_FAULT_INVALID_COMMAND)) {
+				dev_dbg(&client->dev,
+					"page %d reg 0x%x status 0x%x-0x%x\n",
+					page, reg, status, status2);
+				rv = -EINVAL;
+			}
+		}
+	}
+	pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
+	return rv >= 0;
+}
+EXPORT_SYMBOL_GPL(pmbus_check_word_register);
+
+static int pmbus_get_status(struct i2c_client *client, int page, int reg)
+{
+	struct pmbus_data *data = i2c_get_clientdata(client);
+	const struct pmbus_driver_info *info = data->info;
+	int status;
+
+	if (info->get_status) {
+		status = info->get_status(client, page, reg);
+		if (status != -ENODATA)
+			return status;
+	}
+	return  pmbus_read_byte_data(client, page, reg);
+}
+
+static struct pmbus_data *pmbus_update_device(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct pmbus_data *data = i2c_get_clientdata(client);
+	const struct pmbus_driver_info *info = data->info;
+
+	mutex_lock(&data->update_lock);
+	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
+		int i;
+
+		for (i = 0; i < info->pages; i++)
+			data->status[PB_STATUS_BASE + i]
+			    = pmbus_read_byte_data(client, i,
+						   PMBUS_STATUS_BYTE);
+		for (i = 0; i < info->pages; i++) {
+			if (!(info->func[i] & PMBUS_HAVE_STATUS_VOUT))
+				continue;
+			data->status[PB_STATUS_VOUT_BASE + i]
+			  = pmbus_get_status(client, i, PMBUS_STATUS_VOUT);
+		}
+		for (i = 0; i < info->pages; i++) {
+			if (!(info->func[i] & PMBUS_HAVE_STATUS_IOUT))
+				continue;
+			data->status[PB_STATUS_IOUT_BASE + i]
+			  = pmbus_get_status(client, i, PMBUS_STATUS_IOUT);
+		}
+		for (i = 0; i < info->pages; i++) {
+			if (!(info->func[i] & PMBUS_HAVE_STATUS_TEMP))
+				continue;
+			data->status[PB_STATUS_TEMP_BASE + i]
+			  = pmbus_get_status(client, i,
+					     PMBUS_STATUS_TEMPERATURE);
+		}
+		for (i = 0; i < info->pages; i++) {
+			if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN12))
+				continue;
+			data->status[PB_STATUS_FAN_BASE + i]
+			  = pmbus_get_status(client, i, PMBUS_STATUS_FAN_12);
+		}
+
+		if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
+			data->status[PB_STATUS_INPUT_BASE]
+			  = pmbus_get_status(client, 0, PMBUS_STATUS_INPUT);
+
+		if (info->func[0] & PMBUS_HAVE_STATUS_FAN34)
+			data->status[PB_STATUS_FAN34_BASE]
+			  = pmbus_get_status(client, 0, PMBUS_STATUS_FAN_34);
+
+		for (i = 0; i < data->num_sensors; i++) {
+			struct pmbus_sensor *sensor = &data->sensors[i];
+
+			if (!data->valid || sensor->update)
+				sensor->data
+				    = pmbus_read_word_data(client, sensor->page,
+							   sensor->reg);
+		}
+		pmbus_clear_faults(client);
+		data->last_updated = jiffies;
+		data->valid = 1;
+	}
+	mutex_unlock(&data->update_lock);
+	return data;
+}
+
+/*
+ * Convert linear sensor values to milli- or micro-units
+ * depending on sensor type.
+ */
+static int pmbus_reg2data_linear(struct pmbus_data *data,
+				 struct pmbus_sensor *sensor)
+{
+	s16 exponent, mantissa;
+	long val;
+
+	if (sensor->class == PSC_VOLTAGE_OUT) {
+		exponent = data->exponent;
+		mantissa = (s16) sensor->data;
+	} else {
+		exponent = (sensor->data >> 11) & 0x001f;
+		mantissa = sensor->data & 0x07ff;
+
+		if (exponent > 0x0f)
+			exponent |= 0xffe0;	/* sign extend exponent */
+		if (mantissa > 0x03ff)
+			mantissa |= 0xf800;	/* sign extend mantissa */
+	}
+
+	val = mantissa;
+
+	/* scale result to milli-units for all sensors except fans */
+	if (sensor->class != PSC_FAN)
+		val = val * 1000L;
+
+	/* scale result to micro-units for power sensors */
+	if (sensor->class == PSC_POWER)
+		val = val * 1000L;
+
+	if (exponent >= 0)
+		val <<= exponent;
+	else
+		val >>= -exponent;
+
+	return (int)val;
+}
+
+/*
+ * Convert direct sensor values to milli- or micro-units
+ * depending on sensor type.
+ */
+static int pmbus_reg2data_direct(struct pmbus_data *data,
+				 struct pmbus_sensor *sensor)
+{
+	long val = (s16) sensor->data;
+	long m, b, R;
+
+	m = data->info->m[sensor->class];
+	b = data->info->b[sensor->class];
+	R = data->info->R[sensor->class];
+
+	if (m == 0)
+		return 0;
+
+	/* X = 1/m * (Y * 10^-R - b) */
+	R = -R;
+	/* scale result to milli-units for everything but fans */
+	if (sensor->class != PSC_FAN) {
+		R += 3;
+		b *= 1000;
+	}
+
+	/* scale result to micro-units for power sensors */
+	if (sensor->class == PSC_POWER) {
+		R += 3;
+		b *= 1000;
+	}
+
+	while (R > 0) {
+		val *= 10;
+		R--;
+	}
+	while (R < 0) {
+		val = DIV_ROUND_CLOSEST(val, 10);
+		R++;
+	}
+
+	return (int)((val - b) / m);
+}
+
+static int pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
+{
+	int val;
+
+	if (data->info->direct[sensor->class])
+		val = pmbus_reg2data_direct(data, sensor);
+	else
+		val = pmbus_reg2data_linear(data, sensor);
+
+	return val;
+}
+
+#define MAX_MANTISSA	(1023 * 1000)
+#define MIN_MANTISSA	(511 * 1000)
+
+static u16 pmbus_data2reg_linear(struct pmbus_data *data,
+				 enum pmbus_sensor_classes class, long val)
+{
+	s16 exponent = 0, mantissa = 0;
+	bool negative = false;
+
+	/* simple case */
+	if (val == 0)
+		return 0;
+
+	if (val < 0) {
+		negative = true;
+		val = -val;
+	}
+
+	if (class == PSC_VOLTAGE_OUT) {
+		/*
+		 * For a static exponents, we don't have a choice
+		 * but to adjust the value to it.
+		 */
+		if (data->exponent < 0)
+			val <<= -data->exponent;
+		else
+			val >>= data->exponent;
+		val = DIV_ROUND_CLOSEST(val, 1000);
+		if (val > 0x7fff)
+			val = 0x7fff;
+		return negative ? -val : val;
+	}
+
+	/* Power is in uW. Convert to mW before converting. */
+	if (class == PSC_POWER)
+		val = DIV_ROUND_CLOSEST(val, 1000L);
+
+	/*
+	 * For simplicity, convert fan data to milli-units
+	 * before calculating the exponent.
+	 */
+	if (class == PSC_FAN)
+		val = val * 1000;
+
+	/* Reduce large mantissa until it fits into 10 bit */
+	while (val >= MAX_MANTISSA && exponent < 15) {
+		exponent++;
+		val >>= 1;
+	}
+	/* Increase small mantissa to improve precision */
+	while (val < MIN_MANTISSA && exponent > -15) {
+		exponent--;
+		val <<= 1;
+	}
+
+	/* Convert mantissa from milli-units to units */
+	mantissa = DIV_ROUND_CLOSEST(val, 1000);
+
+	/* Ensure that resulting number is within range */
+	if (mantissa > 0x3ff)
+		mantissa = 0x3ff;
+
+	/* restore sign */
+	if (negative)
+		mantissa = -mantissa;
+
+	/* Convert to 5 bit exponent, 11 bit mantissa */
+	return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
+}
+
+static u16 pmbus_data2reg_direct(struct pmbus_data *data,
+				 enum pmbus_sensor_classes class, long val)
+{
+	long m, b, R;
+
+	m = data->info->m[class];
+	b = data->info->b[class];
+	R = data->info->R[class];
+
+	/* Power is in uW. Adjust R and b. */
+	if (class == PSC_POWER) {
+		R -= 3;
+		b *= 1000;
+	}
+
+	/* Calculate Y = (m * X + b) * 10^R */
+	if (class != PSC_FAN) {
+		R -= 3;		/* Adjust R and b for data in milli-units */
+		b *= 1000;
+	}
+	val = val * m + b;
+
+	while (R > 0) {
+		val *= 10;
+		R--;
+	}
+	while (R < 0) {
+		val = DIV_ROUND_CLOSEST(val, 10);
+		R++;
+	}
+
+	return val;
+}
+
+static u16 pmbus_data2reg(struct pmbus_data *data,
+			  enum pmbus_sensor_classes class, long val)
+{
+	u16 regval;
+
+	if (data->info->direct[class])
+		regval = pmbus_data2reg_direct(data, class, val);
+	else
+		regval = pmbus_data2reg_linear(data, class, val);
+
+	return regval;
+}
+
+/*
+ * Return boolean calculated from converted data.
+ * <index> defines a status register index and mask, and optionally
+ * two sensor indexes.
+ * The upper half-word references the two sensors,
+ * the lower half word references status register and mask.
+ * The function returns true if (status[reg] & mask) is true and,
+ * if specified, if v1 >= v2.
+ * To determine if an object exceeds upper limits, specify <v, limit>.
+ * To determine if an object exceeds lower limits, specify <limit, v>.
+ */
+static int pmbus_get_boolean(struct pmbus_data *data, int index, int *val)
+{
+	u8 s1 = (index >> 24) & 0xff;
+	u8 s2 = (index >> 16) & 0xff;

drivers/hwmon/pmbus_core.c line 592

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+	u8 reg = (index >> 8) & 0xff;
+	u8 mask = index & 0xff;
+	int status;
+	u8 regval;
+
+	status = data->status[reg];
+	if (status < 0)
+		return status;
+
+	regval = status & mask;

This test could do with a simple explanatory comment (which is another way of saying I'm not quite clear why this makes sense!)

Quoted 100 lines
drivers/hwmon/pmbus_core.c new file +100 -0
+	if (!s1 && !s2)
+		*val = !!regval;
+	else {
+		int v1, v2;
+		struct pmbus_sensor *sensor1, *sensor2;
+
+		sensor1 = &data->sensors[s1];
+		if (sensor1->data < 0)
+			return sensor1->data;
+		sensor2 = &data->sensors[s2];
+		if (sensor2->data < 0)
+			return sensor2->data;
+
+		v1 = pmbus_reg2data(data, sensor1);
+		v2 = pmbus_reg2data(data, sensor2);
+		*val = !!(regval && v1 >= v2);
+	}
+	return 0;
+}
+
+static ssize_t pmbus_show_boolean(struct device *dev,
+				  struct device_attribute *da, char *buf)
+{
+	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+	struct pmbus_data *data = pmbus_update_device(dev);
+	int val;
+	int err;
+
+	err = pmbus_get_boolean(data, attr->index, &val);
+	if (err)
+		return err;
+	return snprintf(buf, PAGE_SIZE, "%d\n", val);
+}
+
+static ssize_t pmbus_show_sensor(struct device *dev,
+				 struct device_attribute *da, char *buf)
+{
+	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+	struct pmbus_data *data = pmbus_update_device(dev);
+	struct pmbus_sensor *sensor;
+
+	sensor = &data->sensors[attr->index];
+	if (sensor->data < 0)
+		return sensor->data;
+
+	return snprintf(buf, PAGE_SIZE, "%d\n", pmbus_reg2data(data, sensor));
+}
+
+static ssize_t pmbus_set_sensor(struct device *dev,
+				struct device_attribute *devattr,
+				const char *buf, size_t count)
+{
+	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+	struct i2c_client *client = to_i2c_client(dev);
+	struct pmbus_data *data = i2c_get_clientdata(client);
+	struct pmbus_sensor *sensor = &data->sensors[attr->index];
+	ssize_t rv = count;
+	long val = 0;
+	int ret;
+	u16 regval;
+
+	if (strict_strtol(buf, 10, &val) < 0)
+		return -EINVAL;
+
+	mutex_lock(&data->update_lock);
+	regval = pmbus_data2reg(data, sensor->class, val);
+	ret = pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
+	if (ret < 0)
+		rv = ret;
+	else
+		data->sensors[attr->index].data = regval;
+	mutex_unlock(&data->update_lock);
+	return rv;
+}
+
+static ssize_t pmbus_show_label(struct device *dev,
+				struct device_attribute *da, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct pmbus_data *data = i2c_get_clientdata(client);
+	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+
+	return snprintf(buf, PAGE_SIZE, "%s\n",
+			data->labels[attr->index].label);
+}
+
+#define PMBUS_ADD_ATTR(data, _name, _idx, _mode, _type, _show, _set)	\
+do {									\
+	struct sensor_device_attribute *a				\
+	    = &data->_type##s[data->num_##_type##s].attribute;		\
+	BUG_ON(data->num_attributes >= data->max_attributes);		\
+	a->dev_attr.attr.name = _name;					\
+	a->dev_attr.attr.mode = _mode;					\
+	a->dev_attr.show = _show;					\
+	a->dev_attr.store = _set;					\
+	a->index = _idx;						\
+	data->attributes[data->num_attributes] = &a->dev_attr.attr;	\
+	data->num_attributes++;						\
+} while (0)
+

drivers/hwmon/pmbus_core.c line 702

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+#define PMBUS_ADD_GET_ATTR(data, _name, _type, _idx)			\
+	PMBUS_ADD_ATTR(data, _name, _idx, S_IRUGO, _type,		\
+		       pmbus_show_##_type,  NULL)
+
+#define PMBUS_ADD_SET_ATTR(data, _name, _type, _idx)			\
+	PMBUS_ADD_ATTR(data, _name, _idx, S_IWUSR | S_IRUGO, _type,	\
+		       pmbus_show_##_type, pmbus_set_##_type)
+
+static void pmbus_add_boolean(struct pmbus_data *data,
+			      const char *name, const char *type, int seq,

Is val the best name for the next variable? It isn't obvious to me what value this is... Gets pushed into an index by the PMBUS_ADD_GET_ATTR macro... Perhaps keep the idx naming?

Quoted 64 lines
drivers/hwmon/pmbus_core.c new file +64 -0
+			      int val)
+{
+	struct pmbus_boolean *boolean;
+
+	BUG_ON(data->num_booleans >= data->max_booleans);
+
+	boolean = &data->booleans[data->num_booleans];
+
+	snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
+		 name, seq, type);
+	PMBUS_ADD_GET_ATTR(data, boolean->name, boolean, val);
+	data->num_booleans++;
+}
+
+static void pmbus_add_boolean_reg(struct pmbus_data *data,
+				  const char *name, const char *type,
+				  int seq, int reg, int bit)
+{
+	pmbus_add_boolean(data, name, type, seq, (reg << 8) | bit);
+}
+
+static void pmbus_add_boolean_cmp(struct pmbus_data *data,
+				  const char *name, const char *type,
+				  int seq, int i1, int i2, int reg, int mask)
+{
+	pmbus_add_boolean(data, name, type, seq,
+			  (i1 << 24) | (i2 << 16) | (reg << 8) | mask);
+}
+
+static void pmbus_add_sensor(struct pmbus_data *data,
+			     const char *name, const char *type, int seq,
+			     int page, int reg, enum pmbus_sensor_classes class,
+			     bool update)
+{
+	struct pmbus_sensor *sensor;
+
+	BUG_ON(data->num_sensors >= data->max_sensors);
+
+	sensor = &data->sensors[data->num_sensors];
+	snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
+		 name, seq, type);
+	sensor->page = page;
+	sensor->reg = reg;
+	sensor->class = class;
+	sensor->update = update;
+	if (update)
+		PMBUS_ADD_GET_ATTR(data, sensor->name, sensor,
+				   data->num_sensors);
+	else
+		PMBUS_ADD_SET_ATTR(data, sensor->name, sensor,
+				   data->num_sensors);
+	data->num_sensors++;
+}
+
+static void pmbus_add_label(struct pmbus_data *data,
+			    const char *name, int seq,
+			    const char *lstring, int index)
+{
+	struct pmbus_label *label;
+
+	BUG_ON(data->num_labels >= data->max_labels);
+
+	label = &data->labels[data->num_labels];
+	snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);

drivers/hwmon/pmbus_core.c line 776

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+	if (!index)
+		strncpy(label->label, lstring, sizeof(label->label) - 1);
+	else
+		snprintf(label->label, sizeof(label->label), "%s%d", lstring,
+			 index);
+
+	PMBUS_ADD_GET_ATTR(data, label->name, label, data->num_labels);
+	data->num_labels++;
+}
+

const?

Quoted 100 lines
drivers/hwmon/pmbus_core.c new file +100 -0
+static int pmbus_temp_registers[] = {
+	PMBUS_READ_TEMPERATURE_1,
+	PMBUS_READ_TEMPERATURE_2,
+	PMBUS_READ_TEMPERATURE_3
+};
+
+static int pmbus_fan_registers[] = {
+	PMBUS_READ_FAN_SPEED_1,
+	PMBUS_READ_FAN_SPEED_2,
+	PMBUS_READ_FAN_SPEED_3,
+	PMBUS_READ_FAN_SPEED_4
+};
+
+static int pmbus_fan_config_registers[] = {
+	PMBUS_FAN_CONFIG_12,
+	PMBUS_FAN_CONFIG_12,
+	PMBUS_FAN_CONFIG_34,
+	PMBUS_FAN_CONFIG_34
+};
+
+static int pmbus_fan_status_registers[] = {
+	PMBUS_STATUS_FAN_12,
+	PMBUS_STATUS_FAN_12,
+	PMBUS_STATUS_FAN_34,
+	PMBUS_STATUS_FAN_34
+};
+
+/*
+ * Determine maximum number of sensors, booleans, and labels.
+ * To keep things simple, only make a rough high estimate.
+ */
+static void pmbus_find_max_attr(struct i2c_client *client,
+				struct pmbus_data *data)
+{
+	const struct pmbus_driver_info *info = data->info;
+	int page, max_sensors, max_booleans, max_labels;
+
+	max_sensors = PMBUS_MAX_INPUT_SENSORS;
+	max_booleans = PMBUS_MAX_INPUT_BOOLEANS;
+	max_labels = PMBUS_MAX_INPUT_LABELS;
+
+	for (page = 0; page < info->pages; page++) {
+		if (info->func[page] & PMBUS_HAVE_VOUT) {
+			max_sensors += PMBUS_VOUT_SENSORS_PER_PAGE;
+			max_booleans += PMBUS_VOUT_BOOLEANS_PER_PAGE;
+			max_labels++;
+		}
+		if (info->func[page] & PMBUS_HAVE_IOUT) {
+			max_sensors += PMBUS_IOUT_SENSORS_PER_PAGE;
+			max_booleans += PMBUS_IOUT_BOOLEANS_PER_PAGE;
+			max_labels++;
+		}
+		if (info->func[page] & PMBUS_HAVE_POUT) {
+			max_sensors += PMBUS_POUT_SENSORS_PER_PAGE;
+			max_booleans += PMBUS_POUT_BOOLEANS_PER_PAGE;
+			max_labels++;
+		}
+		if (info->func[page] & PMBUS_HAVE_FAN12) {
+			if (page == 0) {
+				max_sensors +=
+				    ARRAY_SIZE(pmbus_fan_registers) *
+				    PMBUS_MAX_SENSORS_PER_FAN;
+				max_booleans +=
+				    ARRAY_SIZE(pmbus_fan_registers) *
+				    PMBUS_MAX_BOOLEANS_PER_FAN;
+			} else {
+				max_sensors += PMBUS_MAX_SENSORS_PER_FAN;
+				max_booleans += PMBUS_MAX_BOOLEANS_PER_FAN;
+			}
+		}
+		if (info->func[page] & PMBUS_HAVE_TEMP) {
+			if (page == 0) {
+				max_sensors +=
+				    ARRAY_SIZE(pmbus_temp_registers) *
+				    PMBUS_MAX_SENSORS_PER_TEMP;
+				max_booleans +=
+				    ARRAY_SIZE(pmbus_temp_registers) *
+				    PMBUS_MAX_BOOLEANS_PER_TEMP;
+			} else {
+				max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
+				max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
+			}
+		}
+	}
+	data->max_sensors = max_sensors;
+	data->max_booleans = max_booleans;
+	data->max_labels = max_labels;
+	data->max_attributes = max_sensors + max_booleans + max_labels;
+}
+
+/*
+ * Search for attributes. Allocate sensors, booleans, and labels as needed.
+ */
+static void pmbus_find_attributes(struct i2c_client *client,
+				  struct pmbus_data *data)
+{
+	const struct pmbus_driver_info *info = data->info;
+	int page, i0, i1, in_index;
+
+	/*

drivers/hwmon/pmbus_core.c line 882

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+	 * Input voltage sensors
+	 */
+	in_index = 1;
+	if (info->func[0] & PMBUS_HAVE_VIN) {
+		bool have_alarm = false;
+
+		i0 = data->num_sensors;
+		pmbus_add_label(data, "in", in_index, "vin", 0);
+		pmbus_add_sensor(data, "in", "input", in_index,
+				 0, PMBUS_READ_VIN, PSC_VOLTAGE_IN, true);

This next lot do rather look like they could be done using an inline function or a macro...

Something like...
#define bob(LIM, NAME, POST, WHAT, TYPE)
if (pmbus_check_word_register(client, 0, LIM)) {
i1 = data->num_sensors;
pmbus_add_sensor(data, NAME, POST, in_index, 0, LIM, WHAT, false); if (info->func[0] & PMBUS_HAV_STATUS_INPUT) { pmbus_add_boolean_reg(data, NAME, POST##_alarm, in_index, PBU_STATUS_INPUT_BASE, TYPE);
have_alarm = true;
}
}

bob(PMBUS_VIN_UV_WARN_LIMIT, "in", "min", PSC_VOLTAGE_IN, PB_VOLTAGE_UV_WARNING); bob(PMBUS_VIN_UV_FAULT_LIMIT, "in", "lcrit", PSC_VOLTAGE_IN, PB_VOLTAGE_UV_FAULT); bob(PMBUS_VIN_OV_WARN_LIMIT, "in", "max", PSC_VOLTAGE_IN, PB_VOLTAGE_OV_WARNING); etc.

basically I'm observing a lot of shared code in these... Still maybe this just acts to hide what is going on.

Quoted 77 lines
drivers/hwmon/pmbus_core.c new file +77 -0
+		if (pmbus_check_word_register(client, 0,
+					      PMBUS_VIN_UV_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "min", in_index,
+					 0, PMBUS_VIN_UV_WARN_LIMIT,
+					 PSC_VOLTAGE_IN, false);
+			if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+				pmbus_add_boolean_reg(data, "in", "min_alarm",
+						      in_index,
+						      PB_STATUS_INPUT_BASE,
+						      PB_VOLTAGE_UV_WARNING);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, 0,
+					      PMBUS_VIN_UV_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "lcrit", in_index,
+					 0, PMBUS_VIN_UV_FAULT_LIMIT,
+					 PSC_VOLTAGE_IN, false);
+			if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+				pmbus_add_boolean_reg(data, "in", "lcrit_alarm",
+						      in_index,
+						      PB_STATUS_INPUT_BASE,
+						      PB_VOLTAGE_UV_FAULT);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, 0,
+					      PMBUS_VIN_OV_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "max", in_index,
+					 0, PMBUS_VIN_OV_WARN_LIMIT,
+					 PSC_VOLTAGE_IN, false);
+			if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+				pmbus_add_boolean_reg(data, "in", "max_alarm",
+						      in_index,
+						      PB_STATUS_INPUT_BASE,
+						      PB_VOLTAGE_OV_WARNING);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, 0,
+					      PMBUS_VIN_OV_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "crit", in_index,
+					 0, PMBUS_VIN_OV_FAULT_LIMIT,
+					 PSC_VOLTAGE_IN, false);
+			if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+				pmbus_add_boolean_reg(data, "in", "crit_alarm",
+						      in_index,
+						      PB_STATUS_INPUT_BASE,
+						      PB_VOLTAGE_OV_FAULT);
+				have_alarm = true;
+			}
+		}
+		/*
+		 * Add generic alarm attribute only if there are no individual
+		 * attributes.
+		 */
+		if (!have_alarm)
+			pmbus_add_boolean_reg(data, "in", "alarm",
+					      in_index,
+					      PB_STATUS_BASE,
+					      PB_STATUS_VIN_UV);
+		in_index++;
+	}
+	if (info->func[0] & PMBUS_HAVE_VCAP) {
+		pmbus_add_label(data, "in", in_index, "vcap", 0);
+		pmbus_add_sensor(data, "in", "input", in_index, 0,
+				 PMBUS_READ_VCAP, PSC_VOLTAGE_IN, true);
+		in_index++;
+	}
+
+	/*
+	 * Output voltage sensors
+	 */

drivers/hwmon/pmbus_core.c line 969

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+	for (page = 0; page < info->pages; page++) {
+		bool have_alarm = false;
+
+		if (!(info->func[page] & PMBUS_HAVE_VOUT))
+			continue;
+
+		i0 = data->num_sensors;
+		pmbus_add_label(data, "in", in_index, "vout", page + 1);
+		pmbus_add_sensor(data, "in", "input", in_index, page,
+				 PMBUS_READ_VOUT, PSC_VOLTAGE_OUT, true);

Looks like that macro needs a few minor additions and you can use it here as well.

Quoted 472 lines
drivers/hwmon/pmbus_core.c new file +472 -0
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_VOUT_UV_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "min", in_index, page,
+					 PMBUS_VOUT_UV_WARN_LIMIT,
+					 PSC_VOLTAGE_OUT, false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+				pmbus_add_boolean_reg(data, "in", "min_alarm",
+						      in_index,
+						      PB_STATUS_VOUT_BASE +
+						      page,
+						      PB_VOLTAGE_UV_WARNING);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_VOUT_UV_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "lcrit", in_index, page,
+					 PMBUS_VOUT_UV_FAULT_LIMIT,
+					 PSC_VOLTAGE_OUT, false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+				pmbus_add_boolean_reg(data, "in", "lcrit_alarm",
+						      in_index,
+						      PB_STATUS_VOUT_BASE +
+						      page,
+						      PB_VOLTAGE_UV_FAULT);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_VOUT_OV_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "max", in_index, page,
+					 PMBUS_VOUT_OV_WARN_LIMIT,
+					 PSC_VOLTAGE_OUT, false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+				pmbus_add_boolean_reg(data, "in", "max_alarm",
+						      in_index,
+						      PB_STATUS_VOUT_BASE +
+						      page,
+						      PB_VOLTAGE_OV_WARNING);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_VOUT_OV_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "in", "crit", in_index, page,
+					 PMBUS_VOUT_OV_FAULT_LIMIT,
+					 PSC_VOLTAGE_OUT, false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+				pmbus_add_boolean_reg(data, "in", "crit_alarm",
+						      in_index,
+						      PB_STATUS_VOUT_BASE +
+						      page,
+						      PB_VOLTAGE_OV_FAULT);
+				have_alarm = true;
+			}
+		}
+		/*
+		 * Add generic alarm attribute only if there are no individual
+		 * attributes.
+		 */
+		if (!have_alarm)
+			pmbus_add_boolean_reg(data, "in", "alarm",
+					      in_index,
+					      PB_STATUS_BASE + page,
+					      PB_STATUS_VOUT_OV);
+		in_index++;
+	}
+
+	/*
+	 * Current sensors
+	 */
+
+	/*
+	 * Input current sensors
+	 */
+	in_index = 1;
+	if (info->func[0] & PMBUS_HAVE_IIN) {
+		i0 = data->num_sensors;
+		pmbus_add_label(data, "curr", in_index, "iin", 0);
+		pmbus_add_sensor(data, "curr", "input", in_index,
+				 0, PMBUS_READ_IIN, PSC_CURRENT_IN, true);
+		if (pmbus_check_word_register(client, 0,
+					      PMBUS_IIN_OC_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "curr", "max", in_index,
+					 0, PMBUS_IIN_OC_WARN_LIMIT,
+					 PSC_CURRENT_IN, false);
+			if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+				pmbus_add_boolean_reg(data, "curr", "max_alarm",
+						      in_index,
+						      PB_STATUS_INPUT_BASE,
+						      PB_IIN_OC_WARNING);
+			}
+		}
+		if (pmbus_check_word_register(client, 0,
+					      PMBUS_IIN_OC_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "curr", "crit", in_index,
+					 0, PMBUS_IIN_OC_FAULT_LIMIT,
+					 PSC_CURRENT_IN, false);
+			if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
+				pmbus_add_boolean_reg(data, "curr",
+						      "crit_alarm",
+						      in_index,
+						      PB_STATUS_INPUT_BASE,
+						      PB_IIN_OC_FAULT);
+		}
+		in_index++;
+	}
+
+	/*
+	 * Output current sensors
+	 */
+	for (page = 0; page < info->pages; page++) {
+		bool have_alarm = false;
+
+		if (!(info->func[page] & PMBUS_HAVE_IOUT))
+			continue;
+
+		i0 = data->num_sensors;
+		pmbus_add_label(data, "curr", in_index, "iout", page + 1);
+		pmbus_add_sensor(data, "curr", "input", in_index, page,
+				 PMBUS_READ_IOUT, PSC_CURRENT_OUT, true);
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_IOUT_OC_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "curr", "max", in_index, page,
+					 PMBUS_IOUT_OC_WARN_LIMIT,
+					 PSC_CURRENT_OUT, false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_IOUT) {
+				pmbus_add_boolean_reg(data, "curr", "max_alarm",
+						      in_index,
+						      PB_STATUS_IOUT_BASE +
+						      page, PB_IOUT_OC_WARNING);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_IOUT_UC_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "curr", "lcrit", in_index, page,
+					 PMBUS_IOUT_UC_FAULT_LIMIT,
+					 PSC_CURRENT_OUT, false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_IOUT) {
+				pmbus_add_boolean_reg(data, "curr",
+						      "lcrit_alarm",
+						      in_index,
+						      PB_STATUS_IOUT_BASE +
+						      page, PB_IOUT_UC_FAULT);
+				have_alarm = true;
+			}
+		}
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_IOUT_OC_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "curr", "crit", in_index, page,
+					 PMBUS_IOUT_OC_FAULT_LIMIT,
+					 PSC_CURRENT_OUT, false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_IOUT) {
+				pmbus_add_boolean_reg(data, "curr",
+						      "crit_alarm",
+						      in_index,
+						      PB_STATUS_IOUT_BASE +
+						      page, PB_IOUT_OC_FAULT);
+				have_alarm = true;
+			}
+		}
+		/*
+		 * Add generic alarm attribute only if there are no individual
+		 * attributes.
+		 */
+		if (!have_alarm)
+			pmbus_add_boolean_reg(data, "curr", "alarm",
+					      in_index,
+					      PB_STATUS_BASE + page,
+					      PB_STATUS_IOUT_OC);
+		in_index++;
+	}
+
+	/*
+	 * Power sensors
+	 */
+	/*
+	 * Input Power sensors
+	 */
+	in_index = 1;
+	if (info->func[0] & PMBUS_HAVE_PIN) {
+		i0 = data->num_sensors;
+		pmbus_add_label(data, "power", in_index, "pin", 0);
+		pmbus_add_sensor(data, "power", "input", in_index,
+				 0, PMBUS_READ_PIN, PSC_POWER, true);
+		if (pmbus_check_word_register(client, 0,
+					      PMBUS_PIN_OP_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "power", "max", in_index,
+					 0, PMBUS_PIN_OP_WARN_LIMIT, PSC_POWER,
+					 false);
+			if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
+				pmbus_add_boolean_reg(data, "power",
+						      "alarm",
+						      in_index,
+						      PB_STATUS_INPUT_BASE,
+						      PB_PIN_OP_WARNING);
+		}
+		in_index++;
+	}
+
+	/*
+	 * Output Power sensors
+	 */
+	for (page = 0; page < info->pages; page++) {
+		bool need_alarm = false;
+
+		if (!(info->func[page] & PMBUS_HAVE_POUT))
+			continue;
+
+		i0 = data->num_sensors;
+		pmbus_add_label(data, "power", in_index, "pout", page + 1);
+		pmbus_add_sensor(data, "power", "input", in_index, page,
+				 PMBUS_READ_POUT, PSC_POWER, true);
+		/*
+		 * Per hwmon sysfs API, power_cap is to be used to limit output
+		 * power.
+		 * We have two registers related to maximum output power,
+		 * PMBUS_POUT_MAX and PMBUS_POUT_OP_WARN_LIMIT.
+		 * PMBUS_POUT_MAX matches the powerX_cap attribute definition.
+		 * There is no attribute in the API to match
+		 * PMBUS_POUT_OP_WARN_LIMIT. We use powerX_max for now.
+		 */
+		if (pmbus_check_word_register(client, page, PMBUS_POUT_MAX)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "power", "cap", in_index, page,
+					 PMBUS_POUT_MAX, PSC_POWER, false);
+			need_alarm = true;
+		}
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_POUT_OP_WARN_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "power", "max", in_index, page,
+					 PMBUS_POUT_OP_WARN_LIMIT, PSC_POWER,
+					 false);
+			need_alarm = true;
+		}
+		if (need_alarm && (info->func[page] & PMBUS_HAVE_STATUS_IOUT))
+			pmbus_add_boolean_reg(data, "power", "alarm",
+					      in_index,
+					      PB_STATUS_IOUT_BASE + page,
+					      PB_POUT_OP_WARNING
+					      | PB_POWER_LIMITING);
+
+		if (pmbus_check_word_register(client, page,
+					      PMBUS_POUT_OP_FAULT_LIMIT)) {
+			i1 = data->num_sensors;
+			pmbus_add_sensor(data, "power", "crit", in_index, page,
+					 PMBUS_POUT_OP_FAULT_LIMIT, PSC_POWER,
+					 false);
+			if (info->func[page] & PMBUS_HAVE_STATUS_IOUT)
+				pmbus_add_boolean_reg(data, "power",
+						      "crit_alarm",
+						      in_index,
+						      PB_STATUS_IOUT_BASE
+						      + page,
+						      PB_POUT_OP_FAULT);
+		}
+		in_index++;
+	}
+
+	/*
+	 * Temperature sensors
+	 */
+	in_index = 1;
+	for (page = 0; page < info->pages; page++) {
+		int t, temps;
+
+		if (!(info->func[page] & PMBUS_HAVE_TEMP))
+			continue;
+
+		temps = page ? 1 : ARRAY_SIZE(pmbus_temp_registers);
+		for (t = 0; t < temps; t++) {
+			bool have_alarm = false;
+
+			if (!pmbus_check_word_register
+			    (client, page, pmbus_temp_registers[t]))
+				break;
+
+			i0 = data->num_sensors;
+			pmbus_add_sensor(data, "temp", "input", in_index, page,
+					 pmbus_temp_registers[t],
+					 PSC_TEMPERATURE, true);
+
+			/*
+			 * PMBus provides only one status register for TEMP1-3.
+			 * Thus, we can not use the status register to determine
+			 * which of the three sensors actually caused an alarm.
+			 * Always compare current temperature against the limit
+			 * registers to determine alarm conditions for a
+			 * specific sensor.
+			 */
+			if (pmbus_check_word_register
+			    (client, page, PMBUS_UT_WARN_LIMIT)) {
+				i1 = data->num_sensors;
+				pmbus_add_sensor(data, "temp", "min", in_index,
+						 page, PMBUS_UT_WARN_LIMIT,
+						 PSC_TEMPERATURE, false);
+				if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+					pmbus_add_boolean_cmp(data, "temp",
+						"min_alarm", in_index, i1, i0,
+						PB_STATUS_TEMP_BASE + page,
+						PB_TEMP_UT_WARNING);
+					have_alarm = true;
+				}
+			}
+			if (pmbus_check_word_register(client, page,
+						      PMBUS_UT_FAULT_LIMIT)) {
+				i1 = data->num_sensors;
+				pmbus_add_sensor(data, "temp", "lcrit",
+						 in_index, page,
+						 PMBUS_UT_FAULT_LIMIT,
+						 PSC_TEMPERATURE, false);
+				if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+					pmbus_add_boolean_cmp(data, "temp",
+						"lcrit_alarm", in_index, i1, i0,
+						PB_STATUS_TEMP_BASE + page,
+						PB_TEMP_UT_FAULT);
+					have_alarm = true;
+				}
+			}
+			if (pmbus_check_word_register
+			    (client, page, PMBUS_OT_WARN_LIMIT)) {
+				i1 = data->num_sensors;
+				pmbus_add_sensor(data, "temp", "max", in_index,
+						 page, PMBUS_OT_WARN_LIMIT,
+						 PSC_TEMPERATURE, false);
+				if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+					pmbus_add_boolean_cmp(data, "temp",
+						"max_alarm", in_index, i0, i1,
+						PB_STATUS_TEMP_BASE + page,
+						PB_TEMP_OT_WARNING);
+					have_alarm = true;
+				}
+			}
+			if (pmbus_check_word_register(client, page,
+						      PMBUS_OT_FAULT_LIMIT)) {
+				i1 = data->num_sensors;
+				pmbus_add_sensor(data, "temp", "crit", in_index,
+						 page, PMBUS_OT_FAULT_LIMIT,
+						 PSC_TEMPERATURE, false);
+				if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+					pmbus_add_boolean_cmp(data, "temp",
+						"crit_alarm", in_index, i0, i1,
+						PB_STATUS_TEMP_BASE + page,
+						PB_TEMP_OT_FAULT);
+					have_alarm = true;
+				}
+			}
+			/*
+			 * Last resort - we were not able to create any alarm
+			 * registers. Report alarm for all sensors using the
+			 * status register temperature alarm bit.
+			 */
+			if (!have_alarm)
+				pmbus_add_boolean_reg(data, "temp", "alarm",
+						      in_index,
+						      PB_STATUS_BASE + page,
+						      PB_STATUS_TEMPERATURE);
+			in_index++;
+		}
+	}
+
+	/*
+	 * Fans
+	 */
+	in_index = 1;
+	for (page = 0; page < info->pages; page++) {
+		int fans, f;
+
+		if (!(info->func[page] & PMBUS_HAVE_FAN12))
+			continue;
+
+		fans = page ? 1 : ARRAY_SIZE(pmbus_fan_registers);
+		for (f = 0; f < fans; f++) {
+			int regval;
+
+			if (!pmbus_check_word_register(client, page,
+						       pmbus_fan_registers[f])
+			    || !pmbus_check_byte_register(client, page,
+						pmbus_fan_config_registers[f]))
+				break;
+
+			/*
+			 * Skip fan if not installed.
+			 * Each fan configuration register covers multiple fans,
+			 * so we have to do some magic.
+			 */
+			regval = pmbus_read_byte_data(client, page,
+				pmbus_fan_config_registers[f]);
+			if (regval < 0 ||
+			    (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
+				continue;
+
+			i0 = data->num_sensors;
+			pmbus_add_sensor(data, "fan", "input", in_index, page,
+					 pmbus_fan_registers[f], PSC_FAN, true);
+
+			/*
+			 * Each fan status register covers multiple fans,
+			 * so we have to do some magic.
+			 */
+			if (pmbus_check_byte_register
+			    (client, page, pmbus_fan_status_registers[f])) {
+				int base;
+
+				if (f > 1)	/* fan 3, 4 */
+					base = PB_STATUS_FAN34_BASE;
+				else
+					base = PB_STATUS_FAN_BASE + page;
+				pmbus_add_boolean_reg(data, "fan", "alarm",
+					in_index, base,
+					PB_FAN_FAN1_WARNING >> (f & 1));
+				pmbus_add_boolean_reg(data, "fan", "fault",
+					in_index, base,
+					PB_FAN_FAN1_FAULT >> (f & 1));
+			}
+			in_index++;
+		}
+	}
+}
+
+/*
+ * Identify chip parameters.
+ * This function is called for all chips.
+ */
+static int pmbus_identify_common(struct i2c_client *client,
+				 struct pmbus_data *data)
+{
+	int vout_mode, exponent;
+
+	vout_mode = pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
+	if (vout_mode >= 0) {
+		/*
+		 * Not all chips support the VOUT_MODE command,
+		 * so a failure to read it is not an error.
+		 */
+		switch (vout_mode >> 5) {
+		case 0:	/* linear mode      */
+			if (data->info->direct[PSC_VOLTAGE_OUT])
+				return -ENODEV;
+
+			exponent = vout_mode & 0x1f;
+			/* and sign-extend it */
+			if (exponent & 0x10)
+				exponent |= ~0x1f;
+			data->exponent = exponent;
+			break;
+		case 2:	/* direct mode      */
+			if (!data->info->direct[PSC_VOLTAGE_OUT])
+				return -ENODEV;
+			break;
+		default:
+			return -ENODEV;
+		}
+	}
+
+	/* Determine maximum number of sensors, booleans, and labels */
+	pmbus_find_max_attr(client, data);
+
+	pmbus_clear_faults(client);
+	return 0;

drivers/hwmon/pmbus_core.c line 1451

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+}
+
+int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
+		   struct pmbus_driver_info *info)
+{
+	const struct pmbus_platform_data *pdata = client->dev.platform_data;
+	struct pmbus_data *data;
+	int ret;
+
+	if (!info) {

Why insist on platform data? Can't we define a default as the pdata looks very simple?

Quoted 24 lines
drivers/hwmon/pmbus_core.c new file +24 -0
+		dev_err(&client->dev, "Missing chip information");
+		return -ENODEV;
+	}
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
+				     | I2C_FUNC_SMBUS_BYTE_DATA
+				     | I2C_FUNC_SMBUS_WORD_DATA))
+		return -ENODEV;
+
+	data = kzalloc(sizeof(*data), GFP_KERNEL);
+	if (!data) {
+		dev_err(&client->dev, "No memory to allocate driver data\n");
+		return -ENOMEM;
+	}
+
+	i2c_set_clientdata(client, data);
+	mutex_init(&data->update_lock);
+
+	/*
+	 * Bail out if status register or PMBus revision register
+	 * does not exist.
+	 */
+	if (i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE) < 0
+	    || i2c_smbus_read_byte_data(client, PMBUS_REVISION) < 0) {

drivers/hwmon/pmbus_core.c line 1485

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+		dev_err(&client->dev,
+			"Status or revision register not found\n");
+		ret = -ENODEV;
+		goto out_data;
+	}
+
+	if (pdata)
+		data->flags = pdata->flags;
+	data->info = info;
+

perhaps a clarifying comment explaining why some devices might not have an identify function?

Quoted 173 lines
drivers/hwmon/pmbus_core.c new file +122 -0
+	if (info->identify) {
+		ret = (*info->identify)(client, info);
+		if (ret < 0) {
+			dev_err(&client->dev, "Chip identification failed\n");
+			goto out_data;
+		}
+	}
+
+	if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
+		dev_err(&client->dev, "Bad number of PMBus pages: %d\n",
+			info->pages);
+		ret = -EINVAL;
+		goto out_data;
+	}
+	/*
+	 * Bail out if more than one page was configured, but we can not
+	 * select the highest page. This is an indication that the wrong
+	 * chip type was selected. Better bail out now than keep
+	 * returning errors later on.
+	 */
+	if (info->pages > 1 && pmbus_set_page(client, info->pages - 1) < 0) {
+		dev_err(&client->dev, "Failed to select page %d\n",
+			info->pages - 1);
+		ret = -EINVAL;
+		goto out_data;
+	}
+
+	ret = pmbus_identify_common(client, data);
+	if (ret < 0) {
+		dev_err(&client->dev, "Failed to identify chip capabilities\n");
+		goto out_data;
+	}
+
+	ret = -ENOMEM;
+	data->sensors = kzalloc(sizeof(struct pmbus_sensor) * data->max_sensors,
+				GFP_KERNEL);
+	if (!data->sensors) {
+		dev_err(&client->dev, "No memory to allocate sensor data\n");
+		goto out_data;
+	}
+
+	data->booleans = kzalloc(sizeof(struct pmbus_boolean)
+				 * data->max_booleans, GFP_KERNEL);
+	if (!data->booleans) {
+		dev_err(&client->dev, "No memory to allocate boolean data\n");
+		goto out_sensors;
+	}
+
+	data->labels = kzalloc(sizeof(struct pmbus_label) * data->max_labels,
+			       GFP_KERNEL);
+	if (!data->labels) {
+		dev_err(&client->dev, "No memory to allocate label data\n");
+		goto out_booleans;
+	}
+
+	data->attributes = kzalloc(sizeof(struct attribute *)
+				   * data->max_attributes, GFP_KERNEL);
+	if (!data->attributes) {
+		dev_err(&client->dev, "No memory to allocate attribute data\n");
+		goto out_labels;
+	}
+
+	pmbus_find_attributes(client, data);
+
+	/*
+	 * If there are no attributes, something is wrong.
+	 * Bail out instead of trying to register nothing.
+	 */
+	if (!data->num_attributes) {
+		dev_err(&client->dev, "No attributes found\n");
+		ret = -ENODEV;
+		goto out_attributes;
+	}
+
+	/* Register sysfs hooks */
+	data->group.attrs = data->attributes;
+	ret = sysfs_create_group(&client->dev.kobj, &data->group);
+	if (ret) {
+		dev_err(&client->dev, "Failed to create sysfs entries\n");
+		goto out_attributes;
+	}
+	data->hwmon_dev = hwmon_device_register(&client->dev);
+	if (IS_ERR(data->hwmon_dev)) {
+		ret = PTR_ERR(data->hwmon_dev);
+		dev_err(&client->dev, "Failed to register hwmon device\n");
+		goto out_hwmon_device_register;
+	}
+	return 0;
+
+out_hwmon_device_register:
+	sysfs_remove_group(&client->dev.kobj, &data->group);
+out_attributes:
+	kfree(data->attributes);
+out_labels:
+	kfree(data->labels);
+out_booleans:
+	kfree(data->booleans);
+out_sensors:
+	kfree(data->sensors);
+out_data:
+	kfree(data);
+	return ret;
+}
+EXPORT_SYMBOL_GPL(pmbus_do_probe);
+
+int pmbus_do_remove(struct i2c_client *client)
+{
+	struct pmbus_data *data = i2c_get_clientdata(client);
+	hwmon_device_unregister(data->hwmon_dev);
+	sysfs_remove_group(&client->dev.kobj, &data->group);
+	kfree(data->attributes);
+	kfree(data->labels);
+	kfree(data->booleans);
+	kfree(data->sensors);
+	kfree(data);
+	return 0;
+}
+EXPORT_SYMBOL_GPL(pmbus_do_remove);
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("PMBus core driver");
+MODULE_LICENSE("GPL");
include/linux/i2c/pmbus.h new file +45 -0
new file mode 100644
index 0000000..69280db
@@ -0,0 +1,45 @@
+/*
+ * Hardware monitoring driver for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _PMBUS_H_
+#define _PMBUS_H_
+
+/* flags */
+
+/*
+ * PMBUS_SKIP_STATUS_CHECK
+ *
+ * During register detection, skip checking the status register for
+ * communication or command errors.
+ *
+ * Some PMBus chips respond with valid data when trying to read an unsupported
+ * register. For such chips, checking the status register is mandatory when
+ * trying to determine if a chip register exists or not.
+ * Other PMBus chips don't support the STATUS_CML register, or report
+ * communication errors for no explicable reason. For such chips, checking
+ * the status register must be disabled.
+ */
+#define PMBUS_SKIP_STATUS_CHECK	(1 << 0)
+
+struct pmbus_platform_data {
+	u32 flags;		/* Device specific flags */
+};
+
+#endif /* _PMBUS_H_ */
#3 lore raw
Quoted 7 lines · Jonathan Cameron
Quoted 2 lines · Guenter Roeck

This driver adds support for hardware monitoring features of various PMBus devices.

Hi Guenter, I'm afraid this isn't the most thorough review ever, but there are a few questions I'd like answered inline. These devices are pretty ugly.

Hi Jonathan,

given the complexity of the driver I am very happy you found the time!

Quoted 3 lines

I'm also a little unhappy with how often you clear faults without it being obvious why. Please have another look at this and add clarifying comments...

Mostly that was to make me feel safer. I removed some; hope it is better now.

Quoted 3 lines

I've suggested use of some macros inline. Not sure whether it's actualy a good idea though. What do you think?

I actually had more function macros in the code, but I am getting a bit away from it after I noticed that it often just obfuscates the code. Only reason for not removing the remaining the function macros is that I didn't find a clean way to replace them with actual code or functions.

Quoted 4 lines

Other than request for a few more comments to explain bits that weren't immediately obvious, the only bit I'd really question is the necessity of the list of pmbus devices. I might have missed something there though...

That is pretty much just to be able to clean up an entry. More see below.

Quoted 27 lines

Thanks,

Jonathan

Quoted 23 lines
---
 drivers/hwmon/Kconfig      |   25 +
 drivers/hwmon/Makefile     |    4 +
 drivers/hwmon/pmbus.c      |  234 +++++++
 drivers/hwmon/pmbus.h      |  307 +++++++++
 drivers/hwmon/pmbus_core.c | 1611 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/i2c/pmbus.h  |   45 ++
 6 files changed, 2226 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/pmbus.c
 create mode 100644 drivers/hwmon/pmbus.h
 create mode 100644 drivers/hwmon/pmbus_core.c
 create mode 100644 include/linux/i2c/pmbus.h
drivers/hwmon/Kconfig +0 -0
index 773e484..9f20e56 100644
@@ -734,6 +734,31 @@ config SENSORS_PCF8591
        These devices are hard to detect and rarely found on mainstream
        hardware.  If unsure, say N.
 
Quoted 2 lines

drivers/hwmon/Kconfig config SENSORS_PCF8591 · line 738

Quoted 2 lines
drivers/hwmon/Kconfig +2 -0
+config PMBUS
+     tristate "PMBus support"

Side note: that should really be a boolean. Will be fixed in next version.

Quoted 78 lines
Quoted 78 lines
drivers/hwmon/Kconfig +23 -0
+     depends on I2C && EXPERIMENTAL
+     default n
+     help
+       Say yes here if you want to enable PMBus support.
+
+       This driver can also be built as a module. If so, the module will
+       be called pmbus_core.
+
+if PMBUS
+
+config SENSORS_PMBUS
+     tristate "Generic PMBus devices"
+     default n
+     help
+       If you say yes here you get hardware monitoring support for generic
+       PMBus devices, including but not limited to BMR450, BMR451, BMR453,
+       BMR454, and LTC2978.
+
+       This driver can also be built as a module. If so, the module will
+       be called pmbus.
+
+endif # PMBUS
+
 config SENSORS_SHT15
      tristate "Sensiron humidity and temperature sensors. SHT15 and compat."
      depends on GENERIC_GPIO
drivers/hwmon/Makefile +4 -0
index dde02d9..f7f158b 100644
@@ -112,6 +112,10 @@ obj-$(CONFIG_SENSORS_W83L786NG)  += w83l786ng.o
 obj-$(CONFIG_SENSORS_WM831X) += wm831x-hwmon.o
 obj-$(CONFIG_SENSORS_WM8350) += wm8350-hwmon.o
 
+# PMBus drivers
+obj-$(CONFIG_PMBUS)          += pmbus_core.o
+obj-$(CONFIG_SENSORS_PMBUS)  += pmbus.o
+
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG
 endif
drivers/hwmon/pmbus.c new file +31 -0
new file mode 100644
index 0000000..e5c3527
@@ -0,0 +1,234 @@
+/*
+ * Hardware monitoring driver for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/list.h>
+#include <linux/i2c.h>
+#include "pmbus.h"
+
+struct pmbus_entry {
Quoted 8 lines

drivers/hwmon/pmbus.c line 36

Quoted 5 lines
drivers/hwmon/pmbus.c new file +5 -0
+     struct list_head list;
+     struct i2c_client *client;
+     struct pmbus_driver_info info;
+};
+

I'd like to see a comment to explain that (I think) this list only contains pmbus drivers directly managed by this driver. (and not say the max8688?)

Correct, and its only purpose is to be able to clean up the locally allocated struct pmbus_driver_info. Other drivers may have static platform data, and thus not have to clean it up.

Quoted 128 lines
Quoted 128 lines
drivers/hwmon/pmbus.c new file +128 -0
+static LIST_HEAD(pmbus_list);
+static DEFINE_MUTEX(pmbus_list_mutex);
+
+/*
+ * Find sensor groups and status registers on each page.
+ */
+static void pmbus_find_sensor_groups(struct i2c_client *client,
+                                  struct pmbus_driver_info *info)
+{
+     int page;
+
+     /* Sensors detected on page 0 only */
+     if (pmbus_check_word_register(client, 0, PMBUS_READ_VIN))
+             info->func[0] |= PMBUS_HAVE_VIN;
+     if (pmbus_check_word_register(client, 0, PMBUS_READ_VCAP))
+             info->func[0] |= PMBUS_HAVE_VCAP;
+     if (pmbus_check_word_register(client, 0, PMBUS_READ_IIN))
+             info->func[0] |= PMBUS_HAVE_IIN;
+     if (pmbus_check_word_register(client, 0, PMBUS_READ_PIN))
+             info->func[0] |= PMBUS_HAVE_PIN;
+     if (info->func[0]
+         && pmbus_check_byte_register(client, 0, PMBUS_STATUS_INPUT))
+             info->func[0] |= PMBUS_HAVE_STATUS_INPUT;
+     if (pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_1)) {
+             info->func[0] |= PMBUS_HAVE_FAN12;
+             if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_12))
+                     info->func[0] |= PMBUS_HAVE_STATUS_FAN12;
+     }
+     if (pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_3)) {
+             info->func[0] |= PMBUS_HAVE_FAN34;
+             if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_34))
+                     info->func[0] |= PMBUS_HAVE_STATUS_FAN34;
+     }
+     if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_1)) {
+             info->func[0] |= PMBUS_HAVE_TEMP;
+             if (pmbus_check_byte_register(client, 0,
+                                           PMBUS_STATUS_TEMPERATURE))
+                     info->func[0] |= PMBUS_HAVE_STATUS_TEMP;
+     }
+
+     /* Sensors detected on all pages */
+     for (page = 0; page < info->pages; page++) {
+             if (pmbus_check_word_register(client, page, PMBUS_READ_VOUT)) {
+                     info->func[page] |= PMBUS_HAVE_VOUT;
+                     if (pmbus_check_byte_register(client, page,
+                                                   PMBUS_STATUS_VOUT))
+                             info->func[page] |= PMBUS_HAVE_STATUS_VOUT;
+             }
+             if (pmbus_check_word_register(client, page, PMBUS_READ_IOUT)) {
+                     info->func[page] |= PMBUS_HAVE_IOUT;
+                     if (pmbus_check_byte_register(client, 0,
+                                                   PMBUS_STATUS_IOUT))
+                             info->func[page] |= PMBUS_HAVE_STATUS_IOUT;
+             }
+             if (pmbus_check_word_register(client, page, PMBUS_READ_POUT))
+                     info->func[page] |= PMBUS_HAVE_POUT;
+     }
+}
+
+/*
+ * Identify chip parameters.
+ */
+static int pmbus_identify(struct i2c_client *client,
+                       struct pmbus_driver_info *info)
+{
+     if (!info->pages) {
+             /*
+              * Check if the PAGE command is supported. If it is,
+              * keep setting the page number until it fails or until the
+              * maximum number of pages has been reached. Assume that
+              * this is the number of pages supported by the chip.
+              */
+             if (pmbus_check_byte_register(client, 0, PMBUS_PAGE)) {
+                     int page;
+
+                     for (page = 1; page < PMBUS_PAGES; page++) {
+                             if (pmbus_set_page(client, page) < 0)
+                                     break;
+                     }
+                     pmbus_set_page(client, 0);
+                     info->pages = page;
+             } else {
+                     info->pages = 1;
+             }
+     }
+
+     /*
+      * We should check if the COEFFICIENTS register is supported.
+      * If it is, and the chip is configured for direct mode, we can read
+      * the coefficients from the chip, one set per group of sensor
+      * registers.
+      *
+      * To do this, we will need access to a chip which actually supports the
+      * COEFFICIENTS command, since the command is too complex to implement
+      * without testing it.
+      */
+
+     /* Try to find sensor groups  */
+     pmbus_find_sensor_groups(client, info);
+
+     pmbus_clear_faults(client);
+
+     return 0;
+}
+
+static void pmbus_entry_remove(struct i2c_client *client)
+{
+     struct pmbus_entry *p;
+
+     mutex_lock(&pmbus_list_mutex);
+     list_for_each_entry(p, &pmbus_list, list) {
+             if (p->client = client) {
+                     list_del(&p->list);
+                     kfree(p);
+                     break;
+             }
+     }
+     mutex_unlock(&pmbus_list_mutex);
+}
+
+static int pmbus_probe(struct i2c_client *client,
+                    const struct i2c_device_id *id)
+{
+     struct pmbus_entry *pe;
+     int ret;
+
+     pe = kzalloc(sizeof(struct pmbus_entry), GFP_KERNEL);
+     if (!pe)
Quoted 8 lines

drivers/hwmon/pmbus.c line 170

Quoted 6 lines
drivers/hwmon/pmbus.c new file +6 -0
+             return -ENOMEM;
+
+     pe->client = client;
+     mutex_lock(&pmbus_list_mutex);
+     list_add_tail(&pe->list, &pmbus_list);
+     mutex_unlock(&pmbus_list_mutex);

I'm a little unclear why the list is needed. Looks like it is used for cleanup purposes. i2c_set_clientdata gets called with a struct pmbus_data *data

Correct.

Quoted 6 lines

in pmbus_do_probe. That structure has a pointer to struct pmbus_driver_info info currently effectively stored in this list. Hence, if we don't have the list I think we can create a pmbus_driver_info struct directly here and get to it via ((struct pmbus_data *)(i2c_get_clientdata(client))->info to free the structure on remove.

You are right, though that would require context information which is currently not exported from pmbus_core.c. Specifically, pmbus.c would need to know about struct pmbus_data which is private to pmbus_core.c. I would prefer to keep it that way.

Maybe I could add an API call into pmbus_core.c to retrieve a pointer to pmbus_driver_info. Do you think that would make sense ? I am a bit at odds with myself if the list or an API function (or something else ?) would be better.

Quoted 363 lines
Quoted 363 lines
drivers/hwmon/pmbus.c new file +64 -0
+
+     pe->info.pages = id->driver_data;
+     pe->info.identify = pmbus_identify;
+
+     ret = pmbus_do_probe(client, id, &pe->info);
+     if (ret < 0)
+             goto out;
+     return 0;
+
+out:
+     pmbus_entry_remove(client);
+     return ret;
+}
+
+static int pmbus_remove(struct i2c_client *client)
+{
+     int ret;
+
+     ret = pmbus_do_remove(client);
+     pmbus_entry_remove(client);
+
+     return ret;
+}
+
+/*
+ * Use driver_data to set the number of pages supported by the chip.
+ */
+static const struct i2c_device_id pmbus_id[] = {
+     {"bmr450", 1},
+     {"bmr451", 1},
+     {"bmr453", 1},
+     {"bmr454", 1},
+     {"ltc2978", 8},
+     {"pmbus", 0},
+     {}
+};
+
+MODULE_DEVICE_TABLE(i2c, pmbus_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver pmbus_driver = {
+     .driver = {
+                .name = "pmbus",
+                },
+     .probe = pmbus_probe,
+     .remove = pmbus_remove,
+     .id_table = pmbus_id,
+};
+
+static int __init pmbus_init(void)
+{
+     return i2c_add_driver(&pmbus_driver);
+}
+
+static void __exit pmbus_exit(void)
+{
+     i2c_del_driver(&pmbus_driver);
+}
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("Generic PMBus driver");
+MODULE_LICENSE("GPL");
+module_init(pmbus_init);
+module_exit(pmbus_exit);
drivers/hwmon/pmbus.h new file +293 -0
new file mode 100644
index 0000000..2dc4e01
@@ -0,0 +1,307 @@
+/*
+ * pmbus.h - Common defines and structures for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef PMBUS_H
+#define PMBUS_H
+
+/*
+ * Registers
+ */
+#define PMBUS_PAGE                   0x00
+#define PMBUS_OPERATION                      0x01
+#define PMBUS_ON_OFF_CONFIG          0x02
+#define PMBUS_CLEAR_FAULTS           0x03
+#define PMBUS_PHASE                  0x04
+
+#define PMBUS_CAPABILITY             0x19
+#define PMBUS_QUERY                  0x1A
+
+#define PMBUS_VOUT_MODE                      0x20
+#define PMBUS_VOUT_COMMAND           0x21
+#define PMBUS_VOUT_TRIM                      0x22
+#define PMBUS_VOUT_CAL_OFFSET                0x23
+#define PMBUS_VOUT_MAX                       0x24
+#define PMBUS_VOUT_MARGIN_HIGH               0x25
+#define PMBUS_VOUT_MARGIN_LOW                0x26
+#define PMBUS_VOUT_TRANSITION_RATE   0x27
+#define PMBUS_VOUT_DROOP             0x28
+#define PMBUS_VOUT_SCALE_LOOP                0x29
+#define PMBUS_VOUT_SCALE_MONITOR     0x2A
+
+#define PMBUS_COEFFICIENTS           0x30
+#define PMBUS_POUT_MAX                       0x31
+
+#define PMBUS_FAN_CONFIG_12          0x3A
+#define PMBUS_FAN_COMMAND_1          0x3B
+#define PMBUS_FAN_COMMAND_2          0x3C
+#define PMBUS_FAN_CONFIG_34          0x3D
+#define PMBUS_FAN_COMMAND_3          0x3E
+#define PMBUS_FAN_COMMAND_4          0x3F
+
+#define PMBUS_VOUT_OV_FAULT_LIMIT    0x40
+#define PMBUS_VOUT_OV_FAULT_RESPONSE 0x41
+#define PMBUS_VOUT_OV_WARN_LIMIT     0x42
+#define PMBUS_VOUT_UV_WARN_LIMIT     0x43
+#define PMBUS_VOUT_UV_FAULT_LIMIT    0x44
+#define PMBUS_VOUT_UV_FAULT_RESPONSE 0x45
+#define PMBUS_IOUT_OC_FAULT_LIMIT    0x46
+#define PMBUS_IOUT_OC_FAULT_RESPONSE 0x47
+#define PMBUS_IOUT_OC_LV_FAULT_LIMIT 0x48
+#define PMBUS_IOUT_OC_LV_FAULT_RESPONSE      0x49
+#define PMBUS_IOUT_OC_WARN_LIMIT     0x4A
+#define PMBUS_IOUT_UC_FAULT_LIMIT    0x4B
+#define PMBUS_IOUT_UC_FAULT_RESPONSE 0x4C
+
+#define PMBUS_OT_FAULT_LIMIT         0x4F
+#define PMBUS_OT_FAULT_RESPONSE              0x50
+#define PMBUS_OT_WARN_LIMIT          0x51
+#define PMBUS_UT_WARN_LIMIT          0x52
+#define PMBUS_UT_FAULT_LIMIT         0x53
+#define PMBUS_UT_FAULT_RESPONSE              0x54
+#define PMBUS_VIN_OV_FAULT_LIMIT     0x55
+#define PMBUS_VIN_OV_FAULT_RESPONSE  0x56
+#define PMBUS_VIN_OV_WARN_LIMIT              0x57
+#define PMBUS_VIN_UV_WARN_LIMIT              0x58
+#define PMBUS_VIN_UV_FAULT_LIMIT     0x59
+
+#define PMBUS_IIN_OC_FAULT_LIMIT     0x5B
+#define PMBUS_IIN_OC_WARN_LIMIT              0x5D
+
+#define PMBUS_POUT_OP_FAULT_LIMIT    0x68
+#define PMBUS_POUT_OP_WARN_LIMIT     0x6A
+#define PMBUS_PIN_OP_WARN_LIMIT              0x6B
+
+#define PMBUS_STATUS_BYTE            0x78
+#define PMBUS_STATUS_WORD            0x79
+#define PMBUS_STATUS_VOUT            0x7A
+#define PMBUS_STATUS_IOUT            0x7B
+#define PMBUS_STATUS_INPUT           0x7C
+#define PMBUS_STATUS_TEMPERATURE     0x7D
+#define PMBUS_STATUS_CML             0x7E
+#define PMBUS_STATUS_OTHER           0x7F
+#define PMBUS_STATUS_MFR_SPECIFIC    0x80
+#define PMBUS_STATUS_FAN_12          0x81
+#define PMBUS_STATUS_FAN_34          0x82
+
+#define PMBUS_READ_VIN                       0x88
+#define PMBUS_READ_IIN                       0x89
+#define PMBUS_READ_VCAP                      0x8A
+#define PMBUS_READ_VOUT                      0x8B
+#define PMBUS_READ_IOUT                      0x8C
+#define PMBUS_READ_TEMPERATURE_1     0x8D
+#define PMBUS_READ_TEMPERATURE_2     0x8E
+#define PMBUS_READ_TEMPERATURE_3     0x8F
+#define PMBUS_READ_FAN_SPEED_1               0x90
+#define PMBUS_READ_FAN_SPEED_2               0x91
+#define PMBUS_READ_FAN_SPEED_3               0x92
+#define PMBUS_READ_FAN_SPEED_4               0x93
+#define PMBUS_READ_DUTY_CYCLE                0x94
+#define PMBUS_READ_FREQUENCY         0x95
+#define PMBUS_READ_POUT                      0x96
+#define PMBUS_READ_PIN                       0x97
+
+#define PMBUS_REVISION                       0x98
+#define PMBUS_MFR_ID                 0x99
+#define PMBUS_MFR_MODEL                      0x9A
+#define PMBUS_MFR_REVISION           0x9B
+#define PMBUS_MFR_LOCATION           0x9C
+#define PMBUS_MFR_DATE                       0x9D
+#define PMBUS_MFR_SERIAL             0x9E
+
+/*
+ * CAPABILITY
+ */
+#define PB_CAPABILITY_SMBALERT               (1<<4)
+#define PB_CAPABILITY_ERROR_CHECK    (1<<7)
+
+/*
+ * VOUT_MODE
+ */
+#define PB_VOUT_MODE_MODE_MASK               0xe0
+#define PB_VOUT_MODE_PARAM_MASK              0x1f
+
+#define PB_VOUT_MODE_LINEAR          0x00
+#define PB_VOUT_MODE_VID             0x20
+#define PB_VOUT_MODE_DIRECT          0x40
+
+/*
+ * Fan configuration
+ */
+#define PB_FAN_2_PULSE_MASK          ((1 << 0) | (1 << 1))
+#define PB_FAN_2_RPM                 (1 << 2)
+#define PB_FAN_2_INSTALLED           (1 << 3)
+#define PB_FAN_1_PULSE_MASK          ((1 << 4) | (1 << 5))
+#define PB_FAN_1_RPM                 (1 << 6)
+#define PB_FAN_1_INSTALLED           (1 << 7)
+
+/*
+ * STATUS_BYTE, STATUS_WORD (lower)
+ */
+#define PB_STATUS_NONE_ABOVE         (1<<0)
+#define PB_STATUS_CML                        (1<<1)
+#define PB_STATUS_TEMPERATURE                (1<<2)
+#define PB_STATUS_VIN_UV             (1<<3)
+#define PB_STATUS_IOUT_OC            (1<<4)
+#define PB_STATUS_VOUT_OV            (1<<5)
+#define PB_STATUS_OFF                        (1<<6)
+#define PB_STATUS_BUSY                       (1<<7)
+
+/*
+ * STATUS_WORD (upper)
+ */
+#define PB_STATUS_UNKNOWN            (1<<8)
+#define PB_STATUS_OTHER                      (1<<9)
+#define PB_STATUS_FANS                       (1<<10)
+#define PB_STATUS_POWER_GOOD_N               (1<<11)
+#define PB_STATUS_WORD_MFR           (1<<12)
+#define PB_STATUS_INPUT                      (1<<13)
+#define PB_STATUS_IOUT_POUT          (1<<14)
+#define PB_STATUS_VOUT                       (1<<15)
+
+/*
+ * STATUS_IOUT
+ */
+#define PB_POUT_OP_WARNING           (1<<0)
+#define PB_POUT_OP_FAULT             (1<<1)
+#define PB_POWER_LIMITING            (1<<2)
+#define PB_CURRENT_SHARE_FAULT               (1<<3)
+#define PB_IOUT_UC_FAULT             (1<<4)
+#define PB_IOUT_OC_WARNING           (1<<5)
+#define PB_IOUT_OC_LV_FAULT          (1<<6)
+#define PB_IOUT_OC_FAULT             (1<<7)
+
+/*
+ * STATUS_VOUT, STATUS_INPUT
+ */
+#define PB_VOLTAGE_UV_FAULT          (1<<4)
+#define PB_VOLTAGE_UV_WARNING                (1<<5)
+#define PB_VOLTAGE_OV_WARNING                (1<<6)
+#define PB_VOLTAGE_OV_FAULT          (1<<7)
+
+/*
+ * STATUS_INPUT
+ */
+#define PB_PIN_OP_WARNING            (1<<0)
+#define PB_IIN_OC_WARNING            (1<<1)
+#define PB_IIN_OC_FAULT                      (1<<2)
+
+/*
+ * STATUS_TEMPERATURE
+ */
+#define PB_TEMP_UT_FAULT             (1<<4)
+#define PB_TEMP_UT_WARNING           (1<<5)
+#define PB_TEMP_OT_WARNING           (1<<6)
+#define PB_TEMP_OT_FAULT             (1<<7)
+
+/*
+ * STATUS_FAN
+ */
+#define PB_FAN_AIRFLOW_WARNING               (1<<0)
+#define PB_FAN_AIRFLOW_FAULT         (1<<1)
+#define PB_FAN_FAN2_SPEED_OVERRIDE   (1<<2)
+#define PB_FAN_FAN1_SPEED_OVERRIDE   (1<<3)
+#define PB_FAN_FAN2_WARNING          (1<<4)
+#define PB_FAN_FAN1_WARNING          (1<<5)
+#define PB_FAN_FAN2_FAULT            (1<<6)
+#define PB_FAN_FAN1_FAULT            (1<<7)
+
+/*
+ * CML_FAULT_STATUS
+ */
+#define PB_CML_FAULT_OTHER_MEM_LOGIC (1<<0)
+#define PB_CML_FAULT_OTHER_COMM              (1<<1)
+#define PB_CML_FAULT_PROCESSOR               (1<<3)
+#define PB_CML_FAULT_MEMORY          (1<<4)
+#define PB_CML_FAULT_PACKET_ERROR    (1<<5)
+#define PB_CML_FAULT_INVALID_DATA    (1<<6)
+#define PB_CML_FAULT_INVALID_COMMAND (1<<7)
+
+enum pmbus_sensor_classes {
+     PSC_VOLTAGE_IN = 0,
+     PSC_VOLTAGE_OUT,
+     PSC_CURRENT_IN,
+     PSC_CURRENT_OUT,
+     PSC_POWER,
+     PSC_TEMPERATURE,
+     PSC_FAN,
+     PSC_NUM_CLASSES         /* Number of power sensor classes */
+};
+
+#define PMBUS_PAGES  32      /* Per PMBus specification */
+
+/* Functionality bit mask */
+#define PMBUS_HAVE_VIN               (1 << 0)
+#define PMBUS_HAVE_VCAP              (1 << 1)
+#define PMBUS_HAVE_VOUT              (1 << 2)
+#define PMBUS_HAVE_IIN               (1 << 3)
+#define PMBUS_HAVE_IOUT              (1 << 4)
+#define PMBUS_HAVE_PIN               (1 << 5)
+#define PMBUS_HAVE_POUT              (1 << 6)
+#define PMBUS_HAVE_FAN12     (1 << 7)
+#define PMBUS_HAVE_FAN34     (1 << 8)
+#define PMBUS_HAVE_TEMP              (1 << 9)
+#define PMBUS_HAVE_TEMP2     (1 << 10)
+#define PMBUS_HAVE_TEMP3     (1 << 11)
+#define PMBUS_HAVE_STATUS_VOUT       (1 << 12)
+#define PMBUS_HAVE_STATUS_IOUT       (1 << 13)
+#define PMBUS_HAVE_STATUS_INPUT      (1 << 14)
+#define PMBUS_HAVE_STATUS_TEMP       (1 << 15)
+#define PMBUS_HAVE_STATUS_FAN12      (1 << 16)
+#define PMBUS_HAVE_STATUS_FAN34      (1 << 17)
+
+struct pmbus_driver_info {
+     int pages;              /* Total number of pages */
+     bool direct[PSC_NUM_CLASSES];
+                             /* true if device uses direct data format
+                                for the given sensor class */
+     /*
+      * Support one set of coefficients for each sensor type
+      * Used for chips providing data in direct mode.
+      */
+     int m[PSC_NUM_CLASSES]; /* mantissa for direct data format */
+     int b[PSC_NUM_CLASSES]; /* offset */
+     int R[PSC_NUM_CLASSES]; /* exponent */
+
+     u32 func[PMBUS_PAGES];  /* Functionality, per page */
+     /*
+      * The get_status function maps manufacturing specific status values
+      * into PMBus standard status values.
+      */
+     int (*get_status)(struct i2c_client *client, int page, int reg);
+     /*
+      * The identify function determines supported PMBus functionality.
+      */
+     int (*identify)(struct i2c_client *client,
+                     struct pmbus_driver_info *info);
+};
Quoted 9 lines

drivers/hwmon/pmbus.h line 299

Quoted 6 lines
drivers/hwmon/pmbus.h new file +6 -0
+
+/* Function declarations */
+
+int pmbus_set_page(struct i2c_client *client, u8 page);
+int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg);
+int pmbus_read_byte_data(struct i2c_client *client, u8 page, u8 reg);

I suppose this makes sense for completeness. But I don't think you currently use read_byte_data in any of the drivers so it needn't be here..

Yes, it is just for completeness.

Quoted 265 lines
Quoted 265 lines
drivers/hwmon/pmbus.h new file +8 -0
+void pmbus_clear_faults(struct i2c_client *client);
+bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg);
+bool pmbus_check_word_register(struct i2c_client *client, int page, int reg);
+int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
+                struct pmbus_driver_info *info);
+int pmbus_do_remove(struct i2c_client *client);
+
+#endif /* PB_H */
drivers/hwmon/pmbus_core.c new file +251 -0
new file mode 100644
index 0000000..fe18722
@@ -0,0 +1,1611 @@
+/*
+ * Hardware monitoring driver for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/delay.h>
+#include <linux/i2c/pmbus.h>
+#include "pmbus.h"
+
+/*
+ * Constants needed to determine number of sensors, booleans, and labels.
+ */
+#define PMBUS_MAX_INPUT_SENSORS              11      /* 6*volt, 3*curr, 2*power */
+#define PMBUS_VOUT_SENSORS_PER_PAGE  5       /* input, min, max, lcrit,
+                                                crit */
+#define PMBUS_IOUT_SENSORS_PER_PAGE  4       /* input, min, max, crit */
+#define PMBUS_POUT_SENSORS_PER_PAGE  4       /* input, cap, max, crit */
+#define PMBUS_MAX_SENSORS_PER_FAN    1       /* input */
+#define PMBUS_MAX_SENSORS_PER_TEMP   5       /* input, min, max, lcrit,
+                                                crit */
+
+#define PMBUS_MAX_INPUT_BOOLEANS     7       /* v: min_alarm, max_alarm,
+                                                lcrit_alarm, crit_alarm;
+                                                c: alarm, crit_alarm;
+                                                p: crit_alarm */
+#define PMBUS_VOUT_BOOLEANS_PER_PAGE 4       /* min_alarm, max_alarm,
+                                                lcrit_alarm, crit_alarm */
+#define PMBUS_IOUT_BOOLEANS_PER_PAGE 3       /* alarm, lcrit_alarm,
+                                                crit_alarm */
+#define PMBUS_POUT_BOOLEANS_PER_PAGE 2       /* alarm, crit_alarm */
+#define PMBUS_MAX_BOOLEANS_PER_FAN   2       /* alarm, fault */
+#define PMBUS_MAX_BOOLEANS_PER_TEMP  4       /* min_alarm, max_alarm,
+                                                lcrit_alarm, crit_alarm */
+
+#define PMBUS_MAX_INPUT_LABELS               4       /* vin, vcap, iin, pin */
+
+/*
+ * status, status_vout, status_iout, status_fans, and status_temp
+ * are paged. status_input and status_fan34 are unpaged.
+ * status_fan34 is a special case to handle a second set of fans
+ * on page 0.
+ */
+#define PB_NUM_STATUS_REG    (PMBUS_PAGES * 5 + 2)
+
+/*
+ * Index into status register array, per status register group
+ */
+#define PB_STATUS_BASE               0
+#define PB_STATUS_VOUT_BASE  (PB_STATUS_BASE + PMBUS_PAGES)
+#define PB_STATUS_IOUT_BASE  (PB_STATUS_VOUT_BASE + PMBUS_PAGES)
+#define PB_STATUS_FAN_BASE   (PB_STATUS_IOUT_BASE + PMBUS_PAGES)
+#define PB_STATUS_FAN34_BASE (PB_STATUS_FAN_BASE + PMBUS_PAGES)
+#define PB_STATUS_INPUT_BASE (PB_STATUS_FAN34_BASE + 1)
+#define PB_STATUS_TEMP_BASE  (PB_STATUS_INPUT_BASE + 1)
+
+struct pmbus_sensor {
+     char name[I2C_NAME_SIZE];       /* sysfs sensor name */
+     struct sensor_device_attribute attribute;
+     u8 page;                /* page number */
+     u8 reg;                 /* register */
+     enum pmbus_sensor_classes class;        /* sensor class */
+     bool update;            /* runtime sensor update needed */
+     int data;               /* Sensor data.
+                                Negative if there was a read error */
+};
+
+struct pmbus_boolean {
+     char name[I2C_NAME_SIZE];       /* sysfs boolean name */
+     struct sensor_device_attribute attribute;
+};
+
+struct pmbus_label {
+     char name[I2C_NAME_SIZE];       /* sysfs label name */
+     struct sensor_device_attribute attribute;
+     char label[I2C_NAME_SIZE];      /* label */
+};
+
+struct pmbus_data {
+     struct device *hwmon_dev;
+
+     u32 flags;              /* from platform data */
+
+     int exponent;           /* linear mode: exponent for output voltages */
+
+     const struct pmbus_driver_info *info;
+
+     int max_attributes;
+     int num_attributes;
+     struct attribute **attributes;
+     struct attribute_group group;
+
+     /*
+      * Sensors cover both sensor and limit registers.
+      */
+     int max_sensors;
+     int num_sensors;
+     struct pmbus_sensor *sensors;
+     /*
+      * Booleans are used for alarms.
+      * Values are determined from status registers.
+      */
+     int max_booleans;
+     int num_booleans;
+     struct pmbus_boolean *booleans;
+     /*
+      * Labels are used to map generic names (e.g., "in1")
+      * to PMBus specific names (e.g., "vin" or "vout1").
+      */
+     int max_labels;
+     int num_labels;
+     struct pmbus_label *labels;
+
+     struct mutex update_lock;
+     bool valid;
+     unsigned long last_updated;     /* in jiffies */
+
+     /*
+      * A single status register covers multiple attributes,
+      * so we keep them all together.
+      */
+     u8 status_bits;
+     u8 status[PB_NUM_STATUS_REG];
+
+     u8 currpage;
+};
+
+int pmbus_set_page(struct i2c_client *client, u8 page)
+{
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     int rv = 0;
+     int newpage;
+
+     if (page != data->currpage) {
+             rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
+             newpage = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
+             if (newpage != page)
+                     rv = -EINVAL;
+             else
+                     data->currpage = page;
+     }
+     return rv;
+}
+EXPORT_SYMBOL_GPL(pmbus_set_page);
+
+static int pmbus_write_byte(struct i2c_client *client, u8 page, u8 value)
+{
+     int rv;
+
+     rv = pmbus_set_page(client, page);
+     if (rv < 0)
+             return rv;
+
+     return i2c_smbus_write_byte(client, value);
+}
+
+static int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg,
+                              u16 word)
+{
+     int rv;
+
+     rv = pmbus_set_page(client, page);
+     if (rv < 0)
+             return rv;
+
+     return i2c_smbus_write_word_data(client, reg, word);
+}
+
+int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg)
+{
+     int rv;
+
+     rv = pmbus_set_page(client, page);
+     if (rv < 0)
+             return rv;
+
+     return i2c_smbus_read_word_data(client, reg);
+}
+EXPORT_SYMBOL_GPL(pmbus_read_word_data);
+
+int pmbus_read_byte_data(struct i2c_client *client, u8 page, u8 reg)
+{
+     int rv;
+
+     rv = pmbus_set_page(client, page);
+     if (rv < 0)
+             return rv;
+
+     return i2c_smbus_read_byte_data(client, reg);
+}
+EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
+
+void pmbus_clear_faults(struct i2c_client *client)
+{
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     int i;
+
+     for (i = 0; i < data->info->pages; i++)
+             pmbus_write_byte(client, i, PMBUS_CLEAR_FAULTS);
+}
+EXPORT_SYMBOL_GPL(pmbus_clear_faults);
+
+bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
+{
+     int rv, status;
+     struct pmbus_data *data = i2c_get_clientdata(client);
+
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
+     rv = pmbus_read_byte_data(client, page, reg);
+     if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) {
+             status = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
+             if (status < 0 || (status & PB_STATUS_CML)) {
+                     int status2 = pmbus_read_byte_data(client, page,
+                                                        PMBUS_STATUS_CML);
+                     if (status2 < 0
+                         || (status2 & PB_CML_FAULT_INVALID_COMMAND)) {
+                             dev_dbg(&client->dev,
+                                     "page %d reg 0x%x status 0x%x-0x%x\n",
+                                     page, reg, status, status2);
+                             rv = -EINVAL;
+                     }
+             }
+     }
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
+     return rv >= 0;
+}
+EXPORT_SYMBOL_GPL(pmbus_check_byte_register);
+
+bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
Quoted 8 lines

drivers/hwmon/pmbus_core.c line 230

Quoted 5 lines
drivers/hwmon/pmbus_core.c new file +5 -0
+{
+     int rv, status;
+     struct pmbus_data *data = i2c_get_clientdata(client);
+
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);

If there have been faults, do we not want to have handled them? That is, should there be any circumstance under which we would want to clear one here?x

That is one place where it is really needed. Status codes are sticky, so if "PB_CML_FAULT_INVALID_COMMAND" was set for whatever reason, it would be reported below even if the following access is ok.

Quoted 4 lines

drivers/hwmon/pmbus_core.c line 257

Quoted 1 line
drivers/hwmon/pmbus_core.c new file +1 -0
+     rv = pmbus_read_word_data(client, page, reg);

I think this is idenical to the check code in the previous function. Worth pulling out to a utility function used by both?

Yes, excellent idea.

Quoted 7 lines
Quoted 7 lines
drivers/hwmon/pmbus_core.c new file +7 -0
+     if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) {
+             status = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
+             if (status < 0 || (status & PB_STATUS_CML)) {
+                     int status2 = pmbus_read_byte_data(client, page,
+                                                        PMBUS_STATUS_CML);
+                     if (status2 < 0
+                         || (status2 & PB_CML_FAULT_INVALID_COMMAND)) {
Quoted 8 lines

drivers/hwmon/pmbus_core.c line 246

Quoted 8 lines
drivers/hwmon/pmbus_core.c new file +8 -0
+                             dev_dbg(&client->dev,
+                                     "page %d reg 0x%x status 0x%x-0x%x\n",
+                                     page, reg, status, status2);
+                             rv = -EINVAL;
+                     }
+             }
+     }
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);

This one isn't strictly needed, though, so I removed it.

Quoted 315 lines
Quoted 315 lines
drivers/hwmon/pmbus_core.c new file +315 -0
+     return rv >= 0;
+}
+EXPORT_SYMBOL_GPL(pmbus_check_word_register);
+
+static int pmbus_get_status(struct i2c_client *client, int page, int reg)
+{
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     const struct pmbus_driver_info *info = data->info;
+     int status;
+
+     if (info->get_status) {
+             status = info->get_status(client, page, reg);
+             if (status != -ENODATA)
+                     return status;
+     }
+     return  pmbus_read_byte_data(client, page, reg);
+}
+
+static struct pmbus_data *pmbus_update_device(struct device *dev)
+{
+     struct i2c_client *client = to_i2c_client(dev);
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     const struct pmbus_driver_info *info = data->info;
+
+     mutex_lock(&data->update_lock);
+     if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
+             int i;
+
+             for (i = 0; i < info->pages; i++)
+                     data->status[PB_STATUS_BASE + i]
+                         = pmbus_read_byte_data(client, i,
+                                                PMBUS_STATUS_BYTE);
+             for (i = 0; i < info->pages; i++) {
+                     if (!(info->func[i] & PMBUS_HAVE_STATUS_VOUT))
+                             continue;
+                     data->status[PB_STATUS_VOUT_BASE + i]
+                       = pmbus_get_status(client, i, PMBUS_STATUS_VOUT);
+             }
+             for (i = 0; i < info->pages; i++) {
+                     if (!(info->func[i] & PMBUS_HAVE_STATUS_IOUT))
+                             continue;
+                     data->status[PB_STATUS_IOUT_BASE + i]
+                       = pmbus_get_status(client, i, PMBUS_STATUS_IOUT);
+             }
+             for (i = 0; i < info->pages; i++) {
+                     if (!(info->func[i] & PMBUS_HAVE_STATUS_TEMP))
+                             continue;
+                     data->status[PB_STATUS_TEMP_BASE + i]
+                       = pmbus_get_status(client, i,
+                                          PMBUS_STATUS_TEMPERATURE);
+             }
+             for (i = 0; i < info->pages; i++) {
+                     if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN12))
+                             continue;
+                     data->status[PB_STATUS_FAN_BASE + i]
+                       = pmbus_get_status(client, i, PMBUS_STATUS_FAN_12);
+             }
+
+             if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
+                     data->status[PB_STATUS_INPUT_BASE]
+                       = pmbus_get_status(client, 0, PMBUS_STATUS_INPUT);
+
+             if (info->func[0] & PMBUS_HAVE_STATUS_FAN34)
+                     data->status[PB_STATUS_FAN34_BASE]
+                       = pmbus_get_status(client, 0, PMBUS_STATUS_FAN_34);
+
+             for (i = 0; i < data->num_sensors; i++) {
+                     struct pmbus_sensor *sensor = &data->sensors[i];
+
+                     if (!data->valid || sensor->update)
+                             sensor->data
+                                 = pmbus_read_word_data(client, sensor->page,
+                                                        sensor->reg);
+             }
+             pmbus_clear_faults(client);
+             data->last_updated = jiffies;
+             data->valid = 1;
+     }
+     mutex_unlock(&data->update_lock);
+     return data;
+}
+
+/*
+ * Convert linear sensor values to milli- or micro-units
+ * depending on sensor type.
+ */
+static int pmbus_reg2data_linear(struct pmbus_data *data,
+                              struct pmbus_sensor *sensor)
+{
+     s16 exponent, mantissa;
+     long val;
+
+     if (sensor->class = PSC_VOLTAGE_OUT) {
+             exponent = data->exponent;
+             mantissa = (s16) sensor->data;
+     } else {
+             exponent = (sensor->data >> 11) & 0x001f;
+             mantissa = sensor->data & 0x07ff;
+
+             if (exponent > 0x0f)
+                     exponent |= 0xffe0;     /* sign extend exponent */
+             if (mantissa > 0x03ff)
+                     mantissa |= 0xf800;     /* sign extend mantissa */
+     }
+
+     val = mantissa;
+
+     /* scale result to milli-units for all sensors except fans */
+     if (sensor->class != PSC_FAN)
+             val = val * 1000L;
+
+     /* scale result to micro-units for power sensors */
+     if (sensor->class = PSC_POWER)
+             val = val * 1000L;
+
+     if (exponent >= 0)
+             val <<= exponent;
+     else
+             val >>= -exponent;
+
+     return (int)val;
+}
+
+/*
+ * Convert direct sensor values to milli- or micro-units
+ * depending on sensor type.
+ */
+static int pmbus_reg2data_direct(struct pmbus_data *data,
+                              struct pmbus_sensor *sensor)
+{
+     long val = (s16) sensor->data;
+     long m, b, R;
+
+     m = data->info->m[sensor->class];
+     b = data->info->b[sensor->class];
+     R = data->info->R[sensor->class];
+
+     if (m = 0)
+             return 0;
+
+     /* X = 1/m * (Y * 10^-R - b) */
+     R = -R;
+     /* scale result to milli-units for everything but fans */
+     if (sensor->class != PSC_FAN) {
+             R += 3;
+             b *= 1000;
+     }
+
+     /* scale result to micro-units for power sensors */
+     if (sensor->class = PSC_POWER) {
+             R += 3;
+             b *= 1000;
+     }
+
+     while (R > 0) {
+             val *= 10;
+             R--;
+     }
+     while (R < 0) {
+             val = DIV_ROUND_CLOSEST(val, 10);
+             R++;
+     }
+
+     return (int)((val - b) / m);
+}
+
+static int pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
+{
+     int val;
+
+     if (data->info->direct[sensor->class])
+             val = pmbus_reg2data_direct(data, sensor);
+     else
+             val = pmbus_reg2data_linear(data, sensor);
+
+     return val;
+}
+
+#define MAX_MANTISSA (1023 * 1000)
+#define MIN_MANTISSA (511 * 1000)
+
+static u16 pmbus_data2reg_linear(struct pmbus_data *data,
+                              enum pmbus_sensor_classes class, long val)
+{
+     s16 exponent = 0, mantissa = 0;
+     bool negative = false;
+
+     /* simple case */
+     if (val = 0)
+             return 0;
+
+     if (val < 0) {
+             negative = true;
+             val = -val;
+     }
+
+     if (class = PSC_VOLTAGE_OUT) {
+             /*
+              * For a static exponents, we don't have a choice
+              * but to adjust the value to it.
+              */
+             if (data->exponent < 0)
+                     val <<= -data->exponent;
+             else
+                     val >>= data->exponent;
+             val = DIV_ROUND_CLOSEST(val, 1000);
+             if (val > 0x7fff)
+                     val = 0x7fff;
+             return negative ? -val : val;
+     }
+
+     /* Power is in uW. Convert to mW before converting. */
+     if (class = PSC_POWER)
+             val = DIV_ROUND_CLOSEST(val, 1000L);
+
+     /*
+      * For simplicity, convert fan data to milli-units
+      * before calculating the exponent.
+      */
+     if (class = PSC_FAN)
+             val = val * 1000;
+
+     /* Reduce large mantissa until it fits into 10 bit */
+     while (val >= MAX_MANTISSA && exponent < 15) {
+             exponent++;
+             val >>= 1;
+     }
+     /* Increase small mantissa to improve precision */
+     while (val < MIN_MANTISSA && exponent > -15) {
+             exponent--;
+             val <<= 1;
+     }
+
+     /* Convert mantissa from milli-units to units */
+     mantissa = DIV_ROUND_CLOSEST(val, 1000);
+
+     /* Ensure that resulting number is within range */
+     if (mantissa > 0x3ff)
+             mantissa = 0x3ff;
+
+     /* restore sign */
+     if (negative)
+             mantissa = -mantissa;
+
+     /* Convert to 5 bit exponent, 11 bit mantissa */
+     return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
+}
+
+static u16 pmbus_data2reg_direct(struct pmbus_data *data,
+                              enum pmbus_sensor_classes class, long val)
+{
+     long m, b, R;
+
+     m = data->info->m[class];
+     b = data->info->b[class];
+     R = data->info->R[class];
+
+     /* Power is in uW. Adjust R and b. */
+     if (class = PSC_POWER) {
+             R -= 3;
+             b *= 1000;
+     }
+
+     /* Calculate Y = (m * X + b) * 10^R */
+     if (class != PSC_FAN) {
+             R -= 3;         /* Adjust R and b for data in milli-units */
+             b *= 1000;
+     }
+     val = val * m + b;
+
+     while (R > 0) {
+             val *= 10;
+             R--;
+     }
+     while (R < 0) {
+             val = DIV_ROUND_CLOSEST(val, 10);
+             R++;
+     }
+
+     return val;
+}
+
+static u16 pmbus_data2reg(struct pmbus_data *data,
+                       enum pmbus_sensor_classes class, long val)
+{
+     u16 regval;
+
+     if (data->info->direct[class])
+             regval = pmbus_data2reg_direct(data, class, val);
+     else
+             regval = pmbus_data2reg_linear(data, class, val);
+
+     return regval;
+}
+
+/*
+ * Return boolean calculated from converted data.
+ * <index> defines a status register index and mask, and optionally
+ * two sensor indexes.
+ * The upper half-word references the two sensors,
+ * the lower half word references status register and mask.
+ * The function returns true if (status[reg] & mask) is true and,
+ * if specified, if v1 >= v2.
+ * To determine if an object exceeds upper limits, specify <v, limit>.
+ * To determine if an object exceeds lower limits, specify <limit, v>.
+ */
+static int pmbus_get_boolean(struct pmbus_data *data, int index, int *val)
+{
+     u8 s1 = (index >> 24) & 0xff;
+     u8 s2 = (index >> 16) & 0xff;
+     u8 reg = (index >> 8) & 0xff;
+     u8 mask = index & 0xff;
+     int status;
+     u8 regval;
+
Quoted 8 lines

drivers/hwmon/pmbus_core.c line 592

Quoted 5 lines
drivers/hwmon/pmbus_core.c new file +5 -0
+     status = data->status[reg];
+     if (status < 0)
+             return status;
+
+     regval = status & mask;

This test could do with a simple explanatory comment (which is another way of saying I'm not quite clear why this makes sense!)

You mean the following test ? If both s1 and s2 are 0, the function returns the result of (status & mask). This is for all booleans which are created with pmbus_add_boolean_reg().

Otherwise, the result is determined by comparison as described above.

I'll add additional comments to describe this in more detail.

Quoted 105 lines
Quoted 105 lines
drivers/hwmon/pmbus_core.c new file +105 -0
+     if (!s1 && !s2)
+             *val = !!regval;
+     else {
+             int v1, v2;
+             struct pmbus_sensor *sensor1, *sensor2;
+
+             sensor1 = &data->sensors[s1];
+             if (sensor1->data < 0)
+                     return sensor1->data;
+             sensor2 = &data->sensors[s2];
+             if (sensor2->data < 0)
+                     return sensor2->data;
+
+             v1 = pmbus_reg2data(data, sensor1);
+             v2 = pmbus_reg2data(data, sensor2);
+             *val = !!(regval && v1 >= v2);
+     }
+     return 0;
+}
+
+static ssize_t pmbus_show_boolean(struct device *dev,
+                               struct device_attribute *da, char *buf)
+{
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+     struct pmbus_data *data = pmbus_update_device(dev);
+     int val;
+     int err;
+
+     err = pmbus_get_boolean(data, attr->index, &val);
+     if (err)
+             return err;
+     return snprintf(buf, PAGE_SIZE, "%d\n", val);
+}
+
+static ssize_t pmbus_show_sensor(struct device *dev,
+                              struct device_attribute *da, char *buf)
+{
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+     struct pmbus_data *data = pmbus_update_device(dev);
+     struct pmbus_sensor *sensor;
+
+     sensor = &data->sensors[attr->index];
+     if (sensor->data < 0)
+             return sensor->data;
+
+     return snprintf(buf, PAGE_SIZE, "%d\n", pmbus_reg2data(data, sensor));
+}
+
+static ssize_t pmbus_set_sensor(struct device *dev,
+                             struct device_attribute *devattr,
+                             const char *buf, size_t count)
+{
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+     struct i2c_client *client = to_i2c_client(dev);
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     struct pmbus_sensor *sensor = &data->sensors[attr->index];
+     ssize_t rv = count;
+     long val = 0;
+     int ret;
+     u16 regval;
+
+     if (strict_strtol(buf, 10, &val) < 0)
+             return -EINVAL;
+
+     mutex_lock(&data->update_lock);
+     regval = pmbus_data2reg(data, sensor->class, val);
+     ret = pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
+     if (ret < 0)
+             rv = ret;
+     else
+             data->sensors[attr->index].data = regval;
+     mutex_unlock(&data->update_lock);
+     return rv;
+}
+
+static ssize_t pmbus_show_label(struct device *dev,
+                             struct device_attribute *da, char *buf)
+{
+     struct i2c_client *client = to_i2c_client(dev);
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+
+     return snprintf(buf, PAGE_SIZE, "%s\n",
+                     data->labels[attr->index].label);
+}
+
+#define PMBUS_ADD_ATTR(data, _name, _idx, _mode, _type, _show, _set) \
+do {                                                                 \
+     struct sensor_device_attribute *a                               \
+         = &data->_type##s[data->num_##_type##s].attribute;          \
+     BUG_ON(data->num_attributes >= data->max_attributes);           \
+     a->dev_attr.attr.name = _name;                                  \
+     a->dev_attr.attr.mode = _mode;                                  \
+     a->dev_attr.show = _show;                                       \
+     a->dev_attr.store = _set;                                       \
+     a->index = _idx;                                                \
+     data->attributes[data->num_attributes] = &a->dev_attr.attr;     \
+     data->num_attributes++;                                         \
+} while (0)
+
+#define PMBUS_ADD_GET_ATTR(data, _name, _type, _idx)                 \
+     PMBUS_ADD_ATTR(data, _name, _idx, S_IRUGO, _type,               \
+                    pmbus_show_##_type,  NULL)
+
+#define PMBUS_ADD_SET_ATTR(data, _name, _type, _idx)                 \
Quoted 8 lines

drivers/hwmon/pmbus_core.c line 702

Quoted 5 lines
drivers/hwmon/pmbus_core.c new file +5 -0
+     PMBUS_ADD_ATTR(data, _name, _idx, S_IWUSR | S_IRUGO, _type,     \
+                    pmbus_show_##_type, pmbus_set_##_type)
+
+static void pmbus_add_boolean(struct pmbus_data *data,
+                           const char *name, const char *type, int seq,

Is val the best name for the next variable? It isn't obvious to me what value this is... Gets pushed into an index by the PMBUS_ADD_GET_ATTR macro... Perhaps keep the idx naming?

Not sure myself. val is composed of up to four individual parameters. I'll name it idx.

Quoted 67 lines
Quoted 67 lines
drivers/hwmon/pmbus_core.c new file +67 -0
+                           int val)
+{
+     struct pmbus_boolean *boolean;
+
+     BUG_ON(data->num_booleans >= data->max_booleans);
+
+     boolean = &data->booleans[data->num_booleans];
+
+     snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
+              name, seq, type);
+     PMBUS_ADD_GET_ATTR(data, boolean->name, boolean, val);
+     data->num_booleans++;
+}
+
+static void pmbus_add_boolean_reg(struct pmbus_data *data,
+                               const char *name, const char *type,
+                               int seq, int reg, int bit)
+{
+     pmbus_add_boolean(data, name, type, seq, (reg << 8) | bit);
+}
+
+static void pmbus_add_boolean_cmp(struct pmbus_data *data,
+                               const char *name, const char *type,
+                               int seq, int i1, int i2, int reg, int mask)
+{
+     pmbus_add_boolean(data, name, type, seq,
+                       (i1 << 24) | (i2 << 16) | (reg << 8) | mask);
+}
+
+static void pmbus_add_sensor(struct pmbus_data *data,
+                          const char *name, const char *type, int seq,
+                          int page, int reg, enum pmbus_sensor_classes class,
+                          bool update)
+{
+     struct pmbus_sensor *sensor;
+
+     BUG_ON(data->num_sensors >= data->max_sensors);
+
+     sensor = &data->sensors[data->num_sensors];
+     snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
+              name, seq, type);
+     sensor->page = page;
+     sensor->reg = reg;
+     sensor->class = class;
+     sensor->update = update;
+     if (update)
+             PMBUS_ADD_GET_ATTR(data, sensor->name, sensor,
+                                data->num_sensors);
+     else
+             PMBUS_ADD_SET_ATTR(data, sensor->name, sensor,
+                                data->num_sensors);
+     data->num_sensors++;
+}
+
+static void pmbus_add_label(struct pmbus_data *data,
+                         const char *name, int seq,
+                         const char *lstring, int index)
+{
+     struct pmbus_label *label;
+
+     BUG_ON(data->num_labels >= data->max_labels);
+
+     label = &data->labels[data->num_labels];
+     snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
+     if (!index)
+             strncpy(label->label, lstring, sizeof(label->label) - 1);
+     else
Quoted 8 lines

drivers/hwmon/pmbus_core.c line 776

Quoted 7 lines
drivers/hwmon/pmbus_core.c new file +7 -0
+             snprintf(label->label, sizeof(label->label), "%s%d", lstring,
+                      index);
+
+     PMBUS_ADD_GET_ATTR(data, label->name, label, data->num_labels);
+     data->num_labels++;
+}
+

const?

yes

Quoted 122 lines
Quoted 96 lines
drivers/hwmon/pmbus_core.c new file +96 -0
+static int pmbus_temp_registers[] = {
+     PMBUS_READ_TEMPERATURE_1,
+     PMBUS_READ_TEMPERATURE_2,
+     PMBUS_READ_TEMPERATURE_3
+};
+
+static int pmbus_fan_registers[] = {
+     PMBUS_READ_FAN_SPEED_1,
+     PMBUS_READ_FAN_SPEED_2,
+     PMBUS_READ_FAN_SPEED_3,
+     PMBUS_READ_FAN_SPEED_4
+};
+
+static int pmbus_fan_config_registers[] = {
+     PMBUS_FAN_CONFIG_12,
+     PMBUS_FAN_CONFIG_12,
+     PMBUS_FAN_CONFIG_34,
+     PMBUS_FAN_CONFIG_34
+};
+
+static int pmbus_fan_status_registers[] = {
+     PMBUS_STATUS_FAN_12,
+     PMBUS_STATUS_FAN_12,
+     PMBUS_STATUS_FAN_34,
+     PMBUS_STATUS_FAN_34
+};
+
+/*
+ * Determine maximum number of sensors, booleans, and labels.
+ * To keep things simple, only make a rough high estimate.
+ */
+static void pmbus_find_max_attr(struct i2c_client *client,
+                             struct pmbus_data *data)
+{
+     const struct pmbus_driver_info *info = data->info;
+     int page, max_sensors, max_booleans, max_labels;
+
+     max_sensors = PMBUS_MAX_INPUT_SENSORS;
+     max_booleans = PMBUS_MAX_INPUT_BOOLEANS;
+     max_labels = PMBUS_MAX_INPUT_LABELS;
+
+     for (page = 0; page < info->pages; page++) {
+             if (info->func[page] & PMBUS_HAVE_VOUT) {
+                     max_sensors += PMBUS_VOUT_SENSORS_PER_PAGE;
+                     max_booleans += PMBUS_VOUT_BOOLEANS_PER_PAGE;
+                     max_labels++;
+             }
+             if (info->func[page] & PMBUS_HAVE_IOUT) {
+                     max_sensors += PMBUS_IOUT_SENSORS_PER_PAGE;
+                     max_booleans += PMBUS_IOUT_BOOLEANS_PER_PAGE;
+                     max_labels++;
+             }
+             if (info->func[page] & PMBUS_HAVE_POUT) {
+                     max_sensors += PMBUS_POUT_SENSORS_PER_PAGE;
+                     max_booleans += PMBUS_POUT_BOOLEANS_PER_PAGE;
+                     max_labels++;
+             }
+             if (info->func[page] & PMBUS_HAVE_FAN12) {
+                     if (page = 0) {
+                             max_sensors +> > +                                 ARRAY_SIZE(pmbus_fan_registers) *
+                                 PMBUS_MAX_SENSORS_PER_FAN;
+                             max_booleans +> > +                                 ARRAY_SIZE(pmbus_fan_registers) *
+                                 PMBUS_MAX_BOOLEANS_PER_FAN;
+                     } else {
+                             max_sensors += PMBUS_MAX_SENSORS_PER_FAN;
+                             max_booleans += PMBUS_MAX_BOOLEANS_PER_FAN;
+                     }
+             }
+             if (info->func[page] & PMBUS_HAVE_TEMP) {
+                     if (page = 0) {
+                             max_sensors +> > +                                 ARRAY_SIZE(pmbus_temp_registers) *
+                                 PMBUS_MAX_SENSORS_PER_TEMP;
+                             max_booleans +> > +                                 ARRAY_SIZE(pmbus_temp_registers) *
+                                 PMBUS_MAX_BOOLEANS_PER_TEMP;
+                     } else {
+                             max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
+                             max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
+                     }
+             }
+     }
+     data->max_sensors = max_sensors;
+     data->max_booleans = max_booleans;
+     data->max_labels = max_labels;
+     data->max_attributes = max_sensors + max_booleans + max_labels;
+}
+
+/*
+ * Search for attributes. Allocate sensors, booleans, and labels as needed.
+ */
+static void pmbus_find_attributes(struct i2c_client *client,
+                               struct pmbus_data *data)
+{
+     const struct pmbus_driver_info *info = data->info;
+     int page, i0, i1, in_index;
+
+     /*

drivers/hwmon/pmbus_core.c line 882

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+      * Input voltage sensors
+      */
+     in_index = 1;
+     if (info->func[0] & PMBUS_HAVE_VIN) {
+             bool have_alarm = false;
+
+             i0 = data->num_sensors;
+             pmbus_add_label(data, "in", in_index, "vin", 0);
+             pmbus_add_sensor(data, "in", "input", in_index,
+                              0, PMBUS_READ_VIN, PSC_VOLTAGE_IN, true);

This next lot do rather look like they could be done using an inline function or a macro...

Something like...
#define bob(LIM, NAME, POST, WHAT, TYPE)

if (pmbus_check_word_register(client, 0, LIM)) {
   i1 = data->num_sensors;
   pmbus_add_sensor(data, NAME, POST, in_index, 0, LIM, WHAT, false);
   if (info->func[0] & PMBUS_HAV_STATUS_INPUT) {
   pmbus_add_boolean_reg(data, NAME, POST##_alarm, in_index, PBU_STATUS_INPUT_BASE,
   TYPE);
   have_alarm = true;
}

}

Quoted 7 lines

bob(PMBUS_VIN_UV_WARN_LIMIT, "in", "min", PSC_VOLTAGE_IN, PB_VOLTAGE_UV_WARNING); bob(PMBUS_VIN_UV_FAULT_LIMIT, "in", "lcrit", PSC_VOLTAGE_IN, PB_VOLTAGE_UV_FAULT); bob(PMBUS_VIN_OV_WARN_LIMIT, "in", "max", PSC_VOLTAGE_IN, PB_VOLTAGE_OV_WARNING); etc.

basically I'm observing a lot of shared code in these... Still maybe this just acts to hide what is going on.

I think I would prefer to keep it as-is. I am not really a friend of function macros anymore.

It would be different if I can extract some of the code into functions, but right now I don't see how I could do that.

Quoted 564 lines
Quoted 77 lines
drivers/hwmon/pmbus_core.c new file +77 -0
+             if (pmbus_check_word_register(client, 0,
+                                           PMBUS_VIN_UV_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "min", in_index,
+                                      0, PMBUS_VIN_UV_WARN_LIMIT,
+                                      PSC_VOLTAGE_IN, false);
+                     if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+                             pmbus_add_boolean_reg(data, "in", "min_alarm",
+                                                   in_index,
+                                                   PB_STATUS_INPUT_BASE,
+                                                   PB_VOLTAGE_UV_WARNING);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, 0,
+                                           PMBUS_VIN_UV_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "lcrit", in_index,
+                                      0, PMBUS_VIN_UV_FAULT_LIMIT,
+                                      PSC_VOLTAGE_IN, false);
+                     if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+                             pmbus_add_boolean_reg(data, "in", "lcrit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_INPUT_BASE,
+                                                   PB_VOLTAGE_UV_FAULT);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, 0,
+                                           PMBUS_VIN_OV_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "max", in_index,
+                                      0, PMBUS_VIN_OV_WARN_LIMIT,
+                                      PSC_VOLTAGE_IN, false);
+                     if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+                             pmbus_add_boolean_reg(data, "in", "max_alarm",
+                                                   in_index,
+                                                   PB_STATUS_INPUT_BASE,
+                                                   PB_VOLTAGE_OV_WARNING);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, 0,
+                                           PMBUS_VIN_OV_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "crit", in_index,
+                                      0, PMBUS_VIN_OV_FAULT_LIMIT,
+                                      PSC_VOLTAGE_IN, false);
+                     if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+                             pmbus_add_boolean_reg(data, "in", "crit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_INPUT_BASE,
+                                                   PB_VOLTAGE_OV_FAULT);
+                             have_alarm = true;
+                     }
+             }
+             /*
+              * Add generic alarm attribute only if there are no individual
+              * attributes.
+              */
+             if (!have_alarm)
+                     pmbus_add_boolean_reg(data, "in", "alarm",
+                                           in_index,
+                                           PB_STATUS_BASE,
+                                           PB_STATUS_VIN_UV);
+             in_index++;
+     }
+     if (info->func[0] & PMBUS_HAVE_VCAP) {
+             pmbus_add_label(data, "in", in_index, "vcap", 0);
+             pmbus_add_sensor(data, "in", "input", in_index, 0,
+                              PMBUS_READ_VCAP, PSC_VOLTAGE_IN, true);
+             in_index++;
+     }
+
+     /*
+      * Output voltage sensors
+      */

drivers/hwmon/pmbus_core.c line 969

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+     for (page = 0; page < info->pages; page++) {
+             bool have_alarm = false;
+
+             if (!(info->func[page] & PMBUS_HAVE_VOUT))
+                     continue;
+
+             i0 = data->num_sensors;
+             pmbus_add_label(data, "in", in_index, "vout", page + 1);
+             pmbus_add_sensor(data, "in", "input", in_index, page,
+                              PMBUS_READ_VOUT, PSC_VOLTAGE_OUT, true);

Looks like that macro needs a few minor additions and you can use it here as well.

Quoted 476 lines
drivers/hwmon/pmbus_core.c new file +476 -0
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_VOUT_UV_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "min", in_index, page,
+                                      PMBUS_VOUT_UV_WARN_LIMIT,
+                                      PSC_VOLTAGE_OUT, false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+                             pmbus_add_boolean_reg(data, "in", "min_alarm",
+                                                   in_index,
+                                                   PB_STATUS_VOUT_BASE +
+                                                   page,
+                                                   PB_VOLTAGE_UV_WARNING);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_VOUT_UV_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "lcrit", in_index, page,
+                                      PMBUS_VOUT_UV_FAULT_LIMIT,
+                                      PSC_VOLTAGE_OUT, false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+                             pmbus_add_boolean_reg(data, "in", "lcrit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_VOUT_BASE +
+                                                   page,
+                                                   PB_VOLTAGE_UV_FAULT);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_VOUT_OV_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "max", in_index, page,
+                                      PMBUS_VOUT_OV_WARN_LIMIT,
+                                      PSC_VOLTAGE_OUT, false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+                             pmbus_add_boolean_reg(data, "in", "max_alarm",
+                                                   in_index,
+                                                   PB_STATUS_VOUT_BASE +
+                                                   page,
+                                                   PB_VOLTAGE_OV_WARNING);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_VOUT_OV_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "in", "crit", in_index, page,
+                                      PMBUS_VOUT_OV_FAULT_LIMIT,
+                                      PSC_VOLTAGE_OUT, false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_VOUT) {
+                             pmbus_add_boolean_reg(data, "in", "crit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_VOUT_BASE +
+                                                   page,
+                                                   PB_VOLTAGE_OV_FAULT);
+                             have_alarm = true;
+                     }
+             }
+             /*
+              * Add generic alarm attribute only if there are no individual
+              * attributes.
+              */
+             if (!have_alarm)
+                     pmbus_add_boolean_reg(data, "in", "alarm",
+                                           in_index,
+                                           PB_STATUS_BASE + page,
+                                           PB_STATUS_VOUT_OV);
+             in_index++;
+     }
+
+     /*
+      * Current sensors
+      */
+
+     /*
+      * Input current sensors
+      */
+     in_index = 1;
+     if (info->func[0] & PMBUS_HAVE_IIN) {
+             i0 = data->num_sensors;
+             pmbus_add_label(data, "curr", in_index, "iin", 0);
+             pmbus_add_sensor(data, "curr", "input", in_index,
+                              0, PMBUS_READ_IIN, PSC_CURRENT_IN, true);
+             if (pmbus_check_word_register(client, 0,
+                                           PMBUS_IIN_OC_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "curr", "max", in_index,
+                                      0, PMBUS_IIN_OC_WARN_LIMIT,
+                                      PSC_CURRENT_IN, false);
+                     if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) {
+                             pmbus_add_boolean_reg(data, "curr", "max_alarm",
+                                                   in_index,
+                                                   PB_STATUS_INPUT_BASE,
+                                                   PB_IIN_OC_WARNING);
+                     }
+             }
+             if (pmbus_check_word_register(client, 0,
+                                           PMBUS_IIN_OC_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "curr", "crit", in_index,
+                                      0, PMBUS_IIN_OC_FAULT_LIMIT,
+                                      PSC_CURRENT_IN, false);
+                     if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
+                             pmbus_add_boolean_reg(data, "curr",
+                                                   "crit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_INPUT_BASE,
+                                                   PB_IIN_OC_FAULT);
+             }
+             in_index++;
+     }
+
+     /*
+      * Output current sensors
+      */
+     for (page = 0; page < info->pages; page++) {
+             bool have_alarm = false;
+
+             if (!(info->func[page] & PMBUS_HAVE_IOUT))
+                     continue;
+
+             i0 = data->num_sensors;
+             pmbus_add_label(data, "curr", in_index, "iout", page + 1);
+             pmbus_add_sensor(data, "curr", "input", in_index, page,
+                              PMBUS_READ_IOUT, PSC_CURRENT_OUT, true);
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_IOUT_OC_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "curr", "max", in_index, page,
+                                      PMBUS_IOUT_OC_WARN_LIMIT,
+                                      PSC_CURRENT_OUT, false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_IOUT) {
+                             pmbus_add_boolean_reg(data, "curr", "max_alarm",
+                                                   in_index,
+                                                   PB_STATUS_IOUT_BASE +
+                                                   page, PB_IOUT_OC_WARNING);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_IOUT_UC_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "curr", "lcrit", in_index, page,
+                                      PMBUS_IOUT_UC_FAULT_LIMIT,
+                                      PSC_CURRENT_OUT, false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_IOUT) {
+                             pmbus_add_boolean_reg(data, "curr",
+                                                   "lcrit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_IOUT_BASE +
+                                                   page, PB_IOUT_UC_FAULT);
+                             have_alarm = true;
+                     }
+             }
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_IOUT_OC_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "curr", "crit", in_index, page,
+                                      PMBUS_IOUT_OC_FAULT_LIMIT,
+                                      PSC_CURRENT_OUT, false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_IOUT) {
+                             pmbus_add_boolean_reg(data, "curr",
+                                                   "crit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_IOUT_BASE +
+                                                   page, PB_IOUT_OC_FAULT);
+                             have_alarm = true;
+                     }
+             }
+             /*
+              * Add generic alarm attribute only if there are no individual
+              * attributes.
+              */
+             if (!have_alarm)
+                     pmbus_add_boolean_reg(data, "curr", "alarm",
+                                           in_index,
+                                           PB_STATUS_BASE + page,
+                                           PB_STATUS_IOUT_OC);
+             in_index++;
+     }
+
+     /*
+      * Power sensors
+      */
+     /*
+      * Input Power sensors
+      */
+     in_index = 1;
+     if (info->func[0] & PMBUS_HAVE_PIN) {
+             i0 = data->num_sensors;
+             pmbus_add_label(data, "power", in_index, "pin", 0);
+             pmbus_add_sensor(data, "power", "input", in_index,
+                              0, PMBUS_READ_PIN, PSC_POWER, true);
+             if (pmbus_check_word_register(client, 0,
+                                           PMBUS_PIN_OP_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "power", "max", in_index,
+                                      0, PMBUS_PIN_OP_WARN_LIMIT, PSC_POWER,
+                                      false);
+                     if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
+                             pmbus_add_boolean_reg(data, "power",
+                                                   "alarm",
+                                                   in_index,
+                                                   PB_STATUS_INPUT_BASE,
+                                                   PB_PIN_OP_WARNING);
+             }
+             in_index++;
+     }
+
+     /*
+      * Output Power sensors
+      */
+     for (page = 0; page < info->pages; page++) {
+             bool need_alarm = false;
+
+             if (!(info->func[page] & PMBUS_HAVE_POUT))
+                     continue;
+
+             i0 = data->num_sensors;
+             pmbus_add_label(data, "power", in_index, "pout", page + 1);
+             pmbus_add_sensor(data, "power", "input", in_index, page,
+                              PMBUS_READ_POUT, PSC_POWER, true);
+             /*
+              * Per hwmon sysfs API, power_cap is to be used to limit output
+              * power.
+              * We have two registers related to maximum output power,
+              * PMBUS_POUT_MAX and PMBUS_POUT_OP_WARN_LIMIT.
+              * PMBUS_POUT_MAX matches the powerX_cap attribute definition.
+              * There is no attribute in the API to match
+              * PMBUS_POUT_OP_WARN_LIMIT. We use powerX_max for now.
+              */
+             if (pmbus_check_word_register(client, page, PMBUS_POUT_MAX)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "power", "cap", in_index, page,
+                                      PMBUS_POUT_MAX, PSC_POWER, false);
+                     need_alarm = true;
+             }
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_POUT_OP_WARN_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "power", "max", in_index, page,
+                                      PMBUS_POUT_OP_WARN_LIMIT, PSC_POWER,
+                                      false);
+                     need_alarm = true;
+             }
+             if (need_alarm && (info->func[page] & PMBUS_HAVE_STATUS_IOUT))
+                     pmbus_add_boolean_reg(data, "power", "alarm",
+                                           in_index,
+                                           PB_STATUS_IOUT_BASE + page,
+                                           PB_POUT_OP_WARNING
+                                           | PB_POWER_LIMITING);
+
+             if (pmbus_check_word_register(client, page,
+                                           PMBUS_POUT_OP_FAULT_LIMIT)) {
+                     i1 = data->num_sensors;
+                     pmbus_add_sensor(data, "power", "crit", in_index, page,
+                                      PMBUS_POUT_OP_FAULT_LIMIT, PSC_POWER,
+                                      false);
+                     if (info->func[page] & PMBUS_HAVE_STATUS_IOUT)
+                             pmbus_add_boolean_reg(data, "power",
+                                                   "crit_alarm",
+                                                   in_index,
+                                                   PB_STATUS_IOUT_BASE
+                                                   + page,
+                                                   PB_POUT_OP_FAULT);
+             }
+             in_index++;
+     }
+
+     /*
+      * Temperature sensors
+      */
+     in_index = 1;
+     for (page = 0; page < info->pages; page++) {
+             int t, temps;
+
+             if (!(info->func[page] & PMBUS_HAVE_TEMP))
+                     continue;
+
+             temps = page ? 1 : ARRAY_SIZE(pmbus_temp_registers);
+             for (t = 0; t < temps; t++) {
+                     bool have_alarm = false;
+
+                     if (!pmbus_check_word_register
+                         (client, page, pmbus_temp_registers[t]))
+                             break;
+
+                     i0 = data->num_sensors;
+                     pmbus_add_sensor(data, "temp", "input", in_index, page,
+                                      pmbus_temp_registers[t],
+                                      PSC_TEMPERATURE, true);
+
+                     /*
+                      * PMBus provides only one status register for TEMP1-3.
+                      * Thus, we can not use the status register to determine
+                      * which of the three sensors actually caused an alarm.
+                      * Always compare current temperature against the limit
+                      * registers to determine alarm conditions for a
+                      * specific sensor.
+                      */
+                     if (pmbus_check_word_register
+                         (client, page, PMBUS_UT_WARN_LIMIT)) {
+                             i1 = data->num_sensors;
+                             pmbus_add_sensor(data, "temp", "min", in_index,
+                                              page, PMBUS_UT_WARN_LIMIT,
+                                              PSC_TEMPERATURE, false);
+                             if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+                                     pmbus_add_boolean_cmp(data, "temp",
+                                             "min_alarm", in_index, i1, i0,
+                                             PB_STATUS_TEMP_BASE + page,
+                                             PB_TEMP_UT_WARNING);
+                                     have_alarm = true;
+                             }
+                     }
+                     if (pmbus_check_word_register(client, page,
+                                                   PMBUS_UT_FAULT_LIMIT)) {
+                             i1 = data->num_sensors;
+                             pmbus_add_sensor(data, "temp", "lcrit",
+                                              in_index, page,
+                                              PMBUS_UT_FAULT_LIMIT,
+                                              PSC_TEMPERATURE, false);
+                             if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+                                     pmbus_add_boolean_cmp(data, "temp",
+                                             "lcrit_alarm", in_index, i1, i0,
+                                             PB_STATUS_TEMP_BASE + page,
+                                             PB_TEMP_UT_FAULT);
+                                     have_alarm = true;
+                             }
+                     }
+                     if (pmbus_check_word_register
+                         (client, page, PMBUS_OT_WARN_LIMIT)) {
+                             i1 = data->num_sensors;
+                             pmbus_add_sensor(data, "temp", "max", in_index,
+                                              page, PMBUS_OT_WARN_LIMIT,
+                                              PSC_TEMPERATURE, false);
+                             if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+                                     pmbus_add_boolean_cmp(data, "temp",
+                                             "max_alarm", in_index, i0, i1,
+                                             PB_STATUS_TEMP_BASE + page,
+                                             PB_TEMP_OT_WARNING);
+                                     have_alarm = true;
+                             }
+                     }
+                     if (pmbus_check_word_register(client, page,
+                                                   PMBUS_OT_FAULT_LIMIT)) {
+                             i1 = data->num_sensors;
+                             pmbus_add_sensor(data, "temp", "crit", in_index,
+                                              page, PMBUS_OT_FAULT_LIMIT,
+                                              PSC_TEMPERATURE, false);
+                             if (info->func[page] & PMBUS_HAVE_STATUS_TEMP) {
+                                     pmbus_add_boolean_cmp(data, "temp",
+                                             "crit_alarm", in_index, i0, i1,
+                                             PB_STATUS_TEMP_BASE + page,
+                                             PB_TEMP_OT_FAULT);
+                                     have_alarm = true;
+                             }
+                     }
+                     /*
+                      * Last resort - we were not able to create any alarm
+                      * registers. Report alarm for all sensors using the
+                      * status register temperature alarm bit.
+                      */
+                     if (!have_alarm)
+                             pmbus_add_boolean_reg(data, "temp", "alarm",
+                                                   in_index,
+                                                   PB_STATUS_BASE + page,
+                                                   PB_STATUS_TEMPERATURE);
+                     in_index++;
+             }
+     }
+
+     /*
+      * Fans
+      */
+     in_index = 1;
+     for (page = 0; page < info->pages; page++) {
+             int fans, f;
+
+             if (!(info->func[page] & PMBUS_HAVE_FAN12))
+                     continue;
+
+             fans = page ? 1 : ARRAY_SIZE(pmbus_fan_registers);
+             for (f = 0; f < fans; f++) {
+                     int regval;
+
+                     if (!pmbus_check_word_register(client, page,
+                                                    pmbus_fan_registers[f])
+                         || !pmbus_check_byte_register(client, page,
+                                             pmbus_fan_config_registers[f]))
+                             break;
+
+                     /*
+                      * Skip fan if not installed.
+                      * Each fan configuration register covers multiple fans,
+                      * so we have to do some magic.
+                      */
+                     regval = pmbus_read_byte_data(client, page,
+                             pmbus_fan_config_registers[f]);
+                     if (regval < 0 ||
+                         (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
+                             continue;
+
+                     i0 = data->num_sensors;
+                     pmbus_add_sensor(data, "fan", "input", in_index, page,
+                                      pmbus_fan_registers[f], PSC_FAN, true);
+
+                     /*
+                      * Each fan status register covers multiple fans,
+                      * so we have to do some magic.
+                      */
+                     if (pmbus_check_byte_register
+                         (client, page, pmbus_fan_status_registers[f])) {
+                             int base;
+
+                             if (f > 1)      /* fan 3, 4 */
+                                     base = PB_STATUS_FAN34_BASE;
+                             else
+                                     base = PB_STATUS_FAN_BASE + page;
+                             pmbus_add_boolean_reg(data, "fan", "alarm",
+                                     in_index, base,
+                                     PB_FAN_FAN1_WARNING >> (f & 1));
+                             pmbus_add_boolean_reg(data, "fan", "fault",
+                                     in_index, base,
+                                     PB_FAN_FAN1_FAULT >> (f & 1));
+                     }
+                     in_index++;
+             }
+     }
+}
+
+/*
+ * Identify chip parameters.
+ * This function is called for all chips.
+ */
+static int pmbus_identify_common(struct i2c_client *client,
+                              struct pmbus_data *data)
+{
+     int vout_mode, exponent;
+
+     vout_mode = pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
+     if (vout_mode >= 0) {
+             /*
+              * Not all chips support the VOUT_MODE command,
+              * so a failure to read it is not an error.
+              */
+             switch (vout_mode >> 5) {
+             case 0: /* linear mode      */
+                     if (data->info->direct[PSC_VOLTAGE_OUT])
+                             return -ENODEV;
+
+                     exponent = vout_mode & 0x1f;
+                     /* and sign-extend it */
+                     if (exponent & 0x10)
+                             exponent |= ~0x1f;
+                     data->exponent = exponent;
+                     break;
+             case 2: /* direct mode      */
+                     if (!data->info->direct[PSC_VOLTAGE_OUT])
+                             return -ENODEV;
+                     break;
+             default:
+                     return -ENODEV;
+             }
+     }
+
+     /* Determine maximum number of sensors, booleans, and labels */
+     pmbus_find_max_attr(client, data);
+
+     pmbus_clear_faults(client);
+     return 0;
+}
+
+int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
+                struct pmbus_driver_info *info)
Quoted 8 lines

drivers/hwmon/pmbus_core.c line 1451

Quoted 6 lines
drivers/hwmon/pmbus_core.c new file +6 -0
+{
+     const struct pmbus_platform_data *pdata = client->dev.platform_data;
+     struct pmbus_data *data;
+     int ret;
+
+     if (!info) {

Why insist on platform data? Can't we define a default as the pdata looks very simple?

There are no mandatory registers in PMBus, so I have no idea what a default would or could be. Basic idea is that platform data (ie supported register groups) is either determined via pmbus.c, or provided by a chip driver. If a chip driver is not needed, pmbus.c should be sufficient and provides the necessary platform data. An "empty" chip driver which does not provide platform data does not fit into this model.

Note that this is not platform_data (pdata), which is actually optional. "info" is struct pmbus_driver_info; I would not call that simple.

Quoted 28 lines
Quoted 28 lines
drivers/hwmon/pmbus_core.c new file +28 -0
+             dev_err(&client->dev, "Missing chip information");
+             return -ENODEV;
+     }
+
+     if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
+                                  | I2C_FUNC_SMBUS_BYTE_DATA
+                                  | I2C_FUNC_SMBUS_WORD_DATA))
+             return -ENODEV;
+
+     data = kzalloc(sizeof(*data), GFP_KERNEL);
+     if (!data) {
+             dev_err(&client->dev, "No memory to allocate driver data\n");
+             return -ENOMEM;
+     }
+
+     i2c_set_clientdata(client, data);
+     mutex_init(&data->update_lock);
+
+     /*
+      * Bail out if status register or PMBus revision register
+      * does not exist.
+      */
+     if (i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE) < 0
+         || i2c_smbus_read_byte_data(client, PMBUS_REVISION) < 0) {
+             dev_err(&client->dev,
+                     "Status or revision register not found\n");
+             ret = -ENODEV;
+             goto out_data;
Quoted 8 lines

drivers/hwmon/pmbus_core.c line 1485

Quoted 6 lines
drivers/hwmon/pmbus_core.c new file +6 -0
+     }
+
+     if (pdata)
+             data->flags = pdata->flags;
+     data->info = info;
+

perhaps a clarifying comment explaining why some devices might not have an identify function?

I'll add some text to pmbus.h.

Quoted 165 lines
Quoted 165 lines
drivers/hwmon/pmbus_core.c new file +122 -0
+     if (info->identify) {
+             ret = (*info->identify)(client, info);
+             if (ret < 0) {
+                     dev_err(&client->dev, "Chip identification failed\n");
+                     goto out_data;
+             }
+     }
+
+     if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
+             dev_err(&client->dev, "Bad number of PMBus pages: %d\n",
+                     info->pages);
+             ret = -EINVAL;
+             goto out_data;
+     }
+     /*
+      * Bail out if more than one page was configured, but we can not
+      * select the highest page. This is an indication that the wrong
+      * chip type was selected. Better bail out now than keep
+      * returning errors later on.
+      */
+     if (info->pages > 1 && pmbus_set_page(client, info->pages - 1) < 0) {
+             dev_err(&client->dev, "Failed to select page %d\n",
+                     info->pages - 1);
+             ret = -EINVAL;
+             goto out_data;
+     }
+
+     ret = pmbus_identify_common(client, data);
+     if (ret < 0) {
+             dev_err(&client->dev, "Failed to identify chip capabilities\n");
+             goto out_data;
+     }
+
+     ret = -ENOMEM;
+     data->sensors = kzalloc(sizeof(struct pmbus_sensor) * data->max_sensors,
+                             GFP_KERNEL);
+     if (!data->sensors) {
+             dev_err(&client->dev, "No memory to allocate sensor data\n");
+             goto out_data;
+     }
+
+     data->booleans = kzalloc(sizeof(struct pmbus_boolean)
+                              * data->max_booleans, GFP_KERNEL);
+     if (!data->booleans) {
+             dev_err(&client->dev, "No memory to allocate boolean data\n");
+             goto out_sensors;
+     }
+
+     data->labels = kzalloc(sizeof(struct pmbus_label) * data->max_labels,
+                            GFP_KERNEL);
+     if (!data->labels) {
+             dev_err(&client->dev, "No memory to allocate label data\n");
+             goto out_booleans;
+     }
+
+     data->attributes = kzalloc(sizeof(struct attribute *)
+                                * data->max_attributes, GFP_KERNEL);
+     if (!data->attributes) {
+             dev_err(&client->dev, "No memory to allocate attribute data\n");
+             goto out_labels;
+     }
+
+     pmbus_find_attributes(client, data);
+
+     /*
+      * If there are no attributes, something is wrong.
+      * Bail out instead of trying to register nothing.
+      */
+     if (!data->num_attributes) {
+             dev_err(&client->dev, "No attributes found\n");
+             ret = -ENODEV;
+             goto out_attributes;
+     }
+
+     /* Register sysfs hooks */
+     data->group.attrs = data->attributes;
+     ret = sysfs_create_group(&client->dev.kobj, &data->group);
+     if (ret) {
+             dev_err(&client->dev, "Failed to create sysfs entries\n");
+             goto out_attributes;
+     }
+     data->hwmon_dev = hwmon_device_register(&client->dev);
+     if (IS_ERR(data->hwmon_dev)) {
+             ret = PTR_ERR(data->hwmon_dev);
+             dev_err(&client->dev, "Failed to register hwmon device\n");
+             goto out_hwmon_device_register;
+     }
+     return 0;
+
+out_hwmon_device_register:
+     sysfs_remove_group(&client->dev.kobj, &data->group);
+out_attributes:
+     kfree(data->attributes);
+out_labels:
+     kfree(data->labels);
+out_booleans:
+     kfree(data->booleans);
+out_sensors:
+     kfree(data->sensors);
+out_data:
+     kfree(data);
+     return ret;
+}
+EXPORT_SYMBOL_GPL(pmbus_do_probe);
+
+int pmbus_do_remove(struct i2c_client *client)
+{
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     hwmon_device_unregister(data->hwmon_dev);
+     sysfs_remove_group(&client->dev.kobj, &data->group);
+     kfree(data->attributes);
+     kfree(data->labels);
+     kfree(data->booleans);
+     kfree(data->sensors);
+     kfree(data);
+     return 0;
+}
+EXPORT_SYMBOL_GPL(pmbus_do_remove);
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("PMBus core driver");
+MODULE_LICENSE("GPL");
include/linux/i2c/pmbus.h new file +37 -0
new file mode 100644
index 0000000..69280db
@@ -0,0 +1,45 @@
+/*
+ * Hardware monitoring driver for PMBus devices
+ *
+ * Copyright (c) 2010, 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _PMBUS_H_
+#define _PMBUS_H_
+
+/* flags */
+
+/*
+ * PMBUS_SKIP_STATUS_CHECK
+ *
+ * During register detection, skip checking the status register for
+ * communication or command errors.
+ *
+ * Some PMBus chips respond with valid data when trying to read an unsupported
+ * register. For such chips, checking the status register is mandatory when
+ * trying to determine if a chip register exists or not.
+ * Other PMBus chips don't support the STATUS_CML register, or report
+ * communication errors for no explicable reason. For such chips, checking
+ * the status register must be disabled.
Quoted 9 lines

include/linux/i2c/pmbus.h line 45

Quoted 8 lines
include/linux/i2c/pmbus.h new file +8 -0
+ */
+#define PMBUS_SKIP_STATUS_CHECK      (1 << 0)
+
+struct pmbus_platform_data {
+     u32 flags;              /* Device specific flags */
+};
+
+#endif /* _PMBUS_H_ */

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

#4 lore raw
Quoted 17 lines · Guenter Roeck
Quoted 7 lines · Jonathan Cameron
Quoted 2 lines · Guenter Roeck

This driver adds support for hardware monitoring features of various PMBus devices.

Hi Guenter, I'm afraid this isn't the most thorough review ever, but there are a few questions I'd like answered inline. These devices are pretty ugly.

Hi Jonathan,

given the complexity of the driver I am very happy you found the time!

Quoted 3 lines

I'm also a little unhappy with how often you clear faults without it being obvious why. Please have another look at this and add clarifying comments...

Mostly that was to make me feel safer. I removed some; hope it is better now.

Quoted 7 lines
Quoted 3 lines

I've suggested use of some macros inline. Not sure whether it's actualy a good idea though. What do you think?

I actually had more function macros in the code, but I am getting a bit away from it after I noticed that it often just obfuscates the code. Only reason for not removing the remaining the function macros is that I didn't find a clean way to replace them with actual code or functions.

Fair enough. They would have been really ugly macros. Just feels like there ought to be a cleaner way of handling those big chunks of very predicable code! Maybe some sort of array of structs with all the relevant info in them?

Quoted 34 lines
Quoted 5 lines

Other than request for a few more comments to explain bits that weren't immediately obvious, the only bit I'd really question is the necessity of the list of pmbus devices. I might have missed something there though...

That is pretty much just to be able to clean up an entry. More see below.

Quoted 27 lines

Thanks,

Jonathan

Quoted 23 lines
---
 drivers/hwmon/Kconfig      |   25 +
 drivers/hwmon/Makefile     |    4 +
 drivers/hwmon/pmbus.c      |  234 +++++++
 drivers/hwmon/pmbus.h      |  307 +++++++++
 drivers/hwmon/pmbus_core.c | 1611 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/i2c/pmbus.h  |   45 ++
 6 files changed, 2226 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/pmbus.c
 create mode 100644 drivers/hwmon/pmbus.h
 create mode 100644 drivers/hwmon/pmbus_core.c
 create mode 100644 include/linux/i2c/pmbus.h
drivers/hwmon/Kconfig +0 -0
index 773e484..9f20e56 100644
@@ -734,6 +734,31 @@ config SENSORS_PCF8591
        These devices are hard to detect and rarely found on mainstream
        hardware.  If unsure, say N.
 
Quoted 5 lines
Quoted 2 lines

drivers/hwmon/Kconfig config SENSORS_PCF8591 · line 738

Quoted 2 lines
drivers/hwmon/Kconfig +2 -0
+config PMBUS
+     tristate "PMBus support"

Side note: that should really be a boolean. Will be fixed in next version.

Why? Can't the pmbus core stuff be a module?

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
drivers/hwmon/Kconfig +8 -0
+     depends on I2C && EXPERIMENTAL
+     default n
+     help
+       Say yes here if you want to enable PMBus support.
+
+       This driver can also be built as a module. If so, the module will
+       be called pmbus_core.
+

...

Quoted 27 lines
Quoted 10 lines
Quoted 10 lines
drivers/hwmon/Kconfig +10 -0
+}
+
+static int pmbus_probe(struct i2c_client *client,
+                    const struct i2c_device_id *id)
+{
+     struct pmbus_entry *pe;
+     int ret;
+
+     pe = kzalloc(sizeof(struct pmbus_entry), GFP_KERNEL);
+     if (!pe)
Quoted 8 lines

drivers/hwmon/Kconfig

Quoted 6 lines
drivers/hwmon/Kconfig +6 -0
+             return -ENOMEM;
+
+     pe->client = client;
+     mutex_lock(&pmbus_list_mutex);
+     list_add_tail(&pe->list, &pmbus_list);
+     mutex_unlock(&pmbus_list_mutex);

I'm a little unclear why the list is needed. Looks like it is used for cleanup purposes. i2c_set_clientdata gets called with a struct pmbus_data *data

Correct.

Quoted 6 lines

in pmbus_do_probe. That structure has a pointer to struct pmbus_driver_info info currently effectively stored in this list. Hence, if we don't have the list I think we can create a pmbus_driver_info struct directly here and get to it via ((struct pmbus_data *)(i2c_get_clientdata(client))->info to free the structure on remove.

Quoted 8 lines

You are right, though that would require context information which is currently not exported from pmbus_core.c. Specifically, pmbus.c would need to know about struct pmbus_data which is private to pmbus_core.c. I would prefer to keep it that way.

Maybe I could add an API call into pmbus_core.c to retrieve a pointer to pmbus_driver_info. Do you think that would make sense ? I am a bit at odds with myself if the list or an API function (or something else ?) would be better.

Are I'd missed the issue with the struct definition being private.

API call is probably the cleanest option. The list just seems to be be adding complexity for no actual gain.

Quoted 10 lines
Quoted 9 lines

drivers/hwmon/Kconfig

Quoted 6 lines
drivers/hwmon/Kconfig +6 -0
+bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
+{
+     int rv, status;
+     struct pmbus_data *data = i2c_get_clientdata(client);
+
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);

If there have been faults, do we not want to have handled them? That is, should there be any circumstance under which we would want to clear one here?x

Quoted 3 lines

That is one place where it is really needed. Status codes are sticky, so if "PB_CML_FAULT_INVALID_COMMAND" was set for whatever reason, it would be reported below even if the following access is ok.

They wouldn't you ideally pick that up and report it when it first occurs rather than clearing it here? i.e. Clear whenever it occurs not at the top of a later function that wants to check the same error code...

Quoted 24 lines
Quoted 5 lines
Quoted 2 lines

+ rv = pmbus_read_word_data(client, page, reg);

I think this is idenical to the check code in the previous function. Worth pulling out to a utility function used by both?

Yes, excellent idea.

Quoted 7 lines
Quoted 7 lines
drivers/hwmon/Kconfig +7 -0
+     if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) {
+             status = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
+             if (status < 0 || (status & PB_STATUS_CML)) {
+                     int status2 = pmbus_read_byte_data(client, page,
+                                                        PMBUS_STATUS_CML);
+                     if (status2 < 0
+                         || (status2 & PB_CML_FAULT_INVALID_COMMAND)) {
Quoted 8 lines

drivers/hwmon/Kconfig

Quoted 8 lines
drivers/hwmon/Kconfig +8 -0
+                             dev_dbg(&client->dev,
+                                     "page %d reg 0x%x status 0x%x-0x%x\n",
+                                     page, reg, status, status2);
+                             rv = -EINVAL;
+                     }
+             }
+     }
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
Quoted 2 lines

This one isn't strictly needed, though, so I removed it.

Good

....

Quoted 30 lines
Quoted 21 lines
Quoted 21 lines
drivers/hwmon/Kconfig +21 -0
+
+/*
+ * Return boolean calculated from converted data.
+ * <index> defines a status register index and mask, and optionally
+ * two sensor indexes.
+ * The upper half-word references the two sensors,
+ * the lower half word references status register and mask.
+ * The function returns true if (status[reg] & mask) is true and,
+ * if specified, if v1 >= v2.
+ * To determine if an object exceeds upper limits, specify <v, limit>.
+ * To determine if an object exceeds lower limits, specify <limit, v>.
+ */
+static int pmbus_get_boolean(struct pmbus_data *data, int index, int *val)
+{
+     u8 s1 = (index >> 24) & 0xff;
+     u8 s2 = (index >> 16) & 0xff;
+     u8 reg = (index >> 8) & 0xff;
+     u8 mask = index & 0xff;
+     int status;
+     u8 regval;
+
Quoted 8 lines

drivers/hwmon/Kconfig

Quoted 5 lines
drivers/hwmon/Kconfig +5 -0
+     status = data->status[reg];
+     if (status < 0)
+             return status;
+
+     regval = status & mask;

This test could do with a simple explanatory comment (which is another way of saying I'm not quite clear why this makes sense!)

Quoted 7 lines

You mean the following test ? If both s1 and s2 are 0, the function returns the result of (status & mask). This is for all booleans which are created with pmbus_add_boolean_reg().

Otherwise, the result is determined by comparison as described above.

I'll add additional comments to describe this in more detail.

Cool. My issue was I couldn't tell what s1 and s2 actually are.

Quoted 327 lines
Quoted 106 lines
Quoted 106 lines
drivers/hwmon/Kconfig +105 -0
+     if (!s1 && !s2)
+             *val = !!regval;
+     else {
+             int v1, v2;
+             struct pmbus_sensor *sensor1, *sensor2;
+
+             sensor1 = &data->sensors[s1];
+             if (sensor1->data < 0)
+                     return sensor1->data;
+             sensor2 = &data->sensors[s2];
+             if (sensor2->data < 0)
+                     return sensor2->data;
+
+             v1 = pmbus_reg2data(data, sensor1);
+             v2 = pmbus_reg2data(data, sensor2);
+             *val = !!(regval && v1 >= v2);
+     }
+     return 0;
+}
+
+static ssize_t pmbus_show_boolean(struct device *dev,
+                               struct device_attribute *da, char *buf)
+{
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+     struct pmbus_data *data = pmbus_update_device(dev);
+     int val;
+     int err;
+
+     err = pmbus_get_boolean(data, attr->index, &val);
+     if (err)
+             return err;
+     return snprintf(buf, PAGE_SIZE, "%d\n", val);
+}
+
+static ssize_t pmbus_show_sensor(struct device *dev,
+                              struct device_attribute *da, char *buf)
+{
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+     struct pmbus_data *data = pmbus_update_device(dev);
+     struct pmbus_sensor *sensor;
+
+     sensor = &data->sensors[attr->index];
+     if (sensor->data < 0)
+             return sensor->data;
+
+     return snprintf(buf, PAGE_SIZE, "%d\n", pmbus_reg2data(data, sensor));
+}
+
+static ssize_t pmbus_set_sensor(struct device *dev,
+                             struct device_attribute *devattr,
+                             const char *buf, size_t count)
+{
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+     struct i2c_client *client = to_i2c_client(dev);
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     struct pmbus_sensor *sensor = &data->sensors[attr->index];
+     ssize_t rv = count;
+     long val = 0;
+     int ret;
+     u16 regval;
+
+     if (strict_strtol(buf, 10, &val) < 0)
+             return -EINVAL;
+
+     mutex_lock(&data->update_lock);
+     regval = pmbus_data2reg(data, sensor->class, val);
+     ret = pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
+     if (ret < 0)
+             rv = ret;
+     else
+             data->sensors[attr->index].data = regval;
+     mutex_unlock(&data->update_lock);
+     return rv;
+}
+
+static ssize_t pmbus_show_label(struct device *dev,
+                             struct device_attribute *da, char *buf)
+{
+     struct i2c_client *client = to_i2c_client(dev);
+     struct pmbus_data *data = i2c_get_clientdata(client);
+     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+
+     return snprintf(buf, PAGE_SIZE, "%s\n",
+                     data->labels[attr->index].label);
+}
+
+#define PMBUS_ADD_ATTR(data, _name, _idx, _mode, _type, _show, _set) \
+do {                                                                 \
+     struct sensor_device_attribute *a                               \
+         = &data->_type##s[data->num_##_type##s].attribute;          \
+     BUG_ON(data->num_attributes >= data->max_attributes);           \
+     a->dev_attr.attr.name = _name;                                  \
+     a->dev_attr.attr.mode = _mode;                                  \
+     a->dev_attr.show = _show;                                       \
+     a->dev_attr.store = _set;                                       \
+     a->index = _idx;                                                \
+     data->attributes[data->num_attributes] = &a->dev_attr.attr;     \
+     data->num_attributes++;                                         \
+} while (0)
+
+#define PMBUS_ADD_GET_ATTR(data, _name, _type, _idx)                 \
+     PMBUS_ADD_ATTR(data, _name, _idx, S_IRUGO, _type,               \
+                    pmbus_show_##_type,  NULL)
+
+#define PMBUS_ADD_SET_ATTR(data, _name, _type, _idx)                 \
Quoted 8 lines

drivers/hwmon/Kconfig

Quoted 5 lines
drivers/hwmon/Kconfig +5 -0
+     PMBUS_ADD_ATTR(data, _name, _idx, S_IWUSR | S_IRUGO, _type,     \
+                    pmbus_show_##_type, pmbus_set_##_type)
+
+static void pmbus_add_boolean(struct pmbus_data *data,
+                           const char *name, const char *type, int seq,

Is val the best name for the next variable? It isn't obvious to me what value this is... Gets pushed into an index by the PMBUS_ADD_GET_ATTR macro... Perhaps keep the idx naming?

Not sure myself. val is composed of up to four individual parameters. I'll name it idx.

Quoted 67 lines
Quoted 67 lines
drivers/hwmon/Kconfig +67 -0
+                           int val)
+{
+     struct pmbus_boolean *boolean;
+
+     BUG_ON(data->num_booleans >= data->max_booleans);
+
+     boolean = &data->booleans[data->num_booleans];
+
+     snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
+              name, seq, type);
+     PMBUS_ADD_GET_ATTR(data, boolean->name, boolean, val);
+     data->num_booleans++;
+}
+
+static void pmbus_add_boolean_reg(struct pmbus_data *data,
+                               const char *name, const char *type,
+                               int seq, int reg, int bit)
+{
+     pmbus_add_boolean(data, name, type, seq, (reg << 8) | bit);
+}
+
+static void pmbus_add_boolean_cmp(struct pmbus_data *data,
+                               const char *name, const char *type,
+                               int seq, int i1, int i2, int reg, int mask)
+{
+     pmbus_add_boolean(data, name, type, seq,
+                       (i1 << 24) | (i2 << 16) | (reg << 8) | mask);
+}
+
+static void pmbus_add_sensor(struct pmbus_data *data,
+                          const char *name, const char *type, int seq,
+                          int page, int reg, enum pmbus_sensor_classes class,
+                          bool update)
+{
+     struct pmbus_sensor *sensor;
+
+     BUG_ON(data->num_sensors >= data->max_sensors);
+
+     sensor = &data->sensors[data->num_sensors];
+     snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
+              name, seq, type);
+     sensor->page = page;
+     sensor->reg = reg;
+     sensor->class = class;
+     sensor->update = update;
+     if (update)
+             PMBUS_ADD_GET_ATTR(data, sensor->name, sensor,
+                                data->num_sensors);
+     else
+             PMBUS_ADD_SET_ATTR(data, sensor->name, sensor,
+                                data->num_sensors);
+     data->num_sensors++;
+}
+
+static void pmbus_add_label(struct pmbus_data *data,
+                         const char *name, int seq,
+                         const char *lstring, int index)
+{
+     struct pmbus_label *label;
+
+     BUG_ON(data->num_labels >= data->max_labels);
+
+     label = &data->labels[data->num_labels];
+     snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
+     if (!index)
+             strncpy(label->label, lstring, sizeof(label->label) - 1);
+     else
Quoted 8 lines

drivers/hwmon/Kconfig

Quoted 7 lines
drivers/hwmon/Kconfig +7 -0
+             snprintf(label->label, sizeof(label->label), "%s%d", lstring,
+                      index);
+
+     PMBUS_ADD_GET_ATTR(data, label->name, label, data->num_labels);
+     data->num_labels++;
+}
+

const?

yes

Quoted 131 lines
Quoted 100 lines
drivers/hwmon/Kconfig +100 -0
+static int pmbus_temp_registers[] = {
+     PMBUS_READ_TEMPERATURE_1,
+     PMBUS_READ_TEMPERATURE_2,
+     PMBUS_READ_TEMPERATURE_3
+};
+
+static int pmbus_fan_registers[] = {
+     PMBUS_READ_FAN_SPEED_1,
+     PMBUS_READ_FAN_SPEED_2,
+     PMBUS_READ_FAN_SPEED_3,
+     PMBUS_READ_FAN_SPEED_4
+};
+
+static int pmbus_fan_config_registers[] = {
+     PMBUS_FAN_CONFIG_12,
+     PMBUS_FAN_CONFIG_12,
+     PMBUS_FAN_CONFIG_34,
+     PMBUS_FAN_CONFIG_34
+};
+
+static int pmbus_fan_status_registers[] = {
+     PMBUS_STATUS_FAN_12,
+     PMBUS_STATUS_FAN_12,
+     PMBUS_STATUS_FAN_34,
+     PMBUS_STATUS_FAN_34
+};
+
+/*
+ * Determine maximum number of sensors, booleans, and labels.
+ * To keep things simple, only make a rough high estimate.
+ */
+static void pmbus_find_max_attr(struct i2c_client *client,
+                             struct pmbus_data *data)
+{
+     const struct pmbus_driver_info *info = data->info;
+     int page, max_sensors, max_booleans, max_labels;
+
+     max_sensors = PMBUS_MAX_INPUT_SENSORS;
+     max_booleans = PMBUS_MAX_INPUT_BOOLEANS;
+     max_labels = PMBUS_MAX_INPUT_LABELS;
+
+     for (page = 0; page < info->pages; page++) {
+             if (info->func[page] & PMBUS_HAVE_VOUT) {
+                     max_sensors += PMBUS_VOUT_SENSORS_PER_PAGE;
+                     max_booleans += PMBUS_VOUT_BOOLEANS_PER_PAGE;
+                     max_labels++;
+             }
+             if (info->func[page] & PMBUS_HAVE_IOUT) {
+                     max_sensors += PMBUS_IOUT_SENSORS_PER_PAGE;
+                     max_booleans += PMBUS_IOUT_BOOLEANS_PER_PAGE;
+                     max_labels++;
+             }
+             if (info->func[page] & PMBUS_HAVE_POUT) {
+                     max_sensors += PMBUS_POUT_SENSORS_PER_PAGE;
+                     max_booleans += PMBUS_POUT_BOOLEANS_PER_PAGE;
+                     max_labels++;
+             }
+             if (info->func[page] & PMBUS_HAVE_FAN12) {
+                     if (page == 0) {
+                             max_sensors +=
+                                 ARRAY_SIZE(pmbus_fan_registers) *
+                                 PMBUS_MAX_SENSORS_PER_FAN;
+                             max_booleans +=
+                                 ARRAY_SIZE(pmbus_fan_registers) *
+                                 PMBUS_MAX_BOOLEANS_PER_FAN;
+                     } else {
+                             max_sensors += PMBUS_MAX_SENSORS_PER_FAN;
+                             max_booleans += PMBUS_MAX_BOOLEANS_PER_FAN;
+                     }
+             }
+             if (info->func[page] & PMBUS_HAVE_TEMP) {
+                     if (page == 0) {
+                             max_sensors +=
+                                 ARRAY_SIZE(pmbus_temp_registers) *
+                                 PMBUS_MAX_SENSORS_PER_TEMP;
+                             max_booleans +=
+                                 ARRAY_SIZE(pmbus_temp_registers) *
+                                 PMBUS_MAX_BOOLEANS_PER_TEMP;
+                     } else {
+                             max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
+                             max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
+                     }
+             }
+     }
+     data->max_sensors = max_sensors;
+     data->max_booleans = max_booleans;
+     data->max_labels = max_labels;
+     data->max_attributes = max_sensors + max_booleans + max_labels;
+}
+
+/*
+ * Search for attributes. Allocate sensors, booleans, and labels as needed.
+ */
+static void pmbus_find_attributes(struct i2c_client *client,
+                               struct pmbus_data *data)
+{
+     const struct pmbus_driver_info *info = data->info;
+     int page, i0, i1, in_index;
+
+     /*

drivers/hwmon/Kconfig

Quoted 10 lines
drivers/hwmon/Kconfig +10 -0
+      * Input voltage sensors
+      */
+     in_index = 1;
+     if (info->func[0] & PMBUS_HAVE_VIN) {
+             bool have_alarm = false;
+
+             i0 = data->num_sensors;
+             pmbus_add_label(data, "in", in_index, "vin", 0);
+             pmbus_add_sensor(data, "in", "input", in_index,
+                              0, PMBUS_READ_VIN, PSC_VOLTAGE_IN, true);

This next lot do rather look like they could be done using an inline function or a macro...

Something like...
#define bob(LIM, NAME, POST, WHAT, TYPE)

if (pmbus_check_word_register(client, 0, LIM)) {
   i1 = data->num_sensors;
   pmbus_add_sensor(data, NAME, POST, in_index, 0, LIM, WHAT, false);
   if (info->func[0] & PMBUS_HAV_STATUS_INPUT) {
   pmbus_add_boolean_reg(data, NAME, POST##_alarm, in_index, PBU_STATUS_INPUT_BASE,
   TYPE);
   have_alarm = true;
}

}

bob(PMBUS_VIN_UV_WARN_LIMIT, "in", "min", PSC_VOLTAGE_IN, PB_VOLTAGE_UV_WARNING); bob(PMBUS_VIN_UV_FAULT_LIMIT, "in", "lcrit", PSC_VOLTAGE_IN, PB_VOLTAGE_UV_FAULT); bob(PMBUS_VIN_OV_WARN_LIMIT, "in", "max", PSC_VOLTAGE_IN, PB_VOLTAGE_OV_WARNING); etc.

Quoted 9 lines
Quoted 2 lines

basically I'm observing a lot of shared code in these... Still maybe this just acts to hide what is going on.

I think I would prefer to keep it as-is. I am not really a friend of function macros anymore.

It would be different if I can extract some of the code into functions, but right now I don't see how I could do that.

Agreed. When I started looking at that I thought it would be easy to do as a function, but the code is way to invasive and you would need a lot of parameters to make that work...

Fine as is then...

#5 lore raw

Hi Jonathan,

Quoted 21 lines · Jonathan Cameron
Quoted 20 lines · Guenter Roeck
Quoted 7 lines · Jonathan Cameron
Quoted 2 lines · Guenter Roeck

This driver adds support for hardware monitoring features of various PMBus devices.

Hi Guenter, I'm afraid this isn't the most thorough review ever, but there are a few questions I'd like answered inline. These devices are pretty ugly.

Hi Jonathan,

given the complexity of the driver I am very happy you found the time!

Quoted 3 lines

I'm also a little unhappy with how often you clear faults without it being obvious why. Please have another look at this and add clarifying comments...

Mostly that was to make me feel safer. I removed some; hope it is better now.

Quoted 3 lines

I've suggested use of some macros inline. Not sure whether it's actualy a good idea though. What do you think?

Quoted 7 lines
Quoted 4 lines

I actually had more function macros in the code, but I am getting a bit away from it after I noticed that it often just obfuscates the code. Only reason for not removing the remaining the function macros is that I didn't find a clean way to replace them with actual code or functions.

Fair enough. They would have been really ugly macros. Just feels like there ought to be a cleaner way of handling those big chunks of very predicable code! Maybe some sort of array of structs with all the relevant info in them?

Sounds like a good idea. Let me think about it; maybe I can come up with something.

[ ... ]

Quoted 7 lines
Quoted 6 lines
Quoted 3 lines

drivers/hwmon/Kconfig config SENSORS_PCF8591 · line 738

Quoted 3 lines
drivers/hwmon/Kconfig +2 -0
+config PMBUS
+     tristate "PMBus support"

Side note: that should really be a boolean. Will be fixed in next version.

Why? Can't the pmbus core stuff be a module?

You are absolutely right. I forgot that this is used to compile the core module. Sorry for the noise.

Quoted 5 lines
Quoted 5 lines
Quoted 1 line

You are right, though that would require context information which is currently not exported from pmbus_core.c. Specifically, pmbus.c would need to know about struct pmbus_data which is private to pmbus_core.c. I would prefer to keep it that way.

Quoted 9 lines
Quoted 4 lines

Maybe I could add an API call into pmbus_core.c to retrieve a pointer to pmbus_driver_info. Do you think that would make sense ? I am a bit at odds with myself if the list or an API function (or something else ?) would be better.

Are I'd missed the issue with the struct definition being private.

API call is probably the cleanest option. The list just seems to be be adding complexity for no actual gain.

The API got rid of the list and reduced the code size by about 25 lines. Definitely a winner.

Quoted 10 lines
Quoted 10 lines
Quoted 9 lines

drivers/hwmon/pmbus_core.c line 256

Quoted 6 lines
drivers/hwmon/pmbus_core.c new file +6 -0
+bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
+{
+     int rv, status;
+     struct pmbus_data *data = i2c_get_clientdata(client);
+
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);

If there have been faults, do we not want to have handled them? That is, should there be any circumstance under which we would want to clear one here?x

Quoted 6 lines
Quoted 3 lines

That is one place where it is really needed. Status codes are sticky, so if "PB_CML_FAULT_INVALID_COMMAND" was set for whatever reason, it would be reported below even if the following access is ok.

They wouldn't you ideally pick that up and report it when it first occurs rather than clearing it here? i.e. Clear whenever it occurs not at the top of a later function that wants to check the same error code...

Makes sense, only I'll have to clean up the status when loading the driver, before starting to do any register checks. I'll see what I can do.

Quoted 24 lines
Quoted 24 lines
Quoted 5 lines
Quoted 2 lines

+ rv = pmbus_read_word_data(client, page, reg);

I think this is idenical to the check code in the previous function. Worth pulling out to a utility function used by both?

Yes, excellent idea.

Quoted 15 lines
Quoted 15 lines
drivers/hwmon/pmbus_core.c new file +15 -0
+     if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) {
+             status = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
+             if (status < 0 || (status & PB_STATUS_CML)) {
+                     int status2 = pmbus_read_byte_data(client, page,
+                                                        PMBUS_STATUS_CML);
+                     if (status2 < 0
+                         || (status2 & PB_CML_FAULT_INVALID_COMMAND)) {
+                             dev_dbg(&client->dev,
+                                     "page %d reg 0x%x status 0x%x-0x%x\n",
+                                     page, reg, status, status2);
+                             rv = -EINVAL;
+                     }
+             }
+     }
+     pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
Quoted 4 lines
Quoted 2 lines

This one isn't strictly needed, though, so I removed it.

Good

Except per discussion above, I'll see if I can remove the one at the top of the function.

Quoted 31 lines

....

Quoted 30 lines
Quoted 29 lines
Quoted 16 lines
drivers/hwmon/pmbus_core.c new file +16 -0
+
+/*
+ * Return boolean calculated from converted data.
+ * <index> defines a status register index and mask, and optionally
+ * two sensor indexes.
+ * The upper half-word references the two sensors,
+ * the lower half word references status register and mask.
+ * The function returns true if (status[reg] & mask) is true and,
+ * if specified, if v1 >= v2.
+ * To determine if an object exceeds upper limits, specify <v, limit>.
+ * To determine if an object exceeds lower limits, specify <limit, v>.
+ */
+static int pmbus_get_boolean(struct pmbus_data *data, int index, int *val)
+{
+     u8 s1 = (index >> 24) & 0xff;
+     u8 s2 = (index >> 16) & 0xff;

drivers/hwmon/pmbus_core.c line 592

Quoted 10 lines
drivers/hwmon/pmbus_core.c new file +10 -0
+     u8 reg = (index >> 8) & 0xff;
+     u8 mask = index & 0xff;
+     int status;
+     u8 regval;
+
+     status = data->status[reg];
+     if (status < 0)
+             return status;
+
+     regval = status & mask;

This test could do with a simple explanatory comment (which is another way of saying I'm not quite clear why this makes sense!)

Quoted 8 lines
Quoted 7 lines

You mean the following test ? If both s1 and s2 are 0, the function returns the result of (status & mask). This is for all booleans which are created with pmbus_add_boolean_reg().

Otherwise, the result is determined by comparison as described above.

I'll add additional comments to describe this in more detail.

Cool. My issue was I couldn't tell what s1 and s2 actually are.

I added more description at the top of the function. Hope it is a bit clearer in the next version.

Thanks,

Guenter

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

#6 lore raw

PATCH v4 2/5 hwmon: (pmbus) Add support for Maxim MAX8688

In reply to Guenter Roeck
---
 drivers/hwmon/Kconfig   |   10 +++
 drivers/hwmon/Makefile  |    1 +
 drivers/hwmon/max8688.c |  158 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 169 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/max8688.c
drivers/hwmon/Kconfig +10 -0
index 9f20e56..02ee4f2 100644
@@ -757,6 +757,16 @@ config SENSORS_PMBUS
 	  This driver can also be built as a module. If so, the module will
 	  be called pmbus.
 
+config SENSORS_MAX8688
+	tristate "Maxim MAX8688"
+	default n
+	help
+	  If you say yes here you get hardware monitoring support for Maxim
+	  MAX8688.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called max8688.
+
 endif # PMBUS
 
 config SENSORS_SHT15
drivers/hwmon/Makefile +1 -0
index f7f158b..00c2e77 100644
@@ -115,6 +115,7 @@ obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 # PMBus drivers
 obj-$(CONFIG_PMBUS)		+= pmbus_core.o
 obj-$(CONFIG_SENSORS_PMBUS)	+= pmbus.o
+obj-$(CONFIG_SENSORS_MAX8688)	+= max8688.o
 
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG
drivers/hwmon/max8688.c new file +158 -0

158 lines not on this page · raw message

Signature · 7 lines
1.7.3.1


_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
#8 lore raw

Re: [PATCH v4 2/5] hwmon: (pmbus) Add support for Maxim MAX8688

Hi Jonathan,

Quoted 3 lines · Jonathan Cameron

Straight forward use of your core driver. I've not checked this against a datasheet, so ack assumes all the numbers are correct!

I have either real hw, eval boards, or home-built boards for all supported chips, so while I would not rule out the possibility that I got something wrong, I have at least verified it with real hardware.

Thanks,
Guenter

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

#9 lore raw

PATCH v4 3/5 hwmon: (pmbus) Add support for Maxim MAX16064

In reply to Guenter Roeck
---
 drivers/hwmon/Kconfig    |   10 +++++
 drivers/hwmon/Makefile   |    1 +
 drivers/hwmon/max16064.c |   91 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 102 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/max16064.c
drivers/hwmon/Kconfig +10 -0
index 02ee4f2..723cadd 100644
@@ -757,6 +757,16 @@ config SENSORS_PMBUS
 	  This driver can also be built as a module. If so, the module will
 	  be called pmbus.
 
+config SENSORS_MAX16064
+	tristate "Maxim MAX16064"
+	default n
+	help
+	  If you say yes here you get hardware monitoring support for Maxim
+	  MAX16064.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called max16064.
+
 config SENSORS_MAX8688
 	tristate "Maxim MAX8688"
 	default n
drivers/hwmon/Makefile +1 -0
index 00c2e77..9c83d0d 100644
@@ -115,6 +115,7 @@ obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 # PMBus drivers
 obj-$(CONFIG_PMBUS)		+= pmbus_core.o
 obj-$(CONFIG_SENSORS_PMBUS)	+= pmbus.o
+obj-$(CONFIG_SENSORS_MAX16064)	+= max16064.o
 obj-$(CONFIG_SENSORS_MAX8688)	+= max8688.o
 
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
drivers/hwmon/max16064.c new file +91 -0

91 lines not on this page · raw message

Signature · 7 lines
1.7.3.1


_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Acked-by on v4 3/5
#10 lore raw

Re: [PATCH v4 3/5] hwmon: (pmbus) Add support for Maxim MAX16064

Again, straight forward use of pmbus_core. Is it actually worth having separate modules for each of these special cases? Could just do the old big table of fixed chip info structures in a single driver...

Still I don't really mind it being done this way either...

Quoted 1 line · Guenter Roeck
Quoted 137 lines
---
 drivers/hwmon/Kconfig    |   10 +++++
 drivers/hwmon/Makefile   |    1 +
 drivers/hwmon/max16064.c |   91 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 102 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/max16064.c
drivers/hwmon/Kconfig +10 -0
index 02ee4f2..723cadd 100644
@@ -757,6 +757,16 @@ config SENSORS_PMBUS
 	  This driver can also be built as a module. If so, the module will
 	  be called pmbus.
 
+config SENSORS_MAX16064
+	tristate "Maxim MAX16064"
+	default n
+	help
+	  If you say yes here you get hardware monitoring support for Maxim
+	  MAX16064.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called max16064.
+
 config SENSORS_MAX8688
 	tristate "Maxim MAX8688"
 	default n
drivers/hwmon/Makefile +1 -0
index 00c2e77..9c83d0d 100644
@@ -115,6 +115,7 @@ obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 # PMBus drivers
 obj-$(CONFIG_PMBUS)		+= pmbus_core.o
 obj-$(CONFIG_SENSORS_PMBUS)	+= pmbus.o
+obj-$(CONFIG_SENSORS_MAX16064)	+= max16064.o
 obj-$(CONFIG_SENSORS_MAX8688)	+= max8688.o
 
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
drivers/hwmon/max16064.c new file +91 -0
new file mode 100644
index 0000000..1d6d717
@@ -0,0 +1,91 @@
+/*
+ * Hardware monitoring driver for Maxim MAX16064
+ *
+ * Copyright (c) 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include "pmbus.h"
+
+static struct pmbus_driver_info max16064_info = {
+	.pages = 4,
+	.direct[PSC_VOLTAGE_IN] = true,
+	.direct[PSC_VOLTAGE_OUT] = true,
+	.direct[PSC_TEMPERATURE] = true,
+	.m[PSC_VOLTAGE_IN] = 19995,
+	.b[PSC_VOLTAGE_IN] = 0,
+	.R[PSC_VOLTAGE_IN] = -1,
+	.m[PSC_VOLTAGE_OUT] = 19995,
+	.b[PSC_VOLTAGE_OUT] = 0,
+	.R[PSC_VOLTAGE_OUT] = -1,
+	.m[PSC_TEMPERATURE] = -7612,
+	.b[PSC_TEMPERATURE] = 335,
+	.R[PSC_TEMPERATURE] = -3,
+	.func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_TEMP
+		| PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_STATUS_TEMP,
+	.func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
+	.func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
+	.func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
+};
+
+static int max16064_probe(struct i2c_client *client,
+			  const struct i2c_device_id *id)
+{
+	return pmbus_do_probe(client, id, &max16064_info);
+}
+
+static int max16064_remove(struct i2c_client *client)
+{
+	return pmbus_do_remove(client);
+}
+
+static const struct i2c_device_id max16064_id[] = {
+	{"max16064", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, max16064_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver max16064_driver = {
+	.driver = {
+		   .name = "max16064",
+		   },
+	.probe = max16064_probe,
+	.remove = max16064_remove,
+	.id_table = max16064_id,
+};
+
+static int __init max16064_init(void)
+{
+	return i2c_add_driver(&max16064_driver);
+}
+
+static void __exit max16064_exit(void)
+{
+	i2c_del_driver(&max16064_driver);
+}
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("PMBus driver for Maxim MAX16064");
+MODULE_LICENSE("GPL");
+module_init(max16064_init);
+module_exit(max16064_exit);
#11 lore raw

Re: [PATCH v4 3/5] hwmon: (pmbus) Add support for Maxim MAX16064

Hi Jonathan,

Quoted 4 lines · Jonathan Cameron

Again, straight forward use of pmbus_core. Is it actually worth having separate modules for each of these special cases? Could just do the old big table of fixed chip info structures in a single driver...

This is actually what I had originally. My reasoning to split it up was that this makes it easier to add support for additional chips without having to modify the core driver. Also, I can keep chip specific code (specifically the _identify and _get_status functions) out of the core driver.

Thanks,
Guenter

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

#12 lore raw

PATCH v4 4/5 hwmon: (pmbus) Add support for Maxim MAX34440/MAX34441

In reply to Guenter Roeck
---
 drivers/hwmon/Kconfig    |   10 +++
 drivers/hwmon/Makefile   |    1 +
 drivers/hwmon/max34440.c |  198 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 209 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/max34440.c
drivers/hwmon/Kconfig +10 -0
index 723cadd..3568a3b 100644
@@ -767,6 +767,16 @@ config SENSORS_MAX16064
 	  This driver can also be built as a module. If so, the module will
 	  be called max16064.
 
+config SENSORS_MAX34440
+	tristate "Maxim MAX34440/MAX34441"
+	default n
+	help
+	  If you say yes here you get hardware monitoring support for Maxim
+	  MAX34440 and MAX34441.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called max34440.
+
 config SENSORS_MAX8688
 	tristate "Maxim MAX8688"
 	default n
drivers/hwmon/Makefile +1 -0
index 9c83d0d..905a1f6 100644
@@ -116,6 +116,7 @@ obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 obj-$(CONFIG_PMBUS)		+= pmbus_core.o
 obj-$(CONFIG_SENSORS_PMBUS)	+= pmbus.o
 obj-$(CONFIG_SENSORS_MAX16064)	+= max16064.o
+obj-$(CONFIG_SENSORS_MAX34440)	+= max34440.o
 obj-$(CONFIG_SENSORS_MAX8688)	+= max8688.o
 
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
drivers/hwmon/max34440.c new file +198 -0

198 lines not on this page · raw message

Signature · 7 lines
1.7.3.1


_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
#13 lore raw

Re: [PATCH v4 4/5] hwmon: (pmbus) Add support for Maxim MAX34440/MAX34441

One trivial formatting nitpick.
Dug out datasheet for this one..
I'm a little unclear how value from there map to those stored in here...

Quoted 108 lines · Guenter Roeck
---
 drivers/hwmon/Kconfig    |   10 +++
 drivers/hwmon/Makefile   |    1 +
 drivers/hwmon/max34440.c |  198 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 209 insertions(+), 0 deletions(-)
 create mode 100644 drivers/hwmon/max34440.c
drivers/hwmon/Kconfig +10 -0
index 723cadd..3568a3b 100644
@@ -767,6 +767,16 @@ config SENSORS_MAX16064
 	  This driver can also be built as a module. If so, the module will
 	  be called max16064.
 
+config SENSORS_MAX34440
+	tristate "Maxim MAX34440/MAX34441"
+	default n
+	help
+	  If you say yes here you get hardware monitoring support for Maxim
+	  MAX34440 and MAX34441.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called max34440.
+
 config SENSORS_MAX8688
 	tristate "Maxim MAX8688"
 	default n
drivers/hwmon/Makefile +1 -0
index 9c83d0d..905a1f6 100644
@@ -116,6 +116,7 @@ obj-$(CONFIG_SENSORS_WM8350)	+= wm8350-hwmon.o
 obj-$(CONFIG_PMBUS)		+= pmbus_core.o
 obj-$(CONFIG_SENSORS_PMBUS)	+= pmbus.o
 obj-$(CONFIG_SENSORS_MAX16064)	+= max16064.o
+obj-$(CONFIG_SENSORS_MAX34440)	+= max34440.o
 obj-$(CONFIG_SENSORS_MAX8688)	+= max8688.o
 
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
drivers/hwmon/max34440.c new file +60 -0
new file mode 100644
index 0000000..6b71bcc
@@ -0,0 +1,198 @@
+/*
+ * Hardware monitoring driver for Maxim MAX34440/MAX34441
+ *
+ * Copyright (c) 2011 Ericsson AB.
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include "pmbus.h"
+
+enum chips { max34440, max34441 };
+
+#define MAX34440_STATUS_OC_WARN		(1 << 0)
+#define MAX34440_STATUS_OC_FAULT	(1 << 1)
+#define MAX34440_STATUS_OT_FAULT	(1 << 5)
+#define MAX34440_STATUS_OT_WARN		(1 << 6)
+
+static int max34440_get_status(struct i2c_client *client, int page, int reg)
+{
+	int ret;
+	int mfg_status;
+
+	ret = pmbus_set_page(client, page);
+	if (ret < 0)
+		return ret;
+
+	switch (reg) {
+	case PMBUS_STATUS_IOUT:
+		mfg_status = pmbus_read_word_data(client, 0,
+						  PMBUS_STATUS_MFR_SPECIFIC);
+		if (mfg_status < 0)
+			return mfg_status;
+		if (mfg_status & MAX34440_STATUS_OC_WARN)
+			ret |= PB_IOUT_OC_WARNING;
+		if (mfg_status & MAX34440_STATUS_OC_FAULT)
+			ret |= PB_IOUT_OC_FAULT;
+		break;
+	case PMBUS_STATUS_TEMPERATURE:
+		mfg_status = pmbus_read_word_data(client, 0,
+						  PMBUS_STATUS_MFR_SPECIFIC);
+		if (mfg_status < 0)
+			return mfg_status;
+		if (mfg_status & MAX34440_STATUS_OT_WARN)

drivers/hwmon/max34440.c line 70

Quoted 10 lines
drivers/hwmon/max34440.c new file +10 -0
+			ret |= PB_TEMP_OT_WARNING;
+		if (mfg_status & MAX34440_STATUS_OT_FAULT)
+			ret |= PB_TEMP_OT_FAULT;
+		break;
+	default:
+		ret = -ENODATA;
+		break;
+	}
+	return ret;
+}

New line here.

Quoted 6 lines
drivers/hwmon/max34440.c new file +6 -0
+static struct pmbus_driver_info max34440_info[] = {
+	[max34440] = {
+		.pages = 14,
+		.direct[PSC_VOLTAGE_IN] = true,
+		.direct[PSC_VOLTAGE_OUT] = true,
+		.direct[PSC_TEMPERATURE] = true,

drivers/hwmon/max34440.c line 86

Quoted 10 lines
drivers/hwmon/max34440.c new file +10 -0
+		.direct[PSC_CURRENT_OUT] = true,
+		.m[PSC_VOLTAGE_IN] = 1,
+		.b[PSC_VOLTAGE_IN] = 0,
+		.R[PSC_VOLTAGE_IN] = 3,
+		.m[PSC_VOLTAGE_OUT] = 1,
+		.b[PSC_VOLTAGE_OUT] = 0,
+		.R[PSC_VOLTAGE_OUT] = 3,
+		.m[PSC_CURRENT_OUT] = 1,
+		.b[PSC_CURRENT_OUT] = 0,
+		.R[PSC_CURRENT_OUT] = 3,

Table 3 of datasheet says R for current is 0... I may be missing something though!

Quoted 31 lines
drivers/hwmon/max34440.c new file +31 -0
+		.m[PSC_TEMPERATURE] = 1,
+		.b[PSC_TEMPERATURE] = 0,
+		.R[PSC_TEMPERATURE] = 2,
+		.func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[4] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[5] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[6] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[7] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[8] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[9] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[10] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[11] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[12] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[13] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.get_status = max34440_get_status,
+	},
+	[max34441] = {
+		.pages = 12,
+		.direct[PSC_VOLTAGE_IN] = true,
+		.direct[PSC_VOLTAGE_OUT] = true,
+		.direct[PSC_TEMPERATURE] = true,
+		.direct[PSC_CURRENT_OUT] = true,

drivers/hwmon/max34440.c line 127

Quoted 10 lines
drivers/hwmon/max34440.c new file +10 -0
+		.direct[PSC_FAN] = true,
+		.m[PSC_VOLTAGE_IN] = 1,
+		.b[PSC_VOLTAGE_IN] = 0,
+		.R[PSC_VOLTAGE_IN] = 3,
+		.m[PSC_VOLTAGE_OUT] = 1,
+		.b[PSC_VOLTAGE_OUT] = 0,
+		.R[PSC_VOLTAGE_OUT] = 3,
+		.m[PSC_CURRENT_OUT] = 1,
+		.b[PSC_CURRENT_OUT] = 0,
+		.R[PSC_CURRENT_OUT] = 3,

Again, table 3 seems to indicate this should be 0 not 3. Am I reading it wrong? Please explain how these numbers are reached...

Quoted 71 lines
drivers/hwmon/max34440.c new file +71 -0
+		.m[PSC_TEMPERATURE] = 1,
+		.b[PSC_TEMPERATURE] = 0,
+		.R[PSC_TEMPERATURE] = 2,
+		.m[PSC_FAN] = 1,
+		.b[PSC_FAN] = 0,
+		.R[PSC_FAN] = 0,
+		.func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[4] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT,
+		.func[5] = PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12,
+		.func[6] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[7] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[8] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[9] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[10] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.func[11] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
+		.get_status = max34440_get_status,
+	},
+};
+
+static int max34440_probe(struct i2c_client *client,
+			  const struct i2c_device_id *id)
+{
+	return pmbus_do_probe(client, id, &max34440_info[id->driver_data]);
+}
+
+static int max34440_remove(struct i2c_client *client)
+{
+	return pmbus_do_remove(client);
+}
+
+static const struct i2c_device_id max34440_id[] = {
+	{"max34440", max34440},
+	{"max34441", max34441},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, max34440_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver max34440_driver = {
+	.driver = {
+		   .name = "max34440",
+		   },
+	.probe = max34440_probe,
+	.remove = max34440_remove,
+	.id_table = max34440_id,
+};
+
+static int __init max34440_init(void)
+{
+	return i2c_add_driver(&max34440_driver);
+}
+
+static void __exit max34440_exit(void)
+{
+	i2c_del_driver(&max34440_driver);
+}
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("PMBus driver for Maxim MAX34440/MAX34441");
+MODULE_LICENSE("GPL");
+module_init(max34440_init);
+module_exit(max34440_exit);
#14 lore raw

Re: [PATCH v4 4/5] hwmon: (pmbus) Add support for Maxim MAX34440/MAX34441

Hi Jonathan,

Quoted 3 lines · Jonathan Cameron

One trivial formatting nitpick.
Dug out datasheet for this one..
I'm a little unclear how value from there map to those stored in here...

[ ... ]

Quoted 10 lines
Quoted 10 lines
drivers/hwmon/max34440.c new file +10 -0
+static struct pmbus_driver_info max34440_info[] = {
+	[max34440] = {
+		.pages = 14,
+		.direct[PSC_VOLTAGE_IN] = true,
+		.direct[PSC_VOLTAGE_OUT] = true,
+		.direct[PSC_TEMPERATURE] = true,
+		.direct[PSC_CURRENT_OUT] = true,
+		.m[PSC_VOLTAGE_IN] = 1,
+		.b[PSC_VOLTAGE_IN] = 0,
+		.R[PSC_VOLTAGE_IN] = 3,
Quoted 8 lines

drivers/hwmon/max34440.c line 86

Quoted 6 lines
drivers/hwmon/max34440.c new file +6 -0
+		.m[PSC_VOLTAGE_OUT] = 1,
+		.b[PSC_VOLTAGE_OUT] = 0,
+		.R[PSC_VOLTAGE_OUT] = 3,
+		.m[PSC_CURRENT_OUT] = 1,
+		.b[PSC_CURRENT_OUT] = 0,
+		.R[PSC_CURRENT_OUT] = 3,

Table 3 of datasheet says R for current is 0... I may be missing something though!

At least this one has a relatively simple reason ;).

The base unit (to which R is applied to) in the datasheet is mV and mA. The base unit used by max8688 and max16064 is V and A. Chips in linear mode also use V and A. I had the choice of either adjusting the code to expect mV and mA for all chips, or to expect V and A for all chips. I decided to use the latter for consistency, and to adjust R in the core driver to the units expected to be reported in the sysfs attributes. For max34440/max34441, the adjustment ends up being 0 either way (3 + (-3) in one direction and (-3) + 3 in the other).

Another option would be to not do any sysfs related adjustments in the core driver, but to do all adjustments via platform data instead. I decided against that because the code to handle linear mode (which expects V and A) would no longer match the code to handle direct mode, which might cause even more confusion.

Thanks,
Guenter

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

#15 lore raw

Re: [PATCH v4 4/5] hwmon: (pmbus) Add support for Maxim MAX34440/MAX34441

Quoted 29 lines · Guenter Roeck

Hi Jonathan,

Quoted 3 lines · Jonathan Cameron

One trivial formatting nitpick.
Dug out datasheet for this one..
I'm a little unclear how value from there map to those stored in here...

[ ... ]

Quoted 10 lines
Quoted 10 lines
drivers/hwmon/max34440.c new file +10 -0
+static struct pmbus_driver_info max34440_info[] = {
+	[max34440] = {
+		.pages = 14,
+		.direct[PSC_VOLTAGE_IN] = true,
+		.direct[PSC_VOLTAGE_OUT] = true,
+		.direct[PSC_TEMPERATURE] = true,
+		.direct[PSC_CURRENT_OUT] = true,
+		.m[PSC_VOLTAGE_IN] = 1,
+		.b[PSC_VOLTAGE_IN] = 0,
+		.R[PSC_VOLTAGE_IN] = 3,
Quoted 8 lines

drivers/hwmon/max34440.c line 86

Quoted 6 lines
drivers/hwmon/max34440.c new file +6 -0
+		.m[PSC_VOLTAGE_OUT] = 1,
+		.b[PSC_VOLTAGE_OUT] = 0,
+		.R[PSC_VOLTAGE_OUT] = 3,
+		.m[PSC_CURRENT_OUT] = 1,
+		.b[PSC_CURRENT_OUT] = 0,
+		.R[PSC_CURRENT_OUT] = 3,

Table 3 of datasheet says R for current is 0... I may be missing something though!

At least this one has a relatively simple reason ;).

Quoted 8 lines

The base unit (to which R is applied to) in the datasheet is mV and mA. The base unit used by max8688 and max16064 is V and A. Chips in linear mode also use V and A. I had the choice of either adjusting the code to expect mV and mA for all chips, or to expect V and A for all chips. I decided to use the latter for consistency, and to adjust R in the core driver to the units expected to be reported in the sysfs attributes. For max34440/max34441, the adjustment ends up being 0 either way (3 + (-3) in one direction and (-3) + 3 in the other).

This reason actually occurred to me whilst cycling home but thanks for clarifying this.

Quoted 6 lines

Another option would be to not do any sysfs related adjustments in the core driver, but to do all adjustments via platform data instead. I decided against that because the code to handle linear mode (which expects V and A) would no longer match the code to handle direct mode, which might cause even more confusion.

What you have works fine for me though you'll have to keep a close eye on any drivers submitted by others as this will be easy to get wrong as people will blindly fill tables in from datasheets.

Quoted 6 lines

Thanks,
Guenter

#16 lore raw

Re: [PATCH v4 4/5] hwmon: (pmbus) Add support for Maxim MAX34440/MAX34441

Quoted 41 lines · Jonathan Cameron
Quoted 29 lines · Guenter Roeck

Hi Jonathan,

Quoted 3 lines · Jonathan Cameron

One trivial formatting nitpick.
Dug out datasheet for this one..
I'm a little unclear how value from there map to those stored in here...

[ ... ]

Quoted 10 lines
Quoted 10 lines
drivers/hwmon/max34440.c new file +10 -0
+static struct pmbus_driver_info max34440_info[] = {
+	[max34440] = {
+		.pages = 14,
+		.direct[PSC_VOLTAGE_IN] = true,
+		.direct[PSC_VOLTAGE_OUT] = true,
+		.direct[PSC_TEMPERATURE] = true,
+		.direct[PSC_CURRENT_OUT] = true,
+		.m[PSC_VOLTAGE_IN] = 1,
+		.b[PSC_VOLTAGE_IN] = 0,
+		.R[PSC_VOLTAGE_IN] = 3,
Quoted 8 lines

drivers/hwmon/max34440.c line 86

Quoted 6 lines
drivers/hwmon/max34440.c new file +6 -0
+		.m[PSC_VOLTAGE_OUT] = 1,
+		.b[PSC_VOLTAGE_OUT] = 0,
+		.R[PSC_VOLTAGE_OUT] = 3,
+		.m[PSC_CURRENT_OUT] = 1,
+		.b[PSC_CURRENT_OUT] = 0,
+		.R[PSC_CURRENT_OUT] = 3,

Table 3 of datasheet says R for current is 0... I may be missing something though!

At least this one has a relatively simple reason ;).

Quoted 8 lines

The base unit (to which R is applied to) in the datasheet is mV and mA. The base unit used by max8688 and max16064 is V and A. Chips in linear mode also use V and A. I had the choice of either adjusting the code to expect mV and mA for all chips, or to expect V and A for all chips. I decided to use the latter for consistency, and to adjust R in the core driver to the units expected to be reported in the sysfs attributes. For max34440/max34441, the adjustment ends up being 0 either way (3 + (-3) in one direction and (-3) + 3 in the other).

This reason actually occurred to me whilst cycling home but thanks for clarifying this.

Quoted 1 line
Quoted 9 lines
Quoted 5 lines

Another option would be to not do any sysfs related adjustments in the core driver, but to do all adjustments via platform data instead. I decided against that because the code to handle linear mode (which expects V and A) would no longer match the code to handle direct mode, which might cause even more confusion.

What you have works fine for me though you'll have to keep a close eye on any drivers submitted by others as this will be easy to get wrong as people will blindly fill tables in from datasheets.

... though they should really test the code before submitting it. But you are definitely right.

Quoted 1 line

Thanks!

Guenter

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors

#17 lore raw

PATCH v4 5/5 hwmon: pmbus driver documentation

In reply to Guenter Roeck
---
 Documentation/hwmon/pmbus |  213 +++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 213 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/hwmon/pmbus
Documentation/hwmon/pmbus new file +213 -0
new file mode 100644
index 0000000..00ed7d4
@@ -0,0 +1,213 @@
+Kernel driver pmbus
+==========
+
+Supported chips:
+  * Ericsson BMR45X series
+    DC/DC Converter
+    Prefixes: 'bmr450', 'bmr451', 'bmr453', 'bmr454'
+    Addresses scanned: -
+    Datasheet:
+ http://archive.ericsson.net/service/internet/picov/get?DocNo(701-EN/LZT146395
+  * Linear Technology LTC2978
+    Octal PMBus Power Supply Monitor and Controller
+    Prefix: 'ltc2978'
+    Addresses scanned: -
+    Datasheet: http://cds.linear.com/docs/Datasheet/2978fa.pdf
+  * Maxim MAX16064
+    Quad Power-Supply Controller
+    Prefix: 'max16064'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX16064.pdf
+  * Maxim MAX34440
+    PMBus 6-Channel Power-Supply Manager
+    Prefixes: 'max34440'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX34440.pdf
+  * Maxim MAX34441
+    PMBus 5-Channel Power-Supply Manager and Intelligent Fan Controller
+    Prefixes: 'max34441'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX34441.pdf
+  * Maxim MAX8688
+    Digital Power-Supply Controller/Monitor
+    Prefix: 'max8688'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX8688.pdf
+  * Generic PMBus devices
+    Prefix: 'pmbus'
+    Addresses scanned: -
+    Datasheet: n.a.
+
+Author: Guenter Roeck <[email protected]>
+
+
+Description
+-----------
+
+This driver supports hardware montoring for various PMBus compliant devices.
+It supports voltage, current, power, and temperature sensors as supported
+by the device.
+
+Each monitored channel has its own high and low limits, plus a critical
+limit.
+
+
+Usage Notes
+-----------
+
+This driver does not probe for PMBus devices, since there is no register
+which can be safely used to identify the chip (The MFG_ID register is not
+supported by all chips), and since there is no well defined address range for
+PMBus devices. You will have to instantiate the devices explicitly.
+
+Example: the following will load the driver for an LTC2978 at address 0x60
+on I2C bus #1:
+$ modprobe pmbus
+$ echo ltc2978 0x60 > /sys/bus/i2c/devices/i2c-1/new_device
+
+
+Platform data support
+---------------------
+
+Support for additional PMBus chips can be added by defining chip parameters in
+a new chip specific driver file. For example, (untested) code to add support for
+Emerson DS1200 power modules might look as follows.
+
+static struct pmbus_driver_info ds1200_info = {
+	.pages = 1,
+	/* Note: All other sensors are in linear mode */
+	.direct[PSC_VOLTAGE_OUT] = true,
+	.direct[PSC_TEMPERATURE] = true,
+	.direct[PSC_CURRENT_OUT] = true,
+	.m[PSC_VOLTAGE_IN] = 1,
+	.b[PSC_VOLTAGE_IN] = 0,
+	.R[PSC_VOLTAGE_IN] = 3,
+	.m[PSC_VOLTAGE_OUT] = 1,
+	.b[PSC_VOLTAGE_OUT] = 0,
+	.R[PSC_VOLTAGE_OUT] = 3,
+	.m[PSC_TEMPERATURE] = 1,
+	.b[PSC_TEMPERATURE] = 0,
+	.R[PSC_TEMPERATURE] = 3,
+	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT
+		   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
+		   | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT
+		   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
+		   | PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12,
+};
+
+static int ds1200_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	return pmbus_do_probe(client, id, &ds1200_info);
+}
+
+static int ds1200_remove(struct i2c_client *client)
+{
+	return pmbus_do_remove(client);
+}
+
+static const struct i2c_device_id ds1200_id[] = {
+	{"ds1200", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, ds1200_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver ds1200_driver = {
+	.driver = {
+		   .name = "ds1200",
+		   },
+	.probe = ds1200_probe,
+	.remove = ds1200_remove,
+	.id_table = ds1200_id,
+};
+
+static int __init ds1200_init(void)
+{
+	return i2c_add_driver(&ds1200_driver);
+}
+
+static void __exit ds1200_exit(void)
+{
+	i2c_del_driver(&ds1200_driver);
+}
+
+
+Sysfs entries
+-------------
+
+When probing the chip, the driver identifies which PMBus registers are
+supported, and determines available sensors from this information.
+Attribute files only exist if respective sensors are suported by the chip.
+Labels are provided to inform the user about the sensor associated with
+a given sysfs entry.
+
+The following attributes are supported. Limits are read-write; all other
+attributes are read-only.
+
+inX_input		Measured voltage. From READ_VIN or READ_VOUT register.
+inX_min			Minumum Voltage.
+			From VIN_UV_WARN_LIMIT or VOUT_UV_WARN_LIMIT register.
+inX_max			Maximum voltage.
+			From VIN_OV_WARN_LIMIT or VOUT_OV_WARN_LIMIT register.
+inX_lcrit		Critical minumum Voltage.
+			From VIN_UV_FAULT_LIMIT or VOUT_UV_FAULT_LIMIT register.
+inX_crit		Critical maximum voltage.
+			From VIN_OV_FAULT_LIMIT or VOUT_OV_FAULT_LIMIT register.
+inX_min_alarm		Voltage low alarm. From VOLTAGE_UV_WARNING status.
+inX_max_alarm		Voltage high alarm. From VOLTAGE_OV_WARNING status.
+inX_lcrit_alarm		Voltage critical low alarm.
+			From VOLTAGE_UV_FAULT status.
+inX_crit_alarm		Voltage critical high alarm.
+			From VOLTAGE_OV_FAULT status.
+inX_label		"vin", "vcap", or "voutY"
+
+currX_input		Measured current. From READ_IIN or READ_IOUT register.
+currX_max		Maximum current.
+			From IIN_OC_WARN_LIMIT or IOUT_OC_WARN_LIMIT register.
+currX_lcrit		Critical minumum output current.
+			From IOUT_UC_FAULT_LIMIT register.
+currX_crit		Critical maximum current.
+			From IIN_OC_FAULT_LIMIT or IOUT_OC_FAULT_LIMIT register.
+currX_alarm		Current high alarm.
+			From IIN_OC_WARNING or IOUT_OC_WARNING status.
+currX_lcrit_alarm	Output current critical low alarm.
+			From IOUT_UC_FAULT status.
+currX_crit_alarm	Current critical high alarm.
+			From IIN_OC_FAULT or IOUT_OC_FAULT status.
+currX_label		"iin" or "vinY"
+
+powerX_input		Measured power. From READ_PIN or READ_POUT register.
+powerX_cap		Output power cap. From POUT_MAX register.
+powerX_max		Power limit. From PIN_OP_WARN_LIMIT or
+			POUT_OP_WARN_LIMIT register.
+powerX_crit		Critical output power limit.
+			From POUT_OP_FAULT_LIMIT register.
+powerX_alarm		Power high alarm.
+			From PIN_OP_WARNING or POUT_OP_WARNING status.
+powerX_crit_alarm	Output power critical high alarm.
+			From POUT_OP_FAULT status.
+powerX_label		"pin" or "poutY"
+
+tempX_input		Measured tempererature.
+			From READ_TEMPERATURE_X register.
+tempX_min		Mimimum tempererature. From UT_WARN_LIMIT register.
+tempX_max		Maximum tempererature. From OT_WARN_LIMIT register.
+tempX_lcrit		Critical low tempererature.
+			From UT_FAULT_LIMIT register.
+tempX_crit		Critical high tempererature.
+			From OT_FAULT_LIMIT register.
+tempX_min_alarm		Chip temperature low alarm. Set by comparing
+			READ_TEMPERATURE_X with UT_WARN_LIMIT if
+			TEMP_UT_WARNING status is set.
+tempX_max_alarm		Chip temperature high alarm. Set by comparing
+			READ_TEMPERATURE_X with OT_WARN_LIMIT if
+			TEMP_OT_WARNING status is set.
+tempX_lcrit_alarm	Chip temperature critical low alarm. Set by comparing
+			READ_TEMPERATURE_X with UT_FAULT_LIMIT if
+			TEMP_UT_FAULT status is set.
+tempX_crit_alarm	Chip temperature critical high alarm. Set by comparing
+			READ_TEMPERATURE_X with OT_FAULT_LIMIT if
+			TEMP_OT_FAULT status is set.
Signature · 7 lines
1.7.3.1


_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
Acked-by on v4 5/5
#18 lore raw

Re: [PATCH v4 5/5] hwmon: pmbus driver documentation

Looks fine to me. Do you want to mention the fan stuff somewhere?

Quoted 1 line · Guenter Roeck
Quoted 50 lines
---
 Documentation/hwmon/pmbus |  213 +++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 213 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/hwmon/pmbus
Documentation/hwmon/pmbus new file +39 -0
new file mode 100644
index 0000000..00ed7d4
@@ -0,0 +1,213 @@
+Kernel driver pmbus
+====================
+
+Supported chips:
+  * Ericsson BMR45X series
+    DC/DC Converter
+    Prefixes: 'bmr450', 'bmr451', 'bmr453', 'bmr454'
+    Addresses scanned: -
+    Datasheet:
+ http://archive.ericsson.net/service/internet/picov/get?DocNo=28701-EN/LZT146395
+  * Linear Technology LTC2978
+    Octal PMBus Power Supply Monitor and Controller
+    Prefix: 'ltc2978'
+    Addresses scanned: -
+    Datasheet: http://cds.linear.com/docs/Datasheet/2978fa.pdf
+  * Maxim MAX16064
+    Quad Power-Supply Controller
+    Prefix: 'max16064'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX16064.pdf
+  * Maxim MAX34440
+    PMBus 6-Channel Power-Supply Manager
+    Prefixes: 'max34440'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX34440.pdf
+  * Maxim MAX34441
+    PMBus 5-Channel Power-Supply Manager and Intelligent Fan Controller
+    Prefixes: 'max34441'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX34441.pdf
+  * Maxim MAX8688
+    Digital Power-Supply Controller/Monitor
+    Prefix: 'max8688'
+    Addresses scanned: -
+    Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX8688.pdf
+  * Generic PMBus devices
+    Prefix: 'pmbus'
+    Addresses scanned: -
+    Datasheet: n.a.

Documentation/hwmon/pmbus line 49

Quoted 10 lines
Documentation/hwmon/pmbus new file +10 -0
+
+Author: Guenter Roeck <[email protected]>
+
+
+Description
+-----------
+
+This driver supports hardware montoring for various PMBus compliant devices.
+It supports voltage, current, power, and temperature sensors as supported
+by the device.

Mention fan stuff?

Quoted 164 lines
Documentation/hwmon/pmbus new file +164 -0
+
+Each monitored channel has its own high and low limits, plus a critical
+limit.
+
+
+Usage Notes
+-----------
+
+This driver does not probe for PMBus devices, since there is no register
+which can be safely used to identify the chip (The MFG_ID register is not
+supported by all chips), and since there is no well defined address range for
+PMBus devices. You will have to instantiate the devices explicitly.
+
+Example: the following will load the driver for an LTC2978 at address 0x60
+on I2C bus #1:
+$ modprobe pmbus
+$ echo ltc2978 0x60 > /sys/bus/i2c/devices/i2c-1/new_device
+
+
+Platform data support
+---------------------
+
+Support for additional PMBus chips can be added by defining chip parameters in
+a new chip specific driver file. For example, (untested) code to add support for
+Emerson DS1200 power modules might look as follows.
+
+static struct pmbus_driver_info ds1200_info = {
+	.pages = 1,
+	/* Note: All other sensors are in linear mode */
+	.direct[PSC_VOLTAGE_OUT] = true,
+	.direct[PSC_TEMPERATURE] = true,
+	.direct[PSC_CURRENT_OUT] = true,
+	.m[PSC_VOLTAGE_IN] = 1,
+	.b[PSC_VOLTAGE_IN] = 0,
+	.R[PSC_VOLTAGE_IN] = 3,
+	.m[PSC_VOLTAGE_OUT] = 1,
+	.b[PSC_VOLTAGE_OUT] = 0,
+	.R[PSC_VOLTAGE_OUT] = 3,
+	.m[PSC_TEMPERATURE] = 1,
+	.b[PSC_TEMPERATURE] = 0,
+	.R[PSC_TEMPERATURE] = 3,
+	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT
+		   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+		   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
+		   | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT
+		   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
+		   | PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12,
+};
+
+static int ds1200_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	return pmbus_do_probe(client, id, &ds1200_info);
+}
+
+static int ds1200_remove(struct i2c_client *client)
+{
+	return pmbus_do_remove(client);
+}
+
+static const struct i2c_device_id ds1200_id[] = {
+	{"ds1200", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, ds1200_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver ds1200_driver = {
+	.driver = {
+		   .name = "ds1200",
+		   },
+	.probe = ds1200_probe,
+	.remove = ds1200_remove,
+	.id_table = ds1200_id,
+};
+
+static int __init ds1200_init(void)
+{
+	return i2c_add_driver(&ds1200_driver);
+}
+
+static void __exit ds1200_exit(void)
+{
+	i2c_del_driver(&ds1200_driver);
+}
+
+
+Sysfs entries
+-------------
+
+When probing the chip, the driver identifies which PMBus registers are
+supported, and determines available sensors from this information.
+Attribute files only exist if respective sensors are suported by the chip.
+Labels are provided to inform the user about the sensor associated with
+a given sysfs entry.
+
+The following attributes are supported. Limits are read-write; all other
+attributes are read-only.
+
+inX_input		Measured voltage. From READ_VIN or READ_VOUT register.
+inX_min			Minumum Voltage.
+			From VIN_UV_WARN_LIMIT or VOUT_UV_WARN_LIMIT register.
+inX_max			Maximum voltage.
+			From VIN_OV_WARN_LIMIT or VOUT_OV_WARN_LIMIT register.
+inX_lcrit		Critical minumum Voltage.
+			From VIN_UV_FAULT_LIMIT or VOUT_UV_FAULT_LIMIT register.
+inX_crit		Critical maximum voltage.
+			From VIN_OV_FAULT_LIMIT or VOUT_OV_FAULT_LIMIT register.
+inX_min_alarm		Voltage low alarm. From VOLTAGE_UV_WARNING status.
+inX_max_alarm		Voltage high alarm. From VOLTAGE_OV_WARNING status.
+inX_lcrit_alarm		Voltage critical low alarm.
+			From VOLTAGE_UV_FAULT status.
+inX_crit_alarm		Voltage critical high alarm.
+			From VOLTAGE_OV_FAULT status.
+inX_label		"vin", "vcap", or "voutY"
+
+currX_input		Measured current. From READ_IIN or READ_IOUT register.
+currX_max		Maximum current.
+			From IIN_OC_WARN_LIMIT or IOUT_OC_WARN_LIMIT register.
+currX_lcrit		Critical minumum output current.
+			From IOUT_UC_FAULT_LIMIT register.
+currX_crit		Critical maximum current.
+			From IIN_OC_FAULT_LIMIT or IOUT_OC_FAULT_LIMIT register.
+currX_alarm		Current high alarm.
+			From IIN_OC_WARNING or IOUT_OC_WARNING status.
+currX_lcrit_alarm	Output current critical low alarm.
+			From IOUT_UC_FAULT status.
+currX_crit_alarm	Current critical high alarm.
+			From IIN_OC_FAULT or IOUT_OC_FAULT status.
+currX_label		"iin" or "vinY"
+
+powerX_input		Measured power. From READ_PIN or READ_POUT register.
+powerX_cap		Output power cap. From POUT_MAX register.
+powerX_max		Power limit. From PIN_OP_WARN_LIMIT or
+			POUT_OP_WARN_LIMIT register.
+powerX_crit		Critical output power limit.
+			From POUT_OP_FAULT_LIMIT register.
+powerX_alarm		Power high alarm.
+			From PIN_OP_WARNING or POUT_OP_WARNING status.
+powerX_crit_alarm	Output power critical high alarm.
+			From POUT_OP_FAULT status.
+powerX_label		"pin" or "poutY"
+
+tempX_input		Measured tempererature.
+			From READ_TEMPERATURE_X register.
+tempX_min		Mimimum tempererature. From UT_WARN_LIMIT register.
+tempX_max		Maximum tempererature. From OT_WARN_LIMIT register.
+tempX_lcrit		Critical low tempererature.
+			From UT_FAULT_LIMIT register.
+tempX_crit		Critical high tempererature.
+			From OT_FAULT_LIMIT register.
+tempX_min_alarm		Chip temperature low alarm. Set by comparing
+			READ_TEMPERATURE_X with UT_WARN_LIMIT if
+			TEMP_UT_WARNING status is set.
+tempX_max_alarm		Chip temperature high alarm. Set by comparing
+			READ_TEMPERATURE_X with OT_WARN_LIMIT if
+			TEMP_OT_WARNING status is set.
+tempX_lcrit_alarm	Chip temperature critical low alarm. Set by comparing
+			READ_TEMPERATURE_X with UT_FAULT_LIMIT if
+			TEMP_UT_FAULT status is set.
+tempX_crit_alarm	Chip temperature critical high alarm. Set by comparing
+			READ_TEMPERATURE_X with OT_FAULT_LIMIT if
+			TEMP_OT_FAULT status is set.