path: root/drivers/hwmon/pmbus/sq24860.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Author: Ziming Zhu <ziming.zhu@silergycorp.com>
 */

#include <linux/bitfield.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/math64.h>

#include "pmbus.h"

#define SQ24860_IIN_CAL_GAIN		0x38
#define SQ24860_READ_VAUX		0xd0
#define SQ24860_READ_VIN_MIN		0xd1
#define SQ24860_READ_VIN_PEAK		0xd2
#define SQ24860_READ_IIN_PEAK		0xd4
#define SQ24860_READ_PIN_PEAK		0xd5
#define SQ24860_READ_TEMP_AVG		0xd6
#define SQ24860_READ_TEMP_PEAK		0xd7
#define SQ24860_READ_VOUT_MIN		0xda
#define SQ24860_READ_VIN_AVG		0xdc
#define SQ24860_READ_VOUT_AVG		0xdd
#define SQ24860_READ_IIN_AVG		0xde
#define SQ24860_READ_PIN_AVG		0xdf
#define SQ24860_VIREF			0xe0
#define SQ24860_PK_MIN_AVG		0xea
#define PK_MIN_AVG_RST_PEAK		BIT(7)
#define PK_MIN_AVG_RST_AVG		BIT(6)
#define PK_MIN_AVG_RST_MIN		BIT(5)
#define PK_MIN_AVG_AVG_CNT		GENMASK(2, 0)
#define SQ24860_MFR_WRITE_PROTECT	0xf8
#define SQ24860_UNLOCKED		BIT(7)

#define SQ24860_8B_SHIFT		2
#define SQ24860_IIN_OCF_NUM		1000000
#define SQ24860_IIN_OCF_DIV		129278
#define SQ24860_IIN_OCF_OFF		165

#define PK_MIN_AVG_RST_MASK		(PK_MIN_AVG_RST_PEAK | \
					 PK_MIN_AVG_RST_AVG  | \
					 PK_MIN_AVG_RST_MIN)
#define SQ24860_MAX_SAMPLES		BIT(FIELD_MAX(PK_MIN_AVG_AVG_CNT))
/*
 * Arbitrary default Rimon value: 1.6kOhm
 */
#define SQ24860_DEFAULT_RIMON		1600000000
#define SQ24860_GIMON			18180

#define SQ24860_VAUX_DIV		20

static int sq24860_write_iin_cal_gain(struct i2c_client *client, u32 rimon)
{
	u64 temp = 6400ULL * 1000000000ULL * 1000ULL;
	u64 denom;
	u64 word;

	if (!rimon)
		return -EINVAL;

	denom = (u64)rimon * SQ24860_GIMON;
	word = div64_u64(temp, denom);
	if (!word || word > U16_MAX)
		return -EINVAL;

	return i2c_smbus_write_word_data(client, SQ24860_IIN_CAL_GAIN,
					(u16)word);
}

static int sq24860_mfr_write_protect_set(struct i2c_client *client,
					 u8 protect)
{
	u8 val;

	switch (protect) {
	case 0:
		val = 0xa2;
		break;
	case PB_WP_ALL:
		val = 0x0;
		break;
	default:
		return -EINVAL;
	}

	return pmbus_write_byte_data(client, -1, SQ24860_MFR_WRITE_PROTECT,
				     val);
}

