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 #define MAX8660_DCDC_MIN_UV 725000
49 #define MAX8660_DCDC_MAX_UV 1800000
50 #define MAX8660_DCDC_STEP 25000
51 #define MAX8660_DCDC_MAX_SEL 0x2b
53 #define MAX8660_LDO5_MIN_UV 1700000
54 #define MAX8660_LDO5_MAX_UV 2000000
55 #define MAX8660_LDO5_STEP 25000
56 #define MAX8660_LDO5_MAX_SEL 0x0c
58 #define MAX8660_LDO67_MIN_UV 1800000
59 #define MAX8660_LDO67_MAX_UV 3300000
60 #define MAX8660_LDO67_STEP 100000
61 #define MAX8660_LDO67_MAX_SEL 0x0f
75 MAX8660_N_REGS
, /* not a real register */
79 struct i2c_client
*client
;
80 u8 shadow_regs
[MAX8660_N_REGS
]; /* as chip is write only */
81 struct regulator_dev
*rdev
[];
84 static int max8660_write(struct max8660
*max8660
, u8 reg
, u8 mask
, u8 val
)
86 static const u8 max8660_addresses
[MAX8660_N_REGS
] =
87 { 0x10, 0x12, 0x20, 0x23, 0x24, 0x29, 0x2a, 0x32, 0x33, 0x39, 0x80 };
90 u8 reg_val
= (max8660
->shadow_regs
[reg
] & mask
) | val
;
91 dev_vdbg(&max8660
->client
->dev
, "Writing reg %02x with %02x\n",
92 max8660_addresses
[reg
], reg_val
);
94 ret
= i2c_smbus_write_byte_data(max8660
->client
,
95 max8660_addresses
[reg
], reg_val
);
97 max8660
->shadow_regs
[reg
] = reg_val
;
107 static int max8660_dcdc_is_enabled(struct regulator_dev
*rdev
)
109 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
110 u8 val
= max8660
->shadow_regs
[MAX8660_OVER1
];
111 u8 mask
= (rdev_get_id(rdev
) == MAX8660_V3
) ? 1 : 4;
112 return !!(val
& mask
);
115 static int max8660_dcdc_enable(struct regulator_dev
*rdev
)
117 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
118 u8 bit
= (rdev_get_id(rdev
) == MAX8660_V3
) ? 1 : 4;
119 return max8660_write(max8660
, MAX8660_OVER1
, 0xff, bit
);
122 static int max8660_dcdc_disable(struct regulator_dev
*rdev
)
124 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
125 u8 mask
= (rdev_get_id(rdev
) == MAX8660_V3
) ? ~1 : ~4;
126 return max8660_write(max8660
, MAX8660_OVER1
, mask
, 0);
129 static int max8660_dcdc_list(struct regulator_dev
*rdev
, unsigned selector
)
131 if (selector
> MAX8660_DCDC_MAX_SEL
)
133 return MAX8660_DCDC_MIN_UV
+ selector
* MAX8660_DCDC_STEP
;
136 static int max8660_dcdc_get(struct regulator_dev
*rdev
)
138 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
139 u8 reg
= (rdev_get_id(rdev
) == MAX8660_V3
) ? MAX8660_ADTV2
: MAX8660_SDTV2
;
140 u8 selector
= max8660
->shadow_regs
[reg
];
141 return MAX8660_DCDC_MIN_UV
+ selector
* MAX8660_DCDC_STEP
;
144 static int max8660_dcdc_set(struct regulator_dev
*rdev
, int min_uV
, int max_uV
,
147 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
148 u8 reg
, selector
, bits
;
151 if (min_uV
< MAX8660_DCDC_MIN_UV
|| min_uV
> MAX8660_DCDC_MAX_UV
)
153 if (max_uV
< MAX8660_DCDC_MIN_UV
|| max_uV
> MAX8660_DCDC_MAX_UV
)
156 selector
= DIV_ROUND_UP(min_uV
- MAX8660_DCDC_MIN_UV
,
159 ret
= max8660_dcdc_list(rdev
, selector
);
160 if (ret
< 0 || ret
> max_uV
)
165 reg
= (rdev_get_id(rdev
) == MAX8660_V3
) ? MAX8660_ADTV2
: MAX8660_SDTV2
;
166 ret
= max8660_write(max8660
, reg
, 0, selector
);
170 /* Select target voltage register and activate regulation */
171 bits
= (rdev_get_id(rdev
) == MAX8660_V3
) ? 0x03 : 0x30;
172 return max8660_write(max8660
, MAX8660_VCC1
, 0xff, bits
);
175 static struct regulator_ops max8660_dcdc_ops
= {
176 .is_enabled
= max8660_dcdc_is_enabled
,
177 .list_voltage
= max8660_dcdc_list
,
178 .set_voltage
= max8660_dcdc_set
,
179 .get_voltage
= max8660_dcdc_get
,
187 static int max8660_ldo5_list(struct regulator_dev
*rdev
, unsigned selector
)
189 if (selector
> MAX8660_LDO5_MAX_SEL
)
191 return MAX8660_LDO5_MIN_UV
+ selector
* MAX8660_LDO5_STEP
;
194 static int max8660_ldo5_get(struct regulator_dev
*rdev
)
196 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
197 u8 selector
= max8660
->shadow_regs
[MAX8660_MDTV2
];
199 return MAX8660_LDO5_MIN_UV
+ selector
* MAX8660_LDO5_STEP
;
202 static int max8660_ldo5_set(struct regulator_dev
*rdev
, int min_uV
, int max_uV
,
205 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
209 if (min_uV
< MAX8660_LDO5_MIN_UV
|| min_uV
> MAX8660_LDO5_MAX_UV
)
211 if (max_uV
< MAX8660_LDO5_MIN_UV
|| max_uV
> MAX8660_LDO5_MAX_UV
)
214 selector
= DIV_ROUND_UP(min_uV
- MAX8660_LDO5_MIN_UV
,
217 ret
= max8660_ldo5_list(rdev
, selector
);
218 if (ret
< 0 || ret
> max_uV
)
223 ret
= max8660_write(max8660
, MAX8660_MDTV2
, 0, selector
);
227 /* Select target voltage register and activate regulation */
228 return max8660_write(max8660
, MAX8660_VCC1
, 0xff, 0xc0);
231 static struct regulator_ops max8660_ldo5_ops
= {
232 .list_voltage
= max8660_ldo5_list
,
233 .set_voltage
= max8660_ldo5_set
,
234 .get_voltage
= max8660_ldo5_get
,
242 static int max8660_ldo67_is_enabled(struct regulator_dev
*rdev
)
244 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
245 u8 val
= max8660
->shadow_regs
[MAX8660_OVER2
];
246 u8 mask
= (rdev_get_id(rdev
) == MAX8660_V6
) ? 2 : 4;
247 return !!(val
& mask
);
250 static int max8660_ldo67_enable(struct regulator_dev
*rdev
)
252 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
253 u8 bit
= (rdev_get_id(rdev
) == MAX8660_V6
) ? 2 : 4;
254 return max8660_write(max8660
, MAX8660_OVER2
, 0xff, bit
);
257 static int max8660_ldo67_disable(struct regulator_dev
*rdev
)
259 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
260 u8 mask
= (rdev_get_id(rdev
) == MAX8660_V6
) ? ~2 : ~4;
261 return max8660_write(max8660
, MAX8660_OVER2
, mask
, 0);
264 static int max8660_ldo67_list(struct regulator_dev
*rdev
, unsigned selector
)
266 if (selector
> MAX8660_LDO67_MAX_SEL
)
268 return MAX8660_LDO67_MIN_UV
+ selector
* MAX8660_LDO67_STEP
;
271 static int max8660_ldo67_get(struct regulator_dev
*rdev
)
273 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
274 u8 shift
= (rdev_get_id(rdev
) == MAX8660_V6
) ? 0 : 4;
275 u8 selector
= (max8660
->shadow_regs
[MAX8660_L12VCR
] >> shift
) & 0xf;
277 return MAX8660_LDO67_MIN_UV
+ selector
* MAX8660_LDO67_STEP
;
280 static int max8660_ldo67_set(struct regulator_dev
*rdev
, int min_uV
,
281 int max_uV
, unsigned int *s
)
283 struct max8660
*max8660
= rdev_get_drvdata(rdev
);
287 if (min_uV
< MAX8660_LDO67_MIN_UV
|| min_uV
> MAX8660_LDO67_MAX_UV
)
289 if (max_uV
< MAX8660_LDO67_MIN_UV
|| max_uV
> MAX8660_LDO67_MAX_UV
)
292 selector
= DIV_ROUND_UP(min_uV
- MAX8660_LDO67_MIN_UV
,
295 ret
= max8660_ldo67_list(rdev
, selector
);
296 if (ret
< 0 || ret
> max_uV
)
301 if (rdev_get_id(rdev
) == MAX8660_V6
)
302 return max8660_write(max8660
, MAX8660_L12VCR
, 0xf0, selector
);
304 return max8660_write(max8660
, MAX8660_L12VCR
, 0x0f, selector
<< 4);
307 static struct regulator_ops max8660_ldo67_ops
= {
308 .is_enabled
= max8660_ldo67_is_enabled
,
309 .enable
= max8660_ldo67_enable
,
310 .disable
= max8660_ldo67_disable
,
311 .list_voltage
= max8660_ldo67_list
,
312 .get_voltage
= max8660_ldo67_get
,
313 .set_voltage
= max8660_ldo67_set
,
316 static struct regulator_desc max8660_reg
[] = {
320 .ops
= &max8660_dcdc_ops
,
321 .type
= REGULATOR_VOLTAGE
,
322 .n_voltages
= MAX8660_DCDC_MAX_SEL
+ 1,
323 .owner
= THIS_MODULE
,
328 .ops
= &max8660_dcdc_ops
,
329 .type
= REGULATOR_VOLTAGE
,
330 .n_voltages
= MAX8660_DCDC_MAX_SEL
+ 1,
331 .owner
= THIS_MODULE
,
336 .ops
= &max8660_ldo5_ops
,
337 .type
= REGULATOR_VOLTAGE
,
338 .n_voltages
= MAX8660_LDO5_MAX_SEL
+ 1,
339 .owner
= THIS_MODULE
,
344 .ops
= &max8660_ldo67_ops
,
345 .type
= REGULATOR_VOLTAGE
,
346 .n_voltages
= MAX8660_LDO67_MAX_SEL
+ 1,
347 .owner
= THIS_MODULE
,
352 .ops
= &max8660_ldo67_ops
,
353 .type
= REGULATOR_VOLTAGE
,
354 .n_voltages
= MAX8660_LDO67_MAX_SEL
+ 1,
355 .owner
= THIS_MODULE
,
359 static int __devinit
max8660_probe(struct i2c_client
*client
,
360 const struct i2c_device_id
*i2c_id
)
362 struct regulator_dev
**rdev
;
363 struct max8660_platform_data
*pdata
= client
->dev
.platform_data
;
364 struct max8660
*max8660
;
365 int boot_on
, i
, id
, ret
= -EINVAL
;
367 if (pdata
->num_subdevs
> MAX8660_V_END
) {
368 dev_err(&client
->dev
, "Too many regulators found!\n");
372 max8660
= kzalloc(sizeof(struct max8660
) +
373 sizeof(struct regulator_dev
*) * MAX8660_V_END
,
380 max8660
->client
= client
;
381 rdev
= max8660
->rdev
;
383 if (pdata
->en34_is_high
) {
384 /* Simulate always on */
385 max8660
->shadow_regs
[MAX8660_OVER1
] = 5;
387 /* Otherwise devices can be toggled via software */
388 max8660_dcdc_ops
.enable
= max8660_dcdc_enable
;
389 max8660_dcdc_ops
.disable
= max8660_dcdc_disable
;
393 * First, set up shadow registers to prevent glitches. As some
394 * registers are shared between regulators, everything must be properly
395 * set up for all regulators in advance.
397 max8660
->shadow_regs
[MAX8660_ADTV1
] =
398 max8660
->shadow_regs
[MAX8660_ADTV2
] =
399 max8660
->shadow_regs
[MAX8660_SDTV1
] =
400 max8660
->shadow_regs
[MAX8660_SDTV2
] = 0x1b;
401 max8660
->shadow_regs
[MAX8660_MDTV1
] =
402 max8660
->shadow_regs
[MAX8660_MDTV2
] = 0x04;
404 for (i
= 0; i
< pdata
->num_subdevs
; i
++) {
406 if (!pdata
->subdevs
[i
].platform_data
)
409 boot_on
= pdata
->subdevs
[i
].platform_data
->constraints
.boot_on
;
411 switch (pdata
->subdevs
[i
].id
) {
414 max8660
->shadow_regs
[MAX8660_OVER1
] |= 1;
419 max8660
->shadow_regs
[MAX8660_OVER1
] |= 4;
427 max8660
->shadow_regs
[MAX8660_OVER2
] |= 2;
431 if (!strcmp(i2c_id
->name
, "max8661")) {
432 dev_err(&client
->dev
, "Regulator not on this chip!\n");
437 max8660
->shadow_regs
[MAX8660_OVER2
] |= 4;
441 dev_err(&client
->dev
, "invalid regulator %s\n",
442 pdata
->subdevs
[i
].name
);
447 /* Finally register devices */
448 for (i
= 0; i
< pdata
->num_subdevs
; i
++) {
450 id
= pdata
->subdevs
[i
].id
;
452 rdev
[i
] = regulator_register(&max8660_reg
[id
], &client
->dev
,
453 pdata
->subdevs
[i
].platform_data
,
455 if (IS_ERR(rdev
[i
])) {
456 ret
= PTR_ERR(rdev
[i
]);
457 dev_err(&client
->dev
, "failed to register %s\n",
458 max8660_reg
[id
].name
);
463 i2c_set_clientdata(client
, max8660
);
464 dev_info(&client
->dev
, "Maxim 8660/8661 regulator driver loaded\n");
469 regulator_unregister(rdev
[i
]);
476 static int __devexit
max8660_remove(struct i2c_client
*client
)
478 struct max8660
*max8660
= i2c_get_clientdata(client
);
481 for (i
= 0; i
< MAX8660_V_END
; i
++)
482 if (max8660
->rdev
[i
])
483 regulator_unregister(max8660
->rdev
[i
]);
489 static const struct i2c_device_id max8660_id
[] = {
494 MODULE_DEVICE_TABLE(i2c
, max8660_id
);
496 static struct i2c_driver max8660_driver
= {
497 .probe
= max8660_probe
,
498 .remove
= __devexit_p(max8660_remove
),
501 .owner
= THIS_MODULE
,
503 .id_table
= max8660_id
,
506 static int __init
max8660_init(void)
508 return i2c_add_driver(&max8660_driver
);
510 subsys_initcall(max8660_init
);
512 static void __exit
max8660_exit(void)
514 i2c_del_driver(&max8660_driver
);
516 module_exit(max8660_exit
);
518 /* Module information */
519 MODULE_DESCRIPTION("MAXIM 8660/8661 voltage regulator driver");
520 MODULE_AUTHOR("Wolfram Sang");
521 MODULE_LICENSE("GPL v2");