[linux-block.git] / drivers / regulator / max597x-regulator.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Device driver for regulators in MAX5970 and MAX5978 IC
 *
 * Copyright (c) 2022 9elements GmbH
 *
 * Author: Patrick Rudolph <patrick.rudolph@9elements.com>
 */

#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/i2c.h>
#include <linux/regmap.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#include <linux/platform_device.h>

#include <linux/mfd/max597x.h>

struct max597x_regulator {
	int num_switches, mon_rng, irng, shunt_micro_ohms, lim_uA;
	struct regmap *regmap;
};

enum max597x_regulator_id {
	MAX597X_SW0,
	MAX597X_SW1,
};

static int max597x_uvp_ovp_check_mode(struct regulator_dev *rdev, int severity)
{
	int ret, reg;

	/* Status1 register contains the soft strap values sampled at POR */
	ret = regmap_read(rdev->regmap, MAX5970_REG_STATUS1, &reg);
	if (ret)
		return ret;

	/* Check soft straps match requested mode */
	if (severity == REGULATOR_SEVERITY_PROT) {
		if (STATUS1_PROT(reg) != STATUS1_PROT_SHUTDOWN)
			return -EOPNOTSUPP;

		return 0;
	}
	if (STATUS1_PROT(reg) == STATUS1_PROT_SHUTDOWN)
		return -EOPNOTSUPP;

	return 0;
}

static int max597x_set_vp(struct regulator_dev *rdev, int lim_uV, int severity,
			  bool enable, bool overvoltage)
{
	int off_h, off_l, reg, ret;
	struct max597x_regulator *data = rdev_get_drvdata(rdev);
	int channel = rdev_get_id(rdev);

	if (overvoltage) {
		if (severity == REGULATOR_SEVERITY_WARN) {
			off_h = MAX5970_REG_CH_OV_WARN_H(channel);
			off_l = MAX5970_REG_CH_OV_WARN_L(channel);
		} else {
			off_h = MAX5970_REG_CH_OV_CRIT_H(channel);
			off_l = MAX5970_REG_CH_OV_CRIT_L(channel);
		}
	} else {
		if (severity == REGULATOR_SEVERITY_WARN) {
			off_h = MAX5970_REG_CH_UV_WARN_H(channel);
			off_l = MAX5970_REG_CH_UV_WARN_L(channel);
		} else {
			off_h = MAX5970_REG_CH_UV_CRIT_H(channel);
			off_l = MAX5970_REG_CH_UV_CRIT_L(channel);
		}
	}

	if (enable)
		/* reg = ADC_MASK * (lim_uV / 1000000) / (data->mon_rng / 1000000) */
		reg = ADC_MASK * lim_uV / data->mon_rng;
	else
		reg = 0;

	ret = regmap_write(rdev->regmap, off_h, MAX5970_VAL2REG_H(reg));
	if (ret)
		return ret;

	ret = regmap_write(rdev->regmap, off_l, MAX5970_VAL2REG_L(reg));
	if (ret)
		return ret;

	return 0;
}

static int max597x_set_uvp(struct regulator_dev *rdev, int lim_uV, int severity,
			   bool enable)
{
	int ret;

	/*
	 * MAX5970 has enable control as a special value in limit reg. Can't
	 * set limit but keep feature disabled or enable W/O given limit.
	 */
	if ((lim_uV && !enable) || (!lim_uV && enable))
		return -EINVAL;

	ret = max597x_uvp_ovp_check_mode(rdev, severity);
	if (ret)
		return ret;

	return max597x_set_vp(rdev, lim_uV, severity, enable, false);
}

static int max597x_set_ovp(struct regulator_dev *rdev, int lim_uV, int severity,
			   bool enable)
{
	int ret;

	/*
	 * MAX5970 has enable control as a special value in limit reg. Can't
	 * set limit but keep feature disabled or enable W/O given limit.
	 */
	if ((lim_uV && !enable) || (!lim_uV && enable))
		return -EINVAL;

	ret = max597x_uvp_ovp_check_mode(rdev, severity);
	if (ret)
		return ret;

	return max597x_set_vp(rdev, lim_uV, severity, enable, true);
}

