xref: /openbmc/linux/drivers/regulator/rt5190a-regulator.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
1  // SPDX-License-Identifier: GPL-2.0+
2  
3  #include <dt-bindings/regulator/richtek,rt5190a-regulator.h>
4  #include <linux/bits.h>
5  #include <linux/i2c.h>
6  #include <linux/interrupt.h>
7  #include <linux/kernel.h>
8  #include <linux/module.h>
9  #include <linux/of.h>
10  #include <linux/property.h>
11  #include <linux/regmap.h>
12  #include <linux/regulator/driver.h>
13  #include <linux/regulator/machine.h>
14  #include <linux/regulator/of_regulator.h>
15  
16  #define RT5190A_REG_MANUFACTURE		0x00
17  #define RT5190A_REG_BUCK2VSEL		0x04
18  #define RT5190A_REG_BUCK3VSEL		0x05
19  #define RT5190A_REG_DCDCCNTL		0x06
20  #define RT5190A_REG_ENABLE		0x07
21  #define RT5190A_REG_DISCHARGE		0x09
22  #define RT5190A_REG_PROTMODE		0x0A
23  #define RT5190A_REG_MUTECNTL		0x0B
24  #define RT5190A_REG_PGSTAT		0x0F
25  #define RT5190A_REG_OVINT		0x10
26  #define RT5190A_REG_HOTDIEMASK		0x17
27  
28  #define RT5190A_VSEL_MASK		GENMASK(6, 0)
29  #define RT5190A_RID_BITMASK(rid)	BIT(rid + 1)
30  #define RT5190A_BUCK1_DISCHG_MASK	GENMASK(1, 0)
31  #define RT5190A_BUCK1_DISCHG_ONVAL	0x01
32  #define RT5190A_OVERVOLT_MASK		GENMASK(7, 0)
33  #define RT5190A_UNDERVOLT_MASK		GENMASK(15, 8)
34  #define RT5190A_CH234OT_MASK		BIT(29)
35  #define RT5190A_CHIPOT_MASK		BIT(28)
36  
37  #define RT5190A_BUCK23_MINUV		600000
38  #define RT5190A_BUCK23_MAXUV		1400000
39  #define RT5190A_BUCK23_STEPUV		10000
40  #define RT5190A_BUCK23_STEPNUM		((1400000 - 600000) / 10000 + 1)
41  
42  enum {
43  	RT5190A_IDX_BUCK1 = 0,
44  	RT5190A_IDX_BUCK2,
45  	RT5190A_IDX_BUCK3,
46  	RT5190A_IDX_BUCK4,
47  	RT5190A_IDX_LDO,
48  	RT5190A_MAX_IDX
49  };
50  
51  struct rt5190a_priv {
52  	struct device *dev;
53  	struct regmap *regmap;
54  	struct regulator_desc rdesc[RT5190A_MAX_IDX];
55  	struct regulator_dev *rdev[RT5190A_MAX_IDX];
56  };
57  
rt5190a_get_error_flags(struct regulator_dev * rdev,unsigned int * flags)58  static int rt5190a_get_error_flags(struct regulator_dev *rdev,
59  				   unsigned int *flags)
60  {
61  	struct regmap *regmap = rdev_get_regmap(rdev);
62  	int rid = rdev_get_id(rdev);
63  	unsigned int pgood_stat;
64  	int ret;
65  
66  	ret = regmap_read(regmap, RT5190A_REG_PGSTAT, &pgood_stat);
67  	if (ret)
68  		return ret;
69  
70  	if (!(pgood_stat & RT5190A_RID_BITMASK(rid)))
71  		*flags = REGULATOR_ERROR_FAIL;
72  	else
73  		*flags = 0;
74  
75  	return 0;
76  }
77  
rt5190a_fixed_buck_set_mode(struct regulator_dev * rdev,unsigned int mode)78  static int rt5190a_fixed_buck_set_mode(struct regulator_dev *rdev,
79  				       unsigned int mode)
80  {
81  	struct regmap *regmap = rdev_get_regmap(rdev);
82  	int rid = rdev_get_id(rdev);
83  	unsigned int mask = RT5190A_RID_BITMASK(rid), val;
84  
85  	switch (mode) {
86  	case REGULATOR_MODE_FAST:
87  		val = mask;
88  		break;
89  	case REGULATOR_MODE_NORMAL:
90  		val = 0;
91  		break;
92  	default:
93  		return -EINVAL;
94  	}
95  
96  	return regmap_update_bits(regmap, RT5190A_REG_DCDCCNTL, mask, val);
97  }
98  
rt5190a_fixed_buck_get_mode(struct regulator_dev * rdev)99  static unsigned int rt5190a_fixed_buck_get_mode(struct regulator_dev *rdev)
100  {
101  	struct regmap *regmap = rdev_get_regmap(rdev);
102  	int rid = rdev_get_id(rdev);
103  	unsigned int val;
104  	int ret;
105  
106  	ret = regmap_read(regmap, RT5190A_REG_DCDCCNTL, &val);
107  	if (ret) {
108  		dev_err(&rdev->dev, "Failed to get mode [%d]\n", ret);
109  		return ret;
110  	}
111  
112  	if (val & RT5190A_RID_BITMASK(rid))
113  		return REGULATOR_MODE_FAST;
114  
115  	return REGULATOR_MODE_NORMAL;
116  }
117  
118  static const struct regulator_ops rt5190a_ranged_buck_ops = {
119  	.enable	= regulator_enable_regmap,
120  	.disable = regulator_disable_regmap,
121  	.is_enabled = regulator_is_enabled_regmap,
122  	.set_voltage_sel = regulator_set_voltage_sel_regmap,
123  	.get_voltage_sel = regulator_get_voltage_sel_regmap,
124  	.list_voltage = regulator_list_voltage_linear,
125  	.set_active_discharge = regulator_set_active_discharge_regmap,
126  	.get_error_flags = rt5190a_get_error_flags,
127  };
128  
129  static const struct regulator_ops rt5190a_fixed_buck_ops = {
130  	.enable	= regulator_enable_regmap,
131  	.disable = regulator_disable_regmap,
132  	.is_enabled = regulator_is_enabled_regmap,
133  	.set_active_discharge = regulator_set_active_discharge_regmap,
134  	.set_mode = rt5190a_fixed_buck_set_mode,
135  	.get_mode = rt5190a_fixed_buck_get_mode,
136  	.get_error_flags = rt5190a_get_error_flags,
137  };
138  
139  static const struct regulator_ops rt5190a_fixed_ldo_ops = {
140  	.enable	= regulator_enable_regmap,
141  	.disable = regulator_disable_regmap,
142  	.is_enabled = regulator_is_enabled_regmap,
143  	.set_active_discharge = regulator_set_active_discharge_regmap,
144  	.get_error_flags = rt5190a_get_error_flags,
145  };
146  
rt5190a_irq_handler(int irq,void * data)147  static irqreturn_t rt5190a_irq_handler(int irq, void *data)
148  {
149  	struct rt5190a_priv *priv = data;
150  	__le32 raws;
151  	unsigned int events, fields;
152  	static const struct {
153  		unsigned int bitmask;
154  		unsigned int report;
155  	} event_tbl[] = {
156  		{ RT5190A_OVERVOLT_MASK, REGULATOR_ERROR_REGULATION_OUT },
157  		{ RT5190A_UNDERVOLT_MASK, REGULATOR_ERROR_UNDER_VOLTAGE }
158  	};
159  	int i, j, ret;
160  
161  	ret = regmap_raw_read(priv->regmap, RT5190A_REG_OVINT, &raws,
162  			      sizeof(raws));
163  	if (ret) {
164  		dev_err(priv->dev, "Failed to read events\n");
165  		return IRQ_NONE;
166  	}
167  
168  	events = le32_to_cpu(raws);
169  
170  	ret = regmap_raw_write(priv->regmap, RT5190A_REG_OVINT, &raws,
171  			       sizeof(raws));
172  	if (ret)
173  		dev_err(priv->dev, "Failed to write-clear events\n");
174  
175  	/* Handle OV,UV events */
176  	for (i = 0; i < ARRAY_SIZE(event_tbl); i++) {
177  		fields = events & event_tbl[i].bitmask;
178  		fields >>= ffs(event_tbl[i].bitmask) - 1;
179  
180  		for (j = 0; j < RT5190A_MAX_IDX; j++) {
181  			if (!(fields & RT5190A_RID_BITMASK(j)))
182  				continue;
183  
184  			regulator_notifier_call_chain(priv->rdev[j],
185  						      event_tbl[i].report,
186  						      NULL);
187  		}
188  	}
189  
190  	/* Handle CH234 OT event */
191  	if (events & RT5190A_CH234OT_MASK) {
192  		for (j = RT5190A_IDX_BUCK2; j < RT5190A_IDX_LDO; j++) {
193  			regulator_notifier_call_chain(priv->rdev[j],
194  						      REGULATOR_ERROR_OVER_TEMP,
195  						      NULL);
196  		}
197  	}
198  
199  	/* Warning if CHIP OT occur */
200  	if (events & RT5190A_CHIPOT_MASK)
201  		dev_warn(priv->dev, "CHIP overheat\n");
202  
203  	return IRQ_HANDLED;
204  }
205  
rt5190a_of_map_mode(unsigned int mode)206  static unsigned int rt5190a_of_map_mode(unsigned int mode)
207  {
208  	switch (mode) {
209  	case RT5190A_OPMODE_AUTO:
210  		return REGULATOR_MODE_NORMAL;
211  	case RT5190A_OPMODE_FPWM:
212  		return REGULATOR_MODE_FAST;
213  	default:
214  		return REGULATOR_MODE_INVALID;
215  	}
216  }
217  
rt5190a_of_parse_cb(struct rt5190a_priv * priv,int rid,struct of_regulator_match * match)218  static int rt5190a_of_parse_cb(struct rt5190a_priv *priv, int rid,
219  			       struct of_regulator_match *match)
220  {
221  	struct regulator_desc *desc = priv->rdesc + rid;
222  	struct regulator_init_data *init_data = match->init_data;
223  	struct device_node *np = match->of_node;
224  	bool latchup_enable;
225  	unsigned int mask = RT5190A_RID_BITMASK(rid), val;
226  
227  	if (!init_data)
228  		return 0;
229  
230  	switch (rid) {
231  	case RT5190A_IDX_BUCK1:
232  	case RT5190A_IDX_BUCK4:
233  	case RT5190A_IDX_LDO:
234  		init_data->constraints.apply_uV = 0;
235  
236  		if (init_data->constraints.min_uV ==
237  				init_data->constraints.max_uV)
238  			desc->fixed_uV = init_data->constraints.min_uV;
239  		else {
240  			dev_err(priv->dev,
241  				"Variable voltage for fixed regulator\n");
242  			return -EINVAL;
243  		}
244  		break;
245  	default:
246  		break;
247  	}
248  
249  	latchup_enable = of_property_read_bool(np, "richtek,latchup-enable");
250  
251  	/* latchup: 0, default hiccup: 1 */
252  	val = !latchup_enable ? mask : 0;
253  
254  	return regmap_update_bits(priv->regmap, RT5190A_REG_PROTMODE, mask, val);
255  }
256  
rt5190a_fillin_regulator_desc(struct regulator_desc * desc,int rid)257  static void rt5190a_fillin_regulator_desc(struct regulator_desc *desc, int rid)
258  {
259  	static const char * const regu_name[] = { "buck1", "buck2",
260  						  "buck3", "buck4",
261  						  "ldo" };
262  	static const char * const supply[] = { NULL, "vin2", "vin3", "vin4",
263  					       "vinldo" };
264  
265  	desc->name = regu_name[rid];
266  	desc->supply_name = supply[rid];
267  	desc->owner = THIS_MODULE;
268  	desc->type = REGULATOR_VOLTAGE;
269  	desc->id = rid;
270  	desc->enable_reg = RT5190A_REG_ENABLE;
271  	desc->enable_mask = RT5190A_RID_BITMASK(rid);
272  	desc->active_discharge_reg = RT5190A_REG_DISCHARGE;
273  	desc->active_discharge_mask = RT5190A_RID_BITMASK(rid);
274  	desc->active_discharge_on = RT5190A_RID_BITMASK(rid);
275  
276  	switch (rid) {
277  	case RT5190A_IDX_BUCK1:
278  		desc->active_discharge_mask = RT5190A_BUCK1_DISCHG_MASK;
279  		desc->active_discharge_on = RT5190A_BUCK1_DISCHG_ONVAL;
280  		desc->n_voltages = 1;
281  		desc->ops = &rt5190a_fixed_buck_ops;
282  		desc->of_map_mode = rt5190a_of_map_mode;
283  		break;
284  	case RT5190A_IDX_BUCK2:
285  		desc->vsel_reg = RT5190A_REG_BUCK2VSEL;
286  		desc->vsel_mask = RT5190A_VSEL_MASK;
287  		desc->min_uV = RT5190A_BUCK23_MINUV;
288  		desc->uV_step = RT5190A_BUCK23_STEPUV;
289  		desc->n_voltages = RT5190A_BUCK23_STEPNUM;
290  		desc->ops = &rt5190a_ranged_buck_ops;
291  		break;
292  	case RT5190A_IDX_BUCK3:
293  		desc->vsel_reg = RT5190A_REG_BUCK3VSEL;
294  		desc->vsel_mask = RT5190A_VSEL_MASK;
295  		desc->min_uV = RT5190A_BUCK23_MINUV;
296  		desc->uV_step = RT5190A_BUCK23_STEPUV;
297  		desc->n_voltages = RT5190A_BUCK23_STEPNUM;
298  		desc->ops = &rt5190a_ranged_buck_ops;
299  		break;
300  	case RT5190A_IDX_BUCK4:
301  		desc->n_voltages = 1;
302  		desc->ops = &rt5190a_fixed_buck_ops;
303  		desc->of_map_mode = rt5190a_of_map_mode;
304  		break;
305  	case RT5190A_IDX_LDO:
306  		desc->n_voltages = 1;
307  		desc->ops = &rt5190a_fixed_ldo_ops;
308  		break;
309  	}
310  }
311  
312  static struct of_regulator_match rt5190a_regulator_match[] = {
313  	{ .name = "buck1", },
314  	{ .name = "buck2", },
315  	{ .name = "buck3", },
316  	{ .name = "buck4", },
317  	{ .name = "ldo", }
318  };
319  
rt5190a_parse_regulator_dt_data(struct rt5190a_priv * priv)320  static int rt5190a_parse_regulator_dt_data(struct rt5190a_priv *priv)
321  {
322  	struct device_node *regulator_np;
323  	struct regulator_desc *reg_desc;
324  	struct of_regulator_match *match;
325  	int i, ret;
326  
327  	for (i = 0; i < RT5190A_MAX_IDX; i++) {
328  		reg_desc = priv->rdesc + i;
329  		match = rt5190a_regulator_match + i;
330  
331  		rt5190a_fillin_regulator_desc(reg_desc, i);
332  
333  		match->desc = reg_desc;
334  	}
335  
336  	regulator_np = of_get_child_by_name(priv->dev->of_node, "regulators");
337  	if (!regulator_np) {
338  		dev_err(priv->dev, "Could not find 'regulators' node\n");
339  		return -ENODEV;
340  	}
341  
342  	ret = of_regulator_match(priv->dev, regulator_np,
343  				 rt5190a_regulator_match,
344  				 ARRAY_SIZE(rt5190a_regulator_match));
345  
346  	of_node_put(regulator_np);
347  
348  	if (ret < 0) {
349  		dev_err(priv->dev,
350  			"Error parsing regulator init data: %d\n", ret);
351  		return ret;
352  	}
353  
354  	for (i = 0; i < RT5190A_MAX_IDX; i++) {
355  		match = rt5190a_regulator_match + i;
356  
357  		ret = rt5190a_of_parse_cb(priv, i, match);
358  		if (ret) {
359  			dev_err(priv->dev, "Failed in [%d] of_parse_cb\n", i);
360  			return ret;
361  		}
362  	}
363  
364  	return 0;
365  }
366  
367  static const struct reg_sequence rt5190a_init_patch[] = {
368  	{ 0x09, 0x3d, },
369  	{ 0x0a, 0x3e, },
370  	{ 0x0b, 0x01, },
371  	{ 0x10, 0xff, },
372  	{ 0x11, 0xff, },
373  	{ 0x12, 0xff, },
374  	{ 0x13, 0xff, },
375  	{ 0x14, 0, },
376  	{ 0x15, 0, },
377  	{ 0x16, 0x3e, },
378  	{ 0x17, 0, }
379  };
380  
rt5190a_device_initialize(struct rt5190a_priv * priv)381  static int rt5190a_device_initialize(struct rt5190a_priv *priv)
382  {
383  	bool mute_enable;
384  	int ret;
385  
386  	ret = regmap_register_patch(priv->regmap, rt5190a_init_patch,
387  				    ARRAY_SIZE(rt5190a_init_patch));
388  	if (ret) {
389  		dev_err(priv->dev, "Failed to do register patch\n");
390  		return ret;
391  	}
392  
393  	mute_enable = device_property_read_bool(priv->dev,
394  						"richtek,mute-enable");
395  
396  	if (mute_enable) {
397  		ret = regmap_write(priv->regmap, RT5190A_REG_MUTECNTL, 0x00);
398  		if (ret) {
399  			dev_err(priv->dev, "Failed to enable mute function\n");
400  			return ret;
401  		}
402  	}
403  
404  	return 0;
405  }
406  
rt5190a_device_check(struct rt5190a_priv * priv)407  static int rt5190a_device_check(struct rt5190a_priv *priv)
408  {
409  	u16 devid;
410  	int ret;
411  
412  	ret = regmap_raw_read(priv->regmap, RT5190A_REG_MANUFACTURE, &devid,
413  			      sizeof(devid));
414  	if (ret)
415  		return ret;
416  
417  	if (devid) {
418  		dev_err(priv->dev, "Incorrect device id 0x%04x\n", devid);
419  		return -ENODEV;
420  	}
421  
422  	return 0;
423  }
424  
425  static const struct regmap_config rt5190a_regmap_config = {
426  	.reg_bits = 8,
427  	.val_bits = 8,
428  	.max_register = RT5190A_REG_HOTDIEMASK,
429  };
430  
rt5190a_probe(struct i2c_client * i2c)431  static int rt5190a_probe(struct i2c_client *i2c)
432  {
433  	struct rt5190a_priv *priv;
434  	struct regulator_config cfg = {};
435  	int i, ret;
436  
437  	priv = devm_kzalloc(&i2c->dev, sizeof(*priv), GFP_KERNEL);
438  	if (!priv)
439  		return -ENOMEM;
440  
441  	priv->dev = &i2c->dev;
442  
443  	priv->regmap = devm_regmap_init_i2c(i2c, &rt5190a_regmap_config);
444  	if (IS_ERR(priv->regmap)) {
445  		dev_err(&i2c->dev, "Failed to allocate regmap\n");
446  		return PTR_ERR(priv->regmap);
447  	}
448  
449  	ret = rt5190a_device_check(priv);
450  	if (ret) {
451  		dev_err(&i2c->dev, "Failed to check device %d\n", ret);
452  		return ret;
453  	}
454  
455  	ret = rt5190a_device_initialize(priv);
456  	if (ret) {
457  		dev_err(&i2c->dev, "Failed to initialize the device\n");
458  		return ret;
459  	}
460  
461  	ret = rt5190a_parse_regulator_dt_data(priv);
462  	if (ret) {
463  		dev_err(&i2c->dev, "Failed to parse regulator dt\n");
464  		return ret;
465  	}
466  
467  	cfg.dev = &i2c->dev;
468  	cfg.regmap = priv->regmap;
469  
470  	for (i = 0; i < RT5190A_MAX_IDX; i++) {
471  		struct regulator_desc *desc = priv->rdesc + i;
472  		struct of_regulator_match *match = rt5190a_regulator_match + i;
473  
474  		cfg.init_data = match->init_data;
475  		cfg.of_node = match->of_node;
476  
477  		priv->rdev[i] = devm_regulator_register(&i2c->dev, desc, &cfg);
478  		if (IS_ERR(priv->rdev[i])) {
479  			dev_err(&i2c->dev, "Failed to register regulator %s\n",
480  				desc->name);
481  			return PTR_ERR(priv->rdev[i]);
482  		}
483  	}
484  
485  	if (i2c->irq) {
486  		ret = devm_request_threaded_irq(&i2c->dev, i2c->irq, NULL,
487  						rt5190a_irq_handler,
488  						IRQF_ONESHOT,
489  						dev_name(&i2c->dev), priv);
490  		if (ret) {
491  			dev_err(&i2c->dev, "Failed to register interrupt\n");
492  			return ret;
493  		}
494  	}
495  
496  	return 0;
497  }
498  
499  static const struct of_device_id __maybe_unused rt5190a_device_table[] = {
500  	{ .compatible = "richtek,rt5190a", },
501  	{}
502  };
503  MODULE_DEVICE_TABLE(of, rt5190a_device_table);
504  
505  static struct i2c_driver rt5190a_driver = {
506  	.driver = {
507  		.name = "rt5190a",
508  		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
509  		.of_match_table = rt5190a_device_table,
510  	},
511  	.probe = rt5190a_probe,
512  };
513  module_i2c_driver(rt5190a_driver);
514  
515  MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
516  MODULE_DESCRIPTION("Richtek RT5190A Regulator Driver");
517  MODULE_LICENSE("GPL v2");
518