static int sq24860_mfr_write_protect_get(struct i2c_client *client)
{
	int ret = pmbus_read_byte_data(client, -1, SQ24860_MFR_WRITE_PROTECT);

	if (ret < 0)
		return ret;

	return (ret & SQ24860_UNLOCKED) ? 0 : PB_WP_ALL;
}

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

	switch (reg) {
	case PMBUS_VIRT_READ_VIN_MAX:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_VIN_PEAK);
		break;

	case PMBUS_VIRT_READ_VIN_MIN:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_VIN_MIN);
		break;

	case PMBUS_VIRT_READ_VIN_AVG:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_VIN_AVG);
		break;

	case PMBUS_VIRT_READ_VOUT_MIN:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_VOUT_MIN);
		break;

	case PMBUS_VIRT_READ_VOUT_AVG:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_VOUT_AVG);
		break;

	case PMBUS_VIRT_READ_IIN_AVG:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_IIN_AVG);
		break;

	case PMBUS_VIRT_READ_IIN_MAX:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_IIN_PEAK);
		break;

	case PMBUS_VIRT_READ_TEMP_AVG:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_TEMP_AVG);
		break;

	case PMBUS_VIRT_READ_TEMP_MAX:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_TEMP_PEAK);
		break;

	case PMBUS_VIRT_READ_PIN_AVG:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_PIN_AVG);
		break;

	case PMBUS_VIRT_READ_PIN_MAX:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_PIN_PEAK);
		break;

	case PMBUS_VIRT_READ_VMON:
		ret = pmbus_read_word_data(client, page, phase,
					   SQ24860_READ_VAUX);
		if (ret < 0)
			break;
		ret = DIV_ROUND_CLOSEST(ret, SQ24860_VAUX_DIV);
		break;

	case PMBUS_VIN_UV_WARN_LIMIT:
	case PMBUS_VIN_UV_FAULT_LIMIT:
	case PMBUS_VIN_OV_WARN_LIMIT:
	case PMBUS_VIN_OV_FAULT_LIMIT:
	case PMBUS_VOUT_UV_WARN_LIMIT:
	case PMBUS_IIN_OC_WARN_LIMIT:
	case PMBUS_OT_WARN_LIMIT:
	case PMBUS_OT_FAULT_LIMIT:
	case PMBUS_PIN_OP_WARN_LIMIT:
		/*
		 * These registers provide an 8 bits value instead of a
		 * 10bits one. Just shifting twice the register value is
		 * enough to make the sensor type conversion work, even
		 * if the datasheet provides different m, b and R for
		 * those.
		 */
		ret = pmbus_read_word_data(client, page, phase, reg);
		if (ret < 0)
			break;
		ret <<= SQ24860_8B_SHIFT;
		break;

	case PMBUS_IIN_OC_FAULT_LIMIT:
		/*
		 * VIREF directly sets the over-current limit at which the eFuse
		 * will turn the FET off and trigger a fault. Expose it through
		 * this generic property instead of a manufacturer specific one.
		 */
		ret = pmbus_read_byte_data(client, page, SQ24860_VIREF);
		if (ret < 0)
			break;
		ret = DIV_ROUND_CLOSEST(ret * SQ24860_IIN_OCF_NUM,
					SQ24860_IIN_OCF_DIV);
		ret += SQ24860_IIN_OCF_OFF;
		break;

	case PMBUS_VIRT_SAMPLES:
		ret = pmbus_read_byte_data(client, page, SQ24860_PK_MIN_AVG);
		if (ret < 0)
			break;
		ret = BIT(FIELD_GET(PK_MIN_AVG_AVG_CNT, ret));
		break;

	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	case PMBUS_VIRT_RESET_VIN_HISTORY:
	case PMBUS_VIRT_RESET_IIN_HISTORY:
	case PMBUS_VIRT_RESET_PIN_HISTORY:
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
		ret = 0;
		break;

	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}

