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");