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>
 21#include <linux/platform_device.h>
 22
 23#include <linux/mfd/max597x.h>
 24
 25struct max597x_regulator {
 26	int num_switches, mon_rng, irng, shunt_micro_ohms, lim_uA;
 27	struct regmap *regmap;
 28};
 29
 30enum max597x_regulator_id {
 31	MAX597X_SW0,
 32	MAX597X_SW1,
 33};
 34
 35static 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
 57static 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
 99static 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
118static 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
137static int max597x_set_ocp(struct regulator_dev *rdev, int lim_uA,
138			   int severity, bool enable)
139{
140	int 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
187	return regmap_write(rdev->regmap, reg, val);
188}
189
190static 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)
196		return REGULATOR_FAILED_RETRY;
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
211static 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
221static 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
253static 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
258static 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
273static 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
360static const struct regmap_config max597x_regmap_config = {
361	.reg_bits = 8,
362	.val_bits = 8,
363	.max_register = MAX_REGISTERS,
364};
365
366static int max597x_adc_range(struct regmap *regmap, const int ch,
367			     u32 *irng, u32 *mon_rng)
368{
369	unsigned int reg;
370	int ret;
371
372	/* Decode current ADC range */
373	ret = regmap_read(regmap, MAX5970_REG_STATUS2, &reg);
374	if (ret)
375		return ret;
376	switch (MAX5970_IRNG(reg, ch)) {
377	case 0:
378		*irng = 100000;	/* 100 mV */
379		break;
380	case 1:
381		*irng = 50000;	/* 50 mV */
382		break;
383	case 2:
384		*irng = 25000;	/* 25 mV */
385		break;
386	default:
387		return -EINVAL;
388	}
389
390	/* Decode current voltage monitor range */
391	ret = regmap_read(regmap, MAX5970_REG_MON_RANGE, &reg);
392	if (ret)
393		return ret;
394
395	*mon_rng = MAX5970_MON_MAX_RANGE_UV >> MAX5970_MON(reg, ch);
396
397	return 0;
398}
399
400static int max597x_setup_irq(struct device *dev,
401			     int irq,
402			     struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES],
403			     int num_switches, struct max597x_regulator *data)
404{
405	struct regulator_irq_desc max597x_notif = {
406		.name = "max597x-irq",
407		.map_event = max597x_irq_handler,
408		.data = data,
409	};
410	int errs = REGULATOR_ERROR_UNDER_VOLTAGE |
411	    REGULATOR_ERROR_UNDER_VOLTAGE_WARN |
412	    REGULATOR_ERROR_OVER_VOLTAGE_WARN |
413	    REGULATOR_ERROR_REGULATION_OUT |
414	    REGULATOR_ERROR_OVER_CURRENT |
415	    REGULATOR_ERROR_OVER_CURRENT_WARN | REGULATOR_ERROR_FAIL;
416	void *irq_helper;
417
418	/* Register notifiers - can fail if IRQ is not given */
419	irq_helper = devm_regulator_irq_helper(dev, &max597x_notif,
420					       irq, 0, errs, NULL,
421					       &rdevs[0], num_switches);
422	if (IS_ERR(irq_helper)) {
423		if (PTR_ERR(irq_helper) == -EPROBE_DEFER)
424			return -EPROBE_DEFER;
425
426		dev_warn(dev, "IRQ disabled %pe\n", irq_helper);
427	}
428
429	return 0;
430}
431
432static int max597x_regulator_probe(struct platform_device *pdev)
433{
434
435
436	struct max597x_data *max597x = dev_get_drvdata(pdev->dev.parent);
437	struct max597x_regulator *data;
438
439	struct regulator_config config = { };
440	struct regulator_dev *rdev;
441	struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES];
442	int num_switches = max597x->num_switches;
443	int ret, i;
444
445	for (i = 0; i < num_switches; i++) {
446		data =
447		    devm_kzalloc(max597x->dev, sizeof(struct max597x_regulator),
448				 GFP_KERNEL);
449		if (!data)
450			return -ENOMEM;
451
452		data->num_switches = num_switches;
453		data->regmap = max597x->regmap;
454
455		ret = max597x_adc_range(data->regmap, i, &max597x->irng[i], &max597x->mon_rng[i]);
456		if (ret < 0)
457			return ret;
458
459		data->irng = max597x->irng[i];
460		data->mon_rng = max597x->mon_rng[i];
461
462		config.dev = max597x->dev;
463		config.driver_data = (void *)data;
464		config.regmap = data->regmap;
465		rdev = devm_regulator_register(max597x->dev,
466					       &regulators[i], &config);
467		if (IS_ERR(rdev)) {
468			dev_err(max597x->dev, "failed to register regulator %s\n",
469				regulators[i].name);
470			return PTR_ERR(rdev);
471		}
472		rdevs[i] = rdev;
473		max597x->shunt_micro_ohms[i] = data->shunt_micro_ohms;
474	}
475
476	if (max597x->irq) {
477		ret =
478		    max597x_setup_irq(max597x->dev, max597x->irq, rdevs, num_switches,
479				      data);
480		if (ret) {
481			dev_err(max597x->dev, "IRQ setup failed");
482			return ret;
483		}
484	}
485
486	return ret;
487}
488
489static struct platform_driver max597x_regulator_driver = {
490	.driver = {
491		.name = "max597x-regulator",
492	},
493	.probe = max597x_regulator_probe,
494};
495
496module_platform_driver(max597x_regulator_driver);
497
498
499MODULE_AUTHOR("Patrick Rudolph <patrick.rudolph@9elements.com>");
500MODULE_DESCRIPTION("MAX5970_hot-swap controller driver");
501MODULE_LICENSE("GPL v2");