static int max597x_set_ocp(struct regulator_dev *rdev, int lim_uA,
			   int severity, bool enable)
{
	int val, reg;
	unsigned int vthst, vthfst;

	struct max597x_regulator *data = rdev_get_drvdata(rdev);
	int rdev_id = rdev_get_id(rdev);
	/*
	 * MAX5970 doesn't has enable control for ocp.
	 * If limit is specified but enable is not set then hold the value in
	 * variable & later use it when ocp needs to be enabled.
	 */
	if (lim_uA != 0 && lim_uA != data->lim_uA)
		data->lim_uA = lim_uA;

	if (severity != REGULATOR_SEVERITY_PROT)
		return -EINVAL;

	if (enable) {

		/* Calc Vtrip threshold in uV. */
		vthst =
		    div_u64(mul_u32_u32(data->shunt_micro_ohms, data->lim_uA),
			    1000000);

		/*
		 * As recommended in datasheed, add 20% margin to avoid
		 * spurious event & passive component tolerance.
		 */
		vthst = div_u64(mul_u32_u32(vthst, 120), 100);

		/* Calc fast Vtrip threshold in uV */
		vthfst = vthst * (MAX5970_FAST2SLOW_RATIO / 100);

		if (vthfst > data->irng) {
			dev_err(&rdev->dev, "Current limit out of range\n");
			return -EINVAL;
		}
		/* Fast trip threshold to be programmed */
		val = div_u64(mul_u32_u32(0xFF, vthfst), data->irng);
	} else
		/*
		 * Since there is no option to disable ocp, set limit to max
		 * value
		 */
		val = 0xFF;

	reg = MAX5970_REG_DAC_FAST(rdev_id);

	return regmap_write(rdev->regmap, reg, val);
}

static int max597x_get_status(struct regulator_dev *rdev)
{
	int val, ret;

	ret = regmap_read(rdev->regmap, MAX5970_REG_STATUS3, &val);
	if (ret)
		return ret;

	if (val & MAX5970_STATUS3_ALERT)
		return REGULATOR_STATUS_ERROR;

	ret = regulator_is_enabled_regmap(rdev);
	if (ret < 0)
		return ret;

	if (ret)
		return REGULATOR_STATUS_ON;

	return REGULATOR_STATUS_OFF;
}

static const struct regulator_ops max597x_switch_ops = {
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
	.get_status = max597x_get_status,
	.set_over_voltage_protection = max597x_set_ovp,
	.set_under_voltage_protection = max597x_set_uvp,
	.set_over_current_protection = max597x_set_ocp,
};

static int max597x_dt_parse(struct device_node *np,
			    const struct regulator_desc *desc,
			    struct regulator_config *cfg)
{
	struct max597x_regulator *data = cfg->driver_data;
	int ret = 0;

	ret =
	    of_property_read_u32(np, "shunt-resistor-micro-ohms",
				 &data->shunt_micro_ohms);
	if (ret < 0)
		dev_err(cfg->dev,
			"property 'shunt-resistor-micro-ohms' not found, err %d\n",
			ret);
	return ret;

}

#define MAX597X_SWITCH(_ID, _ereg, _chan, _supply) {     \
	.name            = #_ID,                         \
	.of_match        = of_match_ptr(#_ID),           \
	.ops             = &max597x_switch_ops,          \
	.regulators_node = of_match_ptr("regulators"),   \
	.type            = REGULATOR_VOLTAGE,            \
	.id              = MAX597X_##_ID,                \
	.owner           = THIS_MODULE,                  \
	.supply_name     = _supply,                      \
	.enable_reg      = _ereg,                        \
	.enable_mask     = CHXEN((_chan)),               \
	.of_parse_cb	 = max597x_dt_parse,		 \
}

static const struct regulator_desc regulators[] = {
	MAX597X_SWITCH(SW0, MAX5970_REG_CHXEN, 0, "vss1"),
	MAX597X_SWITCH(SW1, MAX5970_REG_CHXEN, 1, "vss2"),
};

static int max597x_regmap_read_clear(struct regmap *map, unsigned int reg,
				     unsigned int *val)
{
	int ret;

	ret = regmap_read(map, reg, val);
	if (ret)
		return ret;

	if (*val)
		return regmap_write(map, reg, *val);

	return 0;
}

