linux/drivers/hwmon/pmbus/lx1308.c

// SPDX-License-Identifier: GPL-2.0-or-later

#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include "pmbus.h"

#define LX1308_MFR_IOUT_OCP3_FAULT	0xBE
#define LX1308_MFR_IOUT_OCP3_WARN	0xBF

/*
 * Decode a Linear11-encoded word to an integer value.
 * Linear11 format: bits[15:11] = signed 5-bit exponent,
 * bits[10:0] = signed 11-bit mantissa. Result = mant * 2^exp.
 */
static inline int linear11_to_int(u16 word)
{
	s16 exp = ((s16)word) >> 11;
	s16 mant = ((s16)((word & 0x7ff) << 5)) >> 5;

	return (exp >= 0) ? (int)((u32)mant << exp) : (mant >> -exp);
}

static int lx1308_read_word_data(struct i2c_client *client, int page,
				 int phase, int reg)
{
	int ret;

	if (page > 0)
		return -ENXIO;

	switch (reg) {
	/*
	 * The LX1308 OCP3 registers (slow OCP, 60ms delay) use a
	 * manufacturer-specific U8.0 format. Read the byte value N and present
	 * it as a Linear11 word with exponent 0.
	 */
	case PMBUS_IOUT_OC_FAULT_LIMIT:
		ret = i2c_smbus_read_byte_data(client, LX1308_MFR_IOUT_OCP3_FAULT);
		if (ret < 0)
			break;
		ret &= 0x7FF;
		break;

	case PMBUS_IOUT_OC_WARN_LIMIT:
		ret = i2c_smbus_read_byte_data(client, LX1308_MFR_IOUT_OCP3_WARN);
		if (ret < 0)
			break;
		ret &= 0x7FF;
		break;

	/*
	 * The following registers are not implemented by the LX1308. Return
	 * -ENXIO to suppress the corresponding sysfs attributes.
	 */
	case PMBUS_IIN_OC_WARN_LIMIT:
	case PMBUS_IIN_OC_FAULT_LIMIT:
	case PMBUS_IOUT_UC_FAULT_LIMIT:
	case PMBUS_PIN_OP_WARN_LIMIT:
	case PMBUS_POUT_OP_WARN_LIMIT:
	case PMBUS_UT_WARN_LIMIT:
	case PMBUS_UT_FAULT_LIMIT:
	case PMBUS_MFR_IIN_MAX:
	case PMBUS_MFR_IOUT_MAX:
	case PMBUS_MFR_VIN_MIN:
	case PMBUS_MFR_VIN_MAX:
	case PMBUS_MFR_VOUT_MIN:
	case PMBUS_MFR_VOUT_MAX:
	case PMBUS_MFR_PIN_MAX:
	case PMBUS_MFR_POUT_MAX:
	case PMBUS_MFR_MAX_TEMP_1:
		ret = -ENXIO;
		break;

	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}

static int lx1308_write_word_data(struct i2c_client *client, int page,
				  int reg, u16 word)
{
	int ret;

	if (page > 0)
		return -ENXIO;

	switch (reg) {
	case PMBUS_IOUT_OC_FAULT_LIMIT:
		/*
		 * Decode Linear11 word from pmbus_core back to a plain integer
		 * and write as the U8.0 byte the device expects.
		 */
		ret = i2c_smbus_write_byte_data(client, LX1308_MFR_IOUT_OCP3_FAULT,
						clamp_val(linear11_to_int(word), 0, 255));
		break;

	case PMBUS_IOUT_OC_WARN_LIMIT:
		ret = i2c_smbus_write_byte_data(client, LX1308_MFR_IOUT_OCP3_WARN,
						clamp_val(linear11_to_int(word), 0, 255));
		break;

	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}

static struct pmbus_driver_info lx1308_info = {
	.pages = 1,
	.format[PSC_VOLTAGE_IN] = linear,
	.format[PSC_VOLTAGE_OUT] = linear,
	.format[PSC_CURRENT_IN] = linear,
	.format[PSC_CURRENT_OUT] = linear,
	.format[PSC_POWER] = linear,
	.format[PSC_TEMPERATURE] = linear,

	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
		| PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
		| PMBUS_HAVE_PIN | PMBUS_HAVE_POUT
		| PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
		| PMBUS_HAVE_STATUS_INPUT,

	.read_word_data  = lx1308_read_word_data,
	.write_word_data = lx1308_write_word_data,
};

static const struct of_device_id lx1308_of_match[] = {
	{ .compatible = "luxshare,lx1308" },
	{ }
};

MODULE_DEVICE_TABLE(of, lx1308_of_match);

static const struct i2c_device_id lx1308_id[] = {
	{ "lx1308" },
	{ }
};

MODULE_DEVICE_TABLE(i2c, lx1308_id);

static int lx1308_probe(struct i2c_client *client)
{
	u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
	const struct i2c_device_id *mid;
	int ret;

	ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
	if (ret < 0)
		return dev_err_probe(&client->dev, ret,
				     "Failed to read manufacturer id\n");
	buf[ret] = '\0';

	if (ret != 12 || strncmp(buf, "LUXSHARE", 8))
		return dev_err_probe(&client->dev, -ENODEV,
				     "Unsupported Manufacturer ID '%s'\n", buf);

	ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
	if (ret < 0)
		return dev_err_probe(&client->dev, ret,
				     "Failed to read Manufacturer Model\n");
	buf[ret] = '\0';

	for (mid = lx1308_id; mid->name[0]; mid++) {
		if (!strncasecmp(mid->name, buf, strlen(mid->name)))
			break;
	}
	if (!mid->name[0])
		return dev_err_probe(&client->dev, -ENODEV,
				     "Unsupported Manufacturer Model '%s'\n", buf);

	ret = i2c_smbus_read_block_data(client, PMBUS_MFR_REVISION, buf);
	if (ret < 0)
		return dev_err_probe(&client->dev, ret,
				     "Failed to read Manufacturer Revision\n");
	buf[ret] = '\0';

	if (ret != 12 || buf[0] != 'V')
		return dev_err_probe(&client->dev, -ENODEV,
				     "Unsupported Manufacturer Revision '%s'\n", buf);
	return pmbus_do_probe(client, &lx1308_info);
}

static struct i2c_driver lx1308_driver = {
	.driver = {
		.name = "lx1308",
		.of_match_table = lx1308_of_match,
	},
	.probe = lx1308_probe,
	.id_table = lx1308_id,
};

module_i2c_driver(lx1308_driver);

MODULE_AUTHOR("Brian Chiang <chiang.brian@inventec.com>");
MODULE_DESCRIPTION("PMBus driver for Luxshare LX1308");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("PMBUS");