1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2020 ROHM Semiconductors
3 // ROHM BD9576MUF/BD9573MUF regulator driver
4 
5 #include <linux/err.h>
6 #include <linux/gpio/consumer.h>
7 #include <linux/interrupt.h>
8 #include <linux/jiffies.h>
9 #include <linux/kernel.h>
10 #include <linux/mfd/rohm-bd957x.h>
11 #include <linux/mfd/rohm-generic.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/platform_device.h>
15 #include <linux/regulator/driver.h>
16 #include <linux/regulator/machine.h>
17 #include <linux/regulator/of_regulator.h>
18 #include <linux/slab.h>
19 #include <linux/spinlock.h>
20 #include <linux/workqueue.h>
21 
22 #define BD957X_VOUTS1_VOLT	3300000
23 #define BD957X_VOUTS4_BASE_VOLT	1030000
24 #define BD957X_VOUTS34_NUM_VOLT	32
25 
26 #define BD9576_THERM_IRQ_MASK_TW	BIT(5)
27 #define BD9576_xVD_IRQ_MASK_VOUTL1	BIT(5)
28 #define BD9576_UVD_IRQ_MASK_VOUTS1_OCW	BIT(6)
29 #define BD9576_xVD_IRQ_MASK_VOUT1TO4	0x0F
30 
31 static const unsigned int vout1_volt_table[] = {
32 	5000000, 4900000, 4800000, 4700000, 4600000,
33 	4500000, 4500000, 4500000, 5000000, 5100000,
34 	5200000, 5300000, 5400000, 5500000, 5500000,
35 	5500000
36 };
37 
38 static const unsigned int vout2_volt_table[] = {
39 	1800000, 1780000, 1760000, 1740000, 1720000,
40 	1700000, 1680000, 1660000, 1800000, 1820000,
41 	1840000, 1860000, 1880000, 1900000, 1920000,
42 	1940000
43 };
44 
45 static const unsigned int voutl1_volt_table[] = {
46 	2500000, 2540000, 2580000, 2620000, 2660000,
47 	2700000, 2740000, 2780000, 2500000, 2460000,
48 	2420000, 2380000, 2340000, 2300000, 2260000,
49 	2220000
50 };
51 
52 static const struct linear_range vout1_xvd_ranges[] = {
53 	REGULATOR_LINEAR_RANGE(225000, 0x01, 0x2b, 0),
54 	REGULATOR_LINEAR_RANGE(225000, 0x2c, 0x54, 5000),
55 	REGULATOR_LINEAR_RANGE(425000, 0x55, 0x7f, 0),
56 };
57 
58 static const struct linear_range vout234_xvd_ranges[] = {
59 	REGULATOR_LINEAR_RANGE(17000, 0x01, 0x0f, 0),
60 	REGULATOR_LINEAR_RANGE(17000, 0x10, 0x6d, 1000),
61 	REGULATOR_LINEAR_RANGE(110000, 0x6e, 0x7f, 0),
62 };
63 
64 static const struct linear_range voutL1_xvd_ranges[] = {
65 	REGULATOR_LINEAR_RANGE(34000, 0x01, 0x0f, 0),
66 	REGULATOR_LINEAR_RANGE(34000, 0x10, 0x6d, 2000),
67 	REGULATOR_LINEAR_RANGE(220000, 0x6e, 0x7f, 0),
68 };
69 
70 static struct linear_range voutS1_ocw_ranges_internal[] = {
71 	REGULATOR_LINEAR_RANGE(200000, 0x01, 0x04, 0),
72 	REGULATOR_LINEAR_RANGE(250000, 0x05, 0x18, 50000),
73 	REGULATOR_LINEAR_RANGE(1200000, 0x19, 0x3f, 0),
74 };
75 
76 static struct linear_range voutS1_ocw_ranges[] = {
77 	REGULATOR_LINEAR_RANGE(50000, 0x01, 0x04, 0),
78 	REGULATOR_LINEAR_RANGE(60000, 0x05, 0x18, 10000),
79 	REGULATOR_LINEAR_RANGE(250000, 0x19, 0x3f, 0),
80 };
81 
82 static struct linear_range voutS1_ocp_ranges_internal[] = {
83 	REGULATOR_LINEAR_RANGE(300000, 0x01, 0x06, 0),
84 	REGULATOR_LINEAR_RANGE(350000, 0x7, 0x1b, 50000),
85 	REGULATOR_LINEAR_RANGE(1350000, 0x1c, 0x3f, 0),
86 };
87 
88 static struct linear_range voutS1_ocp_ranges[] = {
89 	REGULATOR_LINEAR_RANGE(70000, 0x01, 0x06, 0),
90 	REGULATOR_LINEAR_RANGE(80000, 0x7, 0x1b, 10000),
91 	REGULATOR_LINEAR_RANGE(280000, 0x1c, 0x3f, 0),
92 };
93 
94 struct bd957x_regulator_data {
95 	struct regulator_desc desc;
96 	int base_voltage;
97 	struct regulator_dev *rdev;
98 	int ovd_notif;
99 	int uvd_notif;
100 	int temp_notif;
101 	int ovd_err;
102 	int uvd_err;
103 	int temp_err;
104 	const struct linear_range *xvd_ranges;
105 	int num_xvd_ranges;
106 	bool oc_supported;
107 	unsigned int ovd_reg;
108 	unsigned int uvd_reg;
109 	unsigned int xvd_mask;
110 	unsigned int ocp_reg;
111 	unsigned int ocp_mask;
112 	unsigned int ocw_reg;
113 	unsigned int ocw_mask;
114 	unsigned int ocw_rfet;
115 };
116 
117 #define BD9576_NUM_REGULATORS 6
118 #define BD9576_NUM_OVD_REGULATORS 5
119 
120 struct bd957x_data {
121 	struct bd957x_regulator_data regulator_data[BD9576_NUM_REGULATORS];
122 	struct regmap *regmap;
123 	struct delayed_work therm_irq_suppress;
124 	struct delayed_work ovd_irq_suppress;
125 	struct delayed_work uvd_irq_suppress;
126 	unsigned int therm_irq;
127 	unsigned int ovd_irq;
128 	unsigned int uvd_irq;
129 	spinlock_t err_lock;
130 	int regulator_global_err;
131 };
132 
133 static int bd957x_vout34_list_voltage(struct regulator_dev *rdev,
134 				      unsigned int selector)
135 {
136 	const struct regulator_desc *desc = rdev->desc;
137 	int multiplier = selector & desc->vsel_mask & 0x7f;
138 	int tune;
139 
140 	/* VOUT3 and 4 has 10mV step */
141 	tune = multiplier * 10000;
142 
143 	if (!(selector & 0x80))
144 		return desc->fixed_uV - tune;
145 
146 	return desc->fixed_uV + tune;
147 }
148 
149 static int bd957x_list_voltage(struct regulator_dev *rdev,
150 			       unsigned int selector)
151 {
152 	const struct regulator_desc *desc = rdev->desc;
153 	int index = selector & desc->vsel_mask & 0x7f;
154 
155 	if (!(selector & 0x80))
156 		index += desc->n_voltages/2;
157 
158 	if (index >= desc->n_voltages)
159 		return -EINVAL;
160 
161 	return desc->volt_table[index];
162 }
163 
164 static void bd9576_fill_ovd_flags(struct bd957x_regulator_data *data,
165 				  bool warn)
166 {
167 	if (warn) {
168 		data->ovd_notif = REGULATOR_EVENT_OVER_VOLTAGE_WARN;
169 		data->ovd_err = REGULATOR_ERROR_OVER_VOLTAGE_WARN;
170 	} else {
171 		data->ovd_notif = REGULATOR_EVENT_REGULATION_OUT;
172 		data->ovd_err = REGULATOR_ERROR_REGULATION_OUT;
173 	}
174 }
175 
176 static void bd9576_fill_ocp_flags(struct bd957x_regulator_data *data,
177 				  bool warn)
178 {
179 	if (warn) {
180 		data->uvd_notif = REGULATOR_EVENT_OVER_CURRENT_WARN;
181 		data->uvd_err = REGULATOR_ERROR_OVER_CURRENT_WARN;
182 	} else {
183 		data->uvd_notif = REGULATOR_EVENT_OVER_CURRENT;
184 		data->uvd_err = REGULATOR_ERROR_OVER_CURRENT;
185 	}
186 }
187 
188 static void bd9576_fill_uvd_flags(struct bd957x_regulator_data *data,
189 				  bool warn)
190 {
191 	if (warn) {
192 		data->uvd_notif = REGULATOR_EVENT_UNDER_VOLTAGE_WARN;
193 		data->uvd_err = REGULATOR_ERROR_UNDER_VOLTAGE_WARN;
194 	} else {
195 		data->uvd_notif = REGULATOR_EVENT_UNDER_VOLTAGE;
196 		data->uvd_err = REGULATOR_ERROR_UNDER_VOLTAGE;
197 	}
198 }
199 
200 static void bd9576_fill_temp_flags(struct bd957x_regulator_data *data,
201 				   bool enable, bool warn)
202 {
203 	if (!enable) {
204 		data->temp_notif = 0;
205 		data->temp_err = 0;
206 	} else if (warn) {
207 		data->temp_notif = REGULATOR_EVENT_OVER_TEMP_WARN;
208 		data->temp_err = REGULATOR_ERROR_OVER_TEMP_WARN;
209 	} else {
210 		data->temp_notif = REGULATOR_EVENT_OVER_TEMP;
211 		data->temp_err = REGULATOR_ERROR_OVER_TEMP;
212 	}
213 }
214 
215 static int bd9576_set_limit(const struct linear_range *r, int num_ranges,
216 			    struct regmap *regmap, int reg, int mask, int lim)
217 {
218 	int ret;
219 	bool found;
220 	int sel = 0;
221 
222 	if (lim) {
223 
224 		ret = linear_range_get_selector_low_array(r, num_ranges,
225 							  lim, &sel, &found);
226 		if (ret)
227 			return ret;
228 
229 		if (!found)
230 			dev_warn(regmap_get_device(regmap),
231 				 "limit %d out of range. Setting lower\n",
232 				 lim);
233 	}
234 
235 	return regmap_update_bits(regmap, reg, mask, sel);
236 }
237 
238 static bool check_ocp_flag_mismatch(struct regulator_dev *rdev, int severity,
239 				    struct bd957x_regulator_data *r)
240 {
241 	if ((severity == REGULATOR_SEVERITY_ERR &&
242 	    r->uvd_notif != REGULATOR_EVENT_OVER_CURRENT) ||
243 	    (severity == REGULATOR_SEVERITY_WARN &&
244 	    r->uvd_notif != REGULATOR_EVENT_OVER_CURRENT_WARN)) {
245 		dev_warn(rdev_get_dev(rdev),
246 			 "Can't support both OCP WARN and ERR\n");
247 		/* Do not overwrite ERR config with WARN */
248 		if (severity == REGULATOR_SEVERITY_WARN)
249 			return true;
250 
251 		bd9576_fill_ocp_flags(r, 0);
252 	}
253 
254 	return false;
255 }
256 
257 static bool check_uvd_flag_mismatch(struct regulator_dev *rdev, int severity,
258 				    struct bd957x_regulator_data *r)
259 {
260 	if ((severity == REGULATOR_SEVERITY_ERR &&
261 	     r->uvd_notif != REGULATOR_EVENT_UNDER_VOLTAGE) ||
262 	     (severity == REGULATOR_SEVERITY_WARN &&
263 	     r->uvd_notif != REGULATOR_EVENT_UNDER_VOLTAGE_WARN)) {
264 		dev_warn(rdev_get_dev(rdev),
265 			 "Can't support both UVD WARN and ERR\n");
266 		if (severity == REGULATOR_SEVERITY_WARN)
267 			return true;
268 
269 		bd9576_fill_uvd_flags(r, 0);
270 	}
271 
272 	return false;
273 }
274 
275 static bool check_ovd_flag_mismatch(struct regulator_dev *rdev, int severity,
276 				    struct bd957x_regulator_data *r)
277 {
278 	if ((severity == REGULATOR_SEVERITY_ERR &&
279 	     r->ovd_notif != REGULATOR_EVENT_REGULATION_OUT) ||
280 	     (severity == REGULATOR_SEVERITY_WARN &&
281 	     r->ovd_notif != REGULATOR_EVENT_OVER_VOLTAGE_WARN)) {
282 		dev_warn(rdev_get_dev(rdev),
283 			 "Can't support both OVD WARN and ERR\n");
284 		if (severity == REGULATOR_SEVERITY_WARN)
285 			return true;
286 
287 		bd9576_fill_ovd_flags(r, 0);
288 	}
289 
290 	return false;
291 }
292 
293 static bool check_temp_flag_mismatch(struct regulator_dev *rdev, int severity,
294 				    struct bd957x_regulator_data *r)
295 {
296 	if ((severity == REGULATOR_SEVERITY_ERR &&
297 	     r->ovd_notif != REGULATOR_EVENT_OVER_TEMP) ||
298 	     (severity == REGULATOR_SEVERITY_WARN &&
299 	     r->ovd_notif != REGULATOR_EVENT_OVER_TEMP_WARN)) {
300 		dev_warn(rdev_get_dev(rdev),
301 			 "Can't support both thermal WARN and ERR\n");
302 		if (severity == REGULATOR_SEVERITY_WARN)
303 			return true;
304 	}
305 
306 	return false;
307 }
308 
309 static int bd9576_set_ocp(struct regulator_dev *rdev, int lim_uA, int severity,
310 			  bool enable)
311 {
312 	struct bd957x_data *d;
313 	struct bd957x_regulator_data *r;
314 	int reg, mask;
315 	int Vfet, rfet;
316 	const struct linear_range *range;
317 	int num_ranges;
318 
319 	if ((lim_uA && !enable) || (!lim_uA && enable))
320 		return -EINVAL;
321 
322 	r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
323 	if (!r->oc_supported)
324 		return -EINVAL;
325 
326 	d = rdev_get_drvdata(rdev);
327 
328 	if (severity == REGULATOR_SEVERITY_PROT) {
329 		reg = r->ocp_reg;
330 		mask = r->ocp_mask;
331 		if (r->ocw_rfet) {
332 			range = voutS1_ocp_ranges;
333 			num_ranges = ARRAY_SIZE(voutS1_ocp_ranges);
334 			rfet = r->ocw_rfet / 1000;
335 		} else {
336 			range = voutS1_ocp_ranges_internal;
337 			num_ranges = ARRAY_SIZE(voutS1_ocp_ranges_internal);
338 			/* Internal values are already micro-amperes */
339 			rfet = 1000;
340 		}
341 	} else {
342 		reg = r->ocw_reg;
343 		mask = r->ocw_mask;
344 
345 		if (r->ocw_rfet) {
346 			range = voutS1_ocw_ranges;
347 			num_ranges = ARRAY_SIZE(voutS1_ocw_ranges);
348 			rfet = r->ocw_rfet / 1000;
349 		} else {
350 			range = voutS1_ocw_ranges_internal;
351 			num_ranges = ARRAY_SIZE(voutS1_ocw_ranges_internal);
352 			/* Internal values are already micro-amperes */
353 			rfet = 1000;
354 		}
355 
356 		/* We abuse uvd fields for OCW on VoutS1 */
357 		if (r->uvd_notif) {
358 			/*
359 			 * If both warning and error are requested, prioritize
360 			 * ERROR configuration
361 			 */
362 			if (check_ocp_flag_mismatch(rdev, severity, r))
363 				return 0;
364 		} else {
365 			bool warn = severity == REGULATOR_SEVERITY_WARN;
366 
367 			bd9576_fill_ocp_flags(r, warn);
368 		}
369 	}
370 
371 	/*
372 	 * limits are given in uA, rfet is mOhm
373 	 * Divide lim_uA by 1000 to get Vfet in uV.
374 	 * (We expect both Rfet and limit uA to be magnitude of hundreds of
375 	 * milli Amperes & milli Ohms => we should still have decent accuracy)
376 	 */
377 	Vfet = lim_uA/1000 * rfet;
378 
379 	return bd9576_set_limit(range, num_ranges, d->regmap,
380 				reg, mask, Vfet);
381 }
382 
383 static int bd9576_set_uvp(struct regulator_dev *rdev, int lim_uV, int severity,
384 			  bool enable)
385 {
386 	struct bd957x_data *d;
387 	struct bd957x_regulator_data *r;
388 	int mask, reg;
389 
390 	if (severity == REGULATOR_SEVERITY_PROT) {
391 		if (!enable || lim_uV)
392 			return -EINVAL;
393 		return 0;
394 	}
395 
396 	/*
397 	 * BD9576 has enable control as a special value in limit reg. Can't
398 	 * set limit but keep feature disabled or enable W/O given limit.
399 	 */
400 	if ((lim_uV && !enable) || (!lim_uV && enable))
401 		return -EINVAL;
402 
403 	r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
404 	d = rdev_get_drvdata(rdev);
405 
406 	mask = r->xvd_mask;
407 	reg = r->uvd_reg;
408 	/*
409 	 * Check that there is no mismatch for what the detection IRQs are to
410 	 * be used.
411 	 */
412 	if (r->uvd_notif) {
413 		if (check_uvd_flag_mismatch(rdev, severity, r))
414 			return 0;
415 	} else {
416 		bd9576_fill_uvd_flags(r, severity == REGULATOR_SEVERITY_WARN);
417 	}
418 
419 	return bd9576_set_limit(r->xvd_ranges, r->num_xvd_ranges, d->regmap,
420 				reg, mask, lim_uV);
421 }
422 
423 static int bd9576_set_ovp(struct regulator_dev *rdev, int lim_uV, int severity,
424 			  bool enable)
425 {
426 	struct bd957x_data *d;
427 	struct bd957x_regulator_data *r;
428 	int mask, reg;
429 
430 	if (severity == REGULATOR_SEVERITY_PROT) {
431 		if (!enable || lim_uV)
432 			return -EINVAL;
433 		return 0;
434 	}
435 
436 	/*
437 	 * BD9576 has enable control as a special value in limit reg. Can't
438 	 * set limit but keep feature disabled or enable W/O given limit.
439 	 */
440 	if ((lim_uV && !enable) || (!lim_uV && enable))
441 		return -EINVAL;
442 
443 	r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
444 	d = rdev_get_drvdata(rdev);
445 
446 	mask = r->xvd_mask;
447 	reg = r->ovd_reg;
448 	/*
449 	 * Check that there is no mismatch for what the detection IRQs are to
450 	 * be used.
451 	 */
452 	if (r->ovd_notif) {
453 		if (check_ovd_flag_mismatch(rdev, severity, r))
454 			return 0;
455 	} else {
456 		bd9576_fill_ovd_flags(r, severity == REGULATOR_SEVERITY_WARN);
457 	}
458 
459 	return bd9576_set_limit(r->xvd_ranges, r->num_xvd_ranges, d->regmap,
460 				reg, mask, lim_uV);
461 }
462 
463 
464 static int bd9576_set_tw(struct regulator_dev *rdev, int lim, int severity,
465 			  bool enable)
466 {
467 	struct bd957x_data *d;
468 	struct bd957x_regulator_data *r;
469 	int i;
470 
471 	/*
472 	 * BD9576MUF has fixed temperature limits
473 	 * The detection can only be enabled/disabled
474 	 */
475 	if (lim)
476 		return -EINVAL;
477 
478 	/* Protection can't be disabled */
479 	if (severity == REGULATOR_SEVERITY_PROT) {
480 		if (!enable)
481 			return -EINVAL;
482 		else
483 			return 0;
484 	}
485 
486 	r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
487 	d = rdev_get_drvdata(rdev);
488 
489 	/*
490 	 * Check that there is no mismatch for what the detection IRQs are to
491 	 * be used.
492 	 */
493 	if (r->temp_notif)
494 		if (check_temp_flag_mismatch(rdev, severity, r))
495 			return 0;
496 
497 	bd9576_fill_temp_flags(r, enable, severity == REGULATOR_SEVERITY_WARN);
498 
499 	if (enable)
500 		return regmap_update_bits(d->regmap, BD957X_REG_INT_THERM_MASK,
501 					 BD9576_THERM_IRQ_MASK_TW, 0);
502 
503 	/*
504 	 * If any of the regulators is interested in thermal warning we keep IRQ
505 	 * enabled.
506 	 */
507 	for (i = 0; i < BD9576_NUM_REGULATORS; i++)
508 		if (d->regulator_data[i].temp_notif)
509 			return 0;
510 
511 	return regmap_update_bits(d->regmap, BD957X_REG_INT_THERM_MASK,
512 				  BD9576_THERM_IRQ_MASK_TW,
513 				  BD9576_THERM_IRQ_MASK_TW);
514 }
515 
516 static const struct regulator_ops bd9573_vout34_ops = {
517 	.is_enabled = regulator_is_enabled_regmap,
518 	.list_voltage = bd957x_vout34_list_voltage,
519 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
520 };
521 
522 static const struct regulator_ops bd9576_vout34_ops = {
523 	.is_enabled = regulator_is_enabled_regmap,
524 	.list_voltage = bd957x_vout34_list_voltage,
525 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
526 	.set_over_voltage_protection = bd9576_set_ovp,
527 	.set_under_voltage_protection = bd9576_set_uvp,
528 	.set_thermal_protection = bd9576_set_tw,
529 };
530 
531 static const struct regulator_ops bd9573_vouts1_regulator_ops = {
532 	.is_enabled = regulator_is_enabled_regmap,
533 };
534 
535 static const struct regulator_ops bd9576_vouts1_regulator_ops = {
536 	.is_enabled = regulator_is_enabled_regmap,
537 	.set_over_current_protection = bd9576_set_ocp,
538 };
539 
540 static const struct regulator_ops bd9573_ops = {
541 	.is_enabled = regulator_is_enabled_regmap,
542 	.list_voltage = bd957x_list_voltage,
543 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
544 };
545 
546 static const struct regulator_ops bd9576_ops = {
547 	.is_enabled = regulator_is_enabled_regmap,
548 	.list_voltage = bd957x_list_voltage,
549 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
550 	.set_over_voltage_protection = bd9576_set_ovp,
551 	.set_under_voltage_protection = bd9576_set_uvp,
552 	.set_thermal_protection = bd9576_set_tw,
553 };
554 
555 static const struct regulator_ops  *bd9573_ops_arr[] = {
556 	[BD957X_VD50]	= &bd9573_ops,
557 	[BD957X_VD18]	= &bd9573_ops,
558 	[BD957X_VDDDR]	= &bd9573_vout34_ops,
559 	[BD957X_VD10]	= &bd9573_vout34_ops,
560 	[BD957X_VOUTL1]	= &bd9573_ops,
561 	[BD957X_VOUTS1]	= &bd9573_vouts1_regulator_ops,
562 };
563 
564 static const struct regulator_ops  *bd9576_ops_arr[] = {
565 	[BD957X_VD50]	= &bd9576_ops,
566 	[BD957X_VD18]	= &bd9576_ops,
567 	[BD957X_VDDDR]	= &bd9576_vout34_ops,
568 	[BD957X_VD10]	= &bd9576_vout34_ops,
569 	[BD957X_VOUTL1]	= &bd9576_ops,
570 	[BD957X_VOUTS1]	= &bd9576_vouts1_regulator_ops,
571 };
572 
573 static int vouts1_get_fet_res(struct device_node *np,
574 				const struct regulator_desc *desc,
575 				struct regulator_config *cfg)
576 {
577 	struct bd957x_regulator_data *data;
578 	int ret;
579 	u32 uohms;
580 
581 	data = container_of(desc, struct bd957x_regulator_data, desc);
582 
583 	ret = of_property_read_u32(np, "rohm,ocw-fet-ron-micro-ohms", &uohms);
584 	if (ret) {
585 		if (ret != -EINVAL)
586 			return ret;
587 
588 		return 0;
589 	}
590 	data->ocw_rfet = uohms;
591 	return 0;
592 }
593 
594 static struct bd957x_data bd957x_regulators = {
595 	.regulator_data = {
596 		{
597 			.desc = {
598 				.name = "VD50",
599 				.of_match = of_match_ptr("regulator-vd50"),
600 				.regulators_node = of_match_ptr("regulators"),
601 				.id = BD957X_VD50,
602 				.type = REGULATOR_VOLTAGE,
603 				.volt_table = &vout1_volt_table[0],
604 				.n_voltages = ARRAY_SIZE(vout1_volt_table),
605 				.vsel_reg = BD957X_REG_VOUT1_TUNE,
606 				.vsel_mask = BD957X_MASK_VOUT1_TUNE,
607 				.enable_reg = BD957X_REG_POW_TRIGGER1,
608 				.enable_mask = BD957X_REGULATOR_EN_MASK,
609 				.enable_val = BD957X_REGULATOR_DIS_VAL,
610 				.enable_is_inverted = true,
611 				.owner = THIS_MODULE,
612 			},
613 			.xvd_ranges = vout1_xvd_ranges,
614 			.num_xvd_ranges = ARRAY_SIZE(vout1_xvd_ranges),
615 			.ovd_reg = BD9576_REG_VOUT1_OVD,
616 			.uvd_reg = BD9576_REG_VOUT1_UVD,
617 			.xvd_mask = BD9576_MASK_XVD,
618 		},
619 		{
620 			.desc = {
621 				.name = "VD18",
622 				.of_match = of_match_ptr("regulator-vd18"),
623 				.regulators_node = of_match_ptr("regulators"),
624 				.id = BD957X_VD18,
625 				.type = REGULATOR_VOLTAGE,
626 				.volt_table = &vout2_volt_table[0],
627 				.n_voltages = ARRAY_SIZE(vout2_volt_table),
628 				.vsel_reg = BD957X_REG_VOUT2_TUNE,
629 				.vsel_mask = BD957X_MASK_VOUT2_TUNE,
630 				.enable_reg = BD957X_REG_POW_TRIGGER2,
631 				.enable_mask = BD957X_REGULATOR_EN_MASK,
632 				.enable_val = BD957X_REGULATOR_DIS_VAL,
633 				.enable_is_inverted = true,
634 				.owner = THIS_MODULE,
635 			},
636 			.xvd_ranges = vout234_xvd_ranges,
637 			.num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges),
638 			.ovd_reg = BD9576_REG_VOUT2_OVD,
639 			.uvd_reg = BD9576_REG_VOUT2_UVD,
640 			.xvd_mask = BD9576_MASK_XVD,
641 		},
642 		{
643 			.desc = {
644 				.name = "VDDDR",
645 				.of_match = of_match_ptr("regulator-vdddr"),
646 				.regulators_node = of_match_ptr("regulators"),
647 				.id = BD957X_VDDDR,
648 				.type = REGULATOR_VOLTAGE,
649 				.n_voltages = BD957X_VOUTS34_NUM_VOLT,
650 				.vsel_reg = BD957X_REG_VOUT3_TUNE,
651 				.vsel_mask = BD957X_MASK_VOUT3_TUNE,
652 				.enable_reg = BD957X_REG_POW_TRIGGER3,
653 				.enable_mask = BD957X_REGULATOR_EN_MASK,
654 				.enable_val = BD957X_REGULATOR_DIS_VAL,
655 				.enable_is_inverted = true,
656 				.owner = THIS_MODULE,
657 			},
658 			.ovd_reg = BD9576_REG_VOUT3_OVD,
659 			.uvd_reg = BD9576_REG_VOUT3_UVD,
660 			.xvd_mask = BD9576_MASK_XVD,
661 			.xvd_ranges = vout234_xvd_ranges,
662 			.num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges),
663 		},
664 		{
665 			.desc = {
666 				.name = "VD10",
667 				.of_match = of_match_ptr("regulator-vd10"),
668 				.regulators_node = of_match_ptr("regulators"),
669 				.id = BD957X_VD10,
670 				.type = REGULATOR_VOLTAGE,
671 				.fixed_uV = BD957X_VOUTS4_BASE_VOLT,
672 				.n_voltages = BD957X_VOUTS34_NUM_VOLT,
673 				.vsel_reg = BD957X_REG_VOUT4_TUNE,
674 				.vsel_mask = BD957X_MASK_VOUT4_TUNE,
675 				.enable_reg = BD957X_REG_POW_TRIGGER4,
676 				.enable_mask = BD957X_REGULATOR_EN_MASK,
677 				.enable_val = BD957X_REGULATOR_DIS_VAL,
678 				.enable_is_inverted = true,
679 				.owner = THIS_MODULE,
680 			},
681 			.xvd_ranges = vout234_xvd_ranges,
682 			.num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges),
683 			.ovd_reg = BD9576_REG_VOUT4_OVD,
684 			.uvd_reg = BD9576_REG_VOUT4_UVD,
685 			.xvd_mask = BD9576_MASK_XVD,
686 		},
687 		{
688 			.desc = {
689 				.name = "VOUTL1",
690 				.of_match = of_match_ptr("regulator-voutl1"),
691 				.regulators_node = of_match_ptr("regulators"),
692 				.id = BD957X_VOUTL1,
693 				.type = REGULATOR_VOLTAGE,
694 				.volt_table = &voutl1_volt_table[0],
695 				.n_voltages = ARRAY_SIZE(voutl1_volt_table),
696 				.vsel_reg = BD957X_REG_VOUTL1_TUNE,
697 				.vsel_mask = BD957X_MASK_VOUTL1_TUNE,
698 				.enable_reg = BD957X_REG_POW_TRIGGERL1,
699 				.enable_mask = BD957X_REGULATOR_EN_MASK,
700 				.enable_val = BD957X_REGULATOR_DIS_VAL,
701 				.enable_is_inverted = true,
702 				.owner = THIS_MODULE,
703 			},
704 			.xvd_ranges = voutL1_xvd_ranges,
705 			.num_xvd_ranges = ARRAY_SIZE(voutL1_xvd_ranges),
706 			.ovd_reg = BD9576_REG_VOUTL1_OVD,
707 			.uvd_reg = BD9576_REG_VOUTL1_UVD,
708 			.xvd_mask = BD9576_MASK_XVD,
709 		},
710 		{
711 			.desc = {
712 				.name = "VOUTS1",
713 				.of_match = of_match_ptr("regulator-vouts1"),
714 				.regulators_node = of_match_ptr("regulators"),
715 				.id = BD957X_VOUTS1,
716 				.type = REGULATOR_VOLTAGE,
717 				.n_voltages = 1,
718 				.fixed_uV = BD957X_VOUTS1_VOLT,
719 				.enable_reg = BD957X_REG_POW_TRIGGERS1,
720 				.enable_mask = BD957X_REGULATOR_EN_MASK,
721 				.enable_val = BD957X_REGULATOR_DIS_VAL,
722 				.enable_is_inverted = true,
723 				.owner = THIS_MODULE,
724 				.of_parse_cb = vouts1_get_fet_res,
725 			},
726 			.oc_supported = true,
727 			.ocw_reg = BD9576_REG_VOUT1S_OCW,
728 			.ocw_mask = BD9576_MASK_VOUT1S_OCW,
729 			.ocp_reg = BD9576_REG_VOUT1S_OCP,
730 			.ocp_mask = BD9576_MASK_VOUT1S_OCP,
731 		},
732 	},
733 };
734 
735 static int bd9576_renable(struct regulator_irq_data *rid, int reg, int mask)
736 {
737 	int val, ret;
738 	struct bd957x_data *d = (struct bd957x_data *)rid->data;
739 
740 	ret = regmap_read(d->regmap, reg, &val);
741 	if (ret)
742 		return REGULATOR_FAILED_RETRY;
743 
744 	if (rid->opaque && rid->opaque == (val & mask)) {
745 		/*
746 		 * It seems we stil have same status. Ack and return
747 		 * information that we are still out of limits and core
748 		 * should not enable IRQ
749 		 */
750 		regmap_write(d->regmap, reg, mask & val);
751 		return REGULATOR_ERROR_ON;
752 	}
753 	rid->opaque = 0;
754 	/*
755 	 * Status was changed. Either prolem was solved or we have new issues.
756 	 * Let's re-enable IRQs and be prepared to report problems again
757 	 */
758 	return REGULATOR_ERROR_CLEARED;
759 }
760 
761 static int bd9576_uvd_renable(struct regulator_irq_data *rid)
762 {
763 	return bd9576_renable(rid, BD957X_REG_INT_UVD_STAT, UVD_IRQ_VALID_MASK);
764 }
765 
766 static int bd9576_ovd_renable(struct regulator_irq_data *rid)
767 {
768 	return bd9576_renable(rid, BD957X_REG_INT_OVD_STAT, OVD_IRQ_VALID_MASK);
769 }
770 
771 static int bd9576_temp_renable(struct regulator_irq_data *rid)
772 {
773 	return bd9576_renable(rid, BD957X_REG_INT_THERM_STAT,
774 			      BD9576_THERM_IRQ_MASK_TW);
775 }
776 
777 static int bd9576_uvd_handler(int irq, struct regulator_irq_data *rid,
778 			      unsigned long *dev_mask)
779 {
780 	int val, ret, i;
781 	struct bd957x_data *d = (struct bd957x_data *)rid->data;
782 
783 	ret = regmap_read(d->regmap, BD957X_REG_INT_UVD_STAT, &val);
784 	if (ret)
785 		return REGULATOR_FAILED_RETRY;
786 
787 	*dev_mask = 0;
788 
789 	rid->opaque = val & UVD_IRQ_VALID_MASK;
790 
791 	/*
792 	 * Go through the set status bits and report either error or warning
793 	 * to the notifier depending on what was flagged in DT
794 	 */
795 	*dev_mask = val & BD9576_xVD_IRQ_MASK_VOUT1TO4;
796 	/* There is 1 bit gap in register after Vout1 .. Vout4 statuses */
797 	*dev_mask |= ((val & BD9576_xVD_IRQ_MASK_VOUTL1) >> 1);
798 	/*
799 	 * We (ab)use the uvd for OCW notification. DT parsing should
800 	 * have added correct OCW flag to uvd_notif and uvd_err for S1
801 	 */
802 	*dev_mask |= ((val & BD9576_UVD_IRQ_MASK_VOUTS1_OCW) >> 1);
803 
804 	for_each_set_bit(i, dev_mask, 6) {
805 		struct bd957x_regulator_data *rdata;
806 		struct regulator_err_state *stat;
807 
808 		rdata = &d->regulator_data[i];
809 		stat  = &rid->states[i];
810 
811 		stat->notifs	= rdata->uvd_notif;
812 		stat->errors	= rdata->uvd_err;
813 	}
814 
815 	ret = regmap_write(d->regmap, BD957X_REG_INT_UVD_STAT,
816 			   UVD_IRQ_VALID_MASK & val);
817 
818 	return 0;
819 }
820 
821 static int bd9576_ovd_handler(int irq, struct regulator_irq_data *rid,
822 			      unsigned long *dev_mask)
823 {
824 	int val, ret, i;
825 	struct bd957x_data *d = (struct bd957x_data *)rid->data;
826 
827 	ret = regmap_read(d->regmap, BD957X_REG_INT_OVD_STAT, &val);
828 	if (ret)
829 		return REGULATOR_FAILED_RETRY;
830 
831 	rid->opaque = val & OVD_IRQ_VALID_MASK;
832 	*dev_mask = 0;
833 
834 	if (!(val & OVD_IRQ_VALID_MASK))
835 		return 0;
836 
837 	*dev_mask = val & BD9576_xVD_IRQ_MASK_VOUT1TO4;
838 	/* There is 1 bit gap in register after Vout1 .. Vout4 statuses */
839 	*dev_mask |= ((val & BD9576_xVD_IRQ_MASK_VOUTL1) >> 1);
840 
841 	for_each_set_bit(i, dev_mask, 5) {
842 		struct bd957x_regulator_data *rdata;
843 		struct regulator_err_state *stat;
844 
845 		rdata = &d->regulator_data[i];
846 		stat  = &rid->states[i];
847 
848 		stat->notifs	= rdata->ovd_notif;
849 		stat->errors	= rdata->ovd_err;
850 	}
851 
852 	/* Clear the sub-IRQ status */
853 	regmap_write(d->regmap, BD957X_REG_INT_OVD_STAT,
854 		     OVD_IRQ_VALID_MASK & val);
855 
856 	return 0;
857 }
858 
859 #define BD9576_DEV_MASK_ALL_REGULATORS 0x3F
860 
861 static int bd9576_thermal_handler(int irq, struct regulator_irq_data *rid,
862 				  unsigned long *dev_mask)
863 {
864 	int val, ret, i;
865 	struct bd957x_data *d = (struct bd957x_data *)rid->data;
866 
867 	ret = regmap_read(d->regmap, BD957X_REG_INT_THERM_STAT, &val);
868 	if (ret)
869 		return REGULATOR_FAILED_RETRY;
870 
871 	if (!(val & BD9576_THERM_IRQ_MASK_TW)) {
872 		*dev_mask = 0;
873 		return 0;
874 	}
875 
876 	*dev_mask = BD9576_DEV_MASK_ALL_REGULATORS;
877 
878 	for (i = 0; i < BD9576_NUM_REGULATORS; i++) {
879 		struct bd957x_regulator_data *rdata;
880 		struct regulator_err_state *stat;
881 
882 		rdata = &d->regulator_data[i];
883 		stat  = &rid->states[i];
884 
885 		stat->notifs	= rdata->temp_notif;
886 		stat->errors	= rdata->temp_err;
887 	}
888 
889 	/* Clear the sub-IRQ status */
890 	regmap_write(d->regmap, BD957X_REG_INT_THERM_STAT,
891 		     BD9576_THERM_IRQ_MASK_TW);
892 
893 	return 0;
894 }
895 
896 static int bd957x_probe(struct platform_device *pdev)
897 {
898 	int i;
899 	unsigned int num_reg_data;
900 	bool vout_mode, ddr_sel, may_have_irqs = false;
901 	struct regmap *regmap;
902 	struct bd957x_data *ic_data;
903 	struct regulator_config config = { 0 };
904 	/* All regulators are related to UVD and thermal IRQs... */
905 	struct regulator_dev *rdevs[BD9576_NUM_REGULATORS];
906 	/* ...But VoutS1 is not flagged by OVD IRQ */
907 	struct regulator_dev *ovd_devs[BD9576_NUM_OVD_REGULATORS];
908 	static const struct regulator_irq_desc bd9576_notif_uvd = {
909 		.name = "bd9576-uvd",
910 		.irq_off_ms = 1000,
911 		.map_event = bd9576_uvd_handler,
912 		.renable = bd9576_uvd_renable,
913 		.data = &bd957x_regulators,
914 	};
915 	static const struct regulator_irq_desc bd9576_notif_ovd = {
916 		.name = "bd9576-ovd",
917 		.irq_off_ms = 1000,
918 		.map_event = bd9576_ovd_handler,
919 		.renable = bd9576_ovd_renable,
920 		.data = &bd957x_regulators,
921 	};
922 	static const struct regulator_irq_desc bd9576_notif_temp = {
923 		.name = "bd9576-temp",
924 		.irq_off_ms = 1000,
925 		.map_event = bd9576_thermal_handler,
926 		.renable = bd9576_temp_renable,
927 		.data = &bd957x_regulators,
928 	};
929 	enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
930 
931 	num_reg_data = ARRAY_SIZE(bd957x_regulators.regulator_data);
932 
933 	ic_data = &bd957x_regulators;
934 
935 	regmap = dev_get_regmap(pdev->dev.parent, NULL);
936 	if (!regmap) {
937 		dev_err(&pdev->dev, "No regmap\n");
938 		return -EINVAL;
939 	}
940 
941 	ic_data->regmap = regmap;
942 	vout_mode = of_property_read_bool(pdev->dev.parent->of_node,
943 					 "rohm,vout1-en-low");
944 	if (vout_mode) {
945 		struct gpio_desc *en;
946 
947 		dev_dbg(&pdev->dev, "GPIO controlled mode\n");
948 
949 		/* VOUT1 enable state judged by VOUT1_EN pin */
950 		/* See if we have GPIO defined */
951 		en = devm_gpiod_get_from_of_node(&pdev->dev,
952 						 pdev->dev.parent->of_node,
953 						 "rohm,vout1-en-gpios", 0,
954 						 GPIOD_OUT_LOW, "vout1-en");
955 		if (!IS_ERR(en)) {
956 			/* VOUT1_OPS gpio ctrl */
957 			/*
958 			 * Regulator core prioritizes the ena_gpio over
959 			 * enable/disable/is_enabled callbacks so no need to
960 			 * clear them. We can still use same ops
961 			 */
962 			config.ena_gpiod = en;
963 		} else {
964 			/*
965 			 * In theory it is possible someone wants to set
966 			 * vout1-en LOW during OTP loading and set VOUT1 to be
967 			 * controlled by GPIO - but control the GPIO from some
968 			 * where else than this driver. For that to work we
969 			 * should unset the is_enabled callback here.
970 			 *
971 			 * I believe such case where rohm,vout1-en-low is set
972 			 * and vout1-en-gpios is not is likely to be a
973 			 * misconfiguration. So let's just err out for now.
974 			 */
975 			dev_err(&pdev->dev,
976 				"Failed to get VOUT1 control GPIO\n");
977 			return PTR_ERR(en);
978 		}
979 	}
980 
981 	/*
982 	 * If more than one PMIC needs to be controlled by same processor then
983 	 * allocate the regulator data array here and use bd9576_regulators as
984 	 * template. At the moment I see no such use-case so I spare some
985 	 * bytes and use bd9576_regulators directly for non-constant configs
986 	 * like DDR voltage selection.
987 	 */
988 	platform_set_drvdata(pdev, ic_data);
989 	ddr_sel =  of_property_read_bool(pdev->dev.parent->of_node,
990 					 "rohm,ddr-sel-low");
991 	if (ddr_sel)
992 		ic_data->regulator_data[2].desc.fixed_uV = 1350000;
993 	else
994 		ic_data->regulator_data[2].desc.fixed_uV = 1500000;
995 
996 	switch (chip) {
997 	case ROHM_CHIP_TYPE_BD9576:
998 		may_have_irqs = true;
999 		dev_dbg(&pdev->dev, "Found BD9576MUF\n");
1000 		break;
1001 	case ROHM_CHIP_TYPE_BD9573:
1002 		dev_dbg(&pdev->dev, "Found BD9573MUF\n");
1003 		break;
1004 	default:
1005 		dev_err(&pdev->dev, "Unsupported chip type\n");
1006 		return -EINVAL;
1007 	}
1008 
1009 	for (i = 0; i < num_reg_data; i++) {
1010 		struct regulator_desc *d;
1011 
1012 		d = &ic_data->regulator_data[i].desc;
1013 
1014 
1015 		if (may_have_irqs) {
1016 			if (d->id >= ARRAY_SIZE(bd9576_ops_arr))
1017 				return -EINVAL;
1018 
1019 			d->ops = bd9576_ops_arr[d->id];
1020 		} else {
1021 			if (d->id >= ARRAY_SIZE(bd9573_ops_arr))
1022 				return -EINVAL;
1023 
1024 			d->ops = bd9573_ops_arr[d->id];
1025 		}
1026 	}
1027 
1028 	config.dev = pdev->dev.parent;
1029 	config.regmap = regmap;
1030 	config.driver_data = ic_data;
1031 
1032 	for (i = 0; i < num_reg_data; i++) {
1033 
1034 		struct bd957x_regulator_data *r = &ic_data->regulator_data[i];
1035 		const struct regulator_desc *desc = &r->desc;
1036 
1037 		r->rdev = devm_regulator_register(&pdev->dev, desc,
1038 							   &config);
1039 		if (IS_ERR(r->rdev)) {
1040 			dev_err(&pdev->dev,
1041 				"failed to register %s regulator\n",
1042 				desc->name);
1043 			return PTR_ERR(r->rdev);
1044 		}
1045 		/*
1046 		 * Clear the VOUT1 GPIO setting - rest of the regulators do not
1047 		 * support GPIO control
1048 		 */
1049 		config.ena_gpiod = NULL;
1050 
1051 		if (!may_have_irqs)
1052 			continue;
1053 
1054 		rdevs[i] = r->rdev;
1055 		if (i < BD957X_VOUTS1)
1056 			ovd_devs[i] = r->rdev;
1057 	}
1058 	if (may_have_irqs) {
1059 		void *ret;
1060 		/*
1061 		 * We can add both the possible error and warning flags here
1062 		 * because the core uses these only for status clearing and
1063 		 * if we use warnings - errors are always clear and the other
1064 		 * way around. We can also add CURRENT flag for all regulators
1065 		 * because it is never set if it is not supported. Same applies
1066 		 * to setting UVD for VoutS1 - it is not accidentally cleared
1067 		 * as it is never set.
1068 		 */
1069 		int uvd_errs = REGULATOR_ERROR_UNDER_VOLTAGE |
1070 			       REGULATOR_ERROR_UNDER_VOLTAGE_WARN |
1071 			       REGULATOR_ERROR_OVER_CURRENT |
1072 			       REGULATOR_ERROR_OVER_CURRENT_WARN;
1073 		int ovd_errs = REGULATOR_ERROR_OVER_VOLTAGE_WARN |
1074 			       REGULATOR_ERROR_REGULATION_OUT;
1075 		int temp_errs = REGULATOR_ERROR_OVER_TEMP |
1076 				REGULATOR_ERROR_OVER_TEMP_WARN;
1077 		int irq;
1078 
1079 		irq = platform_get_irq_byname(pdev, "bd9576-uvd");
1080 
1081 		/* Register notifiers - can fail if IRQ is not given */
1082 		ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_uvd,
1083 						irq, 0, uvd_errs, NULL,
1084 						&rdevs[0],
1085 						BD9576_NUM_REGULATORS);
1086 		if (IS_ERR(ret)) {
1087 			if (PTR_ERR(ret) == -EPROBE_DEFER)
1088 				return -EPROBE_DEFER;
1089 
1090 			dev_warn(&pdev->dev, "UVD disabled %pe\n", ret);
1091 		}
1092 
1093 		irq = platform_get_irq_byname(pdev, "bd9576-ovd");
1094 
1095 		ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_ovd,
1096 						irq, 0, ovd_errs, NULL,
1097 						&ovd_devs[0],
1098 						BD9576_NUM_OVD_REGULATORS);
1099 		if (IS_ERR(ret)) {
1100 			if (PTR_ERR(ret) == -EPROBE_DEFER)
1101 				return -EPROBE_DEFER;
1102 
1103 			dev_warn(&pdev->dev, "OVD disabled %pe\n", ret);
1104 		}
1105 		irq = platform_get_irq_byname(pdev, "bd9576-temp");
1106 
1107 		ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_temp,
1108 						irq, 0, temp_errs, NULL,
1109 						&rdevs[0],
1110 						BD9576_NUM_REGULATORS);
1111 		if (IS_ERR(ret)) {
1112 			if (PTR_ERR(ret) == -EPROBE_DEFER)
1113 				return -EPROBE_DEFER;
1114 
1115 			dev_warn(&pdev->dev, "Thermal warning disabled %pe\n",
1116 				 ret);
1117 		}
1118 	}
1119 	return 0;
1120 }
1121 
1122 static const struct platform_device_id bd957x_pmic_id[] = {
1123 	{ "bd9573-regulator", ROHM_CHIP_TYPE_BD9573 },
1124 	{ "bd9576-regulator", ROHM_CHIP_TYPE_BD9576 },
1125 	{ },
1126 };
1127 MODULE_DEVICE_TABLE(platform, bd957x_pmic_id);
1128 
1129 static struct platform_driver bd957x_regulator = {
1130 	.driver = {
1131 		.name = "bd957x-pmic",
1132 	},
1133 	.probe = bd957x_probe,
1134 	.id_table = bd957x_pmic_id,
1135 };
1136 
1137 module_platform_driver(bd957x_regulator);
1138 
1139 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1140 MODULE_DESCRIPTION("ROHM BD9576/BD9573 voltage regulator driver");
1141 MODULE_LICENSE("GPL");
1142 MODULE_ALIAS("platform:bd957x-pmic");
1143