static int max597x_irq_handler(int irq, struct regulator_irq_data *rid,
			       unsigned long *dev_mask)
{
	struct regulator_err_state *stat;
	struct max597x_regulator *d = (struct max597x_regulator *)rid->data;
	int val, ret, i;

	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT0, &val);
	if (ret)
		return REGULATOR_FAILED_RETRY;

	*dev_mask = 0;
	for (i = 0; i < d->num_switches; i++) {
		stat = &rid->states[i];
		stat->notifs = 0;
		stat->errors = 0;
	}

	for (i = 0; i < d->num_switches; i++) {
		stat = &rid->states[i];

		if (val & UV_STATUS_CRIT(i)) {
			*dev_mask |= 1 << i;
			stat->notifs |= REGULATOR_EVENT_UNDER_VOLTAGE;
			stat->errors |= REGULATOR_ERROR_UNDER_VOLTAGE;
		} else if (val & UV_STATUS_WARN(i)) {
			*dev_mask |= 1 << i;
			stat->notifs |= REGULATOR_EVENT_UNDER_VOLTAGE_WARN;
			stat->errors |= REGULATOR_ERROR_UNDER_VOLTAGE_WARN;
		}
	}

	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT1, &val);
	if (ret)
		return REGULATOR_FAILED_RETRY;

	for (i = 0; i < d->num_switches; i++) {
		stat = &rid->states[i];

		if (val & OV_STATUS_CRIT(i)) {
			*dev_mask |= 1 << i;
			stat->notifs |= REGULATOR_EVENT_REGULATION_OUT;
			stat->errors |= REGULATOR_ERROR_REGULATION_OUT;
		} else if (val & OV_STATUS_WARN(i)) {
			*dev_mask |= 1 << i;
			stat->notifs |= REGULATOR_EVENT_OVER_VOLTAGE_WARN;
			stat->errors |= REGULATOR_ERROR_OVER_VOLTAGE_WARN;
		}
	}

	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT2, &val);
	if (ret)
		return REGULATOR_FAILED_RETRY;

	for (i = 0; i < d->num_switches; i++) {
		stat = &rid->states[i];

		if (val & OC_STATUS_WARN(i)) {
			*dev_mask |= 1 << i;
			stat->notifs |= REGULATOR_EVENT_OVER_CURRENT_WARN;
			stat->errors |= REGULATOR_ERROR_OVER_CURRENT_WARN;
		}
	}

	ret = regmap_read(d->regmap, MAX5970_REG_STATUS0, &val);
	if (ret)
		return REGULATOR_FAILED_RETRY;

	for (i = 0; i < d->num_switches; i++) {
		stat = &rid->states[i];

		if ((val & MAX5970_CB_IFAULTF(i))
		    || (val & MAX5970_CB_IFAULTS(i))) {
			*dev_mask |= 1 << i;
			stat->notifs |=
			    REGULATOR_EVENT_OVER_CURRENT |
			    REGULATOR_EVENT_DISABLE;
			stat->errors |=
			    REGULATOR_ERROR_OVER_CURRENT | REGULATOR_ERROR_FAIL;

			/* Clear the sub-IRQ status */
			regulator_disable_regmap(stat->rdev);
		}
	}
	return 0;
}

static int max597x_adc_range(struct regmap *regmap, const int ch,
			     u32 *irng, u32 *mon_rng)
{
	unsigned int reg;
	int ret;

	/* Decode current ADC range */
	ret = regmap_read(regmap, MAX5970_REG_STATUS2, &reg);
	if (ret)
		return ret;
	switch (MAX5970_IRNG(reg, ch)) {
	case 0:
		*irng = 100000;	/* 100 mV */
		break;
	case 1:
		*irng = 50000;	/* 50 mV */
		break;
	case 2:
		*irng = 25000;	/* 25 mV */
		break;
	default:
		return -EINVAL;
	}

	/* Decode current voltage monitor range */
	ret = regmap_read(regmap, MAX5970_REG_MON_RANGE, &reg);
	if (ret)
		return ret;

	*mon_rng = MAX5970_MON_MAX_RANGE_UV >> MAX5970_MON(reg, ch);

	return 0;
}

static int max597x_setup_irq(struct device *dev,
			     int irq,
			     struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES],
			     int num_switches, struct max597x_regulator *data)
{
	struct regulator_irq_desc max597x_notif = {
		.name = "max597x-irq",
		.map_event = max597x_irq_handler,
		.data = data,
	};
	int errs = REGULATOR_ERROR_UNDER_VOLTAGE |
	    REGULATOR_ERROR_UNDER_VOLTAGE_WARN |
	    REGULATOR_ERROR_OVER_VOLTAGE_WARN |
	    REGULATOR_ERROR_REGULATION_OUT |
	    REGULATOR_ERROR_OVER_CURRENT |
	    REGULATOR_ERROR_OVER_CURRENT_WARN | REGULATOR_ERROR_FAIL;
	void *irq_helper;

	/* Register notifiers - can fail if IRQ is not given */
	irq_helper = devm_regulator_irq_helper(dev, &max597x_notif,
					       irq, 0, errs, NULL,
					       &rdevs[0], num_switches);
	if (IS_ERR(irq_helper)) {
		if (PTR_ERR(irq_helper) == -EPROBE_DEFER)
			return -EPROBE_DEFER;

		dev_warn(dev, "IRQ disabled %pe\n", irq_helper);
	}

	return 0;
}

