2 * Copyright (C) ST-Ericsson SA 2010
4 * License Terms: GNU General Public License v2
6 * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
7 * Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
9 * AB8500 peripheral regulators
11 * AB8500 supports the following regulators:
12 * VAUX1/2/3, VINTCORE, VTVOUT, VAUDIO, VAMIC1/2, VDMIC, VANA
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/err.h>
17 #include <linux/platform_device.h>
18 #include <linux/mfd/ab8500.h>
19 #include <linux/mfd/abx500.h>
20 #include <linux/regulator/driver.h>
21 #include <linux/regulator/machine.h>
22 #include <linux/regulator/ab8500.h>
25 * struct ab8500_regulator_info - ab8500 regulator information
26 * @dev: device pointer
27 * @desc: regulator description
28 * @regulator_dev: regulator device
29 * @max_uV: maximum voltage (for variable voltage supplies)
30 * @min_uV: minimum voltage (for variable voltage supplies)
31 * @fixed_uV: typical voltage (for fixed voltage supplies)
32 * @update_bank: bank to control on/off
33 * @update_reg: register to control on/off
34 * @update_mask: mask to enable/disable regulator
35 * @update_val_enable: bits to enable the regulator in normal (high power) mode
36 * @voltage_bank: bank to control regulator voltage
37 * @voltage_reg: register to control regulator voltage
38 * @voltage_mask: mask to control regulator voltage
39 * @voltages: supported voltage table
40 * @voltages_len: number of supported voltages for the regulator
42 struct ab8500_regulator_info {
44 struct regulator_desc desc;
45 struct regulator_dev *regulator;
60 /* voltage tables for the vauxn/vintcore supplies */
61 static const int ldo_vauxn_voltages[] = {
80 static const int ldo_vaux3_voltages[] = {
91 static const int ldo_vintcore_voltages[] = {
101 static int ab8500_regulator_enable(struct regulator_dev *rdev)
103 int regulator_id, ret;
104 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
106 regulator_id = rdev_get_id(rdev);
107 if (regulator_id >= AB8500_NUM_REGULATORS)
110 ret = abx500_mask_and_set_register_interruptible(info->dev,
111 info->update_bank, info->update_reg,
112 info->update_mask, info->update_val_enable);
114 dev_err(rdev_get_dev(rdev),
115 "couldn't set enable bits for regulator\n");
119 static int ab8500_regulator_disable(struct regulator_dev *rdev)
121 int regulator_id, ret;
122 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
124 regulator_id = rdev_get_id(rdev);
125 if (regulator_id >= AB8500_NUM_REGULATORS)
128 ret = abx500_mask_and_set_register_interruptible(info->dev,
129 info->update_bank, info->update_reg,
130 info->update_mask, 0x0);
132 dev_err(rdev_get_dev(rdev),
133 "couldn't set disable bits for regulator\n");
137 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
139 int regulator_id, ret;
140 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
143 regulator_id = rdev_get_id(rdev);
144 if (regulator_id >= AB8500_NUM_REGULATORS)
147 ret = abx500_get_register_interruptible(info->dev,
148 info->update_bank, info->update_reg, &value);
150 dev_err(rdev_get_dev(rdev),
151 "couldn't read 0x%x register\n", info->update_reg);
155 if (value & info->update_mask)
161 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
164 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
166 regulator_id = rdev_get_id(rdev);
167 if (regulator_id >= AB8500_NUM_REGULATORS)
170 /* return the uV for the fixed regulators */
172 return info->fixed_uV;
174 if (selector >= info->voltages_len)
177 return info->voltages[selector];
180 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
182 int regulator_id, ret;
183 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
186 regulator_id = rdev_get_id(rdev);
187 if (regulator_id >= AB8500_NUM_REGULATORS)
190 ret = abx500_get_register_interruptible(info->dev, info->voltage_bank,
191 info->voltage_reg, &value);
193 dev_err(rdev_get_dev(rdev),
194 "couldn't read voltage reg for regulator\n");
198 /* vintcore has a different layout */
199 value &= info->voltage_mask;
200 if (regulator_id == AB8500_LDO_INTCORE)
201 ret = info->voltages[value >> 0x3];
203 ret = info->voltages[value];
208 static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
209 int min_uV, int max_uV)
211 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
214 /* check the supported voltage */
215 for (i = 0; i < info->voltages_len; i++) {
216 if ((info->voltages[i] >= min_uV) &&
217 (info->voltages[i] <= max_uV))
224 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
225 int min_uV, int max_uV,
228 int regulator_id, ret;
229 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
231 regulator_id = rdev_get_id(rdev);
232 if (regulator_id >= AB8500_NUM_REGULATORS)
235 /* get the appropriate voltages within the range */
236 ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
238 dev_err(rdev_get_dev(rdev),
239 "couldn't get best voltage for regulator\n");
245 /* set the registers for the request */
246 ret = abx500_mask_and_set_register_interruptible(info->dev,
247 info->voltage_bank, info->voltage_reg,
248 info->voltage_mask, (u8)ret);
250 dev_err(rdev_get_dev(rdev),
251 "couldn't set voltage reg for regulator\n");
256 static struct regulator_ops ab8500_regulator_ops = {
257 .enable = ab8500_regulator_enable,
258 .disable = ab8500_regulator_disable,
259 .is_enabled = ab8500_regulator_is_enabled,
260 .get_voltage = ab8500_regulator_get_voltage,
261 .set_voltage = ab8500_regulator_set_voltage,
262 .list_voltage = ab8500_list_voltage,
265 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
268 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
270 regulator_id = rdev_get_id(rdev);
271 if (regulator_id >= AB8500_NUM_REGULATORS)
274 return info->fixed_uV;
277 static struct regulator_ops ab8500_ldo_fixed_ops = {
278 .enable = ab8500_regulator_enable,
279 .disable = ab8500_regulator_disable,
280 .is_enabled = ab8500_regulator_is_enabled,
281 .get_voltage = ab8500_fixed_get_voltage,
282 .list_voltage = ab8500_list_voltage,
285 #define AB8500_LDO(_id, _min_mV, _max_mV, \
286 _u_bank, _u_reg, _u_mask, _u_val_enable, \
287 _v_bank, _v_reg, _v_mask, _v_table, _v_table_len) \
288 [AB8500_LDO_##_id] = { \
290 .name = "LDO-" #_id, \
291 .ops = &ab8500_regulator_ops, \
292 .type = REGULATOR_VOLTAGE, \
293 .id = AB8500_LDO_##_id, \
294 .owner = THIS_MODULE, \
296 .min_uV = (_min_mV) * 1000, \
297 .max_uV = (_max_mV) * 1000, \
298 .update_bank = _u_bank, \
299 .update_reg = _u_reg, \
300 .update_mask = _u_mask, \
301 .update_val_enable = _u_val_enable, \
302 .voltage_bank = _v_bank, \
303 .voltage_reg = _v_reg, \
304 .voltage_mask = _v_mask, \
305 .voltages = _v_table, \
306 .voltages_len = _v_table_len, \
310 #define AB8500_FIXED_LDO(_id, _fixed_mV, \
311 _u_bank, _u_reg, _u_mask, _u_val_enable) \
312 [AB8500_LDO_##_id] = { \
314 .name = "LDO-" #_id, \
315 .ops = &ab8500_ldo_fixed_ops, \
316 .type = REGULATOR_VOLTAGE, \
317 .id = AB8500_LDO_##_id, \
318 .owner = THIS_MODULE, \
320 .fixed_uV = (_fixed_mV) * 1000, \
321 .update_bank = _u_bank, \
322 .update_reg = _u_reg, \
323 .update_mask = _u_mask, \
324 .update_val_enable = _u_val_enable, \
327 static struct ab8500_regulator_info ab8500_regulator_info[] = {
329 * Variable Voltage Regulators
330 * name, min mV, max mV,
331 * update bank, reg, mask, enable val
332 * volt bank, reg, mask, table, table length
334 AB8500_LDO(AUX1, 1100, 3300,
335 0x04, 0x09, 0x03, 0x01, 0x04, 0x1f, 0x0f,
336 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
337 AB8500_LDO(AUX2, 1100, 3300,
338 0x04, 0x09, 0x0c, 0x04, 0x04, 0x20, 0x0f,
339 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
340 AB8500_LDO(AUX3, 1100, 3300,
341 0x04, 0x0a, 0x03, 0x01, 0x04, 0x21, 0x07,
342 ldo_vaux3_voltages, ARRAY_SIZE(ldo_vaux3_voltages)),
343 AB8500_LDO(INTCORE, 1100, 3300,
344 0x03, 0x80, 0x44, 0x04, 0x03, 0x80, 0x38,
345 ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)),
348 * Fixed Voltage Regulators
350 * update bank, reg, mask, enable val
352 AB8500_FIXED_LDO(TVOUT, 2000, 0x03, 0x80, 0x82, 0x02),
353 AB8500_FIXED_LDO(AUDIO, 2000, 0x03, 0x83, 0x02, 0x02),
354 AB8500_FIXED_LDO(ANAMIC1, 2050, 0x03, 0x83, 0x08, 0x08),
355 AB8500_FIXED_LDO(ANAMIC2, 2050, 0x03, 0x83, 0x10, 0x10),
356 AB8500_FIXED_LDO(DMIC, 1800, 0x03, 0x83, 0x04, 0x04),
357 AB8500_FIXED_LDO(ANA, 1200, 0x04, 0x06, 0x0c, 0x04),
360 static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
362 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
363 struct ab8500_platform_data *pdata;
367 dev_err(&pdev->dev, "null mfd parent\n");
370 pdata = dev_get_platdata(ab8500->dev);
372 /* make sure the platform data has the correct size */
373 if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
374 dev_err(&pdev->dev, "platform configuration error\n");
378 /* register all regulators */
379 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
380 struct ab8500_regulator_info *info = NULL;
382 /* assign per-regulator data */
383 info = &ab8500_regulator_info[i];
384 info->dev = &pdev->dev;
386 /* fix for hardware before ab8500v2.0 */
387 if (abx500_get_chip_id(info->dev) < 0x20) {
388 if (info->desc.id == AB8500_LDO_AUX3) {
389 info->desc.n_voltages =
390 ARRAY_SIZE(ldo_vauxn_voltages);
391 info->voltages = ldo_vauxn_voltages;
393 ARRAY_SIZE(ldo_vauxn_voltages);
394 info->voltage_mask = 0xf;
398 /* register regulator with framework */
399 info->regulator = regulator_register(&info->desc, &pdev->dev,
400 &pdata->regulator[i], info);
401 if (IS_ERR(info->regulator)) {
402 err = PTR_ERR(info->regulator);
403 dev_err(&pdev->dev, "failed to register regulator %s\n",
405 /* when we fail, un-register all earlier regulators */
407 info = &ab8500_regulator_info[i];
408 regulator_unregister(info->regulator);
417 static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
421 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
422 struct ab8500_regulator_info *info = NULL;
423 info = &ab8500_regulator_info[i];
424 regulator_unregister(info->regulator);
430 static struct platform_driver ab8500_regulator_driver = {
431 .probe = ab8500_regulator_probe,
432 .remove = __devexit_p(ab8500_regulator_remove),
434 .name = "ab8500-regulator",
435 .owner = THIS_MODULE,
439 static int __init ab8500_regulator_init(void)
443 ret = platform_driver_register(&ab8500_regulator_driver);
445 pr_err("Failed to register ab8500 regulator: %d\n", ret);
449 subsys_initcall(ab8500_regulator_init);
451 static void __exit ab8500_regulator_exit(void)
453 platform_driver_unregister(&ab8500_regulator_driver);
455 module_exit(ab8500_regulator_exit);
457 MODULE_LICENSE("GPL v2");
458 MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
459 MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
460 MODULE_ALIAS("platform:ab8500-regulator");