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