static int max597x_regulator_probe(struct platform_device *pdev)
{
	struct max597x_data *max597x;
	struct regmap *regmap = dev_get_regmap(pdev->dev.parent, NULL);
	struct max597x_regulator *data;
	struct i2c_client *i2c = to_i2c_client(pdev->dev.parent);
	struct regulator_config config = { };
	struct regulator_dev *rdev;
	struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES];
	int num_switches;
	int ret, i;

	if (!regmap)
		return -EPROBE_DEFER;

	max597x = devm_kzalloc(&i2c->dev, sizeof(struct max597x_data), GFP_KERNEL);
	if (!max597x)
		return -ENOMEM;

	i2c_set_clientdata(i2c, max597x);

	if (of_device_is_compatible(i2c->dev.of_node, "maxim,max5978"))
		max597x->num_switches = MAX597x_TYPE_MAX5978;
	else if (of_device_is_compatible(i2c->dev.of_node, "maxim,max5970"))
		max597x->num_switches = MAX597x_TYPE_MAX5970;
	else
		return -ENODEV;

	i2c_set_clientdata(i2c, max597x);
	num_switches = max597x->num_switches;

	for (i = 0; i < num_switches; i++) {
		data =
		    devm_kzalloc(&i2c->dev, sizeof(struct max597x_regulator),
				 GFP_KERNEL);
		if (!data)
			return -ENOMEM;

		data->num_switches = num_switches;
		data->regmap = regmap;

		ret = max597x_adc_range(regmap, i, &max597x->irng[i], &max597x->mon_rng[i]);
		if (ret < 0)
			return ret;

		data->irng = max597x->irng[i];
		data->mon_rng = max597x->mon_rng[i];

		config.dev = &i2c->dev;
		config.driver_data = (void *)data;
		config.regmap = data->regmap;
		rdev = devm_regulator_register(&i2c->dev,
					       &regulators[i], &config);
		if (IS_ERR(rdev)) {
			dev_err(&i2c->dev, "failed to register regulator %s\n",
				regulators[i].name);
			return PTR_ERR(rdev);
		}
		rdevs[i] = rdev;
		max597x->shunt_micro_ohms[i] = data->shunt_micro_ohms;
	}

	if (i2c->irq) {
		ret =
		    max597x_setup_irq(&i2c->dev, i2c->irq, rdevs, num_switches,
				      data);
		if (ret) {
			dev_err(&i2c->dev, "IRQ setup failed");
			return ret;
		}
	}

	return ret;
}

static struct platform_driver max597x_regulator_driver = {
	.driver = {
		.name = "max597x-regulator",
	},
	.probe = max597x_regulator_probe,
};

module_platform_driver(max597x_regulator_driver);