static int sq24860_write_word_data(struct i2c_client *client,
				   int page, int reg, u16 value)
{
	int ret;

	switch (reg) {
	case PMBUS_VIN_UV_WARN_LIMIT:
	case PMBUS_VIN_UV_FAULT_LIMIT:
	case PMBUS_VIN_OV_WARN_LIMIT:
	case PMBUS_VIN_OV_FAULT_LIMIT:
	case PMBUS_VOUT_UV_WARN_LIMIT:
	case PMBUS_IIN_OC_WARN_LIMIT:
	case PMBUS_OT_WARN_LIMIT:
	case PMBUS_OT_FAULT_LIMIT:
	case PMBUS_PIN_OP_WARN_LIMIT:
		value = max_t(s16, (s16)value, 0);
		value >>= SQ24860_8B_SHIFT;
		value = clamp_val(value, 0, 0xff);
		ret = pmbus_write_word_data(client, page, reg, value);
		break;

	case PMBUS_IIN_OC_FAULT_LIMIT:
		value = max_t(s16, (s16)value, SQ24860_IIN_OCF_OFF);
		value -= SQ24860_IIN_OCF_OFF;
		value = DIV_ROUND_CLOSEST(((unsigned int)value) * SQ24860_IIN_OCF_DIV,
					  SQ24860_IIN_OCF_NUM);
		value = clamp_val(value, 0, 0x3f);
		ret = pmbus_write_byte_data(client, page, SQ24860_VIREF, value);
		break;

	case PMBUS_VIRT_SAMPLES:
		value = clamp_val(value, 1, SQ24860_MAX_SAMPLES);
		value = ilog2(value);
		ret = pmbus_update_byte_data(client, page, SQ24860_PK_MIN_AVG,
					     PK_MIN_AVG_AVG_CNT,
					     FIELD_PREP(PK_MIN_AVG_AVG_CNT, value));
		break;

	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	case PMBUS_VIRT_RESET_VIN_HISTORY:
	case PMBUS_VIRT_RESET_IIN_HISTORY:
	case PMBUS_VIRT_RESET_PIN_HISTORY:
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
		/*
		 * SQ24860 has history resets based on MIN/AVG/PEAK instead of per
		 * sensor type. Exposing this quirk in hwmon is not desirable so
		 * reset MIN, AVG and PEAK together. Even is there effectively only
		 * one reset, which resets everything, expose the 5 entries so
		 * userspace is not required map a sensor type to another to trigger
		 * a reset
		 */
		ret = pmbus_update_byte_data(client, 0, SQ24860_PK_MIN_AVG,
					     PK_MIN_AVG_RST_MASK,
					     PK_MIN_AVG_RST_MASK);
		break;

	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}

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

	switch (reg) {
	case PMBUS_WRITE_PROTECT:
		ret = sq24860_mfr_write_protect_get(client);
		break;

	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}

static int sq24860_write_byte_data(struct i2c_client *client,
				   int page, int reg, u8 byte)
{
	int ret;

	switch (reg) {
	case PMBUS_WRITE_PROTECT:
		ret = sq24860_mfr_write_protect_set(client, byte);
		break;

	default:
		ret = -ENODATA;
		break;
	}

	return ret;
}

#if IS_ENABLED(CONFIG_SENSORS_SQ24860_REGULATOR)
static const struct regulator_desc sq24860_reg_desc[] = {
	PMBUS_REGULATOR_ONE_NODE("vout"),
};
#endif

static const struct pmbus_driver_info sq24860_base_info = {
	.pages = 1,
	.format[PSC_VOLTAGE_IN] = direct,
	.m[PSC_VOLTAGE_IN] = 64,
	.b[PSC_VOLTAGE_IN] = 0,
	.R[PSC_VOLTAGE_IN] = 0,
	.format[PSC_VOLTAGE_OUT] = direct,
	.m[PSC_VOLTAGE_OUT] = 64,
	.b[PSC_VOLTAGE_OUT] = 0,
	.R[PSC_VOLTAGE_OUT] = 0,
	.format[PSC_TEMPERATURE] = direct,
	.m[PSC_TEMPERATURE] = 1,
	.b[PSC_TEMPERATURE] = 0,
	.R[PSC_TEMPERATURE] = 0,
	/*
	 * Current and power measurements depend on the calibration gain
	 * programmed from the board-specific IMON resistor value.
	 */
	.format[PSC_CURRENT_IN] = direct,
	.m[PSC_CURRENT_IN] = 16,
	.b[PSC_CURRENT_IN] = 0,
	.R[PSC_CURRENT_IN] = 0,
	.format[PSC_POWER] = direct,
	.m[PSC_POWER] = 2,
	.b[PSC_POWER] = 0,
	.R[PSC_POWER] = 0,
	.func[0] = PMBUS_HAVE_VIN |
		   PMBUS_HAVE_VOUT |
		   PMBUS_HAVE_VMON |
		   PMBUS_HAVE_IIN |
		   PMBUS_HAVE_PIN |
		   PMBUS_HAVE_TEMP |
		   PMBUS_HAVE_STATUS_VOUT |
		   PMBUS_HAVE_STATUS_IOUT |
		   PMBUS_HAVE_STATUS_INPUT |
		   PMBUS_HAVE_STATUS_TEMP |
		   PMBUS_HAVE_SAMPLES,
	.read_word_data = sq24860_read_word_data,
	.write_word_data = sq24860_write_word_data,
	.read_byte_data = sq24860_read_byte_data,
	.write_byte_data = sq24860_write_byte_data,

#if IS_ENABLED(CONFIG_SENSORS_SQ24860_REGULATOR)
	.reg_desc = sq24860_reg_desc,
	.num_regulators = ARRAY_SIZE(sq24860_reg_desc),
#endif
};

static const struct i2c_device_id sq24860_i2c_id[] = {
	{ "sq24860" },
	{}
};
MODULE_DEVICE_TABLE(i2c, sq24860_i2c_id);

static const struct of_device_id sq24860_of_match[] = {
	{ .compatible = "silergy,sq24860" },
	{}
};
MODULE_DEVICE_TABLE(of, sq24860_of_match);

static int sq24860_probe(struct i2c_client *client)
{
	struct device *dev = &client->dev;
	struct pmbus_driver_info *info;
	u32 rimon;
	int ret;

	if (device_property_read_u32(dev, "silergy,rimon-micro-ohms", &rimon))
		rimon = SQ24860_DEFAULT_RIMON;
	ret = sq24860_write_iin_cal_gain(client, rimon);
	if (ret < 0)
		return dev_err_probe(&client->dev, ret,
					     "Failed to set gain\n");
	info = devm_kmemdup(dev, &sq24860_base_info, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	return pmbus_do_probe(client, info);
}

static struct i2c_driver sq24860_driver = {
	.driver = {
		.name = "sq24860",
		.of_match_table = sq24860_of_match,
	},
	.probe = sq24860_probe,
	.id_table = sq24860_i2c_id,
};
module_i2c_driver(sq24860_driver);

MODULE_AUTHOR("Ziming Zhu <ziming.zhu@silergycorp.com>");
MODULE_DESCRIPTION("PMBUS driver for SQ24860 eFuse");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS("PMBUS");