1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2024 ROHM Semiconductors
3 // bd96801-regulator.c ROHM BD96801 regulator driver
4 
5 /*
6  * This version of the "BD86801 scalable PMIC"'s driver supports only very
7  * basic set of the PMIC features. Most notably, there is no support for
8  * the ERRB interrupt and the configurations which should be done when the
9  * PMIC is in STBY mode.
10  *
11  * Supporting the ERRB interrupt would require dropping the regmap-IRQ
12  * usage or working around (or accepting a presense of) a naming conflict
13  * in debugFS IRQs.
14  *
15  * Being able to reliably do the configurations like changing the
16  * regulator safety limits (like limits for the over/under -voltages, over
17  * current, thermal protection) would require the configuring driver to be
18  * synchronized with entity causing the PMIC state transitions. Eg, one
19  * should be able to ensure the PMIC is in STBY state when the
20  * configurations are applied to the hardware. How and when the PMIC state
21  * transitions are to be done is likely to be very system specific, as will
22  * be the need to configure these safety limits. Hence it's not simple to
23  * come up with a generic solution.
24  *
25  * Users who require the ERRB handling and STBY state configurations can
26  * have a look at the original RFC:
27  * https://lore.kernel.org/all/cover.1712920132.git.mazziesaccount@gmail.com/
28  * which implements a workaround to debugFS naming conflict and some of
29  * the safety limit configurations - but leaves the state change handling
30  * and synchronization to be implemented.
31  *
32  * It would be great to hear (and receive a patch!) if you implement the
33  * STBY configuration support or a proper fix to the debugFS naming
34  * conflict in your downstream driver ;)
35  */
36 
37 #include <linux/cleanup.h>
38 #include <linux/delay.h>
39 #include <linux/err.h>
40 #include <linux/interrupt.h>
41 #include <linux/kernel.h>
42 #include <linux/linear_range.h>
43 #include <linux/mfd/rohm-generic.h>
44 #include <linux/mfd/rohm-bd96801.h>
45 #include <linux/module.h>
46 #include <linux/of.h>
47 #include <linux/platform_device.h>
48 #include <linux/regmap.h>
49 #include <linux/regulator/coupler.h>
50 #include <linux/regulator/driver.h>
51 #include <linux/regulator/machine.h>
52 #include <linux/regulator/of_regulator.h>
53 #include <linux/slab.h>
54 #include <linux/timer.h>
55 
56 enum {
57 	BD96801_BUCK1,
58 	BD96801_BUCK2,
59 	BD96801_BUCK3,
60 	BD96801_BUCK4,
61 	BD96801_LDO5,
62 	BD96801_LDO6,
63 	BD96801_LDO7,
64 	BD96801_REGULATOR_AMOUNT,
65 };
66 
67 enum {
68 	BD96801_PROT_OVP,
69 	BD96801_PROT_UVP,
70 	BD96801_PROT_OCP,
71 	BD96801_PROT_TEMP,
72 	BD96801_NUM_PROT,
73 };
74 
75 #define BD96801_ALWAYS_ON_REG		0x3c
76 #define BD96801_REG_ENABLE		0x0b
77 #define BD96801_BUCK1_EN_MASK		BIT(0)
78 #define BD96801_BUCK2_EN_MASK		BIT(1)
79 #define BD96801_BUCK3_EN_MASK		BIT(2)
80 #define BD96801_BUCK4_EN_MASK		BIT(3)
81 #define BD96801_LDO5_EN_MASK		BIT(4)
82 #define BD96801_LDO6_EN_MASK		BIT(5)
83 #define BD96801_LDO7_EN_MASK		BIT(6)
84 
85 #define BD96801_BUCK1_VSEL_REG		0x28
86 #define BD96801_BUCK2_VSEL_REG		0x29
87 #define BD96801_BUCK3_VSEL_REG		0x2a
88 #define BD96801_BUCK4_VSEL_REG		0x2b
89 #define BD96801_LDO5_VSEL_REG		0x25
90 #define BD96801_LDO6_VSEL_REG		0x26
91 #define BD96801_LDO7_VSEL_REG		0x27
92 #define BD96801_BUCK_VSEL_MASK		0x1F
93 #define BD96801_LDO_VSEL_MASK		0xff
94 
95 #define BD96801_MASK_RAMP_DELAY		0xc0
96 #define BD96801_INT_VOUT_BASE_REG	0x21
97 #define BD96801_BUCK_INT_VOUT_MASK	0xff
98 
99 #define BD96801_BUCK_VOLTS		256
100 #define BD96801_LDO_VOLTS		256
101 
102 #define BD96801_OVP_MASK		0x03
103 #define BD96801_MASK_BUCK1_OVP_SHIFT	0x00
104 #define BD96801_MASK_BUCK2_OVP_SHIFT	0x02
105 #define BD96801_MASK_BUCK3_OVP_SHIFT	0x04
106 #define BD96801_MASK_BUCK4_OVP_SHIFT	0x06
107 #define BD96801_MASK_LDO5_OVP_SHIFT	0x00
108 #define BD96801_MASK_LDO6_OVP_SHIFT	0x02
109 #define BD96801_MASK_LDO7_OVP_SHIFT	0x04
110 
111 #define BD96801_PROT_LIMIT_OCP_MIN	0x00
112 #define BD96801_PROT_LIMIT_LOW		0x01
113 #define BD96801_PROT_LIMIT_MID		0x02
114 #define BD96801_PROT_LIMIT_HI		0x03
115 
116 #define BD96801_REG_BUCK1_OCP		0x32
117 #define BD96801_REG_BUCK2_OCP		0x32
118 #define BD96801_REG_BUCK3_OCP		0x33
119 #define BD96801_REG_BUCK4_OCP		0x33
120 
121 #define BD96801_MASK_BUCK1_OCP_SHIFT	0x00
122 #define BD96801_MASK_BUCK2_OCP_SHIFT	0x04
123 #define BD96801_MASK_BUCK3_OCP_SHIFT	0x00
124 #define BD96801_MASK_BUCK4_OCP_SHIFT	0x04
125 
126 #define BD96801_REG_LDO5_OCP		0x34
127 #define BD96801_REG_LDO6_OCP		0x34
128 #define BD96801_REG_LDO7_OCP		0x34
129 
130 #define BD96801_MASK_LDO5_OCP_SHIFT	0x00
131 #define BD96801_MASK_LDO6_OCP_SHIFT	0x02
132 #define BD96801_MASK_LDO7_OCP_SHIFT	0x04
133 
134 #define BD96801_MASK_SHD_INTB		BIT(7)
135 #define BD96801_INTB_FATAL		BIT(7)
136 
137 #define BD96801_NUM_REGULATORS		7
138 #define BD96801_NUM_LDOS		4
139 
140 /*
141  * Ramp rates for bucks are controlled by bits [7:6] as follows:
142  * 00 => 1 mV/uS
143  * 01 => 5 mV/uS
144  * 10 => 10 mV/uS
145  * 11 => 20 mV/uS
146  */
147 static const unsigned int buck_ramp_table[] = { 1000, 5000, 10000, 20000 };
148 
149 /*
150  * This is a voltage range that get's appended to selected
151  * bd96801_buck_init_volts value. The range from 0x0 to 0xF is actually
152  * bd96801_buck_init_volts + 0 ... bd96801_buck_init_volts + 150mV
153  * and the range from 0x10 to 0x1f is bd96801_buck_init_volts - 150mV ...
154  * bd96801_buck_init_volts - 0. But as the members of linear_range
155  * are all unsigned I will apply offset of -150 mV to value in
156  * linear_range - which should increase these ranges with
157  * 150 mV getting all the values to >= 0.
158  */
159 static const struct linear_range bd96801_tune_volts[] = {
160 	REGULATOR_LINEAR_RANGE(150000, 0x00, 0xF, 10000),
161 	REGULATOR_LINEAR_RANGE(0, 0x10, 0x1F, 10000),
162 };
163 
164 static const struct linear_range bd96801_buck_init_volts[] = {
165 	REGULATOR_LINEAR_RANGE(500000 - 150000, 0x00, 0xc8, 5000),
166 	REGULATOR_LINEAR_RANGE(1550000 - 150000, 0xc9, 0xec, 50000),
167 	REGULATOR_LINEAR_RANGE(3300000 - 150000, 0xed, 0xff, 0),
168 };
169 
170 static const struct linear_range bd96801_ldo_int_volts[] = {
171 	REGULATOR_LINEAR_RANGE(300000, 0x00, 0x78, 25000),
172 	REGULATOR_LINEAR_RANGE(3300000, 0x79, 0xff, 0),
173 };
174 
175 #define BD96801_LDO_SD_VOLT_MASK	0x1
176 #define BD96801_LDO_MODE_MASK		0x6
177 #define BD96801_LDO_MODE_INT		0x0
178 #define BD96801_LDO_MODE_SD		0x2
179 #define BD96801_LDO_MODE_DDR		0x4
180 
181 static int ldo_ddr_volt_table[] = {500000, 300000};
182 static int ldo_sd_volt_table[] = {3300000, 1800000};
183 
184 /* Constant IRQ initialization data (templates) */
185 struct bd96801_irqinfo {
186 	int type;
187 	struct regulator_irq_desc irq_desc;
188 	int err_cfg;
189 	int wrn_cfg;
190 	const char *irq_name;
191 };
192 
193 #define BD96801_IRQINFO(_type, _name, _irqoff_ms, _irqname)	\
194 {								\
195 	.type = (_type),					\
196 	.err_cfg = -1,						\
197 	.wrn_cfg = -1,						\
198 	.irq_name = (_irqname),					\
199 	.irq_desc = {						\
200 		.name = (_name),				\
201 		.irq_off_ms = (_irqoff_ms),			\
202 		.map_event = regulator_irq_map_event_simple,	\
203 	},							\
204 }
205 
206 static const struct bd96801_irqinfo buck1_irqinfo[] = {
207 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck1-over-curr-h", 500,
208 			"bd96801-buck1-overcurr-h"),
209 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck1-over-curr-l", 500,
210 			"bd96801-buck1-overcurr-l"),
211 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck1-over-curr-n", 500,
212 			"bd96801-buck1-overcurr-n"),
213 	BD96801_IRQINFO(BD96801_PROT_OVP, "buck1-over-voltage", 500,
214 			"bd96801-buck1-overvolt"),
215 	BD96801_IRQINFO(BD96801_PROT_UVP, "buck1-under-voltage", 500,
216 			"bd96801-buck1-undervolt"),
217 	BD96801_IRQINFO(BD96801_PROT_TEMP, "buck1-over-temp", 500,
218 			"bd96801-buck1-thermal")
219 };
220 
221 static const struct bd96801_irqinfo buck2_irqinfo[] = {
222 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck2-over-curr-h", 500,
223 			"bd96801-buck2-overcurr-h"),
224 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck2-over-curr-l", 500,
225 			"bd96801-buck2-overcurr-l"),
226 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck2-over-curr-n", 500,
227 			"bd96801-buck2-overcurr-n"),
228 	BD96801_IRQINFO(BD96801_PROT_OVP, "buck2-over-voltage", 500,
229 			"bd96801-buck2-overvolt"),
230 	BD96801_IRQINFO(BD96801_PROT_UVP, "buck2-under-voltage", 500,
231 			"bd96801-buck2-undervolt"),
232 	BD96801_IRQINFO(BD96801_PROT_TEMP, "buck2-over-temp", 500,
233 			"bd96801-buck2-thermal")
234 };
235 
236 static const struct bd96801_irqinfo buck3_irqinfo[] = {
237 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck3-over-curr-h", 500,
238 			"bd96801-buck3-overcurr-h"),
239 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck3-over-curr-l", 500,
240 			"bd96801-buck3-overcurr-l"),
241 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck3-over-curr-n", 500,
242 			"bd96801-buck3-overcurr-n"),
243 	BD96801_IRQINFO(BD96801_PROT_OVP, "buck3-over-voltage", 500,
244 			"bd96801-buck3-overvolt"),
245 	BD96801_IRQINFO(BD96801_PROT_UVP, "buck3-under-voltage", 500,
246 			"bd96801-buck3-undervolt"),
247 	BD96801_IRQINFO(BD96801_PROT_TEMP, "buck3-over-temp", 500,
248 			"bd96801-buck3-thermal")
249 };
250 
251 static const struct bd96801_irqinfo buck4_irqinfo[] = {
252 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck4-over-curr-h", 500,
253 			"bd96801-buck4-overcurr-h"),
254 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck4-over-curr-l", 500,
255 			"bd96801-buck4-overcurr-l"),
256 	BD96801_IRQINFO(BD96801_PROT_OCP, "buck4-over-curr-n", 500,
257 			"bd96801-buck4-overcurr-n"),
258 	BD96801_IRQINFO(BD96801_PROT_OVP, "buck4-over-voltage", 500,
259 			"bd96801-buck4-overvolt"),
260 	BD96801_IRQINFO(BD96801_PROT_UVP, "buck4-under-voltage", 500,
261 			"bd96801-buck4-undervolt"),
262 	BD96801_IRQINFO(BD96801_PROT_TEMP, "buck4-over-temp", 500,
263 			"bd96801-buck4-thermal")
264 };
265 
266 static const struct bd96801_irqinfo ldo5_irqinfo[] = {
267 	BD96801_IRQINFO(BD96801_PROT_OCP, "ldo5-overcurr", 500,
268 			"bd96801-ldo5-overcurr"),
269 	BD96801_IRQINFO(BD96801_PROT_OVP, "ldo5-over-voltage", 500,
270 			"bd96801-ldo5-overvolt"),
271 	BD96801_IRQINFO(BD96801_PROT_UVP, "ldo5-under-voltage", 500,
272 			"bd96801-ldo5-undervolt"),
273 };
274 
275 static const struct bd96801_irqinfo ldo6_irqinfo[] = {
276 	BD96801_IRQINFO(BD96801_PROT_OCP, "ldo6-overcurr", 500,
277 			"bd96801-ldo6-overcurr"),
278 	BD96801_IRQINFO(BD96801_PROT_OVP, "ldo6-over-voltage", 500,
279 			"bd96801-ldo6-overvolt"),
280 	BD96801_IRQINFO(BD96801_PROT_UVP, "ldo6-under-voltage", 500,
281 			"bd96801-ldo6-undervolt"),
282 };
283 
284 static const struct bd96801_irqinfo ldo7_irqinfo[] = {
285 	BD96801_IRQINFO(BD96801_PROT_OCP, "ldo7-overcurr", 500,
286 			"bd96801-ldo7-overcurr"),
287 	BD96801_IRQINFO(BD96801_PROT_OVP, "ldo7-over-voltage", 500,
288 			"bd96801-ldo7-overvolt"),
289 	BD96801_IRQINFO(BD96801_PROT_UVP, "ldo7-under-voltage", 500,
290 			"bd96801-ldo7-undervolt"),
291 };
292 
293 struct bd96801_irq_desc {
294 	struct bd96801_irqinfo *irqinfo;
295 	int num_irqs;
296 };
297 
298 struct bd96801_regulator_data {
299 	struct regulator_desc desc;
300 	const struct linear_range *init_ranges;
301 	int num_ranges;
302 	struct bd96801_irq_desc irq_desc;
303 	int initial_voltage;
304 	int ldo_vol_lvl;
305 	int ldo_errs;
306 };
307 
308 struct bd96801_pmic_data {
309 	struct bd96801_regulator_data regulator_data[BD96801_NUM_REGULATORS];
310 	struct regmap *regmap;
311 	int fatal_ind;
312 };
313 
ldo_map_notif(int irq,struct regulator_irq_data * rid,unsigned long * dev_mask)314 static int ldo_map_notif(int irq, struct regulator_irq_data *rid,
315 			 unsigned long *dev_mask)
316 {
317 	int i;
318 
319 	for (i = 0; i < rid->num_states; i++) {
320 		struct bd96801_regulator_data *rdata;
321 		struct regulator_dev *rdev;
322 
323 		rdev = rid->states[i].rdev;
324 		rdata = container_of(rdev->desc, struct bd96801_regulator_data,
325 				     desc);
326 		rid->states[i].notifs = regulator_err2notif(rdata->ldo_errs);
327 		rid->states[i].errors = rdata->ldo_errs;
328 		*dev_mask |= BIT(i);
329 	}
330 	return 0;
331 }
332 
bd96801_list_voltage_lr(struct regulator_dev * rdev,unsigned int selector)333 static int bd96801_list_voltage_lr(struct regulator_dev *rdev,
334 				   unsigned int selector)
335 {
336 	int voltage;
337 	struct bd96801_regulator_data *data;
338 
339 	data = container_of(rdev->desc, struct bd96801_regulator_data, desc);
340 
341 	/*
342 	 * The BD096801 has voltage setting in two registers. One giving the
343 	 * "initial voltage" (can be changed only when regulator is disabled.
344 	 * This driver caches the value and sets it only at startup. The other
345 	 * register is voltage tuning value which applies -150 mV ... +150 mV
346 	 * offset to the voltage.
347 	 *
348 	 * Note that the cached initial voltage stored in regulator data is
349 	 * 'scaled down' by the 150 mV so that all of our tuning values are
350 	 * >= 0. This is done because the linear_ranges uses unsigned values.
351 	 *
352 	 * As a result, we increase the tuning voltage which we get based on
353 	 * the selector by the stored initial_voltage.
354 	 */
355 	voltage = regulator_list_voltage_linear_range(rdev, selector);
356 	if (voltage < 0)
357 		return voltage;
358 
359 	return voltage + data->initial_voltage;
360 }
361 
362 
363 static const struct regulator_ops bd96801_ldo_table_ops = {
364 	.is_enabled = regulator_is_enabled_regmap,
365 	.list_voltage = regulator_list_voltage_table,
366 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
367 };
368 
369 static const struct regulator_ops bd96801_buck_ops = {
370 	.is_enabled = regulator_is_enabled_regmap,
371 	.list_voltage = bd96801_list_voltage_lr,
372 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
373 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
374 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
375 	.set_ramp_delay = regulator_set_ramp_delay_regmap,
376 };
377 
378 static const struct regulator_ops bd96801_ldo_ops = {
379 	.is_enabled = regulator_is_enabled_regmap,
380 	.list_voltage = regulator_list_voltage_linear_range,
381 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
382 };
383 
buck_get_initial_voltage(struct regmap * regmap,struct device * dev,struct bd96801_regulator_data * data)384 static int buck_get_initial_voltage(struct regmap *regmap, struct device *dev,
385 				    struct bd96801_regulator_data *data)
386 {
387 	int ret = 0, sel, initial_uv;
388 	int reg = BD96801_INT_VOUT_BASE_REG + data->desc.id;
389 
390 	if (data->num_ranges) {
391 		ret = regmap_read(regmap, reg, &sel);
392 		sel &= BD96801_BUCK_INT_VOUT_MASK;
393 
394 		ret = linear_range_get_value_array(data->init_ranges,
395 						   data->num_ranges, sel,
396 						   &initial_uv);
397 		if (ret)
398 			return ret;
399 
400 		data->initial_voltage = initial_uv;
401 		dev_dbg(dev, "Tune-scaled initial voltage %u\n",
402 			data->initial_voltage);
403 	}
404 
405 	return 0;
406 }
407 
get_ldo_initial_voltage(struct regmap * regmap,struct device * dev,struct bd96801_regulator_data * data)408 static int get_ldo_initial_voltage(struct regmap *regmap,
409 				   struct device *dev,
410 				   struct bd96801_regulator_data *data)
411 {
412 	int ret;
413 	int cfgreg;
414 
415 	ret = regmap_read(regmap, data->ldo_vol_lvl, &cfgreg);
416 	if (ret)
417 		return ret;
418 
419 	switch (cfgreg & BD96801_LDO_MODE_MASK) {
420 	case BD96801_LDO_MODE_DDR:
421 		data->desc.volt_table = ldo_ddr_volt_table;
422 		data->desc.n_voltages = ARRAY_SIZE(ldo_ddr_volt_table);
423 		break;
424 	case BD96801_LDO_MODE_SD:
425 		data->desc.volt_table = ldo_sd_volt_table;
426 		data->desc.n_voltages = ARRAY_SIZE(ldo_sd_volt_table);
427 		break;
428 	default:
429 		dev_info(dev, "Leaving LDO to normal mode");
430 		return 0;
431 	}
432 
433 	/* SD or DDR mode => override default ops */
434 	data->desc.ops = &bd96801_ldo_table_ops,
435 	data->desc.vsel_mask = 1;
436 	data->desc.vsel_reg = data->ldo_vol_lvl;
437 
438 	return 0;
439 }
440 
get_initial_voltage(struct device * dev,struct regmap * regmap,struct bd96801_regulator_data * data)441 static int get_initial_voltage(struct device *dev, struct regmap *regmap,
442 			struct bd96801_regulator_data *data)
443 {
444 	/* BUCK */
445 	if (data->desc.id <= BD96801_BUCK4)
446 		return buck_get_initial_voltage(regmap, dev, data);
447 
448 	/* LDO */
449 	return get_ldo_initial_voltage(regmap, dev, data);
450 }
451 
bd96801_walk_regulator_dt(struct device * dev,struct regmap * regmap,struct bd96801_regulator_data * data,int num)452 static int bd96801_walk_regulator_dt(struct device *dev, struct regmap *regmap,
453 				     struct bd96801_regulator_data *data,
454 				     int num)
455 {
456 	int i, ret;
457 
458 	struct device_node *nproot __free(device_node) =
459 		of_get_child_by_name(dev->parent->of_node, "regulators");
460 	if (!nproot) {
461 		dev_err(dev, "failed to find regulators node\n");
462 		return -ENODEV;
463 	}
464 	for_each_child_of_node_scoped(nproot, np) {
465 		for (i = 0; i < num; i++) {
466 			if (!of_node_name_eq(np, data[i].desc.of_match))
467 				continue;
468 			/*
469 			 * If STBY configs are supported, we must pass node
470 			 * here to extract the initial voltages from the DT.
471 			 * Thus we do the initial voltage getting in this
472 			 * loop.
473 			 */
474 			ret = get_initial_voltage(dev, regmap, &data[i]);
475 			if (ret) {
476 				dev_err(dev,
477 					"Initializing voltages for %s failed\n",
478 					data[i].desc.name);
479 				return ret;
480 			}
481 
482 			if (of_property_read_bool(np, "rohm,keep-on-stby")) {
483 				ret = regmap_set_bits(regmap,
484 						      BD96801_ALWAYS_ON_REG,
485 						      1 << data[i].desc.id);
486 				if (ret) {
487 					dev_err(dev,
488 						"failed to set %s on-at-stby\n",
489 						data[i].desc.name);
490 					return ret;
491 				}
492 			}
493 		}
494 	}
495 
496 	return 0;
497 }
498 
499 /*
500  * Template for regulator data. Probe will allocate dynamic / driver instance
501  * struct so we should be on a safe side even if there were multiple PMICs to
502  * control. Note that there is a plan to allow multiple PMICs to be used so
503  * systems can scale better. I am however still slightly unsure how the
504  * multi-PMIC case will be handled. I don't know if the processor will have I2C
505  * acces to all of the PMICs or only the first one. I'd guess there will be
506  * access provided to all PMICs for voltage scaling - but the errors will only
507  * be informed via the master PMIC. Eg, we should prepare to support multiple
508  * driver instances - either with or without the IRQs... Well, let's first
509  * just support the simple and clear single-PMIC setup and ponder the multi PMIC
510  * case later. What we can easly do for preparing is to not use static global
511  * data for regulators though.
512  */
513 static const struct bd96801_pmic_data bd96801_data = {
514 	.regulator_data = {
515 	{
516 		.desc = {
517 			.name = "buck1",
518 			.of_match = of_match_ptr("buck1"),
519 			.regulators_node = of_match_ptr("regulators"),
520 			.id = BD96801_BUCK1,
521 			.ops = &bd96801_buck_ops,
522 			.type = REGULATOR_VOLTAGE,
523 			.linear_ranges = bd96801_tune_volts,
524 			.n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts),
525 			.n_voltages = BD96801_BUCK_VOLTS,
526 			.enable_reg = BD96801_REG_ENABLE,
527 			.enable_mask = BD96801_BUCK1_EN_MASK,
528 			.enable_is_inverted = true,
529 			.vsel_reg = BD96801_BUCK1_VSEL_REG,
530 			.vsel_mask = BD96801_BUCK_VSEL_MASK,
531 			.ramp_reg = BD96801_BUCK1_VSEL_REG,
532 			.ramp_mask = BD96801_MASK_RAMP_DELAY,
533 			.ramp_delay_table = &buck_ramp_table[0],
534 			.n_ramp_values = ARRAY_SIZE(buck_ramp_table),
535 			.owner = THIS_MODULE,
536 		},
537 		.init_ranges = bd96801_buck_init_volts,
538 		.num_ranges = ARRAY_SIZE(bd96801_buck_init_volts),
539 		.irq_desc = {
540 			.irqinfo = (struct bd96801_irqinfo *)&buck1_irqinfo[0],
541 			.num_irqs = ARRAY_SIZE(buck1_irqinfo),
542 		},
543 	}, {
544 		.desc = {
545 			.name = "buck2",
546 			.of_match = of_match_ptr("buck2"),
547 			.regulators_node = of_match_ptr("regulators"),
548 			.id = BD96801_BUCK2,
549 			.ops = &bd96801_buck_ops,
550 			.type = REGULATOR_VOLTAGE,
551 			.linear_ranges = bd96801_tune_volts,
552 			.n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts),
553 			.n_voltages = BD96801_BUCK_VOLTS,
554 			.enable_reg = BD96801_REG_ENABLE,
555 			.enable_mask = BD96801_BUCK2_EN_MASK,
556 			.enable_is_inverted = true,
557 			.vsel_reg = BD96801_BUCK2_VSEL_REG,
558 			.vsel_mask = BD96801_BUCK_VSEL_MASK,
559 			.ramp_reg = BD96801_BUCK2_VSEL_REG,
560 			.ramp_mask = BD96801_MASK_RAMP_DELAY,
561 			.ramp_delay_table = &buck_ramp_table[0],
562 			.n_ramp_values = ARRAY_SIZE(buck_ramp_table),
563 			.owner = THIS_MODULE,
564 		},
565 		.irq_desc = {
566 			.irqinfo = (struct bd96801_irqinfo *)&buck2_irqinfo[0],
567 			.num_irqs = ARRAY_SIZE(buck2_irqinfo),
568 		},
569 		.init_ranges = bd96801_buck_init_volts,
570 		.num_ranges = ARRAY_SIZE(bd96801_buck_init_volts),
571 	}, {
572 		.desc = {
573 			.name = "buck3",
574 			.of_match = of_match_ptr("buck3"),
575 			.regulators_node = of_match_ptr("regulators"),
576 			.id = BD96801_BUCK3,
577 			.ops = &bd96801_buck_ops,
578 			.type = REGULATOR_VOLTAGE,
579 			.linear_ranges = bd96801_tune_volts,
580 			.n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts),
581 			.n_voltages = BD96801_BUCK_VOLTS,
582 			.enable_reg = BD96801_REG_ENABLE,
583 			.enable_mask = BD96801_BUCK3_EN_MASK,
584 			.enable_is_inverted = true,
585 			.vsel_reg = BD96801_BUCK3_VSEL_REG,
586 			.vsel_mask = BD96801_BUCK_VSEL_MASK,
587 			.ramp_reg = BD96801_BUCK3_VSEL_REG,
588 			.ramp_mask = BD96801_MASK_RAMP_DELAY,
589 			.ramp_delay_table = &buck_ramp_table[0],
590 			.n_ramp_values = ARRAY_SIZE(buck_ramp_table),
591 			.owner = THIS_MODULE,
592 		},
593 		.irq_desc = {
594 			.irqinfo = (struct bd96801_irqinfo *)&buck3_irqinfo[0],
595 			.num_irqs = ARRAY_SIZE(buck3_irqinfo),
596 		},
597 		.init_ranges = bd96801_buck_init_volts,
598 		.num_ranges = ARRAY_SIZE(bd96801_buck_init_volts),
599 	}, {
600 		.desc = {
601 			.name = "buck4",
602 			.of_match = of_match_ptr("buck4"),
603 			.regulators_node = of_match_ptr("regulators"),
604 			.id = BD96801_BUCK4,
605 			.ops = &bd96801_buck_ops,
606 			.type = REGULATOR_VOLTAGE,
607 			.linear_ranges = bd96801_tune_volts,
608 			.n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts),
609 			.n_voltages = BD96801_BUCK_VOLTS,
610 			.enable_reg = BD96801_REG_ENABLE,
611 			.enable_mask = BD96801_BUCK4_EN_MASK,
612 			.enable_is_inverted = true,
613 			.vsel_reg = BD96801_BUCK4_VSEL_REG,
614 			.vsel_mask = BD96801_BUCK_VSEL_MASK,
615 			.ramp_reg = BD96801_BUCK4_VSEL_REG,
616 			.ramp_mask = BD96801_MASK_RAMP_DELAY,
617 			.ramp_delay_table = &buck_ramp_table[0],
618 			.n_ramp_values = ARRAY_SIZE(buck_ramp_table),
619 			.owner = THIS_MODULE,
620 		},
621 		.irq_desc = {
622 			.irqinfo = (struct bd96801_irqinfo *)&buck4_irqinfo[0],
623 			.num_irqs = ARRAY_SIZE(buck4_irqinfo),
624 		},
625 		.init_ranges = bd96801_buck_init_volts,
626 		.num_ranges = ARRAY_SIZE(bd96801_buck_init_volts),
627 	}, {
628 		.desc = {
629 			.name = "ldo5",
630 			.of_match = of_match_ptr("ldo5"),
631 			.regulators_node = of_match_ptr("regulators"),
632 			.id = BD96801_LDO5,
633 			.ops = &bd96801_ldo_ops,
634 			.type = REGULATOR_VOLTAGE,
635 			.linear_ranges = bd96801_ldo_int_volts,
636 			.n_linear_ranges = ARRAY_SIZE(bd96801_ldo_int_volts),
637 			.n_voltages = BD96801_LDO_VOLTS,
638 			.enable_reg = BD96801_REG_ENABLE,
639 			.enable_mask = BD96801_LDO5_EN_MASK,
640 			.enable_is_inverted = true,
641 			.vsel_reg = BD96801_LDO5_VSEL_REG,
642 			.vsel_mask = BD96801_LDO_VSEL_MASK,
643 			.owner = THIS_MODULE,
644 		},
645 		.irq_desc = {
646 			.irqinfo = (struct bd96801_irqinfo *)&ldo5_irqinfo[0],
647 			.num_irqs = ARRAY_SIZE(ldo5_irqinfo),
648 		},
649 		.ldo_vol_lvl = BD96801_LDO5_VOL_LVL_REG,
650 	}, {
651 		.desc = {
652 			.name = "ldo6",
653 			.of_match = of_match_ptr("ldo6"),
654 			.regulators_node = of_match_ptr("regulators"),
655 			.id = BD96801_LDO6,
656 			.ops = &bd96801_ldo_ops,
657 			.type = REGULATOR_VOLTAGE,
658 			.linear_ranges = bd96801_ldo_int_volts,
659 			.n_linear_ranges = ARRAY_SIZE(bd96801_ldo_int_volts),
660 			.n_voltages = BD96801_LDO_VOLTS,
661 			.enable_reg = BD96801_REG_ENABLE,
662 			.enable_mask = BD96801_LDO6_EN_MASK,
663 			.enable_is_inverted = true,
664 			.vsel_reg = BD96801_LDO6_VSEL_REG,
665 			.vsel_mask = BD96801_LDO_VSEL_MASK,
666 			.owner = THIS_MODULE,
667 		},
668 		.irq_desc = {
669 			.irqinfo = (struct bd96801_irqinfo *)&ldo6_irqinfo[0],
670 			.num_irqs = ARRAY_SIZE(ldo6_irqinfo),
671 		},
672 		.ldo_vol_lvl = BD96801_LDO6_VOL_LVL_REG,
673 	}, {
674 		.desc = {
675 			.name = "ldo7",
676 			.of_match = of_match_ptr("ldo7"),
677 			.regulators_node = of_match_ptr("regulators"),
678 			.id = BD96801_LDO7,
679 			.ops = &bd96801_ldo_ops,
680 			.type = REGULATOR_VOLTAGE,
681 			.linear_ranges = bd96801_ldo_int_volts,
682 			.n_linear_ranges = ARRAY_SIZE(bd96801_ldo_int_volts),
683 			.n_voltages = BD96801_LDO_VOLTS,
684 			.enable_reg = BD96801_REG_ENABLE,
685 			.enable_mask = BD96801_LDO7_EN_MASK,
686 			.enable_is_inverted = true,
687 			.vsel_reg = BD96801_LDO7_VSEL_REG,
688 			.vsel_mask = BD96801_LDO_VSEL_MASK,
689 			.owner = THIS_MODULE,
690 		},
691 		.irq_desc = {
692 			.irqinfo = (struct bd96801_irqinfo *)&ldo7_irqinfo[0],
693 			.num_irqs = ARRAY_SIZE(ldo7_irqinfo),
694 		},
695 		.ldo_vol_lvl = BD96801_LDO7_VOL_LVL_REG,
696 	},
697 	},
698 };
699 
initialize_pmic_data(struct device * dev,struct bd96801_pmic_data * pdata)700 static int initialize_pmic_data(struct device *dev,
701 				struct bd96801_pmic_data *pdata)
702 {
703 	int r, i;
704 
705 	/*
706 	 * Allocate and initialize IRQ data for all of the regulators. We
707 	 * wish to modify IRQ information independently for each driver
708 	 * instance.
709 	 */
710 	for (r = 0; r < BD96801_NUM_REGULATORS; r++) {
711 		const struct bd96801_irqinfo *template;
712 		struct bd96801_irqinfo *new;
713 		int num_infos;
714 
715 		template = pdata->regulator_data[r].irq_desc.irqinfo;
716 		num_infos = pdata->regulator_data[r].irq_desc.num_irqs;
717 
718 		new = devm_kcalloc(dev, num_infos, sizeof(*new), GFP_KERNEL);
719 		if (!new)
720 			return -ENOMEM;
721 
722 		pdata->regulator_data[r].irq_desc.irqinfo = new;
723 
724 		for (i = 0; i < num_infos; i++)
725 			new[i] = template[i];
726 	}
727 
728 	return 0;
729 }
730 
bd96801_rdev_intb_irqs(struct platform_device * pdev,struct bd96801_pmic_data * pdata,struct bd96801_irqinfo * iinfo,struct regulator_dev * rdev)731 static int bd96801_rdev_intb_irqs(struct platform_device *pdev,
732 				  struct bd96801_pmic_data *pdata,
733 				  struct bd96801_irqinfo *iinfo,
734 				  struct regulator_dev *rdev)
735 {
736 	struct regulator_dev *rdev_arr[1];
737 	void *retp;
738 	int err = 0;
739 	int irq;
740 	int err_flags[] = {
741 		[BD96801_PROT_OVP] = REGULATOR_ERROR_REGULATION_OUT,
742 		[BD96801_PROT_UVP] = REGULATOR_ERROR_UNDER_VOLTAGE,
743 		[BD96801_PROT_OCP] = REGULATOR_ERROR_OVER_CURRENT,
744 		[BD96801_PROT_TEMP] = REGULATOR_ERROR_OVER_TEMP,
745 
746 	};
747 	int wrn_flags[] = {
748 		[BD96801_PROT_OVP] = REGULATOR_ERROR_OVER_VOLTAGE_WARN,
749 		[BD96801_PROT_UVP] = REGULATOR_ERROR_UNDER_VOLTAGE_WARN,
750 		[BD96801_PROT_OCP] = REGULATOR_ERROR_OVER_CURRENT_WARN,
751 		[BD96801_PROT_TEMP] = REGULATOR_ERROR_OVER_TEMP_WARN,
752 	};
753 
754 	/*
755 	 * Don't install IRQ handler if both error and warning
756 	 * notifications are explicitly disabled
757 	 */
758 	if (!iinfo->err_cfg && !iinfo->wrn_cfg)
759 		return 0;
760 
761 	if (WARN_ON(iinfo->type >= BD96801_NUM_PROT))
762 		return -EINVAL;
763 
764 	if (iinfo->err_cfg)
765 		err = err_flags[iinfo->type];
766 	else if (iinfo->wrn_cfg)
767 		err = wrn_flags[iinfo->type];
768 
769 	iinfo->irq_desc.data = pdata;
770 	irq = platform_get_irq_byname(pdev, iinfo->irq_name);
771 	if (irq < 0)
772 		return irq;
773 	/* Find notifications for this IRQ (WARN/ERR) */
774 
775 	rdev_arr[0] = rdev;
776 	retp = devm_regulator_irq_helper(&pdev->dev,
777 					 &iinfo->irq_desc, irq,
778 					 0, err, NULL, rdev_arr,
779 					 1);
780 	if (IS_ERR(retp))
781 		return PTR_ERR(retp);
782 
783 	return 0;
784 }
785 
786 
787 
bd96801_probe(struct platform_device * pdev)788 static int bd96801_probe(struct platform_device *pdev)
789 {
790 	struct regulator_dev *ldo_errs_rdev_arr[BD96801_NUM_LDOS];
791 	struct bd96801_regulator_data *rdesc;
792 	struct regulator_config config = {};
793 	int ldo_errs_arr[BD96801_NUM_LDOS];
794 	struct bd96801_pmic_data *pdata;
795 	int temp_notif_ldos = 0;
796 	struct device *parent;
797 	int i, ret;
798 	void *retp;
799 
800 	parent = pdev->dev.parent;
801 
802 	pdata = devm_kmemdup(&pdev->dev, &bd96801_data, sizeof(bd96801_data),
803 			     GFP_KERNEL);
804 	if (!pdata)
805 		return -ENOMEM;
806 
807 	if (initialize_pmic_data(&pdev->dev, pdata))
808 		return -ENOMEM;
809 
810 	pdata->regmap = dev_get_regmap(parent, NULL);
811 	if (!pdata->regmap) {
812 		dev_err(&pdev->dev, "No register map found\n");
813 		return -ENODEV;
814 	}
815 
816 	rdesc = &pdata->regulator_data[0];
817 
818 	config.driver_data = pdata;
819 	config.regmap = pdata->regmap;
820 	config.dev = parent;
821 
822 	ret = bd96801_walk_regulator_dt(&pdev->dev, pdata->regmap, rdesc,
823 					BD96801_NUM_REGULATORS);
824 	if (ret)
825 		return ret;
826 
827 	for (i = 0; i < ARRAY_SIZE(pdata->regulator_data); i++) {
828 		struct regulator_dev *rdev;
829 		struct bd96801_irq_desc *idesc = &rdesc[i].irq_desc;
830 		int j;
831 
832 		rdev = devm_regulator_register(&pdev->dev,
833 					       &rdesc[i].desc, &config);
834 		if (IS_ERR(rdev)) {
835 			dev_err(&pdev->dev,
836 				"failed to register %s regulator\n",
837 				rdesc[i].desc.name);
838 			return PTR_ERR(rdev);
839 		}
840 		/*
841 		 * LDOs don't have own temperature monitoring. If temperature
842 		 * notification was requested for this LDO from DT then we will
843 		 * add the regulator to be notified if central IC temperature
844 		 * exceeds threshold.
845 		 */
846 		if (rdesc[i].ldo_errs) {
847 			ldo_errs_rdev_arr[temp_notif_ldos] = rdev;
848 			ldo_errs_arr[temp_notif_ldos] = rdesc[i].ldo_errs;
849 			temp_notif_ldos++;
850 		}
851 
852 		/* Register INTB handlers for configured protections */
853 		for (j = 0; j < idesc->num_irqs; j++) {
854 			ret = bd96801_rdev_intb_irqs(pdev, pdata,
855 						     &idesc->irqinfo[j], rdev);
856 			if (ret)
857 				return ret;
858 		}
859 	}
860 	if (temp_notif_ldos) {
861 		int irq;
862 		struct regulator_irq_desc tw_desc = {
863 			.name = "bd96801-core-thermal",
864 			.irq_off_ms = 500,
865 			.map_event = ldo_map_notif,
866 		};
867 
868 		irq = platform_get_irq_byname(pdev, "bd96801-core-thermal");
869 		if (irq < 0)
870 			return irq;
871 
872 		retp = devm_regulator_irq_helper(&pdev->dev, &tw_desc, irq, 0,
873 						 0, &ldo_errs_arr[0],
874 						 &ldo_errs_rdev_arr[0],
875 						 temp_notif_ldos);
876 		if (IS_ERR(retp))
877 			return PTR_ERR(retp);
878 	}
879 
880 	return 0;
881 }
882 
883 static const struct platform_device_id bd96801_pmic_id[] = {
884 	{ "bd96801-regulator", },
885 	{ }
886 };
887 MODULE_DEVICE_TABLE(platform, bd96801_pmic_id);
888 
889 static struct platform_driver bd96801_regulator = {
890 	.driver = {
891 		.name = "bd96801-pmic"
892 	},
893 	.probe = bd96801_probe,
894 	.id_table = bd96801_pmic_id,
895 };
896 
897 module_platform_driver(bd96801_regulator);
898 
899 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
900 MODULE_DESCRIPTION("BD96801 voltage regulator driver");
901 MODULE_LICENSE("GPL");
902