1  // SPDX-License-Identifier: GPL-2.0-only
2  /*
3   * max8660.c  --  Voltage regulation for the Maxim 8660/8661
4   *
5   * based on max1586.c and wm8400-regulator.c
6   *
7   * Copyright (C) 2009 Wolfram Sang, Pengutronix e.K.
8   *
9   * Some info:
10   *
11   * Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX8660-MAX8661.pdf
12   *
13   * This chip is a bit nasty because it is a write-only device. Thus, the driver
14   * uses shadow registers to keep track of its values. The main problem appears
15   * to be the initialization: When Linux boots up, we cannot know if the chip is
16   * in the default state or not, so we would have to pass such information in
17   * platform_data. As this adds a bit of complexity to the driver, this is left
18   * out for now until it is really needed.
19   *
20   * [A|S|M]DTV1 registers are currently not used, but [A|S|M]DTV2.
21   *
22   * If the driver is feature complete, it might be worth to check if one set of
23   * functions for V3-V7 is sufficient. For maximum flexibility during
24   * development, they are separated for now.
25   */
26  
27  #include <linux/module.h>
28  #include <linux/err.h>
29  #include <linux/i2c.h>
30  #include <linux/platform_device.h>
31  #include <linux/regulator/driver.h>
32  #include <linux/slab.h>
33  #include <linux/regulator/max8660.h>
34  #include <linux/of.h>
35  #include <linux/of_device.h>
36  #include <linux/regulator/of_regulator.h>
37  
38  #define MAX8660_DCDC_MIN_UV	 725000
39  #define MAX8660_DCDC_MAX_UV	1800000
40  #define MAX8660_DCDC_STEP	  25000
41  #define MAX8660_DCDC_MAX_SEL	0x2b
42  
43  #define MAX8660_LDO5_MIN_UV	1700000
44  #define MAX8660_LDO5_MAX_UV	2000000
45  #define MAX8660_LDO5_STEP	  25000
46  #define MAX8660_LDO5_MAX_SEL	0x0c
47  
48  #define MAX8660_LDO67_MIN_UV	1800000
49  #define MAX8660_LDO67_MAX_UV	3300000
50  #define MAX8660_LDO67_STEP	 100000
51  #define MAX8660_LDO67_MAX_SEL	0x0f
52  
53  enum {
54  	MAX8660_OVER1,
55  	MAX8660_OVER2,
56  	MAX8660_VCC1,
57  	MAX8660_ADTV1,
58  	MAX8660_ADTV2,
59  	MAX8660_SDTV1,
60  	MAX8660_SDTV2,
61  	MAX8660_MDTV1,
62  	MAX8660_MDTV2,
63  	MAX8660_L12VCR,
64  	MAX8660_FPWM,
65  	MAX8660_N_REGS,	/* not a real register */
66  };
67  
68  struct max8660 {
69  	struct i2c_client *client;
70  	u8 shadow_regs[MAX8660_N_REGS];		/* as chip is write only */
71  };
72  
max8660_write(struct max8660 * max8660,u8 reg,u8 mask,u8 val)73  static int max8660_write(struct max8660 *max8660, u8 reg, u8 mask, u8 val)
74  {
75  	static const u8 max8660_addresses[MAX8660_N_REGS] = {
76  	 0x10, 0x12, 0x20, 0x23, 0x24, 0x29, 0x2a, 0x32, 0x33, 0x39, 0x80
77  	};
78  
79  	int ret;
80  	u8 reg_val = (max8660->shadow_regs[reg] & mask) | val;
81  
82  	dev_vdbg(&max8660->client->dev, "Writing reg %02x with %02x\n",
83  			max8660_addresses[reg], reg_val);
84  
85  	ret = i2c_smbus_write_byte_data(max8660->client,
86  			max8660_addresses[reg], reg_val);
87  	if (ret == 0)
88  		max8660->shadow_regs[reg] = reg_val;
89  
90  	return ret;
91  }
92  
93  
94  /*
95   * DCDC functions
96   */
97  
max8660_dcdc_is_enabled(struct regulator_dev * rdev)98  static int max8660_dcdc_is_enabled(struct regulator_dev *rdev)
99  {
100  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
101  	u8 val = max8660->shadow_regs[MAX8660_OVER1];
102  	u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
103  
104  	return !!(val & mask);
105  }
106  
max8660_dcdc_enable(struct regulator_dev * rdev)107  static int max8660_dcdc_enable(struct regulator_dev *rdev)
108  {
109  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
110  	u8 bit = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
111  
112  	return max8660_write(max8660, MAX8660_OVER1, 0xff, bit);
113  }
114  
max8660_dcdc_disable(struct regulator_dev * rdev)115  static int max8660_dcdc_disable(struct regulator_dev *rdev)
116  {
117  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
118  	u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? ~1 : ~4;
119  
120  	return max8660_write(max8660, MAX8660_OVER1, mask, 0);
121  }
122  
max8660_dcdc_get_voltage_sel(struct regulator_dev * rdev)123  static int max8660_dcdc_get_voltage_sel(struct regulator_dev *rdev)
124  {
125  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
126  	u8 reg = (rdev_get_id(rdev) == MAX8660_V3) ? MAX8660_ADTV2 : MAX8660_SDTV2;
127  	u8 selector = max8660->shadow_regs[reg];
128  
129  	return selector;
130  }
131  
max8660_dcdc_set_voltage_sel(struct regulator_dev * rdev,unsigned int selector)132  static int max8660_dcdc_set_voltage_sel(struct regulator_dev *rdev,
133  					unsigned int selector)
134  {
135  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
136  	u8 reg, bits;
137  	int ret;
138  
139  	reg = (rdev_get_id(rdev) == MAX8660_V3) ? MAX8660_ADTV2 : MAX8660_SDTV2;
140  	ret = max8660_write(max8660, reg, 0, selector);
141  	if (ret)
142  		return ret;
143  
144  	/* Select target voltage register and activate regulation */
145  	bits = (rdev_get_id(rdev) == MAX8660_V3) ? 0x03 : 0x30;
146  	return max8660_write(max8660, MAX8660_VCC1, 0xff, bits);
147  }
148  
149  static struct regulator_ops max8660_dcdc_ops = {
150  	.is_enabled = max8660_dcdc_is_enabled,
151  	.list_voltage = regulator_list_voltage_linear,
152  	.map_voltage = regulator_map_voltage_linear,
153  	.set_voltage_sel = max8660_dcdc_set_voltage_sel,
154  	.get_voltage_sel = max8660_dcdc_get_voltage_sel,
155  };
156  
157  
158  /*
159   * LDO5 functions
160   */
161  
max8660_ldo5_get_voltage_sel(struct regulator_dev * rdev)162  static int max8660_ldo5_get_voltage_sel(struct regulator_dev *rdev)
163  {
164  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
165  
166  	u8 selector = max8660->shadow_regs[MAX8660_MDTV2];
167  	return selector;
168  }
169  
max8660_ldo5_set_voltage_sel(struct regulator_dev * rdev,unsigned int selector)170  static int max8660_ldo5_set_voltage_sel(struct regulator_dev *rdev,
171  					unsigned int selector)
172  {
173  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
174  	int ret;
175  
176  	ret = max8660_write(max8660, MAX8660_MDTV2, 0, selector);
177  	if (ret)
178  		return ret;
179  
180  	/* Select target voltage register and activate regulation */
181  	return max8660_write(max8660, MAX8660_VCC1, 0xff, 0xc0);
182  }
183  
184  static const struct regulator_ops max8660_ldo5_ops = {
185  	.list_voltage = regulator_list_voltage_linear,
186  	.map_voltage = regulator_map_voltage_linear,
187  	.set_voltage_sel = max8660_ldo5_set_voltage_sel,
188  	.get_voltage_sel = max8660_ldo5_get_voltage_sel,
189  };
190  
191  
192  /*
193   * LDO67 functions
194   */
195  
max8660_ldo67_is_enabled(struct regulator_dev * rdev)196  static int max8660_ldo67_is_enabled(struct regulator_dev *rdev)
197  {
198  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
199  	u8 val = max8660->shadow_regs[MAX8660_OVER2];
200  	u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
201  
202  	return !!(val & mask);
203  }
204  
max8660_ldo67_enable(struct regulator_dev * rdev)205  static int max8660_ldo67_enable(struct regulator_dev *rdev)
206  {
207  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
208  	u8 bit = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
209  
210  	return max8660_write(max8660, MAX8660_OVER2, 0xff, bit);
211  }
212  
max8660_ldo67_disable(struct regulator_dev * rdev)213  static int max8660_ldo67_disable(struct regulator_dev *rdev)
214  {
215  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
216  	u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? ~2 : ~4;
217  
218  	return max8660_write(max8660, MAX8660_OVER2, mask, 0);
219  }
220  
max8660_ldo67_get_voltage_sel(struct regulator_dev * rdev)221  static int max8660_ldo67_get_voltage_sel(struct regulator_dev *rdev)
222  {
223  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
224  	u8 shift = (rdev_get_id(rdev) == MAX8660_V6) ? 0 : 4;
225  	u8 selector = (max8660->shadow_regs[MAX8660_L12VCR] >> shift) & 0xf;
226  
227  	return selector;
228  }
229  
max8660_ldo67_set_voltage_sel(struct regulator_dev * rdev,unsigned int selector)230  static int max8660_ldo67_set_voltage_sel(struct regulator_dev *rdev,
231  					 unsigned int selector)
232  {
233  	struct max8660 *max8660 = rdev_get_drvdata(rdev);
234  
235  	if (rdev_get_id(rdev) == MAX8660_V6)
236  		return max8660_write(max8660, MAX8660_L12VCR, 0xf0, selector);
237  	else
238  		return max8660_write(max8660, MAX8660_L12VCR, 0x0f,
239  				     selector << 4);
240  }
241  
242  static const struct regulator_ops max8660_ldo67_ops = {
243  	.is_enabled = max8660_ldo67_is_enabled,
244  	.enable = max8660_ldo67_enable,
245  	.disable = max8660_ldo67_disable,
246  	.list_voltage = regulator_list_voltage_linear,
247  	.map_voltage = regulator_map_voltage_linear,
248  	.get_voltage_sel = max8660_ldo67_get_voltage_sel,
249  	.set_voltage_sel = max8660_ldo67_set_voltage_sel,
250  };
251  
252  static const struct regulator_desc max8660_reg[] = {
253  	{
254  		.name = "V3(DCDC)",
255  		.id = MAX8660_V3,
256  		.ops = &max8660_dcdc_ops,
257  		.type = REGULATOR_VOLTAGE,
258  		.n_voltages = MAX8660_DCDC_MAX_SEL + 1,
259  		.owner = THIS_MODULE,
260  		.min_uV = MAX8660_DCDC_MIN_UV,
261  		.uV_step = MAX8660_DCDC_STEP,
262  	},
263  	{
264  		.name = "V4(DCDC)",
265  		.id = MAX8660_V4,
266  		.ops = &max8660_dcdc_ops,
267  		.type = REGULATOR_VOLTAGE,
268  		.n_voltages = MAX8660_DCDC_MAX_SEL + 1,
269  		.owner = THIS_MODULE,
270  		.min_uV = MAX8660_DCDC_MIN_UV,
271  		.uV_step = MAX8660_DCDC_STEP,
272  	},
273  	{
274  		.name = "V5(LDO)",
275  		.id = MAX8660_V5,
276  		.ops = &max8660_ldo5_ops,
277  		.type = REGULATOR_VOLTAGE,
278  		.n_voltages = MAX8660_LDO5_MAX_SEL + 1,
279  		.owner = THIS_MODULE,
280  		.min_uV = MAX8660_LDO5_MIN_UV,
281  		.uV_step = MAX8660_LDO5_STEP,
282  	},
283  	{
284  		.name = "V6(LDO)",
285  		.id = MAX8660_V6,
286  		.ops = &max8660_ldo67_ops,
287  		.type = REGULATOR_VOLTAGE,
288  		.n_voltages = MAX8660_LDO67_MAX_SEL + 1,
289  		.owner = THIS_MODULE,
290  		.min_uV = MAX8660_LDO67_MIN_UV,
291  		.uV_step = MAX8660_LDO67_STEP,
292  	},
293  	{
294  		.name = "V7(LDO)",
295  		.id = MAX8660_V7,
296  		.ops = &max8660_ldo67_ops,
297  		.type = REGULATOR_VOLTAGE,
298  		.n_voltages = MAX8660_LDO67_MAX_SEL + 1,
299  		.owner = THIS_MODULE,
300  		.min_uV = MAX8660_LDO67_MIN_UV,
301  		.uV_step = MAX8660_LDO67_STEP,
302  	},
303  };
304  
305  enum {
306  	MAX8660 = 0,
307  	MAX8661 = 1,
308  };
309  
310  #ifdef CONFIG_OF
311  static const struct of_device_id max8660_dt_ids[] = {
312  	{ .compatible = "maxim,max8660", .data = (void *) MAX8660 },
313  	{ .compatible = "maxim,max8661", .data = (void *) MAX8661 },
314  	{ }
315  };
316  MODULE_DEVICE_TABLE(of, max8660_dt_ids);
317  
max8660_pdata_from_dt(struct device * dev,struct device_node ** of_node,struct max8660_platform_data * pdata)318  static int max8660_pdata_from_dt(struct device *dev,
319  				 struct device_node **of_node,
320  				 struct max8660_platform_data *pdata)
321  {
322  	int matched, i;
323  	struct device_node *np;
324  	struct max8660_subdev_data *sub;
325  	struct of_regulator_match rmatch[ARRAY_SIZE(max8660_reg)] = { };
326  
327  	np = of_get_child_by_name(dev->of_node, "regulators");
328  	if (!np) {
329  		dev_err(dev, "missing 'regulators' subnode in DT\n");
330  		return -EINVAL;
331  	}
332  
333  	for (i = 0; i < ARRAY_SIZE(rmatch); i++)
334  		rmatch[i].name = max8660_reg[i].name;
335  
336  	matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(rmatch));
337  	of_node_put(np);
338  	if (matched <= 0)
339  		return matched;
340  
341  	pdata->subdevs = devm_kcalloc(dev,
342  				      matched,
343  				      sizeof(struct max8660_subdev_data),
344  				      GFP_KERNEL);
345  	if (!pdata->subdevs)
346  		return -ENOMEM;
347  
348  	pdata->num_subdevs = matched;
349  	sub = pdata->subdevs;
350  
351  	for (i = 0; i < matched; i++) {
352  		sub->id = i;
353  		sub->name = rmatch[i].name;
354  		sub->platform_data = rmatch[i].init_data;
355  		of_node[i] = rmatch[i].of_node;
356  		sub++;
357  	}
358  
359  	return 0;
360  }
361  #else
max8660_pdata_from_dt(struct device * dev,struct device_node ** of_node,struct max8660_platform_data * pdata)362  static inline int max8660_pdata_from_dt(struct device *dev,
363  					struct device_node **of_node,
364  					struct max8660_platform_data *pdata)
365  {
366  	return 0;
367  }
368  #endif
369  
max8660_probe(struct i2c_client * client)370  static int max8660_probe(struct i2c_client *client)
371  {
372  	const struct i2c_device_id *i2c_id = i2c_client_get_device_id(client);
373  	struct device *dev = &client->dev;
374  	struct max8660_platform_data pdata_of, *pdata = dev_get_platdata(dev);
375  	struct regulator_config config = { };
376  	struct max8660 *max8660;
377  	int boot_on, i, id, ret = -EINVAL;
378  	struct device_node *of_node[MAX8660_V_END];
379  	unsigned long type;
380  
381  	if (dev->of_node && !pdata) {
382  		const struct of_device_id *id;
383  
384  		id = of_match_device(of_match_ptr(max8660_dt_ids), dev);
385  		if (!id)
386  			return -ENODEV;
387  
388  		ret = max8660_pdata_from_dt(dev, of_node, &pdata_of);
389  		if (ret < 0)
390  			return ret;
391  
392  		pdata = &pdata_of;
393  		type = (unsigned long) id->data;
394  	} else {
395  		type = i2c_id->driver_data;
396  		memset(of_node, 0, sizeof(of_node));
397  	}
398  
399  	if (pdata->num_subdevs > MAX8660_V_END) {
400  		dev_err(dev, "Too many regulators found!\n");
401  		return -EINVAL;
402  	}
403  
404  	max8660 = devm_kzalloc(dev, sizeof(struct max8660), GFP_KERNEL);
405  	if (!max8660)
406  		return -ENOMEM;
407  
408  	max8660->client = client;
409  
410  	if (pdata->en34_is_high) {
411  		/* Simulate always on */
412  		max8660->shadow_regs[MAX8660_OVER1] = 5;
413  	} else {
414  		/* Otherwise devices can be toggled via software */
415  		max8660_dcdc_ops.enable = max8660_dcdc_enable;
416  		max8660_dcdc_ops.disable = max8660_dcdc_disable;
417  	}
418  
419  	/*
420  	 * First, set up shadow registers to prevent glitches. As some
421  	 * registers are shared between regulators, everything must be properly
422  	 * set up for all regulators in advance.
423  	 */
424  	max8660->shadow_regs[MAX8660_ADTV1] =
425  		max8660->shadow_regs[MAX8660_ADTV2] =
426  		max8660->shadow_regs[MAX8660_SDTV1] =
427  		max8660->shadow_regs[MAX8660_SDTV2] = 0x1b;
428  	max8660->shadow_regs[MAX8660_MDTV1] =
429  		max8660->shadow_regs[MAX8660_MDTV2] = 0x04;
430  
431  	for (i = 0; i < pdata->num_subdevs; i++) {
432  
433  		if (!pdata->subdevs[i].platform_data)
434  			boot_on = false;
435  		else
436  			boot_on = pdata->subdevs[i].platform_data->constraints.boot_on;
437  
438  		switch (pdata->subdevs[i].id) {
439  		case MAX8660_V3:
440  			if (boot_on)
441  				max8660->shadow_regs[MAX8660_OVER1] |= 1;
442  			break;
443  
444  		case MAX8660_V4:
445  			if (boot_on)
446  				max8660->shadow_regs[MAX8660_OVER1] |= 4;
447  			break;
448  
449  		case MAX8660_V5:
450  			break;
451  
452  		case MAX8660_V6:
453  			if (boot_on)
454  				max8660->shadow_regs[MAX8660_OVER2] |= 2;
455  			break;
456  
457  		case MAX8660_V7:
458  			if (type == MAX8661) {
459  				dev_err(dev, "Regulator not on this chip!\n");
460  				return -EINVAL;
461  			}
462  
463  			if (boot_on)
464  				max8660->shadow_regs[MAX8660_OVER2] |= 4;
465  			break;
466  
467  		default:
468  			dev_err(dev, "invalid regulator %s\n",
469  				 pdata->subdevs[i].name);
470  			return ret;
471  		}
472  	}
473  
474  	/* Finally register devices */
475  	for (i = 0; i < pdata->num_subdevs; i++) {
476  		struct regulator_dev *rdev;
477  
478  		id = pdata->subdevs[i].id;
479  
480  		config.dev = dev;
481  		config.init_data = pdata->subdevs[i].platform_data;
482  		config.of_node = of_node[i];
483  		config.driver_data = max8660;
484  
485  		rdev = devm_regulator_register(&client->dev,
486  						  &max8660_reg[id], &config);
487  		if (IS_ERR(rdev)) {
488  			dev_err(&client->dev, "failed to register %s\n",
489  				max8660_reg[id].name);
490  			return PTR_ERR(rdev);
491  		}
492  	}
493  
494  	i2c_set_clientdata(client, max8660);
495  	return 0;
496  }
497  
498  static const struct i2c_device_id max8660_id[] = {
499  	{ .name = "max8660", .driver_data = MAX8660 },
500  	{ .name = "max8661", .driver_data = MAX8661 },
501  	{ }
502  };
503  MODULE_DEVICE_TABLE(i2c, max8660_id);
504  
505  static struct i2c_driver max8660_driver = {
506  	.probe = max8660_probe,
507  	.driver		= {
508  		.name	= "max8660",
509  		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
510  	},
511  	.id_table	= max8660_id,
512  };
513  
max8660_init(void)514  static int __init max8660_init(void)
515  {
516  	return i2c_add_driver(&max8660_driver);
517  }
518  subsys_initcall(max8660_init);
519  
max8660_exit(void)520  static void __exit max8660_exit(void)
521  {
522  	i2c_del_driver(&max8660_driver);
523  }
524  module_exit(max8660_exit);
525  
526  /* Module information */
527  MODULE_DESCRIPTION("MAXIM 8660/8661 voltage regulator driver");
528  MODULE_AUTHOR("Wolfram Sang");
529  MODULE_LICENSE("GPL v2");
530