drivers/hwmon/pmbus/isl68137.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Hardware monitoring driver for Renesas Digital Multiphase Voltage Regulators
  *
  * Copyright (c) 2017 Google Inc
  * Copyright (c) 2020 Renesas Electronics America
  *
  */

 #include <linux/err.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/string.h>
 #include <linux/sysfs.h>

 #include "pmbus.h"

 #define ISL68137_VOUT_AVS	0x30
 #define RAA_DMPVR2_READ_VMON	0xc8
 #define MAX_CHANNELS            4

 enum chips {
 	isl68137,
 	isl68220,
 	isl68221,
 	isl68222,
 	isl68223,
 	isl68224,
 	isl68225,
 	isl68226,
 	isl68227,
 	isl68229,
 	isl68233,
 	isl68239,
 	isl69222,
 	isl69223,
 	isl69224,
 	isl69225,
 	isl69227,
 	isl69228,
 	isl69234,
 	isl69236,
 	isl69239,
 	isl69242,
 	isl69243,
 	isl69247,
 	isl69248,
 	isl69254,
 	isl69255,
 	isl69256,
 	isl69259,
 	isl69260,
 	isl69268,
 	isl69269,
 	isl69298,
 	raa228000,
 	raa228004,
 	raa228006,
 	raa228228,
 	raa229001,
 	raa229004,
 };

 enum variants {
 	raa_dmpvr1_2rail,
 	raa_dmpvr2_1rail,
 	raa_dmpvr2_2rail,
 	raa_dmpvr2_2rail_nontc,
 	raa_dmpvr2_3rail,
 	raa_dmpvr2_hv,
 };

 struct isl68137_channel {
 	u32 vout_voltage_divider[2];
 };

 struct isl68137_data {
 	struct pmbus_driver_info info;
 	struct isl68137_channel channel[MAX_CHANNELS];
 };

 #define to_isl68137_data(x)	container_of(x, struct isl68137_data, info)

 static const struct i2c_device_id raa_dmpvr_id[];

 static ssize_t isl68137_avs_enable_show_page(struct i2c_client *client,
 					     int page,
 					     char *buf)
 {
 	int val = pmbus_read_byte_data(client, page, PMBUS_OPERATION);

 	return sprintf(buf, "%d\n",
 		       (val & ISL68137_VOUT_AVS) == ISL68137_VOUT_AVS ? 1 : 0);
 }

 static ssize_t isl68137_avs_enable_store_page(struct i2c_client *client,
 					      int page,
 					      const char *buf, size_t count)
 {
 	int rc, op_val;
 	bool result;

 	rc = kstrtobool(buf, &result);
 	if (rc)
 		return rc;

 	op_val = result ? ISL68137_VOUT_AVS : 0;

 	/*
 	 * Writes to VOUT setpoint over AVSBus will persist after the VRM is
 	 * switched to PMBus control. Switching back to AVSBus control
 	 * restores this persisted setpoint rather than re-initializing to
 	 * PMBus VOUT_COMMAND. Writing VOUT_COMMAND first over PMBus before
 	 * enabling AVS control is the workaround.
 	 */
 	if (op_val == ISL68137_VOUT_AVS) {
 		rc = pmbus_read_word_data(client, page, 0xff,
 					  PMBUS_VOUT_COMMAND);
 		if (rc < 0)
 			return rc;

 		rc = pmbus_write_word_data(client, page, PMBUS_VOUT_COMMAND,
 					   rc);
 		if (rc < 0)
 			return rc;
 	}

 	rc = pmbus_update_byte_data(client, page, PMBUS_OPERATION,
 				    ISL68137_VOUT_AVS, op_val);

 	return (rc < 0) ? rc : count;
 }

 static ssize_t isl68137_avs_enable_show(struct device *dev,
 					struct device_attribute *devattr,
 					char *buf)
 {
 	struct i2c_client *client = to_i2c_client(dev->parent);
 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

 	return isl68137_avs_enable_show_page(client, attr->index, buf);
 }

 static ssize_t isl68137_avs_enable_store(struct device *dev,
 				struct device_attribute *devattr,
 				const char *buf, size_t count)
 {
 	struct i2c_client *client = to_i2c_client(dev->parent);
 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

 	return isl68137_avs_enable_store_page(client, attr->index, buf, count);
 }

 static SENSOR_DEVICE_ATTR_RW(avs0_enable, isl68137_avs_enable, 0);
 static SENSOR_DEVICE_ATTR_RW(avs1_enable, isl68137_avs_enable, 1);

 static struct attribute *enable_attrs[] = {
 	&sensor_dev_attr_avs0_enable.dev_attr.attr,
 	&sensor_dev_attr_avs1_enable.dev_attr.attr,
 	NULL,
 };

 static const struct attribute_group enable_group = {
 	.attrs = enable_attrs,
 };

 static const struct attribute_group *isl68137_attribute_groups[] = {
 	&enable_group,
 	NULL,
 };

 static int raa_dmpvr2_read_word_data(struct i2c_client *client, int page,
 				     int phase, int reg)
 {
 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 	const struct isl68137_data *data = to_isl68137_data(info);
 	int ret;
 	u64 temp;

 	switch (reg) {
 	case PMBUS_VIRT_READ_VMON:
 		ret = pmbus_read_word_data(client, page, phase,
 					   RAA_DMPVR2_READ_VMON);
 		break;
 	case PMBUS_READ_POUT:
 	case PMBUS_READ_VOUT:
 		/*
 		 * In cases where a voltage divider is attached to the target
 		 * rail between Vout and the Vsense pin, both Vout and Pout
 		 * should be scaled by the voltage divider scaling factor.
 		 * I.e. Vout = Vsense * Rtotal / Rout
 		 */
 		ret = pmbus_read_word_data(client, page, phase, reg);
 		if (ret > 0) {
 			temp = DIV_U64_ROUND_CLOSEST((u64)ret *
 				data->channel[page].vout_voltage_divider[1],
 				data->channel[page].vout_voltage_divider[0]);
 			ret = clamp_val(temp, 0, 0xffff);
 		}
 		break;
 	default:
 		ret = -ENODATA;
 		break;
 	}

 	return ret;
 }

 static int raa_dmpvr2_write_word_data(struct i2c_client *client, int page,
 				      int reg, u16 word)
 {
 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 	const struct isl68137_data *data = to_isl68137_data(info);
 	int ret;
 	u64 temp;

 	switch (reg) {
 	case PMBUS_VOUT_MAX:
 	case PMBUS_VOUT_MARGIN_HIGH:
 	case PMBUS_VOUT_MARGIN_LOW:
 	case PMBUS_VOUT_OV_FAULT_LIMIT:
 	case PMBUS_VOUT_UV_FAULT_LIMIT:
 	case PMBUS_VOUT_COMMAND:
 		/*
 		 * In cases where a voltage divider is attached to the target
 		 * rail between Vout and the Vsense pin, Vout related PMBus
 		 * commands should be scaled based on the expected voltage
 		 * at the Vsense pin.
 		 * I.e. Vsense = Vout * Rout / Rtotal
 		 */
 		temp = DIV_U64_ROUND_CLOSEST((u64)word *
 				data->channel[page].vout_voltage_divider[0],
 				data->channel[page].vout_voltage_divider[1]);
 		ret = clamp_val(temp, 0, 0xffff);
 		break;
 	default:
 		ret = -ENODATA;
 		break;
 	}
 	return ret;
 }

 static struct pmbus_driver_info raa_dmpvr_info = {
 	.pages = 3,
 	.format[PSC_VOLTAGE_IN] = direct,
 	.format[PSC_VOLTAGE_OUT] = direct,
 	.format[PSC_CURRENT_IN] = direct,
 	.format[PSC_CURRENT_OUT] = direct,
 	.format[PSC_POWER] = direct,
 	.format[PSC_TEMPERATURE] = direct,
 	.m[PSC_VOLTAGE_IN] = 1,
 	.b[PSC_VOLTAGE_IN] = 0,
 	.R[PSC_VOLTAGE_IN] = 2,
 	.m[PSC_VOLTAGE_OUT] = 1,
 	.b[PSC_VOLTAGE_OUT] = 0,
 	.R[PSC_VOLTAGE_OUT] = 3,
 	.m[PSC_CURRENT_IN] = 1,
 	.b[PSC_CURRENT_IN] = 0,
 	.R[PSC_CURRENT_IN] = 2,
 	.m[PSC_CURRENT_OUT] = 1,
 	.b[PSC_CURRENT_OUT] = 0,
 	.R[PSC_CURRENT_OUT] = 1,
 	.m[PSC_POWER] = 1,
 	.b[PSC_POWER] = 0,
 	.R[PSC_POWER] = 0,
 	.m[PSC_TEMPERATURE] = 1,
 	.b[PSC_TEMPERATURE] = 0,
 	.R[PSC_TEMPERATURE] = 0,
 	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
 	    | PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP2
 	    | PMBUS_HAVE_TEMP3 | PMBUS_HAVE_STATUS_TEMP
 	    | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 	    | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT
 		| PMBUS_HAVE_VMON,
 	.func[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT
 	    | PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP3 | PMBUS_HAVE_STATUS_TEMP
 	    | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT
 	    | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT,
 	.func[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT
 	    | PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP3 | PMBUS_HAVE_STATUS_TEMP
 	    | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT
 	    | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT,
 };

 static int isl68137_probe_child_from_dt(struct device *dev,
 					struct device_node *child,
 					struct isl68137_data *data)
 {
 	u32 channel, rout, rtotal;
 	int err;

 	err = of_property_read_u32(child, "reg", &channel);
 	if (err) {
 		dev_err(dev, "missing reg property of %pOFn\n", child);
 		return err;
 	}
 	if (channel >= data->info.pages) {
 		dev_err(dev, "invalid reg %d of %pOFn\n", channel, child);
 		return -EINVAL;
 	}

 	err = of_property_read_u32_array(child, "vout-voltage-divider",
 					 data->channel[channel].vout_voltage_divider,
 					 ARRAY_SIZE(data->channel[channel].vout_voltage_divider));
 	if (err && err != -EINVAL) {
 		dev_err(dev,
 			"malformed vout-voltage-divider value for channel %d\n",
 			channel);
 		return err;
 	}

 	rout = data->channel[channel].vout_voltage_divider[0];
 	rtotal = data->channel[channel].vout_voltage_divider[1];
 	if (rout == 0) {
 		dev_err(dev,
 			"Voltage divider output resistance must be greater than 0\n");
 		return -EINVAL;
 	}
 	if (rtotal < rout) {
 		dev_err(dev,
 			"Voltage divider total resistance is less than output resistance\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int isl68137_probe_from_dt(struct device *dev,
 				  struct isl68137_data *data)
 {
 	const struct device_node *np = dev->of_node;
 	struct device_node *child;
 	int err;

 	for_each_child_of_node(np, child) {
 		if (strcmp(child->name, "channel"))
 			continue;

 		err = isl68137_probe_child_from_dt(dev, child, data);
 		if (err)
 			return err;
 	}

 	return 0;
 }

 static int isl68137_probe(struct i2c_client *client)
 {
 	struct device *dev = &client->dev;
 	struct pmbus_driver_info *info;
 	struct isl68137_data *data;
 	int i, err;

 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 	if (!data)
 		return -ENOMEM;

 	/*
 	 * Initialize all voltage dividers to Rout=1 and Rtotal=1 to simplify
 	 * logic in PMBus word read/write functions
 	 */
 	for (i = 0; i < MAX_CHANNELS; i++)
 		memset(data->channel[i].vout_voltage_divider,
 		       1,
 		       sizeof(data->channel[i].vout_voltage_divider));

 	memcpy(&data->info, &raa_dmpvr_info, sizeof(data->info));
 	info = &data->info;

 	switch (i2c_match_id(raa_dmpvr_id, client)->driver_data) {
 	case raa_dmpvr1_2rail:
 		info->pages = 2;
 		info->R[PSC_VOLTAGE_IN] = 3;
 		info->func[0] &= ~PMBUS_HAVE_VMON;
 		info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 		    | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 		    | PMBUS_HAVE_POUT;
 		info->read_word_data = raa_dmpvr2_read_word_data;
 		info->write_word_data = raa_dmpvr2_write_word_data;
 		info->groups = isl68137_attribute_groups;
 		break;
 	case raa_dmpvr2_1rail:
 		info->pages = 1;
 		info->read_word_data = raa_dmpvr2_read_word_data;
 		info->write_word_data = raa_dmpvr2_write_word_data;
 		break;
 	case raa_dmpvr2_2rail_nontc:
 		info->func[0] &= ~PMBUS_HAVE_TEMP3;
 		info->func[1] &= ~PMBUS_HAVE_TEMP3;
 		fallthrough;
 	case raa_dmpvr2_2rail:
 		info->pages = 2;
 		info->read_word_data = raa_dmpvr2_read_word_data;
 		info->write_word_data = raa_dmpvr2_write_word_data;
 		break;
 	case raa_dmpvr2_3rail:
 		info->read_word_data = raa_dmpvr2_read_word_data;
 		info->write_word_data = raa_dmpvr2_write_word_data;
 		break;
 	case raa_dmpvr2_hv:
 		info->pages = 1;
 		info->R[PSC_VOLTAGE_IN] = 1;
 		info->m[PSC_VOLTAGE_OUT] = 2;
 		info->R[PSC_VOLTAGE_OUT] = 2;
 		info->m[PSC_CURRENT_IN] = 2;
 		info->m[PSC_POWER] = 2;
 		info->R[PSC_POWER] = -1;
 		info->read_word_data = raa_dmpvr2_read_word_data;
 		info->write_word_data = raa_dmpvr2_write_word_data;
 		break;
 	default:
 		return -ENODEV;
 	}

 	err = isl68137_probe_from_dt(dev, data);
 	if (err)
 		return err;

 	return pmbus_do_probe(client, info);
 }

 static const struct i2c_device_id raa_dmpvr_id[] = {
 	{"isl68137", raa_dmpvr1_2rail},
 	{"isl68220", raa_dmpvr2_2rail},
 	{"isl68221", raa_dmpvr2_3rail},
 	{"isl68222", raa_dmpvr2_2rail},
 	{"isl68223", raa_dmpvr2_2rail},
 	{"isl68224", raa_dmpvr2_3rail},
 	{"isl68225", raa_dmpvr2_2rail},
 	{"isl68226", raa_dmpvr2_3rail},
 	{"isl68227", raa_dmpvr2_1rail},
 	{"isl68229", raa_dmpvr2_3rail},
 	{"isl68233", raa_dmpvr2_2rail},
 	{"isl68239", raa_dmpvr2_3rail},

 	{"isl69222", raa_dmpvr2_2rail},
 	{"isl69223", raa_dmpvr2_3rail},
 	{"isl69224", raa_dmpvr2_2rail},
 	{"isl69225", raa_dmpvr2_2rail},
 	{"isl69227", raa_dmpvr2_3rail},
 	{"isl69228", raa_dmpvr2_3rail},
 	{"isl69234", raa_dmpvr2_2rail},
 	{"isl69236", raa_dmpvr2_2rail},
 	{"isl69239", raa_dmpvr2_3rail},
 	{"isl69242", raa_dmpvr2_2rail},
 	{"isl69243", raa_dmpvr2_1rail},
 	{"isl69247", raa_dmpvr2_2rail},
 	{"isl69248", raa_dmpvr2_2rail},
 	{"isl69254", raa_dmpvr2_2rail},
 	{"isl69255", raa_dmpvr2_2rail},
 	{"isl69256", raa_dmpvr2_2rail},
 	{"isl69259", raa_dmpvr2_2rail},
 	{"isl69260", raa_dmpvr2_2rail},
 	{"isl69268", raa_dmpvr2_2rail},
 	{"isl69269", raa_dmpvr2_3rail},
 	{"isl69298", raa_dmpvr2_2rail},

 	{"raa228000", raa_dmpvr2_hv},
 	{"raa228004", raa_dmpvr2_hv},
 	{"raa228006", raa_dmpvr2_hv},
 	{"raa228228", raa_dmpvr2_2rail_nontc},
 	{"raa229001", raa_dmpvr2_2rail},
 	{"raa229004", raa_dmpvr2_2rail},
 	{}
 };

 MODULE_DEVICE_TABLE(i2c, raa_dmpvr_id);

 static const struct of_device_id isl68137_of_match[] = {
 	{ .compatible = "isil,isl68137", .data = (void *)raa_dmpvr1_2rail },
 	{ .compatible = "renesas,isl68220", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl68221", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl68222", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl68223", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl68224", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl68225", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl68226", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl68227", .data = (void *)raa_dmpvr2_1rail },
 	{ .compatible = "renesas,isl68229", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl68233", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl68239", .data = (void *)raa_dmpvr2_3rail },

 	{ .compatible = "renesas,isl69222", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69223", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl69224", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69225", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69227", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl69228", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl69234", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69236", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69239", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl69242", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69243", .data = (void *)raa_dmpvr2_1rail },
 	{ .compatible = "renesas,isl69247", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69248", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69254", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69255", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69256", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69259", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "isil,isl69260", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,isl69268", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "isil,isl69269", .data = (void *)raa_dmpvr2_3rail },
 	{ .compatible = "renesas,isl69298", .data = (void *)raa_dmpvr2_2rail },

 	{ .compatible = "renesas,raa228000", .data = (void *)raa_dmpvr2_hv },
 	{ .compatible = "renesas,raa228004", .data = (void *)raa_dmpvr2_hv },
 	{ .compatible = "renesas,raa228006", .data = (void *)raa_dmpvr2_hv },
 	{ .compatible = "renesas,raa228228", .data = (void *)raa_dmpvr2_2rail_nontc },
 	{ .compatible = "renesas,raa229001", .data = (void *)raa_dmpvr2_2rail },
 	{ .compatible = "renesas,raa229004", .data = (void *)raa_dmpvr2_2rail },
 	{ },
 };

 MODULE_DEVICE_TABLE(of, isl68137_of_match);

 /* This is the driver that will be inserted */
 static struct i2c_driver isl68137_driver = {
 	.driver = {
 		.name = "isl68137",
 		.of_match_table = isl68137_of_match,
 	},
 	.probe = isl68137_probe,
 	.id_table = raa_dmpvr_id,
 };

 module_i2c_driver(isl68137_driver);

 MODULE_AUTHOR("Maxim Sloyko <maxims@google.com>");
 MODULE_DESCRIPTION("PMBus driver for Renesas digital multiphase voltage regulators");
 MODULE_LICENSE("GPL");
 MODULE_IMPORT_NS(PMBUS);
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Hardware monitoring driver for Renesas Digital Multiphase Voltage Regulators
	*
	* Copyright (c) 2017 Google Inc
	* Copyright (c) 2020 Renesas Electronics America
	*
	*/

	#include <linux/err.h>
	#include <linux/hwmon-sysfs.h>
	#include <linux/i2c.h>
	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/of.h>
	#include <linux/string.h>
	#include <linux/sysfs.h>

	#include "pmbus.h"

	#define ISL68137_VOUT_AVS 0x30
	#define RAA_DMPVR2_READ_VMON 0xc8
	#define MAX_CHANNELS 4

	enum chips {
	isl68137,
	isl68220,
	isl68221,
	isl68222,
	isl68223,
	isl68224,
	isl68225,
	isl68226,
	isl68227,
	isl68229,
	isl68233,
	isl68239,
	isl69222,
	isl69223,
	isl69224,
	isl69225,
	isl69227,
	isl69228,
	isl69234,
	isl69236,
	isl69239,
	isl69242,
	isl69243,
	isl69247,
	isl69248,
	isl69254,
	isl69255,
	isl69256,
	isl69259,
	isl69260,
	isl69268,
	isl69269,
	isl69298,
	raa228000,
	raa228004,
	raa228006,
	raa228228,
	raa229001,
	raa229004,
	};

	enum variants {
	raa_dmpvr1_2rail,
	raa_dmpvr2_1rail,
	raa_dmpvr2_2rail,
	raa_dmpvr2_2rail_nontc,
	raa_dmpvr2_3rail,
	raa_dmpvr2_hv,
	};

	struct isl68137_channel {
	u32 vout_voltage_divider[2];
	};

	struct isl68137_data {
	struct pmbus_driver_info info;
	struct isl68137_channel channel[MAX_CHANNELS];
	};

	#define to_isl68137_data(x) container_of(x, struct isl68137_data, info)

	static const struct i2c_device_id raa_dmpvr_id[];

	static ssize_t isl68137_avs_enable_show_page(struct i2c_client *client,
	int page,
	char *buf)
	{
	int val = pmbus_read_byte_data(client, page, PMBUS_OPERATION);

	return sprintf(buf, "%d\n",
	(val & ISL68137_VOUT_AVS) == ISL68137_VOUT_AVS ? 1 : 0);
	}

	static ssize_t isl68137_avs_enable_store_page(struct i2c_client *client,
	int page,
	const char *buf, size_t count)
	{
	int rc, op_val;
	bool result;

	rc = kstrtobool(buf, &result);
	if (rc)
	return rc;

	op_val = result ? ISL68137_VOUT_AVS : 0;

	/*
	* Writes to VOUT setpoint over AVSBus will persist after the VRM is
	* switched to PMBus control. Switching back to AVSBus control
	* restores this persisted setpoint rather than re-initializing to
	* PMBus VOUT_COMMAND. Writing VOUT_COMMAND first over PMBus before
	* enabling AVS control is the workaround.
	*/
	if (op_val == ISL68137_VOUT_AVS) {
	rc = pmbus_read_word_data(client, page, 0xff,
	PMBUS_VOUT_COMMAND);
	if (rc < 0)
	return rc;

	rc = pmbus_write_word_data(client, page, PMBUS_VOUT_COMMAND,
	rc);
	if (rc < 0)
	return rc;
	}

	rc = pmbus_update_byte_data(client, page, PMBUS_OPERATION,
	ISL68137_VOUT_AVS, op_val);

	return (rc < 0) ? rc : count;
	}

	static ssize_t isl68137_avs_enable_show(struct device *dev,
	struct device_attribute *devattr,
	char *buf)
	{
	struct i2c_client *client = to_i2c_client(dev->parent);
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

	return isl68137_avs_enable_show_page(client, attr->index, buf);
	}

	static ssize_t isl68137_avs_enable_store(struct device *dev,
	struct device_attribute *devattr,
	const char *buf, size_t count)
	{
	struct i2c_client *client = to_i2c_client(dev->parent);
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

	return isl68137_avs_enable_store_page(client, attr->index, buf, count);
	}

	static SENSOR_DEVICE_ATTR_RW(avs0_enable, isl68137_avs_enable, 0);
	static SENSOR_DEVICE_ATTR_RW(avs1_enable, isl68137_avs_enable, 1);

	static struct attribute *enable_attrs[] = {
	&sensor_dev_attr_avs0_enable.dev_attr.attr,
	&sensor_dev_attr_avs1_enable.dev_attr.attr,
	NULL,
	};

	static const struct attribute_group enable_group = {
	.attrs = enable_attrs,
	};

	static const struct attribute_group *isl68137_attribute_groups[] = {
	&enable_group,
	NULL,
	};

	static int raa_dmpvr2_read_word_data(struct i2c_client *client, int page,
	int phase, int reg)
	{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	const struct isl68137_data *data = to_isl68137_data(info);
	int ret;
	u64 temp;

	switch (reg) {
	case PMBUS_VIRT_READ_VMON:
	ret = pmbus_read_word_data(client, page, phase,
	RAA_DMPVR2_READ_VMON);
	break;
	case PMBUS_READ_POUT:
	case PMBUS_READ_VOUT:
	/*
	* In cases where a voltage divider is attached to the target
	* rail between Vout and the Vsense pin, both Vout and Pout
	* should be scaled by the voltage divider scaling factor.
	* I.e. Vout = Vsense * Rtotal / Rout
	*/
	ret = pmbus_read_word_data(client, page, phase, reg);
	if (ret > 0) {
	temp = DIV_U64_ROUND_CLOSEST((u64)ret *
	data->channel[page].vout_voltage_divider[1],
	data->channel[page].vout_voltage_divider[0]);
	ret = clamp_val(temp, 0, 0xffff);
	}
	break;
	default:
	ret = -ENODATA;
	break;
	}

	return ret;
	}

	static int raa_dmpvr2_write_word_data(struct i2c_client *client, int page,
	int reg, u16 word)
	{
	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
	const struct isl68137_data *data = to_isl68137_data(info);
	int ret;
	u64 temp;

	switch (reg) {
	case PMBUS_VOUT_MAX:
	case PMBUS_VOUT_MARGIN_HIGH:
	case PMBUS_VOUT_MARGIN_LOW:
	case PMBUS_VOUT_OV_FAULT_LIMIT:
	case PMBUS_VOUT_UV_FAULT_LIMIT:
	case PMBUS_VOUT_COMMAND:
	/*
	* In cases where a voltage divider is attached to the target
	* rail between Vout and the Vsense pin, Vout related PMBus
	* commands should be scaled based on the expected voltage
	* at the Vsense pin.
	* I.e. Vsense = Vout * Rout / Rtotal
	*/
	temp = DIV_U64_ROUND_CLOSEST((u64)word *
	data->channel[page].vout_voltage_divider[0],
	data->channel[page].vout_voltage_divider[1]);
	ret = clamp_val(temp, 0, 0xffff);
	break;
	default:
	ret = -ENODATA;
	break;
	}
	return ret;
	}

	static struct pmbus_driver_info raa_dmpvr_info = {
	.pages = 3,
	.format[PSC_VOLTAGE_IN] = direct,
	.format[PSC_VOLTAGE_OUT] = direct,
	.format[PSC_CURRENT_IN] = direct,
	.format[PSC_CURRENT_OUT] = direct,
	.format[PSC_POWER] = direct,
	.format[PSC_TEMPERATURE] = direct,
	.m[PSC_VOLTAGE_IN] = 1,
	.b[PSC_VOLTAGE_IN] = 0,
	.R[PSC_VOLTAGE_IN] = 2,
	.m[PSC_VOLTAGE_OUT] = 1,
	.b[PSC_VOLTAGE_OUT] = 0,
	.R[PSC_VOLTAGE_OUT] = 3,
	.m[PSC_CURRENT_IN] = 1,
	.b[PSC_CURRENT_IN] = 0,
	.R[PSC_CURRENT_IN] = 2,
	.m[PSC_CURRENT_OUT] = 1,
	.b[PSC_CURRENT_OUT] = 0,
	.R[PSC_CURRENT_OUT] = 1,
	.m[PSC_POWER] = 1,
	.b[PSC_POWER] = 0,
	.R[PSC_POWER] = 0,
	.m[PSC_TEMPERATURE] = 1,
	.b[PSC_TEMPERATURE] = 0,
	.R[PSC_TEMPERATURE] = 0,
	.func[0] = PMBUS_HAVE_VIN \| PMBUS_HAVE_IIN \| PMBUS_HAVE_PIN
	\| PMBUS_HAVE_STATUS_INPUT \| PMBUS_HAVE_TEMP \| PMBUS_HAVE_TEMP2
	\| PMBUS_HAVE_TEMP3 \| PMBUS_HAVE_STATUS_TEMP
	\| PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT
	\| PMBUS_HAVE_IOUT \| PMBUS_HAVE_STATUS_IOUT \| PMBUS_HAVE_POUT
	\| PMBUS_HAVE_VMON,
	.func[1] = PMBUS_HAVE_IIN \| PMBUS_HAVE_PIN \| PMBUS_HAVE_STATUS_INPUT
	\| PMBUS_HAVE_TEMP \| PMBUS_HAVE_TEMP3 \| PMBUS_HAVE_STATUS_TEMP
	\| PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT \| PMBUS_HAVE_IOUT
	\| PMBUS_HAVE_STATUS_IOUT \| PMBUS_HAVE_POUT,
	.func[2] = PMBUS_HAVE_IIN \| PMBUS_HAVE_PIN \| PMBUS_HAVE_STATUS_INPUT
	\| PMBUS_HAVE_TEMP \| PMBUS_HAVE_TEMP3 \| PMBUS_HAVE_STATUS_TEMP
	\| PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT \| PMBUS_HAVE_IOUT
	\| PMBUS_HAVE_STATUS_IOUT \| PMBUS_HAVE_POUT,
	};

	static int isl68137_probe_child_from_dt(struct device *dev,
	struct device_node *child,
	struct isl68137_data *data)
	{
	u32 channel, rout, rtotal;
	int err;

	err = of_property_read_u32(child, "reg", &channel);
	if (err) {
	dev_err(dev, "missing reg property of %pOFn\n", child);
	return err;
	}
	if (channel >= data->info.pages) {
	dev_err(dev, "invalid reg %d of %pOFn\n", channel, child);
	return -EINVAL;
	}

	err = of_property_read_u32_array(child, "vout-voltage-divider",
	data->channel[channel].vout_voltage_divider,
	ARRAY_SIZE(data->channel[channel].vout_voltage_divider));
	if (err && err != -EINVAL) {
	dev_err(dev,
	"malformed vout-voltage-divider value for channel %d\n",
	channel);
	return err;
	}

	rout = data->channel[channel].vout_voltage_divider[0];
	rtotal = data->channel[channel].vout_voltage_divider[1];
	if (rout == 0) {
	dev_err(dev,
	"Voltage divider output resistance must be greater than 0\n");
	return -EINVAL;
	}
	if (rtotal < rout) {
	dev_err(dev,
	"Voltage divider total resistance is less than output resistance\n");
	return -EINVAL;
	}

	return 0;
	}

	static int isl68137_probe_from_dt(struct device *dev,
	struct isl68137_data *data)
	{
	const struct device_node *np = dev->of_node;
	struct device_node *child;
	int err;

	for_each_child_of_node(np, child) {
	if (strcmp(child->name, "channel"))
	continue;

	err = isl68137_probe_child_from_dt(dev, child, data);
	if (err)
	return err;
	}

	return 0;
	}

	static int isl68137_probe(struct i2c_client *client)
	{
	struct device *dev = &client->dev;
	struct pmbus_driver_info *info;
	struct isl68137_data *data;
	int i, err;

	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
	if (!data)
	return -ENOMEM;

	/*
	* Initialize all voltage dividers to Rout=1 and Rtotal=1 to simplify
	* logic in PMBus word read/write functions
	*/
	for (i = 0; i < MAX_CHANNELS; i++)
	memset(data->channel[i].vout_voltage_divider,
	1,
	sizeof(data->channel[i].vout_voltage_divider));

	memcpy(&data->info, &raa_dmpvr_info, sizeof(data->info));
	info = &data->info;

	switch (i2c_match_id(raa_dmpvr_id, client)->driver_data) {
	case raa_dmpvr1_2rail:
	info->pages = 2;
	info->R[PSC_VOLTAGE_IN] = 3;
	info->func[0] &= ~PMBUS_HAVE_VMON;
	info->func[1] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT
	\| PMBUS_HAVE_IOUT \| PMBUS_HAVE_STATUS_IOUT
	\| PMBUS_HAVE_POUT;
	info->read_word_data = raa_dmpvr2_read_word_data;
	info->write_word_data = raa_dmpvr2_write_word_data;
	info->groups = isl68137_attribute_groups;
	break;
	case raa_dmpvr2_1rail:
	info->pages = 1;
	info->read_word_data = raa_dmpvr2_read_word_data;
	info->write_word_data = raa_dmpvr2_write_word_data;
	break;
	case raa_dmpvr2_2rail_nontc:
	info->func[0] &= ~PMBUS_HAVE_TEMP3;
	info->func[1] &= ~PMBUS_HAVE_TEMP3;
	fallthrough;
	case raa_dmpvr2_2rail:
	info->pages = 2;
	info->read_word_data = raa_dmpvr2_read_word_data;
	info->write_word_data = raa_dmpvr2_write_word_data;
	break;
	case raa_dmpvr2_3rail:
	info->read_word_data = raa_dmpvr2_read_word_data;
	info->write_word_data = raa_dmpvr2_write_word_data;
	break;
	case raa_dmpvr2_hv:
	info->pages = 1;
	info->R[PSC_VOLTAGE_IN] = 1;
	info->m[PSC_VOLTAGE_OUT] = 2;
	info->R[PSC_VOLTAGE_OUT] = 2;
	info->m[PSC_CURRENT_IN] = 2;
	info->m[PSC_POWER] = 2;
	info->R[PSC_POWER] = -1;
	info->read_word_data = raa_dmpvr2_read_word_data;
	info->write_word_data = raa_dmpvr2_write_word_data;
	break;
	default:
	return -ENODEV;
	}

	err = isl68137_probe_from_dt(dev, data);
	if (err)
	return err;

	return pmbus_do_probe(client, info);
	}

	static const struct i2c_device_id raa_dmpvr_id[] = {
	{"isl68137", raa_dmpvr1_2rail},
	{"isl68220", raa_dmpvr2_2rail},
	{"isl68221", raa_dmpvr2_3rail},
	{"isl68222", raa_dmpvr2_2rail},
	{"isl68223", raa_dmpvr2_2rail},
	{"isl68224", raa_dmpvr2_3rail},
	{"isl68225", raa_dmpvr2_2rail},
	{"isl68226", raa_dmpvr2_3rail},
	{"isl68227", raa_dmpvr2_1rail},
	{"isl68229", raa_dmpvr2_3rail},
	{"isl68233", raa_dmpvr2_2rail},
	{"isl68239", raa_dmpvr2_3rail},

	{"isl69222", raa_dmpvr2_2rail},
	{"isl69223", raa_dmpvr2_3rail},
	{"isl69224", raa_dmpvr2_2rail},
	{"isl69225", raa_dmpvr2_2rail},
	{"isl69227", raa_dmpvr2_3rail},
	{"isl69228", raa_dmpvr2_3rail},
	{"isl69234", raa_dmpvr2_2rail},
	{"isl69236", raa_dmpvr2_2rail},
	{"isl69239", raa_dmpvr2_3rail},
	{"isl69242", raa_dmpvr2_2rail},
	{"isl69243", raa_dmpvr2_1rail},
	{"isl69247", raa_dmpvr2_2rail},
	{"isl69248", raa_dmpvr2_2rail},
	{"isl69254", raa_dmpvr2_2rail},
	{"isl69255", raa_dmpvr2_2rail},
	{"isl69256", raa_dmpvr2_2rail},
	{"isl69259", raa_dmpvr2_2rail},
	{"isl69260", raa_dmpvr2_2rail},
	{"isl69268", raa_dmpvr2_2rail},
	{"isl69269", raa_dmpvr2_3rail},
	{"isl69298", raa_dmpvr2_2rail},

	{"raa228000", raa_dmpvr2_hv},
	{"raa228004", raa_dmpvr2_hv},
	{"raa228006", raa_dmpvr2_hv},
	{"raa228228", raa_dmpvr2_2rail_nontc},
	{"raa229001", raa_dmpvr2_2rail},
	{"raa229004", raa_dmpvr2_2rail},
	{}
	};

	MODULE_DEVICE_TABLE(i2c, raa_dmpvr_id);

	static const struct of_device_id isl68137_of_match[] = {
	{ .compatible = "isil,isl68137", .data = (void *)raa_dmpvr1_2rail },
	{ .compatible = "renesas,isl68220", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl68221", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl68222", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl68223", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl68224", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl68225", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl68226", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl68227", .data = (void *)raa_dmpvr2_1rail },
	{ .compatible = "renesas,isl68229", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl68233", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl68239", .data = (void *)raa_dmpvr2_3rail },

	{ .compatible = "renesas,isl69222", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69223", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl69224", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69225", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69227", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl69228", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl69234", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69236", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69239", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl69242", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69243", .data = (void *)raa_dmpvr2_1rail },
	{ .compatible = "renesas,isl69247", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69248", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69254", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69255", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69256", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69259", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "isil,isl69260", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,isl69268", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "isil,isl69269", .data = (void *)raa_dmpvr2_3rail },
	{ .compatible = "renesas,isl69298", .data = (void *)raa_dmpvr2_2rail },

	{ .compatible = "renesas,raa228000", .data = (void *)raa_dmpvr2_hv },
	{ .compatible = "renesas,raa228004", .data = (void *)raa_dmpvr2_hv },
	{ .compatible = "renesas,raa228006", .data = (void *)raa_dmpvr2_hv },
	{ .compatible = "renesas,raa228228", .data = (void *)raa_dmpvr2_2rail_nontc },
	{ .compatible = "renesas,raa229001", .data = (void *)raa_dmpvr2_2rail },
	{ .compatible = "renesas,raa229004", .data = (void *)raa_dmpvr2_2rail },
	{ },
	};

	MODULE_DEVICE_TABLE(of, isl68137_of_match);

	/* This is the driver that will be inserted */
	static struct i2c_driver isl68137_driver = {
	.driver = {
	.name = "isl68137",
	.of_match_table = isl68137_of_match,
	},
	.probe = isl68137_probe,
	.id_table = raa_dmpvr_id,
	};

	module_i2c_driver(isl68137_driver);

	MODULE_AUTHOR("Maxim Sloyko <maxims@google.com>");
	MODULE_DESCRIPTION("PMBus driver for Renesas digital multiphase voltage regulators");
	MODULE_LICENSE("GPL");
	MODULE_IMPORT_NS(PMBUS);