1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) STMicroelectronics 2018
3 // Author: Pascal Paillet <p.paillet@st.com> for STMicroelectronics.
4 
5 #include <linux/interrupt.h>
6 #include <linux/mfd/stpmic1.h>
7 #include <linux/module.h>
8 #include <linux/of_irq.h>
9 #include <linux/platform_device.h>
10 #include <linux/regmap.h>
11 #include <linux/regulator/driver.h>
12 #include <linux/regulator/machine.h>
13 #include <linux/regulator/of_regulator.h>
14 
15 #include <dt-bindings/mfd/st,stpmic1.h>
16 
17 /**
18  * stpmic1 regulator description: this structure is used as driver data
19  * @desc: regulator framework description
20  * @mask_reset_reg: mask reset register address
21  * @mask_reset_mask: mask rank and mask reset register mask
22  * @icc_reg: icc register address
23  * @icc_mask: icc register mask
24  */
25 struct stpmic1_regulator_cfg {
26 	struct regulator_desc desc;
27 	u8 mask_reset_reg;
28 	u8 mask_reset_mask;
29 	u8 icc_reg;
30 	u8 icc_mask;
31 };
32 
33 static int stpmic1_set_mode(struct regulator_dev *rdev, unsigned int mode);
34 static unsigned int stpmic1_get_mode(struct regulator_dev *rdev);
35 static int stpmic1_set_icc(struct regulator_dev *rdev);
36 static unsigned int stpmic1_map_mode(unsigned int mode);
37 
38 enum {
39 	STPMIC1_BUCK1 = 0,
40 	STPMIC1_BUCK2 = 1,
41 	STPMIC1_BUCK3 = 2,
42 	STPMIC1_BUCK4 = 3,
43 	STPMIC1_LDO1 = 4,
44 	STPMIC1_LDO2 = 5,
45 	STPMIC1_LDO3 = 6,
46 	STPMIC1_LDO4 = 7,
47 	STPMIC1_LDO5 = 8,
48 	STPMIC1_LDO6 = 9,
49 	STPMIC1_VREF_DDR = 10,
50 	STPMIC1_BOOST = 11,
51 	STPMIC1_VBUS_OTG = 12,
52 	STPMIC1_SW_OUT = 13,
53 };
54 
55 /* Enable time worst case is 5000mV/(2250uV/uS) */
56 #define PMIC_ENABLE_TIME_US 2200
57 /* Ramp delay worst case is (2250uV/uS) */
58 #define PMIC_RAMP_DELAY 2200
59 
60 static const struct linear_range buck1_ranges[] = {
61 	REGULATOR_LINEAR_RANGE(725000, 0, 4, 0),
62 	REGULATOR_LINEAR_RANGE(725000, 5, 36, 25000),
63 	REGULATOR_LINEAR_RANGE(1500000, 37, 63, 0),
64 };
65 
66 static const struct linear_range buck2_ranges[] = {
67 	REGULATOR_LINEAR_RANGE(1000000, 0, 17, 0),
68 	REGULATOR_LINEAR_RANGE(1050000, 18, 19, 0),
69 	REGULATOR_LINEAR_RANGE(1100000, 20, 21, 0),
70 	REGULATOR_LINEAR_RANGE(1150000, 22, 23, 0),
71 	REGULATOR_LINEAR_RANGE(1200000, 24, 25, 0),
72 	REGULATOR_LINEAR_RANGE(1250000, 26, 27, 0),
73 	REGULATOR_LINEAR_RANGE(1300000, 28, 29, 0),
74 	REGULATOR_LINEAR_RANGE(1350000, 30, 31, 0),
75 	REGULATOR_LINEAR_RANGE(1400000, 32, 33, 0),
76 	REGULATOR_LINEAR_RANGE(1450000, 34, 35, 0),
77 	REGULATOR_LINEAR_RANGE(1500000, 36, 63, 0),
78 };
79 
80 static const struct linear_range buck3_ranges[] = {
81 	REGULATOR_LINEAR_RANGE(1000000, 0, 19, 0),
82 	REGULATOR_LINEAR_RANGE(1100000, 20, 23, 0),
83 	REGULATOR_LINEAR_RANGE(1200000, 24, 27, 0),
84 	REGULATOR_LINEAR_RANGE(1300000, 28, 31, 0),
85 	REGULATOR_LINEAR_RANGE(1400000, 32, 35, 0),
86 	REGULATOR_LINEAR_RANGE(1500000, 36, 55, 100000),
87 	REGULATOR_LINEAR_RANGE(3400000, 56, 63, 0),
88 };
89 
90 static const struct linear_range buck4_ranges[] = {
91 	REGULATOR_LINEAR_RANGE(600000, 0, 27, 25000),
92 	REGULATOR_LINEAR_RANGE(1300000, 28, 29, 0),
93 	REGULATOR_LINEAR_RANGE(1350000, 30, 31, 0),
94 	REGULATOR_LINEAR_RANGE(1400000, 32, 33, 0),
95 	REGULATOR_LINEAR_RANGE(1450000, 34, 35, 0),
96 	REGULATOR_LINEAR_RANGE(1500000, 36, 60, 100000),
97 	REGULATOR_LINEAR_RANGE(3900000, 61, 63, 0),
98 };
99 
100 static const struct linear_range ldo1_ranges[] = {
101 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
102 	REGULATOR_LINEAR_RANGE(1700000, 8, 24, 100000),
103 	REGULATOR_LINEAR_RANGE(3300000, 25, 31, 0),
104 };
105 
106 static const struct linear_range ldo2_ranges[] = {
107 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
108 	REGULATOR_LINEAR_RANGE(1700000, 8, 24, 100000),
109 	REGULATOR_LINEAR_RANGE(3300000, 25, 30, 0),
110 };
111 
112 static const struct linear_range ldo3_ranges[] = {
113 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
114 	REGULATOR_LINEAR_RANGE(1700000, 8, 24, 100000),
115 	REGULATOR_LINEAR_RANGE(3300000, 25, 30, 0),
116 	/* with index 31 LDO3 is in DDR mode */
117 	REGULATOR_LINEAR_RANGE(500000, 31, 31, 0),
118 };
119 
120 static const struct linear_range ldo5_ranges[] = {
121 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
122 	REGULATOR_LINEAR_RANGE(1700000, 8, 30, 100000),
123 	REGULATOR_LINEAR_RANGE(3900000, 31, 31, 0),
124 };
125 
126 static const struct linear_range ldo6_ranges[] = {
127 	REGULATOR_LINEAR_RANGE(900000, 0, 24, 100000),
128 	REGULATOR_LINEAR_RANGE(3300000, 25, 31, 0),
129 };
130 
131 static const struct regulator_ops stpmic1_ldo_ops = {
132 	.list_voltage = regulator_list_voltage_linear_range,
133 	.map_voltage = regulator_map_voltage_linear_range,
134 	.is_enabled = regulator_is_enabled_regmap,
135 	.enable = regulator_enable_regmap,
136 	.disable = regulator_disable_regmap,
137 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
138 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
139 	.set_over_current_protection = stpmic1_set_icc,
140 };
141 
142 static const struct regulator_ops stpmic1_ldo3_ops = {
143 	.list_voltage = regulator_list_voltage_linear_range,
144 	.map_voltage = regulator_map_voltage_iterate,
145 	.is_enabled = regulator_is_enabled_regmap,
146 	.enable = regulator_enable_regmap,
147 	.disable = regulator_disable_regmap,
148 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
149 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
150 	.get_bypass = regulator_get_bypass_regmap,
151 	.set_bypass = regulator_set_bypass_regmap,
152 	.set_over_current_protection = stpmic1_set_icc,
153 };
154 
155 static const struct regulator_ops stpmic1_ldo4_fixed_regul_ops = {
156 	.is_enabled = regulator_is_enabled_regmap,
157 	.enable = regulator_enable_regmap,
158 	.disable = regulator_disable_regmap,
159 	.set_over_current_protection = stpmic1_set_icc,
160 };
161 
162 static const struct regulator_ops stpmic1_buck_ops = {
163 	.list_voltage = regulator_list_voltage_linear_range,
164 	.map_voltage = regulator_map_voltage_linear_range,
165 	.is_enabled = regulator_is_enabled_regmap,
166 	.enable = regulator_enable_regmap,
167 	.disable = regulator_disable_regmap,
168 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
169 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
170 	.set_pull_down = regulator_set_pull_down_regmap,
171 	.set_mode = stpmic1_set_mode,
172 	.get_mode = stpmic1_get_mode,
173 	.set_over_current_protection = stpmic1_set_icc,
174 };
175 
176 static const struct regulator_ops stpmic1_vref_ddr_ops = {
177 	.is_enabled = regulator_is_enabled_regmap,
178 	.enable = regulator_enable_regmap,
179 	.disable = regulator_disable_regmap,
180 };
181 
182 static const struct regulator_ops stpmic1_boost_regul_ops = {
183 	.is_enabled = regulator_is_enabled_regmap,
184 	.enable = regulator_enable_regmap,
185 	.disable = regulator_disable_regmap,
186 	.set_over_current_protection = stpmic1_set_icc,
187 };
188 
189 static const struct regulator_ops stpmic1_switch_regul_ops = {
190 	.is_enabled = regulator_is_enabled_regmap,
191 	.enable = regulator_enable_regmap,
192 	.disable = regulator_disable_regmap,
193 	.set_over_current_protection = stpmic1_set_icc,
194 	.set_active_discharge = regulator_set_active_discharge_regmap,
195 };
196 
197 #define REG_LDO(ids, base) { \
198 	.name = #ids, \
199 	.id = STPMIC1_##ids, \
200 	.n_voltages = 32, \
201 	.ops = &stpmic1_ldo_ops, \
202 	.linear_ranges = base ## _ranges, \
203 	.n_linear_ranges = ARRAY_SIZE(base ## _ranges), \
204 	.type = REGULATOR_VOLTAGE, \
205 	.owner = THIS_MODULE, \
206 	.vsel_reg = ids##_ACTIVE_CR, \
207 	.vsel_mask = LDO_VOLTAGE_MASK, \
208 	.enable_reg = ids##_ACTIVE_CR, \
209 	.enable_mask = LDO_ENABLE_MASK, \
210 	.enable_val = 1, \
211 	.disable_val = 0, \
212 	.enable_time = PMIC_ENABLE_TIME_US, \
213 	.ramp_delay = PMIC_RAMP_DELAY, \
214 	.supply_name = #base, \
215 }
216 
217 #define REG_LDO3(ids, base) { \
218 	.name = #ids, \
219 	.id = STPMIC1_##ids, \
220 	.n_voltages = 32, \
221 	.ops = &stpmic1_ldo3_ops, \
222 	.linear_ranges = ldo3_ranges, \
223 	.n_linear_ranges = ARRAY_SIZE(ldo3_ranges), \
224 	.type = REGULATOR_VOLTAGE, \
225 	.owner = THIS_MODULE, \
226 	.vsel_reg = LDO3_ACTIVE_CR, \
227 	.vsel_mask = LDO_VOLTAGE_MASK, \
228 	.enable_reg = LDO3_ACTIVE_CR, \
229 	.enable_mask = LDO_ENABLE_MASK, \
230 	.enable_val = 1, \
231 	.disable_val = 0, \
232 	.enable_time = PMIC_ENABLE_TIME_US, \
233 	.ramp_delay = PMIC_RAMP_DELAY, \
234 	.bypass_reg = LDO3_ACTIVE_CR, \
235 	.bypass_mask = LDO_BYPASS_MASK, \
236 	.bypass_val_on = LDO_BYPASS_MASK, \
237 	.bypass_val_off = 0, \
238 	.supply_name = #base, \
239 }
240 
241 #define REG_LDO4(ids, base) { \
242 	.name = #ids, \
243 	.id = STPMIC1_##ids, \
244 	.n_voltages = 1, \
245 	.ops = &stpmic1_ldo4_fixed_regul_ops, \
246 	.type = REGULATOR_VOLTAGE, \
247 	.owner = THIS_MODULE, \
248 	.min_uV = 3300000, \
249 	.fixed_uV = 3300000, \
250 	.enable_reg = LDO4_ACTIVE_CR, \
251 	.enable_mask = LDO_ENABLE_MASK, \
252 	.enable_val = 1, \
253 	.disable_val = 0, \
254 	.enable_time = PMIC_ENABLE_TIME_US, \
255 	.ramp_delay = PMIC_RAMP_DELAY, \
256 	.supply_name = #base, \
257 }
258 
259 #define REG_BUCK(ids, base) { \
260 	.name = #ids, \
261 	.id = STPMIC1_##ids, \
262 	.ops = &stpmic1_buck_ops, \
263 	.n_voltages = 64, \
264 	.linear_ranges = base ## _ranges, \
265 	.n_linear_ranges = ARRAY_SIZE(base ## _ranges), \
266 	.type = REGULATOR_VOLTAGE, \
267 	.owner = THIS_MODULE, \
268 	.vsel_reg = ids##_ACTIVE_CR, \
269 	.vsel_mask = BUCK_VOLTAGE_MASK, \
270 	.enable_reg = ids##_ACTIVE_CR, \
271 	.enable_mask = BUCK_ENABLE_MASK, \
272 	.enable_val = 1, \
273 	.disable_val = 0, \
274 	.enable_time = PMIC_ENABLE_TIME_US, \
275 	.ramp_delay = PMIC_RAMP_DELAY, \
276 	.of_map_mode = stpmic1_map_mode, \
277 	.pull_down_reg = ids##_PULL_DOWN_REG, \
278 	.pull_down_mask = ids##_PULL_DOWN_MASK, \
279 	.supply_name = #base, \
280 }
281 
282 #define REG_VREF_DDR(ids, base) { \
283 	.name = #ids, \
284 	.id = STPMIC1_##ids, \
285 	.n_voltages = 1, \
286 	.ops = &stpmic1_vref_ddr_ops, \
287 	.type = REGULATOR_VOLTAGE, \
288 	.owner = THIS_MODULE, \
289 	.min_uV = 500000, \
290 	.fixed_uV = 500000, \
291 	.enable_reg = VREF_DDR_ACTIVE_CR, \
292 	.enable_mask = BUCK_ENABLE_MASK, \
293 	.enable_val = 1, \
294 	.disable_val = 0, \
295 	.enable_time = PMIC_ENABLE_TIME_US, \
296 	.supply_name = #base, \
297 }
298 
299 #define REG_BOOST(ids, base) { \
300 	.name = #ids, \
301 	.id = STPMIC1_##ids, \
302 	.n_voltages = 1, \
303 	.ops = &stpmic1_boost_regul_ops, \
304 	.type = REGULATOR_VOLTAGE, \
305 	.owner = THIS_MODULE, \
306 	.min_uV = 0, \
307 	.fixed_uV = 5000000, \
308 	.enable_reg = BST_SW_CR, \
309 	.enable_mask = BOOST_ENABLED, \
310 	.enable_val = BOOST_ENABLED, \
311 	.disable_val = 0, \
312 	.enable_time = PMIC_ENABLE_TIME_US, \
313 	.supply_name = #base, \
314 }
315 
316 #define REG_VBUS_OTG(ids, base) { \
317 	.name = #ids, \
318 	.id = STPMIC1_##ids, \
319 	.n_voltages = 1, \
320 	.ops = &stpmic1_switch_regul_ops, \
321 	.type = REGULATOR_VOLTAGE, \
322 	.owner = THIS_MODULE, \
323 	.min_uV = 0, \
324 	.fixed_uV = 5000000, \
325 	.enable_reg = BST_SW_CR, \
326 	.enable_mask = USBSW_OTG_SWITCH_ENABLED, \
327 	.enable_val = USBSW_OTG_SWITCH_ENABLED, \
328 	.disable_val = 0, \
329 	.enable_time = PMIC_ENABLE_TIME_US, \
330 	.supply_name = #base, \
331 	.active_discharge_reg = BST_SW_CR, \
332 	.active_discharge_mask = VBUS_OTG_DISCHARGE, \
333 	.active_discharge_on = VBUS_OTG_DISCHARGE, \
334 }
335 
336 #define REG_SW_OUT(ids, base) { \
337 	.name = #ids, \
338 	.id = STPMIC1_##ids, \
339 	.n_voltages = 1, \
340 	.ops = &stpmic1_switch_regul_ops, \
341 	.type = REGULATOR_VOLTAGE, \
342 	.owner = THIS_MODULE, \
343 	.min_uV = 0, \
344 	.fixed_uV = 5000000, \
345 	.enable_reg = BST_SW_CR, \
346 	.enable_mask = SWIN_SWOUT_ENABLED, \
347 	.enable_val = SWIN_SWOUT_ENABLED, \
348 	.disable_val = 0, \
349 	.enable_time = PMIC_ENABLE_TIME_US, \
350 	.supply_name = #base, \
351 	.active_discharge_reg = BST_SW_CR, \
352 	.active_discharge_mask = SW_OUT_DISCHARGE, \
353 	.active_discharge_on = SW_OUT_DISCHARGE, \
354 }
355 
356 static const struct stpmic1_regulator_cfg stpmic1_regulator_cfgs[] = {
357 	[STPMIC1_BUCK1] = {
358 		.desc = REG_BUCK(BUCK1, buck1),
359 		.icc_reg = BUCKS_ICCTO_CR,
360 		.icc_mask = BIT(0),
361 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
362 		.mask_reset_mask = BIT(0),
363 	},
364 	[STPMIC1_BUCK2] = {
365 		.desc = REG_BUCK(BUCK2, buck2),
366 		.icc_reg = BUCKS_ICCTO_CR,
367 		.icc_mask = BIT(1),
368 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
369 		.mask_reset_mask = BIT(1),
370 	},
371 	[STPMIC1_BUCK3] = {
372 		.desc = REG_BUCK(BUCK3, buck3),
373 		.icc_reg = BUCKS_ICCTO_CR,
374 		.icc_mask = BIT(2),
375 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
376 		.mask_reset_mask = BIT(2),
377 	},
378 	[STPMIC1_BUCK4] = {
379 		.desc = REG_BUCK(BUCK4, buck4),
380 		.icc_reg = BUCKS_ICCTO_CR,
381 		.icc_mask = BIT(3),
382 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
383 		.mask_reset_mask = BIT(3),
384 	},
385 	[STPMIC1_LDO1] = {
386 		.desc = REG_LDO(LDO1, ldo1),
387 		.icc_reg = LDOS_ICCTO_CR,
388 		.icc_mask = BIT(0),
389 		.mask_reset_reg = LDOS_MASK_RESET_CR,
390 		.mask_reset_mask = BIT(0),
391 	},
392 	[STPMIC1_LDO2] = {
393 		.desc = REG_LDO(LDO2, ldo2),
394 		.icc_reg = LDOS_ICCTO_CR,
395 		.icc_mask = BIT(1),
396 		.mask_reset_reg = LDOS_MASK_RESET_CR,
397 		.mask_reset_mask = BIT(1),
398 	},
399 	[STPMIC1_LDO3] = {
400 		.desc = REG_LDO3(LDO3, ldo3),
401 		.icc_reg = LDOS_ICCTO_CR,
402 		.icc_mask = BIT(2),
403 		.mask_reset_reg = LDOS_MASK_RESET_CR,
404 		.mask_reset_mask = BIT(2),
405 	},
406 	[STPMIC1_LDO4] = {
407 		.desc = REG_LDO4(LDO4, ldo4),
408 		.icc_reg = LDOS_ICCTO_CR,
409 		.icc_mask = BIT(3),
410 		.mask_reset_reg = LDOS_MASK_RESET_CR,
411 		.mask_reset_mask = BIT(3),
412 	},
413 	[STPMIC1_LDO5] = {
414 		.desc = REG_LDO(LDO5, ldo5),
415 		.icc_reg = LDOS_ICCTO_CR,
416 		.icc_mask = BIT(4),
417 		.mask_reset_reg = LDOS_MASK_RESET_CR,
418 		.mask_reset_mask = BIT(4),
419 	},
420 	[STPMIC1_LDO6] = {
421 		.desc = REG_LDO(LDO6, ldo6),
422 		.icc_reg = LDOS_ICCTO_CR,
423 		.icc_mask = BIT(5),
424 		.mask_reset_reg = LDOS_MASK_RESET_CR,
425 		.mask_reset_mask = BIT(5),
426 	},
427 	[STPMIC1_VREF_DDR] = {
428 		.desc = REG_VREF_DDR(VREF_DDR, vref_ddr),
429 		.mask_reset_reg = LDOS_MASK_RESET_CR,
430 		.mask_reset_mask = BIT(6),
431 	},
432 	[STPMIC1_BOOST] = {
433 		.desc = REG_BOOST(BOOST, boost),
434 		.icc_reg = BUCKS_ICCTO_CR,
435 		.icc_mask = BIT(6),
436 	},
437 	[STPMIC1_VBUS_OTG] = {
438 		.desc = REG_VBUS_OTG(VBUS_OTG, pwr_sw1),
439 		.icc_reg = BUCKS_ICCTO_CR,
440 		.icc_mask = BIT(4),
441 	},
442 	[STPMIC1_SW_OUT] = {
443 		.desc = REG_SW_OUT(SW_OUT, pwr_sw2),
444 		.icc_reg = BUCKS_ICCTO_CR,
445 		.icc_mask = BIT(5),
446 	},
447 };
448 
449 static unsigned int stpmic1_map_mode(unsigned int mode)
450 {
451 	switch (mode) {
452 	case STPMIC1_BUCK_MODE_NORMAL:
453 		return REGULATOR_MODE_NORMAL;
454 	case STPMIC1_BUCK_MODE_LP:
455 		return REGULATOR_MODE_STANDBY;
456 	default:
457 		return REGULATOR_MODE_INVALID;
458 	}
459 }
460 
461 static unsigned int stpmic1_get_mode(struct regulator_dev *rdev)
462 {
463 	int value;
464 	struct regmap *regmap = rdev_get_regmap(rdev);
465 
466 	regmap_read(regmap, rdev->desc->enable_reg, &value);
467 
468 	if (value & STPMIC1_BUCK_MODE_LP)
469 		return REGULATOR_MODE_STANDBY;
470 
471 	return REGULATOR_MODE_NORMAL;
472 }
473 
474 static int stpmic1_set_mode(struct regulator_dev *rdev, unsigned int mode)
475 {
476 	int value;
477 	struct regmap *regmap = rdev_get_regmap(rdev);
478 
479 	switch (mode) {
480 	case REGULATOR_MODE_NORMAL:
481 		value = STPMIC1_BUCK_MODE_NORMAL;
482 		break;
483 	case REGULATOR_MODE_STANDBY:
484 		value = STPMIC1_BUCK_MODE_LP;
485 		break;
486 	default:
487 		return -EINVAL;
488 	}
489 
490 	return regmap_update_bits(regmap, rdev->desc->enable_reg,
491 				  STPMIC1_BUCK_MODE_LP, value);
492 }
493 
494 static int stpmic1_set_icc(struct regulator_dev *rdev)
495 {
496 	struct stpmic1_regulator_cfg *cfg = rdev_get_drvdata(rdev);
497 	struct regmap *regmap = rdev_get_regmap(rdev);
498 
499 	/* enable switch off in case of over current */
500 	return regmap_update_bits(regmap, cfg->icc_reg, cfg->icc_mask,
501 				  cfg->icc_mask);
502 }
503 
504 static irqreturn_t stpmic1_curlim_irq_handler(int irq, void *data)
505 {
506 	struct regulator_dev *rdev = (struct regulator_dev *)data;
507 
508 	regulator_lock(rdev);
509 
510 	/* Send an overcurrent notification */
511 	regulator_notifier_call_chain(rdev,
512 				      REGULATOR_EVENT_OVER_CURRENT,
513 				      NULL);
514 
515 	regulator_unlock(rdev);
516 
517 	return IRQ_HANDLED;
518 }
519 
520 #define MATCH(_name, _id) \
521 	[STPMIC1_##_id] = { \
522 		.name = #_name, \
523 		.desc = &stpmic1_regulator_cfgs[STPMIC1_##_id].desc, \
524 	}
525 
526 static struct of_regulator_match stpmic1_matches[] = {
527 	MATCH(buck1, BUCK1),
528 	MATCH(buck2, BUCK2),
529 	MATCH(buck3, BUCK3),
530 	MATCH(buck4, BUCK4),
531 	MATCH(ldo1, LDO1),
532 	MATCH(ldo2, LDO2),
533 	MATCH(ldo3, LDO3),
534 	MATCH(ldo4, LDO4),
535 	MATCH(ldo5, LDO5),
536 	MATCH(ldo6, LDO6),
537 	MATCH(vref_ddr, VREF_DDR),
538 	MATCH(boost, BOOST),
539 	MATCH(pwr_sw1, VBUS_OTG),
540 	MATCH(pwr_sw2, SW_OUT),
541 };
542 
543 static int stpmic1_regulator_register(struct platform_device *pdev, int id,
544 				      struct of_regulator_match *match,
545 				      const struct stpmic1_regulator_cfg *cfg)
546 {
547 	struct stpmic1 *pmic_dev = dev_get_drvdata(pdev->dev.parent);
548 	struct regulator_dev *rdev;
549 	struct regulator_config config = {};
550 	int ret = 0;
551 	int irq;
552 
553 	config.dev = &pdev->dev;
554 	config.init_data = match->init_data;
555 	config.of_node = match->of_node;
556 	config.regmap = pmic_dev->regmap;
557 	config.driver_data = (void *)cfg;
558 
559 	rdev = devm_regulator_register(&pdev->dev, &cfg->desc, &config);
560 	if (IS_ERR(rdev)) {
561 		dev_err(&pdev->dev, "failed to register %s regulator\n",
562 			cfg->desc.name);
563 		return PTR_ERR(rdev);
564 	}
565 
566 	/* set mask reset */
567 	if (of_get_property(config.of_node, "st,mask-reset", NULL) &&
568 	    cfg->mask_reset_reg != 0) {
569 		ret = regmap_update_bits(pmic_dev->regmap,
570 					 cfg->mask_reset_reg,
571 					 cfg->mask_reset_mask,
572 					 cfg->mask_reset_mask);
573 		if (ret) {
574 			dev_err(&pdev->dev, "set mask reset failed\n");
575 			return ret;
576 		}
577 	}
578 
579 	/* setup an irq handler for over-current detection */
580 	irq = of_irq_get(config.of_node, 0);
581 	if (irq > 0) {
582 		ret = devm_request_threaded_irq(&pdev->dev,
583 						irq, NULL,
584 						stpmic1_curlim_irq_handler,
585 						IRQF_ONESHOT | IRQF_SHARED,
586 						pdev->name, rdev);
587 		if (ret) {
588 			dev_err(&pdev->dev, "Request IRQ failed\n");
589 			return ret;
590 		}
591 	}
592 	return 0;
593 }
594 
595 static int stpmic1_regulator_probe(struct platform_device *pdev)
596 {
597 	int i, ret;
598 
599 	ret = of_regulator_match(&pdev->dev, pdev->dev.of_node, stpmic1_matches,
600 				 ARRAY_SIZE(stpmic1_matches));
601 	if (ret < 0) {
602 		dev_err(&pdev->dev,
603 			"Error in PMIC regulator device tree node");
604 		return ret;
605 	}
606 
607 	for (i = 0; i < ARRAY_SIZE(stpmic1_regulator_cfgs); i++) {
608 		ret = stpmic1_regulator_register(pdev, i, &stpmic1_matches[i],
609 						 &stpmic1_regulator_cfgs[i]);
610 		if (ret < 0)
611 			return ret;
612 	}
613 
614 	dev_dbg(&pdev->dev, "stpmic1_regulator driver probed\n");
615 
616 	return 0;
617 }
618 
619 static const struct of_device_id of_pmic_regulator_match[] = {
620 	{ .compatible = "st,stpmic1-regulators" },
621 	{ },
622 };
623 
624 MODULE_DEVICE_TABLE(of, of_pmic_regulator_match);
625 
626 static struct platform_driver stpmic1_regulator_driver = {
627 	.driver = {
628 		.name = "stpmic1-regulator",
629 		.of_match_table = of_match_ptr(of_pmic_regulator_match),
630 	},
631 	.probe = stpmic1_regulator_probe,
632 };
633 
634 module_platform_driver(stpmic1_regulator_driver);
635 
636 MODULE_DESCRIPTION("STPMIC1 PMIC voltage regulator driver");
637 MODULE_AUTHOR("Pascal Paillet <p.paillet@st.com>");
638 MODULE_LICENSE("GPL v2");
639