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 | |
55 | enum { |
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 | |
69 | enum { |
70 | RTQ2208_AUTO_MODE = 0, |
71 | RTQ2208_FCCM, |
72 | }; |
73 | |
74 | struct 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 | |
85 | struct 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 */ |
92 | static 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(map: rdev->regmap, reg: rdesc->mode_reg, |
111 | mask: rdesc->mode_mask, val: val << shift); |
112 | } |
113 | |
114 | static 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(map: rdev->regmap, reg: rdesc->mode_reg, val: &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 | |
128 | static 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(x: 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(map: rdev->regmap, reg: desc->ramp_reg, |
160 | RTQ2208_BUCK_RSPUP_MASK | RTQ2208_BUCK_RSPDN_MASK, val); |
161 | } |
162 | |
163 | static 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(map: rdev->regmap, reg: rdesc->suspend_config_reg, bits: rdesc->suspend_enable_mask); |
169 | } |
170 | |
171 | static 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(map: rdev->regmap, reg: rdesc->suspend_config_reg, mask: rdesc->suspend_enable_mask, val: 0); |
177 | } |
178 | |
179 | static 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(map: rdev->regmap, reg: rdesc->suspend_config_reg, |
199 | mask: rdesc->suspend_mode_mask, val: val << shift); |
200 | } |
201 | |
202 | static 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 | |
218 | static 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 | |
227 | static 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 | |
239 | static 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(map: rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, val: buck_clr_masks, val_count: 5); |
247 | if (ret) |
248 | return dev_err_probe(dev: rdev_map->dev, err: ret, fmt: "Failed to clr buck irqs\n" ); |
249 | |
250 | /* write clear general irq once */ |
251 | ret = regmap_bulk_write(map: rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, val: sts_clr_masks, val_count: 2); |
252 | if (ret) |
253 | return dev_err_probe(dev: rdev_map->dev, err: ret, fmt: "Failed to clr general irqs\n" ); |
254 | |
255 | /* unmask buck ov/uv irq */ |
256 | ret = regmap_bulk_write(map: rdev_map->regmap, RTQ2208_REG_FLT_MASKBUCK_CB, val: buck_masks, val_count: 5); |
257 | if (ret) |
258 | return dev_err_probe(dev: rdev_map->dev, err: ret, fmt: "Failed to unmask buck irqs\n" ); |
259 | |
260 | /* unmask needed general irq */ |
261 | return regmap_bulk_write(map: rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1_MASK, val: sts_masks, val_count: 2); |
262 | } |
263 | |
264 | static 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(map: rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, |
276 | val: buck_flags, ARRAY_SIZE(buck_flags)); |
277 | if (ret) |
278 | return IRQ_NONE; |
279 | |
280 | ret = regmap_bulk_read(map: rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, |
281 | val: sts_flags, ARRAY_SIZE(sts_flags)); |
282 | if (ret) |
283 | return IRQ_NONE; |
284 | |
285 | /* clear irq event */ |
286 | ret = regmap_bulk_write(map: rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, |
287 | val: buck_flags, ARRAY_SIZE(buck_flags)); |
288 | if (ret) |
289 | return IRQ_NONE; |
290 | |
291 | ret = regmap_bulk_write(map: rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, |
292 | val: 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 | |
333 | static 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 | |
338 | static 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(node: dev->of_node, name: "regulators" ); |
351 | if (!np) |
352 | np = dev->of_node; |
353 | |
354 | ret = of_regulator_match(dev, node: np, matches: rtq2208_ldo_match, num_matches: n_fixed); |
355 | |
356 | of_node_put(node: 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 | |
376 | static 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 | |
444 | static 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, propname: "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, n: 1, size: sizeof(*rdesc[0]), GFP_KERNEL); |
457 | if (!rdesc[i]) |
458 | return -ENOMEM; |
459 | |
460 | rtq2208_init_regulator_desc(rdesc: rdesc[i], mtp_sel, idx, rtq2208_ldo_match, ldo_idx: &ldo_idx); |
461 | } |
462 | |
463 | /* init ldo fixed_uV */ |
464 | ret = rtq2208_of_get_fixed_voltage(dev, rtq2208_ldo_match, n_fixed: ldo_idx); |
465 | if (ret) |
466 | return dev_err_probe(dev, err: ret, fmt: "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 | */ |
477 | static 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 | |
504 | static const struct regmap_config rtq2208_regmap_config = { |
505 | .reg_bits = 8, |
506 | .val_bits = 8, |
507 | .max_register = 0xEF, |
508 | }; |
509 | |
510 | static 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, size: 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(ptr: regmap)) |
528 | return dev_err_probe(dev, err: PTR_ERR(ptr: regmap), fmt: "Failed to allocate regmap\n" ); |
529 | |
530 | /* get needed regulator */ |
531 | ret = rtq2208_regulator_check(slave_addr: i2c->addr, num: &n_regulator, regulator_idx_table, buck_masks); |
532 | if (ret) |
533 | return dev_err_probe(dev, err: ret, fmt: "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, regulator_desc: &rdesc[i]->desc, config: &cfg); |
550 | if (IS_ERR(ptr: rdev)) |
551 | return PTR_ERR(ptr: 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, irq: i2c->irq, NULL, thread_fn: rtq2208_irq_handler, |
563 | IRQF_ONESHOT, devname: dev_name(dev), dev_id: rdev_map); |
564 | } |
565 | |
566 | static const struct of_device_id rtq2208_device_tables[] = { |
567 | { .compatible = "richtek,rtq2208" }, |
568 | {} |
569 | }; |
570 | MODULE_DEVICE_TABLE(of, rtq2208_device_tables); |
571 | |
572 | static struct i2c_driver rtq2208_driver = { |
573 | .driver = { |
574 | .name = "rtq2208" , |
575 | .of_match_table = rtq2208_device_tables, |
576 | }, |
577 | .probe = rtq2208_probe, |
578 | }; |
579 | module_i2c_driver(rtq2208_driver); |
580 | |
581 | MODULE_AUTHOR("Alina Yu <alina_yu@richtek.com>" ); |
582 | MODULE_DESCRIPTION("Richtek RTQ2208 Regulator Driver" ); |
583 | MODULE_LICENSE("GPL" ); |
584 | |