[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 ret, 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);
	ret = regmap_write(rdev->regmap, reg, val);

	return ret;
}

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

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

	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 const struct regmap_config max597x_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = MAX_REGISTERS,
};

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 = dev_get_drvdata(pdev->dev.parent);
	struct max597x_regulator *data;

	struct regulator_config config = { };
	struct regulator_dev *rdev;
	struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES];
	int num_switches = max597x->num_switches;
	int ret, i;

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

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

		ret = max597x_adc_range(data->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 = max597x->dev;
		config.driver_data = (void *)data;
		config.regmap = data->regmap;
		rdev = devm_regulator_register(max597x->dev,
					       &regulators[i], &config);
		if (IS_ERR(rdev)) {
			dev_err(max597x->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 (max597x->irq) {
		ret =
		    max597x_setup_irq(max597x->dev, max597x->irq, rdevs, num_switches,
				      data);
		if (ret) {
			dev_err(max597x->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	{
140	int ret, val, reg;
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);
186	ret = regmap_write(rdev->regmap, reg, val);
187
188	return ret;
189	}
190
191	static int max597x_get_status(struct regulator_dev *rdev)
192	{
193	int val, ret;
194
195	ret = regmap_read(rdev->regmap, MAX5970_REG_STATUS3, &val);
196	if (ret)
197	return REGULATOR_FAILED_RETRY;
198
199	if (val & MAX5970_STATUS3_ALERT)
200	return REGULATOR_STATUS_ERROR;
201
202	ret = regulator_is_enabled_regmap(rdev);
203	if (ret < 0)
204	return ret;
205
206	if (ret)
207	return REGULATOR_STATUS_ON;
208
209	return REGULATOR_STATUS_OFF;
210	}
211
212	static const struct regulator_ops max597x_switch_ops = {
213	.enable = regulator_enable_regmap,
214	.disable = regulator_disable_regmap,
215	.is_enabled = regulator_is_enabled_regmap,
216	.get_status = max597x_get_status,
217	.set_over_voltage_protection = max597x_set_ovp,
218	.set_under_voltage_protection = max597x_set_uvp,
219	.set_over_current_protection = max597x_set_ocp,
220	};
221
222	static int max597x_dt_parse(struct device_node *np,
223	const struct regulator_desc *desc,
224	struct regulator_config *cfg)
225	{
226	struct max597x_regulator *data = cfg->driver_data;
227	int ret = 0;
228
229	ret =
230	of_property_read_u32(np, "shunt-resistor-micro-ohms",
231	&data->shunt_micro_ohms);
232	if (ret < 0)
233	dev_err(cfg->dev,
234	"property 'shunt-resistor-micro-ohms' not found, err %d\n",
235	ret);
236	return ret;
237
238	}
239
240	#define MAX597X_SWITCH(_ID, _ereg, _chan, _supply) { \
241	.name = #_ID, \
242	.of_match = of_match_ptr(#_ID), \
243	.ops = &max597x_switch_ops, \
244	.regulators_node = of_match_ptr("regulators"), \
245	.type = REGULATOR_VOLTAGE, \
246	.id = MAX597X_##_ID, \
247	.owner = THIS_MODULE, \
248	.supply_name = _supply, \
249	.enable_reg = _ereg, \
250	.enable_mask = CHXEN((_chan)), \
251	.of_parse_cb = max597x_dt_parse, \
252	}
253
254	static const struct regulator_desc regulators[] = {
255	MAX597X_SWITCH(SW0, MAX5970_REG_CHXEN, 0, "vss1"),
256	MAX597X_SWITCH(SW1, MAX5970_REG_CHXEN, 1, "vss2"),
257	};
258
259	static int max597x_regmap_read_clear(struct regmap *map, unsigned int reg,
260	unsigned int *val)
261	{
262	int ret;
263
264	ret = regmap_read(map, reg, val);
265	if (ret)
266	return ret;
267
268	if (*val)
269	return regmap_write(map, reg, *val);
270
271	return 0;
272	}
273
274	static int max597x_irq_handler(int irq, struct regulator_irq_data *rid,
275	unsigned long *dev_mask)
276	{
277	struct regulator_err_state *stat;
278	struct max597x_regulator d = (struct max597x_regulator )rid->data;
279	int val, ret, i;
280
281	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT0, &val);
282	if (ret)
283	return REGULATOR_FAILED_RETRY;
284
285	*dev_mask = 0;
286	for (i = 0; i < d->num_switches; i++) {
287	stat = &rid->states[i];
288	stat->notifs = 0;
289	stat->errors = 0;
290	}
291
292	for (i = 0; i < d->num_switches; i++) {
293	stat = &rid->states[i];
294
295	if (val & UV_STATUS_CRIT(i)) {
296	*dev_mask \|= 1 << i;
297	stat->notifs \|= REGULATOR_EVENT_UNDER_VOLTAGE;
298	stat->errors \|= REGULATOR_ERROR_UNDER_VOLTAGE;
299	} else if (val & UV_STATUS_WARN(i)) {
300	*dev_mask \|= 1 << i;
301	stat->notifs \|= REGULATOR_EVENT_UNDER_VOLTAGE_WARN;
302	stat->errors \|= REGULATOR_ERROR_UNDER_VOLTAGE_WARN;
303	}
304	}
305
306	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT1, &val);
307	if (ret)
308	return REGULATOR_FAILED_RETRY;
309
310	for (i = 0; i < d->num_switches; i++) {
311	stat = &rid->states[i];
312
313	if (val & OV_STATUS_CRIT(i)) {
314	*dev_mask \|= 1 << i;
315	stat->notifs \|= REGULATOR_EVENT_REGULATION_OUT;
316	stat->errors \|= REGULATOR_ERROR_REGULATION_OUT;
317	} else if (val & OV_STATUS_WARN(i)) {
318	*dev_mask \|= 1 << i;
319	stat->notifs \|= REGULATOR_EVENT_OVER_VOLTAGE_WARN;
320	stat->errors \|= REGULATOR_ERROR_OVER_VOLTAGE_WARN;
321	}
322	}
323
324	ret = max597x_regmap_read_clear(d->regmap, MAX5970_REG_FAULT2, &val);
325	if (ret)
326	return REGULATOR_FAILED_RETRY;
327
328	for (i = 0; i < d->num_switches; i++) {
329	stat = &rid->states[i];
330
331	if (val & OC_STATUS_WARN(i)) {
332	*dev_mask \|= 1 << i;
333	stat->notifs \|= REGULATOR_EVENT_OVER_CURRENT_WARN;
334	stat->errors \|= REGULATOR_ERROR_OVER_CURRENT_WARN;
335	}
336	}
337
338	ret = regmap_read(d->regmap, MAX5970_REG_STATUS0, &val);
339	if (ret)
340	return REGULATOR_FAILED_RETRY;
341
342	for (i = 0; i < d->num_switches; i++) {
343	stat = &rid->states[i];
344
345	if ((val & MAX5970_CB_IFAULTF(i))
346	\|\| (val & MAX5970_CB_IFAULTS(i))) {
347	*dev_mask \|= 1 << i;
348	stat->notifs \|=
349	REGULATOR_EVENT_OVER_CURRENT \|
350	REGULATOR_EVENT_DISABLE;
351	stat->errors \|=
352	REGULATOR_ERROR_OVER_CURRENT \| REGULATOR_ERROR_FAIL;
353
354	/* Clear the sub-IRQ status */
355	regulator_disable_regmap(stat->rdev);
356	}
357	}
358	return 0;
359	}
360
361	static const struct regmap_config max597x_regmap_config = {
362	.reg_bits = 8,
363	.val_bits = 8,
364	.max_register = MAX_REGISTERS,
365	};
366
367	static int max597x_adc_range(struct regmap *regmap, const int ch,
368	u32 irng, u32 mon_rng)
369	{
370	unsigned int reg;
371	int ret;
372
373	/* Decode current ADC range */
374	ret = regmap_read(regmap, MAX5970_REG_STATUS2, &reg);
375	if (ret)
376	return ret;
377	switch (MAX5970_IRNG(reg, ch)) {
378	case 0:
379	irng = 100000; / 100 mV */
380	break;
381	case 1:
382	irng = 50000; / 50 mV */
383	break;
384	case 2:
385	irng = 25000; / 25 mV */
386	break;
387	default:
388	return -EINVAL;
389	}
390
391	/* Decode current voltage monitor range */
392	ret = regmap_read(regmap, MAX5970_REG_MON_RANGE, &reg);
393	if (ret)
394	return ret;
395
396	*mon_rng = MAX5970_MON_MAX_RANGE_UV >> MAX5970_MON(reg, ch);
397
398	return 0;
399	}
400
401	static int max597x_setup_irq(struct device *dev,
402	int irq,
403	struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES],
404	int num_switches, struct max597x_regulator *data)
405	{
406	struct regulator_irq_desc max597x_notif = {
407	.name = "max597x-irq",
408	.map_event = max597x_irq_handler,
409	.data = data,
410	};
411	int errs = REGULATOR_ERROR_UNDER_VOLTAGE \|
412	REGULATOR_ERROR_UNDER_VOLTAGE_WARN \|
413	REGULATOR_ERROR_OVER_VOLTAGE_WARN \|
414	REGULATOR_ERROR_REGULATION_OUT \|
415	REGULATOR_ERROR_OVER_CURRENT \|
416	REGULATOR_ERROR_OVER_CURRENT_WARN \| REGULATOR_ERROR_FAIL;
417	void *irq_helper;
418
419	/* Register notifiers - can fail if IRQ is not given */
420	irq_helper = devm_regulator_irq_helper(dev, &max597x_notif,
421	irq, 0, errs, NULL,
422	&rdevs[0], num_switches);
423	if (IS_ERR(irq_helper)) {
424	if (PTR_ERR(irq_helper) == -EPROBE_DEFER)
425	return -EPROBE_DEFER;
426
427	dev_warn(dev, "IRQ disabled %pe\n", irq_helper);
428	}
429
430	return 0;
431	}
432
433	static int max597x_regulator_probe(struct platform_device *pdev)
434	{
435
436
437	struct max597x_data *max597x = dev_get_drvdata(pdev->dev.parent);
438	struct max597x_regulator *data;
439
440	struct regulator_config config = { };
441	struct regulator_dev *rdev;
442	struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES];
443	int num_switches = max597x->num_switches;
444	int ret, i;
445
446	for (i = 0; i < num_switches; i++) {
447	data =
448	devm_kzalloc(max597x->dev, sizeof(struct max597x_regulator),
449	GFP_KERNEL);
450	if (!data)
451	return -ENOMEM;
452
453	data->num_switches = num_switches;
454	data->regmap = max597x->regmap;
455
38493f00 PR	456	ret = max597x_adc_range(data->regmap, i, &max597x->irng[i], &max597x->mon_rng[i]);
	457	if (ret < 0)
	458	return ret;
	459
	460	data->irng = max597x->irng[i];
	461	data->mon_rng = max597x->mon_rng[i];
	462
	463	config.dev = max597x->dev;
	464	config.driver_data = (void *)data;
	465	config.regmap = data->regmap;
	466	rdev = devm_regulator_register(max597x->dev,
	467	&regulators[i], &config);
	468	if (IS_ERR(rdev)) {
	469	dev_err(max597x->dev, "failed to register regulator %s\n",
	470	regulators[i].name);
	471	return PTR_ERR(rdev);
	472	}
	473	rdevs[i] = rdev;
	474	max597x->shunt_micro_ohms[i] = data->shunt_micro_ohms;
	475	}
	476
	477	if (max597x->irq) {
	478	ret =
	479	max597x_setup_irq(max597x->dev, max597x->irq, rdevs, num_switches,
	480	data);
	481	if (ret) {
	482	dev_err(max597x->dev, "IRQ setup failed");
	483	return ret;
	484	}
	485	}
	486
	487	return ret;
	488	}
	489
	490	static struct platform_driver max597x_regulator_driver = {
	491	.driver = {
	492	.name = "max597x-regulator",
	493	},
	494	.probe = max597x_regulator_probe,
	495	};
	496
	497	module_platform_driver(max597x_regulator_driver);
	498
	499
	500	MODULE_AUTHOR("Patrick Rudolph <patrick.rudolph@9elements.com>");
	501	MODULE_DESCRIPTION("MAX5970_hot-swap controller driver");
	502	MODULE_LICENSE("GPL v2");