MODULE_AUTHOR("Patrick Rudolph <patrick.rudolph@9elements.com>");
MODULE_DESCRIPTION("MAX5970_hot-swap controller driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
38493f00 PR	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Device driver for regulators in MAX5970 and MAX5978 IC
	4	*
	5	* Copyright (c) 2022 9elements GmbH
	6	*
	7	* Author: Patrick Rudolph <patrick.rudolph@9elements.com>
	8	*/
	9
	10	#include <linux/bitops.h>
	11	#include <linux/device.h>
	12	#include <linux/err.h>
	13	#include <linux/module.h>
	14	#include <linux/io.h>
	15	#include <linux/of.h>
	16	#include <linux/i2c.h>
	17	#include <linux/regmap.h>
	18	#include <linux/regulator/driver.h>
	19	#include <linux/regulator/machine.h>
	20	#include <linux/regulator/of_regulator.h>
38493f00 PR	21	#include <linux/platform_device.h>
	22
	23	#include <linux/mfd/max597x.h>
	24
	25	struct max597x_regulator {
	26	int num_switches, mon_rng, irng, shunt_micro_ohms, lim_uA;
	27	struct regmap *regmap;
	28	};
	29
	30	enum max597x_regulator_id {
	31	MAX597X_SW0,
	32	MAX597X_SW1,
	33	};
	34
	35	static int max597x_uvp_ovp_check_mode(struct regulator_dev *rdev, int severity)
	36	{
	37	int ret, reg;
	38
	39	/* Status1 register contains the soft strap values sampled at POR */
	40	ret = regmap_read(rdev->regmap, MAX5970_REG_STATUS1, &reg);
	41	if (ret)
	42	return ret;
	43
	44	/* Check soft straps match requested mode */
	45	if (severity == REGULATOR_SEVERITY_PROT) {
	46	if (STATUS1_PROT(reg) != STATUS1_PROT_SHUTDOWN)
	47	return -EOPNOTSUPP;
	48
	49	return 0;
	50	}
	51	if (STATUS1_PROT(reg) == STATUS1_PROT_SHUTDOWN)
	52	return -EOPNOTSUPP;
	53
	54	return 0;
	55	}
	56
	57	static int max597x_set_vp(struct regulator_dev *rdev, int lim_uV, int severity,
	58	bool enable, bool overvoltage)
	59	{
	60	int off_h, off_l, reg, ret;
	61	struct max597x_regulator *data = rdev_get_drvdata(rdev);
	62	int channel = rdev_get_id(rdev);
	63
	64	if (overvoltage) {
	65	if (severity == REGULATOR_SEVERITY_WARN) {
	66	off_h = MAX5970_REG_CH_OV_WARN_H(channel);
	67	off_l = MAX5970_REG_CH_OV_WARN_L(channel);
	68	} else {
	69	off_h = MAX5970_REG_CH_OV_CRIT_H(channel);
	70	off_l = MAX5970_REG_CH_OV_CRIT_L(channel);
	71	}
	72	} else {
	73	if (severity == REGULATOR_SEVERITY_WARN) {
	74	off_h = MAX5970_REG_CH_UV_WARN_H(channel);
	75	off_l = MAX5970_REG_CH_UV_WARN_L(channel);
	76	} else {
	77	off_h = MAX5970_REG_CH_UV_CRIT_H(channel);
	78	off_l = MAX5970_REG_CH_UV_CRIT_L(channel);
	79	}
	80	}
	81
	82	if (enable)
	83	/* reg = ADC_MASK * (lim_uV / 1000000) / (data->mon_rng / 1000000) */
	84	reg = ADC_MASK * lim_uV / data->mon_rng;
85	else
86	reg = 0;
87
88	ret = regmap_write(rdev->regmap, off_h, MAX5970_VAL2REG_H(reg));
89	if (ret)
90	return ret;
91
92	ret = regmap_write(rdev->regmap, off_l, MAX5970_VAL2REG_L(reg));
93	if (ret)
94	return ret;
95
96	return 0;
97	}
98
99	static int max597x_set_uvp(struct regulator_dev *rdev, int lim_uV, int severity,
100	bool enable)
101	{
102	int ret;
103
104	/*
105	* MAX5970 has enable control as a special value in limit reg. Can't
106	* set limit but keep feature disabled or enable W/O given limit.
107	*/
108	if ((lim_uV && !enable) \|\| (!lim_uV && enable))
109	return -EINVAL;
110
111	ret = max597x_uvp_ovp_check_mode(rdev, severity);
112	if (ret)
113	return ret;
114
115	return max597x_set_vp(rdev, lim_uV, severity, enable, false);
116	}
117
118	static int max597x_set_ovp(struct regulator_dev *rdev, int lim_uV, int severity,
119	bool enable)
120	{
121	int ret;
122
123	/*
124	* MAX5970 has enable control as a special value in limit reg. Can't
125	* set limit but keep feature disabled or enable W/O given limit.
126	*/
127	if ((lim_uV && !enable) \|\| (!lim_uV && enable))
128	return -EINVAL;
129
130	ret = max597x_uvp_ovp_check_mode(rdev, severity);
131	if (ret)
132	return ret;
133
134	return max597x_set_vp(rdev, lim_uV, severity, enable, true);
135	}
136
137	static int max597x_set_ocp(struct regulator_dev *rdev, int lim_uA,
138	int severity, bool enable)
139	{
48aa4730	140	int val, reg;
38493f00 PR	141	unsigned int vthst, vthfst;
	142
	143	struct max597x_regulator *data = rdev_get_drvdata(rdev);
	144	int rdev_id = rdev_get_id(rdev);
	145	/*
	146	* MAX5970 doesn't has enable control for ocp.
	147	* If limit is specified but enable is not set then hold the value in
	148	* variable & later use it when ocp needs to be enabled.
	149	*/
	150	if (lim_uA != 0 && lim_uA != data->lim_uA)
	151	data->lim_uA = lim_uA;
	152
	153	if (severity != REGULATOR_SEVERITY_PROT)
	154	return -EINVAL;
	155
	156	if (enable) {
	157
	158	/* Calc Vtrip threshold in uV. */
	159	vthst =
	160	div_u64(mul_u32_u32(data->shunt_micro_ohms, data->lim_uA),
	161	1000000);
	162
	163	/*
	164	* As recommended in datasheed, add 20% margin to avoid
	165	* spurious event & passive component tolerance.
	166	*/
	167	vthst = div_u64(mul_u32_u32(vthst, 120), 100);
	168
	169	/* Calc fast Vtrip threshold in uV */
	170	vthfst = vthst * (MAX5970_FAST2SLOW_RATIO / 100);
	171
	172	if (vthfst > data->irng) {
	173	dev_err(&rdev->dev, "Current limit out of range\n");
	174	return -EINVAL;
	175	}
	176	/* Fast trip threshold to be programmed */
	177	val = div_u64(mul_u32_u32(0xFF, vthfst), data->irng);
	178	} else
	179	/*
	180	* Since there is no option to disable ocp, set limit to max
	181	* value
	182	*/
	183	val = 0xFF;
	184
	185	reg = MAX5970_REG_DAC_FAST(rdev_id);
38493f00	186
48aa4730	187	return regmap_write(rdev->regmap, reg, val);
38493f00 PR	188	}
	189
	190	static int max597x_get_status(struct regulator_dev *rdev)
	191	{
	192	int val, ret;
	193
	194	ret = regmap_read(rdev->regmap, MAX5970_REG_STATUS3, &val);
	195	if (ret)
d0566564	196	return ret;
38493f00 PR	197
	198	if (val & MAX5970_STATUS3_ALERT)
	199	return REGULATOR_STATUS_ERROR;
	200
	201	ret = regulator_is_enabled_regmap(rdev);
	202	if (ret < 0)
	203	return ret;
	204
	205	if (ret)
	206	return REGULATOR_STATUS_ON;
	207
	208	return REGULATOR_STATUS_OFF;
	209	}
	210
	211	static const struct regulator_ops max597x_switch_ops = {
	212	.enable = regulator_enable_regmap,
	213	.disable = regulator_disable_regmap,
	214	.is_enabled = regulator_is_enabled_regmap,
	215	.get_status = max597x_get_status,
	216	.set_over_voltage_protection = max597x_set_ovp,
	217	.set_under_voltage_protection = max597x_set_uvp,
	218	.set_over_current_protection = max597x_set_ocp,
	219	};
	220
	221	static int max597x_dt_parse(struct device_node *np,
	222	const struct regulator_desc *desc,
	223	struct regulator_config *cfg)
	224	{
	225	struct max597x_regulator *data = cfg->driver_data;
	226	int ret = 0;
	227
	228	ret =
	229	of_property_read_u32(np, "shunt-resistor-micro-ohms",
	230	&data->shunt_micro_ohms);
	231	if (ret < 0)
	232	dev_err(cfg->dev,
	233	"property 'shunt-resistor-micro-ohms' not found, err %d\n",
	234	ret);
	235	return ret;
	236
	237	}
	238
	239	#define MAX597X_SWITCH(_ID, _ereg, _chan, _supply) { \
	240	.name = #_ID, \
	241	.of_match = of_match_ptr(#_ID), \
	242	.ops = &max597x_switch_ops, \
	243	.regulators_node = of_match_ptr("regulators"), \
	244	.type = REGULATOR_VOLTAGE, \
	245	.id = MAX597X_##_ID, \
	246	.owner = THIS_MODULE, \
	247	.supply_name = _supply, \
	248	.enable_reg = _ereg, \
	249	.enable_mask = CHXEN((_chan)), \
	250	.of_parse_cb = max597x_dt_parse, \
	251	}
	252
	253	static const struct regulator_desc regulators[] = {
	254	MAX597X_SWITCH(SW0, MAX5970_REG_CHXEN, 0, "vss1"),
	255	MAX597X_SWITCH(SW1, MAX5970_REG_CHXEN, 1, "vss2"),
	256	};
	257
	258	static int max597x_regmap_read_clear(struct regmap *map, unsigned int reg,
	259	unsigned int *val)
	260	{
261	int ret;
262
263	ret = regmap_read(map, reg, val);
264	if (ret)
265	return ret;
266
267	if (*val)
268	return regmap_write(map, reg, *val);
269
270	return 0;
271	}
272
273	static int max597x_irq_handler(int irq, struct regulator_irq_data *rid,
274	unsigned long *dev_mask)
275	{
276	struct regulator_err_state *stat;
277	struct max597x_regulator d = (struct max597x_regulator )rid->data;
278	int val, ret, i;
279
280	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT0, &val);
281	if (ret)
282	return REGULATOR_FAILED_RETRY;
283
284	*dev_mask = 0;
285	for (i = 0; i < d->num_switches; i++) {
286	stat = &rid->states[i];
287	stat->notifs = 0;
288	stat->errors = 0;
289	}
290
291	for (i = 0; i < d->num_switches; i++) {
292	stat = &rid->states[i];
293
294	if (val & UV_STATUS_CRIT(i)) {
295	*dev_mask \|= 1 << i;
296	stat->notifs \|= REGULATOR_EVENT_UNDER_VOLTAGE;
297	stat->errors \|= REGULATOR_ERROR_UNDER_VOLTAGE;
298	} else if (val & UV_STATUS_WARN(i)) {
299	*dev_mask \|= 1 << i;
300	stat->notifs \|= REGULATOR_EVENT_UNDER_VOLTAGE_WARN;
301	stat->errors \|= REGULATOR_ERROR_UNDER_VOLTAGE_WARN;
302	}
303	}
304
305	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT1, &val);
306	if (ret)
307	return REGULATOR_FAILED_RETRY;
308
309	for (i = 0; i < d->num_switches; i++) {
310	stat = &rid->states[i];
311
312	if (val & OV_STATUS_CRIT(i)) {
313	*dev_mask \|= 1 << i;
314	stat->notifs \|= REGULATOR_EVENT_REGULATION_OUT;
315	stat->errors \|= REGULATOR_ERROR_REGULATION_OUT;
316	} else if (val & OV_STATUS_WARN(i)) {
317	*dev_mask \|= 1 << i;
318	stat->notifs \|= REGULATOR_EVENT_OVER_VOLTAGE_WARN;
319	stat->errors \|= REGULATOR_ERROR_OVER_VOLTAGE_WARN;
320	}
321	}
322
323	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT2, &val);
324	if (ret)
325	return REGULATOR_FAILED_RETRY;
326
327	for (i = 0; i < d->num_switches; i++) {
328	stat = &rid->states[i];
329
330	if (val & OC_STATUS_WARN(i)) {
331	*dev_mask \|= 1 << i;
332	stat->notifs \|= REGULATOR_EVENT_OVER_CURRENT_WARN;
333	stat->errors \|= REGULATOR_ERROR_OVER_CURRENT_WARN;
334	}
335	}
336
337	ret = regmap_read(d->regmap, MAX5970_REG_STATUS0, &val);
338	if (ret)
339	return REGULATOR_FAILED_RETRY;
340
341	for (i = 0; i < d->num_switches; i++) {
342	stat = &rid->states[i];
343
344	if ((val & MAX5970_CB_IFAULTF(i))
345	\|\| (val & MAX5970_CB_IFAULTS(i))) {
346	*dev_mask \|= 1 << i;
347	stat->notifs \|=
348	REGULATOR_EVENT_OVER_CURRENT \|
349	REGULATOR_EVENT_DISABLE;
350	stat->errors \|=
351	REGULATOR_ERROR_OVER_CURRENT \| REGULATOR_ERROR_FAIL;
352
353	/* Clear the sub-IRQ status */
354	regulator_disable_regmap(stat->rdev);
355	}
356	}
357	return 0;
358	}
359
38493f00 PR	360	static int max597x_adc_range(struct regmap *regmap, const int ch,
	361	u32 irng, u32 mon_rng)
	362	{
	363	unsigned int reg;
	364	int ret;
	365
	366	/* Decode current ADC range */
	367	ret = regmap_read(regmap, MAX5970_REG_STATUS2, &reg);
	368	if (ret)
	369	return ret;
	370	switch (MAX5970_IRNG(reg, ch)) {
	371	case 0:
	372	irng = 100000; / 100 mV */
	373	break;
	374	case 1:
	375	irng = 50000; / 50 mV */
	376	break;
	377	case 2:
	378	irng = 25000; / 25 mV */
	379	break;
	380	default:
	381	return -EINVAL;
	382	}
	383
	384	/* Decode current voltage monitor range */
	385	ret = regmap_read(regmap, MAX5970_REG_MON_RANGE, &reg);
	386	if (ret)
	387	return ret;
	388
	389	*mon_rng = MAX5970_MON_MAX_RANGE_UV >> MAX5970_MON(reg, ch);
	390
	391	return 0;
	392	}
	393
	394	static int max597x_setup_irq(struct device *dev,
	395	int irq,
	396	struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES],
	397	int num_switches, struct max597x_regulator *data)
	398	{
	399	struct regulator_irq_desc max597x_notif = {
	400	.name = "max597x-irq",
	401	.map_event = max597x_irq_handler,
	402	.data = data,
	403	};
	404	int errs = REGULATOR_ERROR_UNDER_VOLTAGE \|
	405	REGULATOR_ERROR_UNDER_VOLTAGE_WARN \|
	406	REGULATOR_ERROR_OVER_VOLTAGE_WARN \|
	407	REGULATOR_ERROR_REGULATION_OUT \|
	408	REGULATOR_ERROR_OVER_CURRENT \|
	409	REGULATOR_ERROR_OVER_CURRENT_WARN \| REGULATOR_ERROR_FAIL;
	410	void *irq_helper;
	411
	412	/* Register notifiers - can fail if IRQ is not given */
	413	irq_helper = devm_regulator_irq_helper(dev, &max597x_notif,
	414	irq, 0, errs, NULL,
	415	&rdevs[0], num_switches);
	416	if (IS_ERR(irq_helper)) {
	417	if (PTR_ERR(irq_helper) == -EPROBE_DEFER)
	418	return -EPROBE_DEFER;
	419
	420	dev_warn(dev, "IRQ disabled %pe\n", irq_helper);
	421	}
	422
	423	return 0;
424	}
425
426	static int max597x_regulator_probe(struct platform_device *pdev)
427	{
7f62cb88 NS	428	struct max597x_data *max597x;
7f62cb88 NS	429	struct regmap *regmap = dev_get_regmap(pdev->dev.parent, NULL);
38493f00	430	struct max597x_regulator *data;
7f62cb88	431	struct i2c_client *i2c = to_i2c_client(pdev->dev.parent);
38493f00 PR	432	struct regulator_config config = { };
	433	struct regulator_dev *rdev;
	434	struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES];
