2 * max8660.c -- Voltage regulation for the Maxim 8660/8661
4 * based on max1586.c and wm8400-regulator.c
6 * Copyright (C) 2009 Wolfram Sang, Pengutronix e.K.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; version 2 of the License.
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 * Place, Suite 330, Boston, MA 02111-1307 USA
23 * Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX8660-MAX8661.pdf
25 * This chip is a bit nasty because it is a write-only device. Thus, the driver
26 * uses shadow registers to keep track of its values. The main problem appears
27 * to be the initialization: When Linux boots up, we cannot know if the chip is
28 * in the default state or not, so we would have to pass such information in
29 * platform_data. As this adds a bit of complexity to the driver, this is left
30 * out for now until it is really needed.
32 * [A|S|M]DTV1 registers are currently not used, but [A|S|M]DTV2.
34 * If the driver is feature complete, it might be worth to check if one set of
35 * functions for V3-V7 is sufficient. For maximum flexibility during
36 * development, they are separated for now.
40 #include <linux/module.h>
41 #include <linux/err.h>
42 #include <linux/i2c.h>
43 #include <linux/platform_device.h>
44 #include <linux/regulator/driver.h>
45 #include <linux/slab.h>
46 #include <linux/regulator/max8660.h>
48 #include <linux/of_device.h>
49 #include <linux/regulator/of_regulator.h>
51 #define MAX8660_DCDC_MIN_UV 725000
52 #define MAX8660_DCDC_MAX_UV 1800000
53 #define MAX8660_DCDC_STEP 25000
54 #define MAX8660_DCDC_MAX_SEL 0x2b
56 #define MAX8660_LDO5_MIN_UV 1700000
57 #define MAX8660_LDO5_MAX_UV 2000000
58 #define MAX8660_LDO5_STEP 25000
59 #define MAX8660_LDO5_MAX_SEL 0x0c
61 #define MAX8660_LDO67_MIN_UV 1800000
62 #define MAX8660_LDO67_MAX_UV 3300000
63 #define MAX8660_LDO67_STEP 100000
64 #define MAX8660_LDO67_MAX_SEL 0x0f
78 MAX8660_N_REGS, /* not a real register */
82 struct i2c_client *client;
83 u8 shadow_regs[MAX8660_N_REGS]; /* as chip is write only */
86 static int max8660_write(struct max8660 *max8660, u8 reg, u8 mask, u8 val)
88 static const u8 max8660_addresses[MAX8660_N_REGS] = {
89 0x10, 0x12, 0x20, 0x23, 0x24, 0x29, 0x2a, 0x32, 0x33, 0x39, 0x80 };
92 u8 reg_val = (max8660->shadow_regs[reg] & mask) | val;
94 dev_vdbg(&max8660->client->dev, "Writing reg %02x with %02x\n",
95 max8660_addresses[reg], reg_val);
97 ret = i2c_smbus_write_byte_data(max8660->client,
98 max8660_addresses[reg], reg_val);
100 max8660->shadow_regs[reg] = reg_val;
110 static int max8660_dcdc_is_enabled(struct regulator_dev *rdev)
112 struct max8660 *max8660 = rdev_get_drvdata(rdev);
113 u8 val = max8660->shadow_regs[MAX8660_OVER1];
114 u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
116 return !!(val & mask);
119 static int max8660_dcdc_enable(struct regulator_dev *rdev)
121 struct max8660 *max8660 = rdev_get_drvdata(rdev);
122 u8 bit = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
124 return max8660_write(max8660, MAX8660_OVER1, 0xff, bit);
127 static int max8660_dcdc_disable(struct regulator_dev *rdev)
129 struct max8660 *max8660 = rdev_get_drvdata(rdev);
130 u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? ~1 : ~4;
132 return max8660_write(max8660, MAX8660_OVER1, mask, 0);
135 static int max8660_dcdc_get_voltage_sel(struct regulator_dev *rdev)
137 struct max8660 *max8660 = rdev_get_drvdata(rdev);
138 u8 reg = (rdev_get_id(rdev) == MAX8660_V3) ? MAX8660_ADTV2 : MAX8660_SDTV2;
139 u8 selector = max8660->shadow_regs[reg];
144 static int max8660_dcdc_set_voltage_sel(struct regulator_dev *rdev,
145 unsigned int selector)
147 struct max8660 *max8660 = rdev_get_drvdata(rdev);
151 reg = (rdev_get_id(rdev) == MAX8660_V3) ? MAX8660_ADTV2 : MAX8660_SDTV2;
152 ret = max8660_write(max8660, reg, 0, selector);
156 /* Select target voltage register and activate regulation */
157 bits = (rdev_get_id(rdev) == MAX8660_V3) ? 0x03 : 0x30;
158 return max8660_write(max8660, MAX8660_VCC1, 0xff, bits);
161 static struct regulator_ops max8660_dcdc_ops = {
162 .is_enabled = max8660_dcdc_is_enabled,
163 .list_voltage = regulator_list_voltage_linear,
164 .map_voltage = regulator_map_voltage_linear,
165 .set_voltage_sel = max8660_dcdc_set_voltage_sel,
166 .get_voltage_sel = max8660_dcdc_get_voltage_sel,
174 static int max8660_ldo5_get_voltage_sel(struct regulator_dev *rdev)
176 struct max8660 *max8660 = rdev_get_drvdata(rdev);
178 u8 selector = max8660->shadow_regs[MAX8660_MDTV2];
182 static int max8660_ldo5_set_voltage_sel(struct regulator_dev *rdev,
183 unsigned int selector)
185 struct max8660 *max8660 = rdev_get_drvdata(rdev);
188 ret = max8660_write(max8660, MAX8660_MDTV2, 0, selector);
192 /* Select target voltage register and activate regulation */
193 return max8660_write(max8660, MAX8660_VCC1, 0xff, 0xc0);
196 static struct regulator_ops max8660_ldo5_ops = {
197 .list_voltage = regulator_list_voltage_linear,
198 .map_voltage = regulator_map_voltage_linear,
199 .set_voltage_sel = max8660_ldo5_set_voltage_sel,
200 .get_voltage_sel = max8660_ldo5_get_voltage_sel,
208 static int max8660_ldo67_is_enabled(struct regulator_dev *rdev)
210 struct max8660 *max8660 = rdev_get_drvdata(rdev);
211 u8 val = max8660->shadow_regs[MAX8660_OVER2];
212 u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
214 return !!(val & mask);
217 static int max8660_ldo67_enable(struct regulator_dev *rdev)
219 struct max8660 *max8660 = rdev_get_drvdata(rdev);
220 u8 bit = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
222 return max8660_write(max8660, MAX8660_OVER2, 0xff, bit);
225 static int max8660_ldo67_disable(struct regulator_dev *rdev)
227 struct max8660 *max8660 = rdev_get_drvdata(rdev);
228 u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? ~2 : ~4;
230 return max8660_write(max8660, MAX8660_OVER2, mask, 0);
233 static int max8660_ldo67_get_voltage_sel(struct regulator_dev *rdev)
235 struct max8660 *max8660 = rdev_get_drvdata(rdev);
236 u8 shift = (rdev_get_id(rdev) == MAX8660_V6) ? 0 : 4;
237 u8 selector = (max8660->shadow_regs[MAX8660_L12VCR] >> shift) & 0xf;
242 static int max8660_ldo67_set_voltage_sel(struct regulator_dev *rdev,
243 unsigned int selector)
245 struct max8660 *max8660 = rdev_get_drvdata(rdev);
247 if (rdev_get_id(rdev) == MAX8660_V6)
248 return max8660_write(max8660, MAX8660_L12VCR, 0xf0, selector);
250 return max8660_write(max8660, MAX8660_L12VCR, 0x0f,
254 static struct regulator_ops max8660_ldo67_ops = {
255 .is_enabled = max8660_ldo67_is_enabled,
256 .enable = max8660_ldo67_enable,
257 .disable = max8660_ldo67_disable,
258 .list_voltage = regulator_list_voltage_linear,
259 .map_voltage = regulator_map_voltage_linear,
260 .get_voltage_sel = max8660_ldo67_get_voltage_sel,
261 .set_voltage_sel = max8660_ldo67_set_voltage_sel,
264 static const struct regulator_desc max8660_reg[] = {
268 .ops = &max8660_dcdc_ops,
269 .type = REGULATOR_VOLTAGE,
270 .n_voltages = MAX8660_DCDC_MAX_SEL + 1,
271 .owner = THIS_MODULE,
272 .min_uV = MAX8660_DCDC_MIN_UV,
273 .uV_step = MAX8660_DCDC_STEP,
278 .ops = &max8660_dcdc_ops,
279 .type = REGULATOR_VOLTAGE,
280 .n_voltages = MAX8660_DCDC_MAX_SEL + 1,
281 .owner = THIS_MODULE,
282 .min_uV = MAX8660_DCDC_MIN_UV,
283 .uV_step = MAX8660_DCDC_STEP,
288 .ops = &max8660_ldo5_ops,
289 .type = REGULATOR_VOLTAGE,
290 .n_voltages = MAX8660_LDO5_MAX_SEL + 1,
291 .owner = THIS_MODULE,
292 .min_uV = MAX8660_LDO5_MIN_UV,
293 .uV_step = MAX8660_LDO5_STEP,
298 .ops = &max8660_ldo67_ops,
299 .type = REGULATOR_VOLTAGE,
300 .n_voltages = MAX8660_LDO67_MAX_SEL + 1,
301 .owner = THIS_MODULE,
302 .min_uV = MAX8660_LDO67_MIN_UV,
303 .uV_step = MAX8660_LDO67_STEP,
308 .ops = &max8660_ldo67_ops,
309 .type = REGULATOR_VOLTAGE,
310 .n_voltages = MAX8660_LDO67_MAX_SEL + 1,
311 .owner = THIS_MODULE,
312 .min_uV = MAX8660_LDO67_MIN_UV,
313 .uV_step = MAX8660_LDO67_STEP,
323 static const struct of_device_id max8660_dt_ids[] = {
324 { .compatible = "maxim,max8660", .data = (void *) MAX8660 },
325 { .compatible = "maxim,max8661", .data = (void *) MAX8661 },
328 MODULE_DEVICE_TABLE(of, max8660_dt_ids);
330 static int max8660_pdata_from_dt(struct device *dev,
331 struct device_node **of_node,
332 struct max8660_platform_data *pdata)
335 struct device_node *np;
336 struct max8660_subdev_data *sub;
337 struct of_regulator_match rmatch[ARRAY_SIZE(max8660_reg)];
339 np = of_get_child_by_name(dev->of_node, "regulators");
341 dev_err(dev, "missing 'regulators' subnode in DT\n");
345 for (i = 0; i < ARRAY_SIZE(rmatch); i++)
346 rmatch[i].name = max8660_reg[i].name;
348 matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(rmatch));
353 pdata->subdevs = devm_kzalloc(dev, sizeof(struct max8660_subdev_data) *
354 matched, GFP_KERNEL);
358 pdata->num_subdevs = matched;
359 sub = pdata->subdevs;
361 for (i = 0; i < matched; i++) {
363 sub->name = rmatch[i].name;
364 sub->platform_data = rmatch[i].init_data;
365 of_node[i] = rmatch[i].of_node;
372 static inline int max8660_pdata_from_dt(struct device *dev,
373 struct device_node **of_node,
374 struct max8660_platform_data *pdata)
380 static int max8660_probe(struct i2c_client *client,
381 const struct i2c_device_id *i2c_id)
383 struct device *dev = &client->dev;
384 struct max8660_platform_data *pdata = dev_get_platdata(dev);
385 struct regulator_config config = { };
386 struct max8660 *max8660;
387 int boot_on, i, id, ret = -EINVAL;
388 struct device_node *of_node[MAX8660_V_END];
391 if (dev->of_node && !pdata) {
392 const struct of_device_id *id;
393 struct max8660_platform_data pdata_of;
395 id = of_match_device(of_match_ptr(max8660_dt_ids), dev);
399 ret = max8660_pdata_from_dt(dev, of_node, &pdata_of);
404 type = (unsigned long) id->data;
406 type = i2c_id->driver_data;
407 memset(of_node, 0, sizeof(of_node));
410 if (pdata->num_subdevs > MAX8660_V_END) {
411 dev_err(dev, "Too many regulators found!\n");
415 max8660 = devm_kzalloc(dev, sizeof(struct max8660), GFP_KERNEL);
419 max8660->client = client;
421 if (pdata->en34_is_high) {
422 /* Simulate always on */
423 max8660->shadow_regs[MAX8660_OVER1] = 5;
425 /* Otherwise devices can be toggled via software */
426 max8660_dcdc_ops.enable = max8660_dcdc_enable;
427 max8660_dcdc_ops.disable = max8660_dcdc_disable;
431 * First, set up shadow registers to prevent glitches. As some
432 * registers are shared between regulators, everything must be properly
433 * set up for all regulators in advance.
435 max8660->shadow_regs[MAX8660_ADTV1] =
436 max8660->shadow_regs[MAX8660_ADTV2] =
437 max8660->shadow_regs[MAX8660_SDTV1] =
438 max8660->shadow_regs[MAX8660_SDTV2] = 0x1b;
439 max8660->shadow_regs[MAX8660_MDTV1] =
440 max8660->shadow_regs[MAX8660_MDTV2] = 0x04;
442 for (i = 0; i < pdata->num_subdevs; i++) {
444 if (!pdata->subdevs[i].platform_data)
447 boot_on = pdata->subdevs[i].platform_data->constraints.boot_on;
449 switch (pdata->subdevs[i].id) {
452 max8660->shadow_regs[MAX8660_OVER1] |= 1;
457 max8660->shadow_regs[MAX8660_OVER1] |= 4;
465 max8660->shadow_regs[MAX8660_OVER2] |= 2;
469 if (type == MAX8661) {
470 dev_err(dev, "Regulator not on this chip!\n");
475 max8660->shadow_regs[MAX8660_OVER2] |= 4;
479 dev_err(dev, "invalid regulator %s\n",
480 pdata->subdevs[i].name);
485 /* Finally register devices */
486 for (i = 0; i < pdata->num_subdevs; i++) {
487 struct regulator_dev *rdev;
489 id = pdata->subdevs[i].id;
492 config.init_data = pdata->subdevs[i].platform_data;
493 config.of_node = of_node[i];
494 config.driver_data = max8660;
496 rdev = devm_regulator_register(&client->dev,
497 &max8660_reg[id], &config);
500 dev_err(&client->dev, "failed to register %s\n",
501 max8660_reg[id].name);
502 return PTR_ERR(rdev);
506 i2c_set_clientdata(client, max8660);
510 static const struct i2c_device_id max8660_id[] = {
511 { .name = "max8660", .driver_data = MAX8660 },
512 { .name = "max8661", .driver_data = MAX8661 },
515 MODULE_DEVICE_TABLE(i2c, max8660_id);
517 static struct i2c_driver max8660_driver = {
518 .probe = max8660_probe,
521 .owner = THIS_MODULE,
523 .id_table = max8660_id,
526 static int __init max8660_init(void)
528 return i2c_add_driver(&max8660_driver);
530 subsys_initcall(max8660_init);
532 static void __exit max8660_exit(void)
534 i2c_del_driver(&max8660_driver);
536 module_exit(max8660_exit);
538 /* Module information */
539 MODULE_DESCRIPTION("MAXIM 8660/8661 voltage regulator driver");
540 MODULE_AUTHOR("Wolfram Sang");
541 MODULE_LICENSE("GPL v2");