xref: /linux/drivers/regulator/rtq2208-regulator.c (revision 21d1ccf0e97d533d5dee470f5adce45358a0f996)
1 // SPDX-License-Identifier: GPL-2.0+
2 
3 #include <linux/bitops.h>
4 #include <linux/bitfield.h>
5 #include <linux/util_macros.h>
6 #include <linux/module.h>
7 #include <linux/i2c.h>
8 #include <linux/regmap.h>
9 #include <linux/regulator/driver.h>
10 #include <linux/regulator/machine.h>
11 #include <linux/regulator/of_regulator.h>
12 #include <linux/mod_devicetable.h>
13 
14 /* Register */
15 #define RTQ2208_REG_GLOBAL_INT1			0x12
16 #define RTQ2208_REG_FLT_RECORDBUCK_CB		0x18
17 #define RTQ2208_REG_GLOBAL_INT1_MASK		0x1D
18 #define RTQ2208_REG_FLT_MASKBUCK_CB		0x1F
19 #define RTQ2208_REG_BUCK_C_CFG0			0x32
20 #define RTQ2208_REG_BUCK_B_CFG0			0x42
21 #define RTQ2208_REG_BUCK_A_CFG0			0x52
22 #define RTQ2208_REG_BUCK_D_CFG0			0x62
23 #define RTQ2208_REG_BUCK_G_CFG0			0x72
24 #define RTQ2208_REG_BUCK_F_CFG0			0x82
25 #define RTQ2208_REG_BUCK_E_CFG0			0x92
26 #define RTQ2208_REG_BUCK_H_CFG0			0xA2
27 #define RTQ2208_REG_LDO1_CFG			0xB1
28 #define RTQ2208_REG_LDO2_CFG			0xC1
29 #define RTQ2208_REG_LDO_DVS_CTRL		0xD0
30 #define RTQ2208_REG_HIDDEN_BUCKPH		0x55
31 #define RTQ2208_REG_HIDDEN_LDOCFG0		0x8F
32 #define RTQ2208_REG_HIDDEN_LDOCFG1		0x96
33 #define RTQ2208_REG_HIDDEN0			0xFE
34 #define RTQ2208_REG_HIDDEN1			0xFF
35 
36 /* Mask */
37 #define RTQ2208_BUCK_NR_MTP_SEL_MASK		GENMASK(7, 0)
38 #define RTQ2208_BUCK_EN_NR_MTP_SEL0_MASK	BIT(0)
39 #define RTQ2208_BUCK_EN_NR_MTP_SEL1_MASK	BIT(1)
40 #define RTQ2208_BUCK_RSPUP_MASK			GENMASK(6, 4)
41 #define RTQ2208_BUCK_RSPDN_MASK			GENMASK(2, 0)
42 #define RTQ2208_BUCK_NRMODE_MASK		BIT(5)
43 #define RTQ2208_BUCK_STRMODE_MASK		BIT(5)
44 #define RTQ2208_BUCK_EN_STR_MASK		BIT(0)
45 #define RTQ2208_LDO_EN_STR_MASK			BIT(7)
46 #define RTQ2208_EN_DIS_MASK			BIT(0)
47 #define RTQ2208_BUCK_RAMP_SEL_MASK		GENMASK(2, 0)
48 #define RTQ2208_HD_INT_MASK			BIT(0)
49 #define RTQ2208_LDO1_DISCHG_EN_MASK		BIT(4)
50 #define RTQ2208_LDO1_VOSEL_SD_MASK		BIT(5)
51 #define RTQ2208_LDO2_DISCHG_EN_MASK		BIT(6)
52 #define RTQ2208_LDO2_VOSEL_SD_MASK		BIT(7)
53 #define RTQ2208_MASK_BUCKPH_GROUP1		GENMASK(6, 4)
54 #define RTQ2208_MASK_BUCKPH_GROUP2		GENMASK(2, 0)
55 #define RTQ2208_MASK_LDO2_OPT0			BIT(7)
56 #define RTQ2208_MASK_LDO2_OPT1			BIT(6)
57 #define RTQ2208_MASK_LDO1_FIXED			BIT(6)
58 
59 /* Size */
60 #define RTQ2208_VOUT_MAXNUM			256
61 #define RTQ2208_BUCK_NUM_IRQ_REGS		5
62 #define RTQ2208_STS_NUM_IRQ_REGS		2
63 
64 /* Value */
65 #define RTQ2208_RAMP_VALUE_MIN_uV		500
66 #define RTQ2208_RAMP_VALUE_MAX_uV		16000
67 
68 #define RTQ2208_BUCK_MASK(uv_irq, ov_irq)	(1 << ((uv_irq) % 8) | 1 << ((ov_irq) % 8))
69 
70 enum {
71 	RTQ2208_BUCK_B = 0,
72 	RTQ2208_BUCK_C,
73 	RTQ2208_BUCK_D,
74 	RTQ2208_BUCK_A,
75 	RTQ2208_BUCK_F,
76 	RTQ2208_BUCK_G,
77 	RTQ2208_BUCK_H,
78 	RTQ2208_BUCK_E,
79 	RTQ2208_LDO2,
80 	RTQ2208_LDO1,
81 	RTQ2208_LDO_MAX,
82 };
83 
84 enum {
85 	RTQ2208_AUTO_MODE = 0,
86 	RTQ2208_FCCM,
87 };
88 
89 struct rtq2208_regulator_desc {
90 	struct regulator_desc desc;
91 	unsigned int mtp_sel_reg;
92 	unsigned int mtp_sel_mask;
93 	unsigned int mode_reg;
94 	unsigned int mode_mask;
95 	unsigned int suspend_config_reg;
96 	unsigned int suspend_enable_mask;
97 	unsigned int suspend_mode_mask;
98 };
99 
100 struct rtq2208_rdev_map {
101 	struct regulator_dev *rdev[RTQ2208_LDO_MAX];
102 	struct regmap *regmap;
103 	struct device *dev;
104 };
105 
106 /* set Normal Auto/FCCM mode */
rtq2208_set_mode(struct regulator_dev * rdev,unsigned int mode)107 static int rtq2208_set_mode(struct regulator_dev *rdev, unsigned int mode)
108 {
109 	const struct rtq2208_regulator_desc *rdesc =
110 		(const struct rtq2208_regulator_desc *)rdev->desc;
111 	unsigned int val, shift;
112 
113 	switch (mode) {
114 	case REGULATOR_MODE_NORMAL:
115 		val = RTQ2208_AUTO_MODE;
116 		break;
117 	case REGULATOR_MODE_FAST:
118 		val = RTQ2208_FCCM;
119 		break;
120 	default:
121 		return -EINVAL;
122 	}
123 
124 	shift = ffs(rdesc->mode_mask) - 1;
125 	return regmap_update_bits(rdev->regmap, rdesc->mode_reg,
126 				  rdesc->mode_mask, val << shift);
127 }
128 
rtq2208_get_mode(struct regulator_dev * rdev)129 static unsigned int rtq2208_get_mode(struct regulator_dev *rdev)
130 {
131 	const struct rtq2208_regulator_desc *rdesc =
132 		(const struct rtq2208_regulator_desc *)rdev->desc;
133 	unsigned int mode_val;
134 	int ret;
135 
136 	ret = regmap_read(rdev->regmap, rdesc->mode_reg, &mode_val);
137 	if (ret)
138 		return REGULATOR_MODE_INVALID;
139 
140 	return (mode_val & rdesc->mode_mask) ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
141 }
142 
rtq2208_set_ramp_delay(struct regulator_dev * rdev,int ramp_delay)143 static int rtq2208_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
144 {
145 	const struct regulator_desc *desc = rdev->desc;
146 	unsigned int sel = 0, val;
147 
148 	ramp_delay = max(ramp_delay, RTQ2208_RAMP_VALUE_MIN_uV);
149 	ramp_delay = min(ramp_delay, RTQ2208_RAMP_VALUE_MAX_uV);
150 
151 	ramp_delay /= RTQ2208_RAMP_VALUE_MIN_uV;
152 
153 	/*
154 	 * fls(ramp_delay) - 1: doing LSB shift, let it starts from 0
155 	 *
156 	 * RTQ2208_BUCK_RAMP_SEL_MASK - sel: doing descending order shifting.
157 	 * Because the relation of seleltion and value is like that
158 	 *
159 	 * seletion: value
160 	 * 010: 16mv
161 	 * ...
162 	 * 111: 0.5mv
163 	 *
164 	 * For example, if I would like to select 16mv, the fls(ramp_delay) - 1 will be 0b010,
165 	 * and I need to use 0b111 - sel to do the shifting
166 	 */
167 
168 	sel = fls(ramp_delay) - 1;
169 	sel = RTQ2208_BUCK_RAMP_SEL_MASK - sel;
170 
171 	val = FIELD_PREP(RTQ2208_BUCK_RSPUP_MASK, sel) | FIELD_PREP(RTQ2208_BUCK_RSPDN_MASK, sel);
172 
173 	return regmap_update_bits(rdev->regmap, desc->ramp_reg,
174 				  RTQ2208_BUCK_RSPUP_MASK | RTQ2208_BUCK_RSPDN_MASK, val);
175 }
176 
rtq2208_set_suspend_enable(struct regulator_dev * rdev)177 static int rtq2208_set_suspend_enable(struct regulator_dev *rdev)
178 {
179 	const struct rtq2208_regulator_desc *rdesc =
180 		(const struct rtq2208_regulator_desc *)rdev->desc;
181 
182 	return regmap_set_bits(rdev->regmap, rdesc->suspend_config_reg, rdesc->suspend_enable_mask);
183 }
184 
rtq2208_set_suspend_disable(struct regulator_dev * rdev)185 static int rtq2208_set_suspend_disable(struct regulator_dev *rdev)
186 {
187 	const struct rtq2208_regulator_desc *rdesc =
188 		(const struct rtq2208_regulator_desc *)rdev->desc;
189 
190 	return regmap_update_bits(rdev->regmap, rdesc->suspend_config_reg, rdesc->suspend_enable_mask, 0);
191 }
192 
rtq2208_set_suspend_mode(struct regulator_dev * rdev,unsigned int mode)193 static int rtq2208_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode)
194 {
195 	const struct rtq2208_regulator_desc *rdesc =
196 		(const struct rtq2208_regulator_desc *)rdev->desc;
197 	unsigned int val, shift;
198 
199 	switch (mode) {
200 	case REGULATOR_MODE_NORMAL:
201 		val = RTQ2208_AUTO_MODE;
202 		break;
203 	case REGULATOR_MODE_FAST:
204 		val = RTQ2208_FCCM;
205 		break;
206 	default:
207 		return -EINVAL;
208 	}
209 
210 	shift = ffs(rdesc->suspend_mode_mask) - 1;
211 
212 	return regmap_update_bits(rdev->regmap, rdesc->suspend_config_reg,
213 			rdesc->suspend_mode_mask, val << shift);
214 }
215 
216 static const struct regulator_ops rtq2208_regulator_buck_ops = {
217 	.enable = regulator_enable_regmap,
218 	.disable = regulator_disable_regmap,
219 	.is_enabled = regulator_is_enabled_regmap,
220 	.list_voltage = regulator_list_voltage_linear_range,
221 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
222 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
223 	.set_mode = rtq2208_set_mode,
224 	.get_mode = rtq2208_get_mode,
225 	.set_ramp_delay = rtq2208_set_ramp_delay,
226 	.set_active_discharge = regulator_set_active_discharge_regmap,
227 	.set_suspend_enable = rtq2208_set_suspend_enable,
228 	.set_suspend_disable = rtq2208_set_suspend_disable,
229 	.set_suspend_mode = rtq2208_set_suspend_mode,
230 };
231 
232 static const struct regulator_ops rtq2208_regulator_ldo_fix_ops = {
233 	.enable = regulator_enable_regmap,
234 	.disable = regulator_disable_regmap,
235 	.is_enabled = regulator_is_enabled_regmap,
236 	.set_active_discharge = regulator_set_active_discharge_regmap,
237 	.set_suspend_enable = rtq2208_set_suspend_enable,
238 	.set_suspend_disable = rtq2208_set_suspend_disable,
239 };
240 
241 static const struct regulator_ops rtq2208_regulator_ldo_adj_ops = {
242 	.enable = regulator_enable_regmap,
243 	.disable = regulator_disable_regmap,
244 	.is_enabled = regulator_is_enabled_regmap,
245 	.list_voltage = regulator_list_voltage_table,
246 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
247 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
248 	.set_active_discharge = regulator_set_active_discharge_regmap,
249 	.set_suspend_enable = rtq2208_set_suspend_enable,
250 	.set_suspend_disable = rtq2208_set_suspend_disable,
251 };
252 
253 static const unsigned int rtq2208_ldo_volt_table[] = {
254 	1800000,
255 	3300000,
256 };
257 
rtq2208_of_map_mode(unsigned int mode)258 static unsigned int rtq2208_of_map_mode(unsigned int mode)
259 {
260 	switch (mode) {
261 	case RTQ2208_AUTO_MODE:
262 		return REGULATOR_MODE_NORMAL;
263 	case RTQ2208_FCCM:
264 		return REGULATOR_MODE_FAST;
265 	default:
266 		return REGULATOR_MODE_INVALID;
267 	}
268 }
269 
rtq2208_init_irq_mask(struct rtq2208_rdev_map * rdev_map,unsigned int * buck_masks)270 static int rtq2208_init_irq_mask(struct rtq2208_rdev_map *rdev_map, unsigned int *buck_masks)
271 {
272 	unsigned char buck_clr_masks[5] = {0x33, 0x33, 0x33, 0x33, 0x33},
273 		      sts_clr_masks[2] = {0xE7, 0xF7}, sts_masks[2] = {0xE6, 0xF6};
274 	int ret;
275 
276 	/* write clear all buck irq once */
277 	ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, buck_clr_masks, 5);
278 	if (ret)
279 		return dev_err_probe(rdev_map->dev, ret, "Failed to clr buck irqs\n");
280 
281 	/* write clear general irq once */
282 	ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, sts_clr_masks, 2);
283 	if (ret)
284 		return dev_err_probe(rdev_map->dev, ret, "Failed to clr general irqs\n");
285 
286 	/* unmask buck ov/uv irq */
287 	ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_MASKBUCK_CB, buck_masks, 5);
288 	if (ret)
289 		return dev_err_probe(rdev_map->dev, ret, "Failed to unmask buck irqs\n");
290 
291 	/* unmask needed general irq */
292 	return regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1_MASK, sts_masks, 2);
293 }
294 
rtq2208_irq_handler(int irqno,void * devid)295 static irqreturn_t rtq2208_irq_handler(int irqno, void *devid)
296 {
297 	unsigned char buck_flags[RTQ2208_BUCK_NUM_IRQ_REGS], sts_flags[RTQ2208_STS_NUM_IRQ_REGS];
298 	int ret = 0, i, uv_bit, ov_bit;
299 	struct rtq2208_rdev_map *rdev_map = devid;
300 	struct regulator_dev *rdev;
301 
302 	if (!rdev_map)
303 		return IRQ_NONE;
304 
305 	/* read irq event */
306 	ret = regmap_bulk_read(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB,
307 				buck_flags, ARRAY_SIZE(buck_flags));
308 	if (ret)
309 		return IRQ_NONE;
310 
311 	ret = regmap_bulk_read(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1,
312 				sts_flags, ARRAY_SIZE(sts_flags));
313 	if (ret)
314 		return IRQ_NONE;
315 
316 	/* clear irq event */
317 	ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB,
318 				buck_flags, ARRAY_SIZE(buck_flags));
319 	if (ret)
320 		return IRQ_NONE;
321 
322 	ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1,
323 				sts_flags, ARRAY_SIZE(sts_flags));
324 	if (ret)
325 		return IRQ_NONE;
326 
327 	for (i = 0; i < RTQ2208_LDO_MAX; i++) {
328 		if (!rdev_map->rdev[i])
329 			continue;
330 
331 		rdev = rdev_map->rdev[i];
332 		/* uv irq */
333 		uv_bit = (i & 1) ? 4 : 0;
334 		if (buck_flags[i >> 1] & (1 << uv_bit))
335 			regulator_notifier_call_chain(rdev,
336 					REGULATOR_EVENT_UNDER_VOLTAGE, NULL);
337 		/* ov irq */
338 		ov_bit = uv_bit + 1;
339 		if (buck_flags[i >> 1] & (1 << ov_bit))
340 			regulator_notifier_call_chain(rdev,
341 					REGULATOR_EVENT_REGULATION_OUT, NULL);
342 
343 		/* hd irq */
344 		if (sts_flags[1] & RTQ2208_HD_INT_MASK)
345 			regulator_notifier_call_chain(rdev,
346 					REGULATOR_EVENT_OVER_TEMP, NULL);
347 	}
348 
349 	return IRQ_HANDLED;
350 }
351 
352 #define BUCK_INFO(_name, _id)						\
353 {									\
354 	.name = _name,							\
355 	.base = RTQ2208_REG_BUCK_##_id##_CFG0,				\
356 	.enable_reg = BUCK_RG_SHIFT(RTQ2208_REG_BUCK_##_id##_CFG0, 2),	\
357 	.dis_reg = RTQ2208_REG_BUCK_##_id##_CFG0,			\
358 }
359 
360 #define LDO_INFO(_name, _id)						\
361 {									\
362 	.name = _name,							\
363 	.base = RTQ2208_REG_LDO##_id##_CFG,				\
364 	.enable_reg = RTQ2208_REG_LDO##_id##_CFG,			\
365 	.dis_mask = RTQ2208_LDO##_id##_DISCHG_EN_MASK,			\
366 	.dis_on = RTQ2208_LDO##_id##_DISCHG_EN_MASK,			\
367 	.vsel_mask = RTQ2208_LDO##_id##_VOSEL_SD_MASK,			\
368 }
369 
370 #define BUCK_RG_SHIFT(_base, _shift)	(_base + _shift)
371 #define	VSEL_SHIFT(_sel)	(_sel ? 3 : 1)
372 #define MTP_SEL_MASK(_sel)	RTQ2208_BUCK_EN_NR_MTP_SEL##_sel##_MASK
373 
374 static const struct linear_range rtq2208_vout_range[] = {
375 	REGULATOR_LINEAR_RANGE(400000, 0, 180, 5000),
376 	REGULATOR_LINEAR_RANGE(1310000, 181, 255, 10000),
377 };
378 
rtq2208_init_regulator_desc(struct rtq2208_regulator_desc * rdesc,int mtp_sel,int idx,unsigned int ldo1_fixed,unsigned int ldo2_fixed)379 static void rtq2208_init_regulator_desc(struct rtq2208_regulator_desc *rdesc, int mtp_sel, int idx,
380 					unsigned int ldo1_fixed, unsigned int ldo2_fixed)
381 {
382 	struct regulator_desc *desc;
383 	unsigned int fixed_uV;
384 	static const struct {
385 		char *name;
386 		int base;
387 		int enable_reg;
388 		int dis_reg;
389 		int dis_mask;
390 		int dis_on;
391 		int vsel_mask;
392 	} regulator_info[] = {
393 		BUCK_INFO("buck-b", B),
394 		BUCK_INFO("buck-c", C),
395 		BUCK_INFO("buck-d", D),
396 		BUCK_INFO("buck-a", A),
397 		BUCK_INFO("buck-f", F),
398 		BUCK_INFO("buck-g", G),
399 		BUCK_INFO("buck-h", H),
400 		BUCK_INFO("buck-e", E),
401 		LDO_INFO("ldo2", 2),
402 		LDO_INFO("ldo1", 1),
403 	}, *curr_info;
404 
405 	curr_info = regulator_info + idx;
406 	desc = &rdesc->desc;
407 	desc->name = curr_info->name;
408 	desc->of_match = of_match_ptr(curr_info->name);
409 	desc->regulators_node = of_match_ptr("regulators");
410 	desc->id = idx;
411 	desc->owner = THIS_MODULE;
412 	desc->type = REGULATOR_VOLTAGE;
413 	desc->enable_mask = mtp_sel ? MTP_SEL_MASK(1) : MTP_SEL_MASK(0);
414 	desc->enable_reg = curr_info->enable_reg;
415 	desc->active_discharge_off = 0;
416 
417 	rdesc->mode_mask = RTQ2208_BUCK_NRMODE_MASK;
418 
419 	switch (idx) {
420 	case RTQ2208_BUCK_B ... RTQ2208_BUCK_E:
421 		/* init buck desc */
422 		desc->ops = &rtq2208_regulator_buck_ops;
423 		desc->vsel_reg = curr_info->base + VSEL_SHIFT(mtp_sel);
424 		desc->vsel_mask = RTQ2208_BUCK_NR_MTP_SEL_MASK;
425 		desc->n_voltages = RTQ2208_VOUT_MAXNUM;
426 		desc->linear_ranges = rtq2208_vout_range;
427 		desc->n_linear_ranges = ARRAY_SIZE(rtq2208_vout_range);
428 		desc->ramp_reg = BUCK_RG_SHIFT(curr_info->base, 5);
429 		desc->of_map_mode = rtq2208_of_map_mode;
430 		desc->active_discharge_reg = curr_info->dis_reg;
431 		desc->active_discharge_on = RTQ2208_EN_DIS_MASK;
432 		desc->active_discharge_mask = RTQ2208_EN_DIS_MASK;
433 
434 		rdesc->mode_reg = BUCK_RG_SHIFT(curr_info->base, 2);
435 		rdesc->suspend_config_reg = BUCK_RG_SHIFT(curr_info->base, 4);
436 		rdesc->suspend_enable_mask = RTQ2208_BUCK_EN_STR_MASK;
437 		rdesc->suspend_mode_mask = RTQ2208_BUCK_STRMODE_MASK;
438 		break;
439 	default:
440 		fixed_uV = idx == RTQ2208_LDO2 ? ldo2_fixed : ldo1_fixed;
441 		if (fixed_uV) {
442 			desc->n_voltages = 1;
443 			desc->fixed_uV = fixed_uV;
444 			desc->ops = &rtq2208_regulator_ldo_fix_ops;
445 		} else {
446 			desc->n_voltages = ARRAY_SIZE(rtq2208_ldo_volt_table);
447 			desc->volt_table = rtq2208_ldo_volt_table;
448 			desc->ops = &rtq2208_regulator_ldo_adj_ops;
449 		}
450 
451 		/* init ldo desc */
452 		desc->active_discharge_reg = RTQ2208_REG_LDO_DVS_CTRL;
453 		desc->active_discharge_on = curr_info->dis_on;
454 		desc->active_discharge_mask = curr_info->dis_mask;
455 		desc->vsel_reg = RTQ2208_REG_LDO_DVS_CTRL;
456 		desc->vsel_mask = curr_info->vsel_mask;
457 
458 		rdesc->suspend_config_reg = curr_info->base;
459 		rdesc->suspend_enable_mask = RTQ2208_LDO_EN_STR_MASK;
460 		break;
461 	}
462 }
463 
rtq2208_parse_regulator_dt_data(int n_regulator,const unsigned int * regulator_idx_table,struct rtq2208_regulator_desc * rdesc[RTQ2208_LDO_MAX],struct device * dev,unsigned int ldo1_fixed,unsigned int ldo2_fixed)464 static int rtq2208_parse_regulator_dt_data(int n_regulator, const unsigned int *regulator_idx_table,
465 		struct rtq2208_regulator_desc *rdesc[RTQ2208_LDO_MAX], struct device *dev,
466 		unsigned int ldo1_fixed, unsigned int ldo2_fixed)
467 {
468 	int mtp_sel, i, idx;
469 
470 	/* get mtp_sel0 or mtp_sel1 */
471 	mtp_sel = device_property_read_bool(dev, "richtek,mtp-sel-high");
472 
473 	for (i = 0; i < n_regulator; i++) {
474 		idx = regulator_idx_table[i];
475 
476 		rdesc[i] = devm_kcalloc(dev, 1, sizeof(*rdesc[0]), GFP_KERNEL);
477 		if (!rdesc[i])
478 			return -ENOMEM;
479 
480 		rtq2208_init_regulator_desc(rdesc[i], mtp_sel, idx, ldo1_fixed, ldo2_fixed);
481 	}
482 
483 	return 0;
484 
485 }
486 
rtq2208_regulator_check(struct device * dev,int * num,int * regulator_idx_table,unsigned int * buck_masks,unsigned int * ldo1_fixed_uV,unsigned int * ldo2_fixed_uV)487 static int rtq2208_regulator_check(struct device *dev, int *num, int *regulator_idx_table,
488 				   unsigned int *buck_masks, unsigned int *ldo1_fixed_uV,
489 				   unsigned int *ldo2_fixed_uV)
490 {
491 	struct regmap *regmap = dev_get_regmap(dev, NULL);
492 	bool rtq2208_used_table[RTQ2208_LDO_MAX] = {0};
493 	u8 entry_key[] = { 0x69, 0x01 };
494 	unsigned int buck_phase, ldo_cfg0, ldo_cfg1;
495 	int i, ret;
496 	u8 mask;
497 
498 	ret = regmap_raw_write(regmap, RTQ2208_REG_HIDDEN0, entry_key, ARRAY_SIZE(entry_key));
499 	if (ret)
500 		return dev_err_probe(dev, ret, "Failed to enter hidden page\n");
501 
502 	ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_BUCKPH, &buck_phase);
503 	if (ret)
504 		return dev_err_probe(dev, ret, "Failed to read buck phase configuration\n");
505 
506 	ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_LDOCFG0, &ldo_cfg0);
507 	if (ret)
508 		return dev_err_probe(dev, ret, "Failed to read ldo cfg0\n");
509 
510 	ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_LDOCFG1, &ldo_cfg1);
511 	if (ret)
512 		return dev_err_probe(dev, ret, "Failed to read ldo cfg1\n");
513 
514 	ret = regmap_write(regmap, RTQ2208_REG_HIDDEN1, 0x00);
515 	if (ret)
516 		return dev_err_probe(dev, ret, "Failed to exit hidden page\n");
517 
518 	dev_info(dev, "BUCK Phase 0x%x\n", buck_phase);
519 	/*
520 	 * Use buck phase configuration to assign used table mask
521 	 *                                 GROUP1       GROUP2
522 	 * 0      -> 2P + 2P                BC           FG
523 	 * 1      -> 2P + 1P + 1P           BCA          FGE
524 	 * 2      -> 1P + 1P + 1P + 1P      BCDA         FGHE
525 	 * 3      -> 3P + 1P                BC           FG
526 	 * others -> 4P                     C            G
527 	 */
528 	switch (FIELD_GET(RTQ2208_MASK_BUCKPH_GROUP1, buck_phase)) {
529 	case 2:
530 		rtq2208_used_table[RTQ2208_BUCK_D] = true;
531 		fallthrough;
532 	case 1:
533 		rtq2208_used_table[RTQ2208_BUCK_A] = true;
534 		fallthrough;
535 	case 0:
536 	case 3:
537 		rtq2208_used_table[RTQ2208_BUCK_B] = true;
538 		fallthrough;
539 	default:
540 		rtq2208_used_table[RTQ2208_BUCK_C] = true;
541 		break;
542 	}
543 
544 	switch (FIELD_GET(RTQ2208_MASK_BUCKPH_GROUP2, buck_phase)) {
545 	case 2:
546 		rtq2208_used_table[RTQ2208_BUCK_F] = true;
547 		fallthrough;
548 	case 1:
549 		rtq2208_used_table[RTQ2208_BUCK_E] = true;
550 		fallthrough;
551 	case 0:
552 	case 3:
553 		rtq2208_used_table[RTQ2208_BUCK_H] = true;
554 		fallthrough;
555 	default:
556 		rtq2208_used_table[RTQ2208_BUCK_G] = true;
557 		break;
558 	}
559 
560 	*ldo1_fixed_uV = FIELD_GET(RTQ2208_MASK_LDO1_FIXED, ldo_cfg1) ? 1200000 : 0;
561 
562 	if (!FIELD_GET(RTQ2208_MASK_LDO2_OPT0, ldo_cfg0) &&
563 	    !FIELD_GET(RTQ2208_MASK_LDO2_OPT1, ldo_cfg1))
564 		*ldo2_fixed_uV = 0;
565 	else if (FIELD_GET(RTQ2208_MASK_LDO2_OPT1, ldo_cfg1))
566 		*ldo2_fixed_uV = 900000;
567 	else
568 		*ldo2_fixed_uV = 1200000;
569 
570 	/* By default, LDO1 & LDO2 are always used */
571 	rtq2208_used_table[RTQ2208_LDO1] = rtq2208_used_table[RTQ2208_LDO2] = true;
572 
573 	for (i = 0; i < RTQ2208_LDO_MAX; i++) {
574 		if (!rtq2208_used_table[i])
575 			continue;
576 
577 		regulator_idx_table[(*num)++] = i;
578 
579 		mask = RTQ2208_BUCK_MASK(4 * i, 4 * i + 1);
580 		buck_masks[i >> 1] &= ~mask;
581 	}
582 
583 	return 0;
584 }
585 
586 static const struct regmap_config rtq2208_regmap_config = {
587 	.reg_bits = 8,
588 	.val_bits = 8,
589 	.max_register = 0xFF,
590 };
591 
rtq2208_probe(struct i2c_client * i2c)592 static int rtq2208_probe(struct i2c_client *i2c)
593 {
594 	struct device *dev = &i2c->dev;
595 	struct regmap *regmap;
596 	struct rtq2208_regulator_desc *rdesc[RTQ2208_LDO_MAX];
597 	struct regulator_dev *rdev;
598 	struct regulator_config cfg = {};
599 	struct rtq2208_rdev_map *rdev_map;
600 	int i, ret = 0, idx, n_regulator = 0;
601 	unsigned int regulator_idx_table[RTQ2208_LDO_MAX],
602 		     buck_masks[RTQ2208_BUCK_NUM_IRQ_REGS] = {0x33, 0x33, 0x33, 0x33, 0x33};
603 	unsigned int ldo1_fixed_uV, ldo2_fixed_uV;
604 
605 	rdev_map = devm_kzalloc(dev, sizeof(struct rtq2208_rdev_map), GFP_KERNEL);
606 	if (!rdev_map)
607 		return -ENOMEM;
608 
609 	regmap = devm_regmap_init_i2c(i2c, &rtq2208_regmap_config);
610 	if (IS_ERR(regmap))
611 		return dev_err_probe(dev, PTR_ERR(regmap), "Failed to allocate regmap\n");
612 
613 	/* get needed regulator */
614 	ret = rtq2208_regulator_check(dev, &n_regulator, regulator_idx_table, buck_masks,
615 				      &ldo1_fixed_uV, &ldo2_fixed_uV);
616 	if (ret)
617 		return dev_err_probe(dev, ret, "Failed to check used regulators\n");
618 
619 	rdev_map->regmap = regmap;
620 	rdev_map->dev = dev;
621 
622 	cfg.dev = dev;
623 
624 	/* init regulator desc */
625 	ret = rtq2208_parse_regulator_dt_data(n_regulator, regulator_idx_table, rdesc, dev,
626 					      ldo1_fixed_uV, ldo2_fixed_uV);
627 	if (ret)
628 		return ret;
629 
630 	for (i = 0; i < n_regulator; i++) {
631 		idx = regulator_idx_table[i];
632 
633 		/* register regulator */
634 		rdev = devm_regulator_register(dev, &rdesc[i]->desc, &cfg);
635 		if (IS_ERR(rdev))
636 			return PTR_ERR(rdev);
637 
638 		rdev_map->rdev[idx] = rdev;
639 	}
640 
641 	/* init interrupt mask */
642 	ret = rtq2208_init_irq_mask(rdev_map, buck_masks);
643 	if (ret)
644 		return ret;
645 
646 	/* register interrupt */
647 	return devm_request_threaded_irq(dev, i2c->irq, NULL, rtq2208_irq_handler,
648 					IRQF_ONESHOT, dev_name(dev), rdev_map);
649 }
650 
651 static const struct of_device_id rtq2208_device_tables[] = {
652 	{ .compatible = "richtek,rtq2208" },
653 	{}
654 };
655 MODULE_DEVICE_TABLE(of, rtq2208_device_tables);
656 
657 static struct i2c_driver rtq2208_driver = {
658 	.driver = {
659 		.name = "rtq2208",
660 		.of_match_table = rtq2208_device_tables,
661 	},
662 	.probe = rtq2208_probe,
663 };
664 module_i2c_driver(rtq2208_driver);
665 
666 MODULE_AUTHOR("Alina Yu <alina_yu@richtek.com>");
667 MODULE_DESCRIPTION("Richtek RTQ2208 Regulator Driver");
668 MODULE_LICENSE("GPL");
669