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