7f62cb88	435	int num_switches;
38493f00 PR	436	int ret, i;
38493f00 PR	437
7f62cb88 NS	438	if (!regmap)
	439	return -EPROBE_DEFER;
	440
	441	max597x = devm_kzalloc(&i2c->dev, sizeof(struct max597x_data), GFP_KERNEL);
	442	if (!max597x)
	443	return -ENOMEM;
	444
	445	i2c_set_clientdata(i2c, max597x);
	446
	447	if (of_device_is_compatible(i2c->dev.of_node, "maxim,max5978"))
	448	max597x->num_switches = MAX597x_TYPE_MAX5978;
	449	else if (of_device_is_compatible(i2c->dev.of_node, "maxim,max5970"))
	450	max597x->num_switches = MAX597x_TYPE_MAX5970;
	451	else
	452	return -ENODEV;
	453
	454	i2c_set_clientdata(i2c, max597x);
	455	num_switches = max597x->num_switches;
	456
38493f00 PR	457	for (i = 0; i < num_switches; i++) {
38493f00 PR	458	data =
7f62cb88	459	devm_kzalloc(&i2c->dev, sizeof(struct max597x_regulator),
38493f00 PR	460	GFP_KERNEL);
	461	if (!data)
	462	return -ENOMEM;
	463
	464	data->num_switches = num_switches;
7f62cb88	465	data->regmap = regmap;
38493f00	466
7f62cb88	467	ret = max597x_adc_range(regmap, i, &max597x->irng[i], &max597x->mon_rng[i]);
38493f00 PR	468	if (ret < 0)
	469	return ret;
	470
	471	data->irng = max597x->irng[i];
	472	data->mon_rng = max597x->mon_rng[i];
	473
7f62cb88	474	config.dev = &i2c->dev;
38493f00 PR	475	config.driver_data = (void *)data;
38493f00 PR	476	config.regmap = data->regmap;
7f62cb88	477	rdev = devm_regulator_register(&i2c->dev,
38493f00 PR	478	&regulators[i], &config);
38493f00 PR	479	if (IS_ERR(rdev)) {
7f62cb88	480	dev_err(&i2c->dev, "failed to register regulator %s\n",
38493f00 PR	481	regulators[i].name);
	482	return PTR_ERR(rdev);
	483	}
	484	rdevs[i] = rdev;
	485	max597x->shunt_micro_ohms[i] = data->shunt_micro_ohms;
	486	}
	487
7f62cb88	488	if (i2c->irq) {
38493f00	489	ret =
7f62cb88	490	max597x_setup_irq(&i2c->dev, i2c->irq, rdevs, num_switches,
38493f00 PR	491	data);
38493f00 PR	492	if (ret) {
7f62cb88	493	dev_err(&i2c->dev, "IRQ setup failed");
38493f00 PR	494	return ret;
	495	}
	496	}
	497
	498	return ret;
	499	}
	500
	501	static struct platform_driver max597x_regulator_driver = {
	502	.driver = {
	503	.name = "max597x-regulator",
	504	},
	505	.probe = max597x_regulator_probe,
	506	};
	507
	508	module_platform_driver(max597x_regulator_driver);
	509
	510
	511	MODULE_AUTHOR("Patrick Rudolph <patrick.rudolph@9elements.com>");
	512	MODULE_DESCRIPTION("MAX5970_hot-swap controller driver");
	513	MODULE_LICENSE("GPL v2");