2 * Copyright (C) ST-Ericsson SA 2010
4 * License Terms: GNU General Public License v2
6 * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
8 * AB8500 peripheral regulators
10 * AB8500 supports the following regulators,
11 * LDOs - VAUDIO, VANAMIC2/2, VDIGMIC, VINTCORE12, VTVOUT,
14 * for DB8500 cut 1.0 and previous versions of the silicon, all accesses
15 * to registers are through the DB8500 SPI. In cut 1.1 onwards, these
16 * accesses are through the DB8500 PRCMU I2C
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/err.h>
22 #include <linux/platform_device.h>
23 #include <linux/mfd/ab8500.h>
24 #include <linux/mfd/abx500.h>
25 #include <linux/regulator/driver.h>
26 #include <linux/regulator/machine.h>
27 #include <linux/regulator/ab8500.h>
30 * struct ab8500_regulator_info - ab8500 regulator information
31 * @desc: regulator description
32 * @regulator_dev: regulator device
33 * @max_uV: maximum voltage (for variable voltage supplies)
34 * @min_uV: minimum voltage (for variable voltage supplies)
35 * @fixed_uV: typical voltage (for fixed voltage supplies)
36 * @update_bank: bank to control on/off
37 * @update_reg: register to control on/off
38 * @mask: mask to enable/disable regulator
39 * @enable: bits to enable the regulator in normal(high power) mode
40 * @voltage_bank: bank to control regulator voltage
41 * @voltage_reg: register to control regulator voltage
42 * @voltage_mask: mask to control regulator voltage
43 * @supported_voltages: supported voltage table
44 * @voltages_len: number of supported voltages for the regulator
46 struct ab8500_regulator_info {
48 struct regulator_desc desc;
49 struct regulator_dev *regulator;
60 int const *supported_voltages;
64 /* voltage tables for the vauxn/vintcore supplies */
65 static const int ldo_vauxn_voltages[] = {
84 static const int ldo_vaux3_voltages[] = {
95 static const int ldo_vintcore_voltages[] = {
105 static int ab8500_regulator_enable(struct regulator_dev *rdev)
107 int regulator_id, ret;
108 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
110 regulator_id = rdev_get_id(rdev);
111 if (regulator_id >= AB8500_NUM_REGULATORS)
114 ret = abx500_mask_and_set_register_interruptible(info->dev,
115 info->update_bank, info->update_reg, info->mask, info->enable);
117 dev_err(rdev_get_dev(rdev),
118 "couldn't set enable bits for regulator\n");
122 static int ab8500_regulator_disable(struct regulator_dev *rdev)
124 int regulator_id, ret;
125 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
127 regulator_id = rdev_get_id(rdev);
128 if (regulator_id >= AB8500_NUM_REGULATORS)
131 ret = abx500_mask_and_set_register_interruptible(info->dev,
132 info->update_bank, info->update_reg, info->mask, 0x0);
134 dev_err(rdev_get_dev(rdev),
135 "couldn't set disable bits for regulator\n");
139 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
141 int regulator_id, ret;
142 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
145 regulator_id = rdev_get_id(rdev);
146 if (regulator_id >= AB8500_NUM_REGULATORS)
149 ret = abx500_get_register_interruptible(info->dev,
150 info->update_bank, info->update_reg, &value);
152 dev_err(rdev_get_dev(rdev),
153 "couldn't read 0x%x register\n", info->update_reg);
157 if (value & info->mask)
163 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
166 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
168 regulator_id = rdev_get_id(rdev);
169 if (regulator_id >= AB8500_NUM_REGULATORS)
172 /* return the uV for the fixed regulators */
174 return info->fixed_uV;
176 if (selector >= info->voltages_len)
179 return info->supported_voltages[selector];
182 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
184 int regulator_id, ret;
185 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
188 regulator_id = rdev_get_id(rdev);
189 if (regulator_id >= AB8500_NUM_REGULATORS)
192 ret = abx500_get_register_interruptible(info->dev, info->voltage_bank,
193 info->voltage_reg, &value);
195 dev_err(rdev_get_dev(rdev),
196 "couldn't read voltage reg for regulator\n");
200 /* vintcore has a different layout */
201 value &= info->voltage_mask;
202 if (regulator_id == AB8500_LDO_INTCORE)
203 ret = info->supported_voltages[value >> 0x3];
205 ret = info->supported_voltages[value];
210 static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
211 int min_uV, int max_uV)
213 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
216 /* check the supported voltage */
217 for (i = 0; i < info->voltages_len; i++) {
218 if ((info->supported_voltages[i] >= min_uV) &&
219 (info->supported_voltages[i] <= max_uV))
226 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
227 int min_uV, int max_uV,
230 int regulator_id, ret;
231 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
233 regulator_id = rdev_get_id(rdev);
234 if (regulator_id >= AB8500_NUM_REGULATORS)
237 /* get the appropriate voltages within the range */
238 ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
240 dev_err(rdev_get_dev(rdev),
241 "couldn't get best voltage for regulator\n");
247 /* set the registers for the request */
248 ret = abx500_mask_and_set_register_interruptible(info->dev,
249 info->voltage_bank, info->voltage_reg,
250 info->voltage_mask, (u8)ret);
252 dev_err(rdev_get_dev(rdev),
253 "couldn't set voltage reg for regulator\n");
258 static struct regulator_ops ab8500_regulator_ops = {
259 .enable = ab8500_regulator_enable,
260 .disable = ab8500_regulator_disable,
261 .is_enabled = ab8500_regulator_is_enabled,
262 .get_voltage = ab8500_regulator_get_voltage,
263 .set_voltage = ab8500_regulator_set_voltage,
264 .list_voltage = ab8500_list_voltage,
267 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
270 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
272 regulator_id = rdev_get_id(rdev);
273 if (regulator_id >= AB8500_NUM_REGULATORS)
276 return info->fixed_uV;
279 static struct regulator_ops ab8500_ldo_fixed_ops = {
280 .enable = ab8500_regulator_enable,
281 .disable = ab8500_regulator_disable,
282 .is_enabled = ab8500_regulator_is_enabled,
283 .get_voltage = ab8500_fixed_get_voltage,
284 .list_voltage = ab8500_list_voltage,
287 #define AB8500_LDO(_id, min, max, bank, reg, reg_mask, \
288 reg_enable, volt_bank, volt_reg, volt_mask, \
289 voltages, len_volts) \
292 .name = "LDO-" #_id, \
293 .ops = &ab8500_regulator_ops, \
294 .type = REGULATOR_VOLTAGE, \
295 .id = AB8500_LDO_##_id, \
296 .owner = THIS_MODULE, \
298 .min_uV = (min) * 1000, \
299 .max_uV = (max) * 1000, \
300 .update_bank = bank, \
303 .enable = reg_enable, \
304 .voltage_bank = volt_bank, \
305 .voltage_reg = volt_reg, \
306 .voltage_mask = volt_mask, \
307 .supported_voltages = voltages, \
308 .voltages_len = len_volts, \
312 #define AB8500_FIXED_LDO(_id, fixed, bank, reg, \
313 reg_mask, reg_enable) \
316 .name = "LDO-" #_id, \
317 .ops = &ab8500_ldo_fixed_ops, \
318 .type = REGULATOR_VOLTAGE, \
319 .id = AB8500_LDO_##_id, \
320 .owner = THIS_MODULE, \
322 .fixed_uV = fixed * 1000, \
323 .update_bank = bank, \
326 .enable = reg_enable, \
329 static struct ab8500_regulator_info ab8500_regulator_info[] = {
331 * Variable Voltage LDOs
332 * name, min uV, max uV, ctrl bank, ctrl reg, reg mask, enable mask,
333 * volt ctrl bank, volt ctrl reg, volt ctrl mask, volt table,
334 * num supported volts
336 AB8500_LDO(AUX1, 1100, 3300, 0x04, 0x09, 0x3, 0x1, 0x04, 0x1f, 0xf,
337 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
338 AB8500_LDO(AUX2, 1100, 3300, 0x04, 0x09, 0xc, 0x4, 0x04, 0x20, 0xf,
339 ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
340 AB8500_LDO(AUX3, 1100, 3300, 0x04, 0x0a, 0x3, 0x1, 0x04, 0x21, 0x7,
341 ldo_vaux3_voltages, ARRAY_SIZE(ldo_vaux3_voltages)),
342 AB8500_LDO(INTCORE, 1100, 3300, 0x03, 0x80, 0x44, 0x4, 0x03, 0x80, 0x38,
343 ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)),
347 * name, o/p uV, ctrl bank, ctrl reg, enable, disable
349 AB8500_FIXED_LDO(TVOUT, 2000, 0x03, 0x80, 0x82, 0x2),
350 AB8500_FIXED_LDO(AUDIO, 2000, 0x03, 0x83, 0x2, 0x2),
351 AB8500_FIXED_LDO(ANAMIC1, 2050, 0x03, 0x83, 0x08, 0x08),
352 AB8500_FIXED_LDO(ANAMIC2, 2050, 0x03, 0x83, 0x10, 0x10),
353 AB8500_FIXED_LDO(DMIC, 1800, 0x03, 0x83, 0x04, 0x04),
354 AB8500_FIXED_LDO(ANA, 1200, 0x04, 0x06, 0xc, 0x4),
357 static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
359 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
360 struct ab8500_platform_data *pdata;
364 dev_err(&pdev->dev, "null mfd parent\n");
367 pdata = dev_get_platdata(ab8500->dev);
369 /* make sure the platform data has the correct size */
370 if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
371 dev_err(&pdev->dev, "platform configuration error\n");
375 /* register all regulators */
376 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
377 struct ab8500_regulator_info *info = NULL;
379 /* assign per-regulator data */
380 info = &ab8500_regulator_info[i];
381 info->dev = &pdev->dev;
383 /* fix for hardware before ab8500v2.0 */
384 if (abx500_get_chip_id(info->dev) < 0x20) {
385 if (info->desc.id == AB8500_LDO_AUX3) {
386 info->desc.n_voltages =
387 ARRAY_SIZE(ldo_vauxn_voltages);
388 info->supported_voltages = ldo_vauxn_voltages;
390 ARRAY_SIZE(ldo_vauxn_voltages);
391 info->voltage_mask = 0xf;
395 /* register regulator with framework */
396 info->regulator = regulator_register(&info->desc, &pdev->dev,
397 &pdata->regulator[i], info);
398 if (IS_ERR(info->regulator)) {
399 err = PTR_ERR(info->regulator);
400 dev_err(&pdev->dev, "failed to register regulator %s\n",
402 /* when we fail, un-register all earlier regulators */
404 info = &ab8500_regulator_info[i];
405 regulator_unregister(info->regulator);
414 static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
418 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
419 struct ab8500_regulator_info *info = NULL;
420 info = &ab8500_regulator_info[i];
421 regulator_unregister(info->regulator);
427 static struct platform_driver ab8500_regulator_driver = {
428 .probe = ab8500_regulator_probe,
429 .remove = __devexit_p(ab8500_regulator_remove),
431 .name = "ab8500-regulator",
432 .owner = THIS_MODULE,
436 static int __init ab8500_regulator_init(void)
440 ret = platform_driver_register(&ab8500_regulator_driver);
442 pr_err("Failed to register ab8500 regulator: %d\n", ret);
446 subsys_initcall(ab8500_regulator_init);
448 static void __exit ab8500_regulator_exit(void)
450 platform_driver_unregister(&ab8500_regulator_driver);
452 module_exit(ab8500_regulator_exit);
454 MODULE_LICENSE("GPL v2");
455 MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
456 MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
457 MODULE_ALIAS("platform:ab8500-regulator");