4 * Regulator driver for TPS65073 PMIC
6 * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation version 2.
12 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
13 * whether express or implied; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/err.h>
22 #include <linux/platform_device.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regulator/tps6507x.h>
27 #include <linux/slab.h>
28 #include <linux/mfd/tps6507x.h>
29 #include <linux/regulator/of_regulator.h>
32 #define TPS6507X_DCDC_1 0
33 #define TPS6507X_DCDC_2 1
34 #define TPS6507X_DCDC_3 2
36 #define TPS6507X_LDO_1 3
37 #define TPS6507X_LDO_2 4
39 #define TPS6507X_MAX_REG_ID TPS6507X_LDO_2
41 /* Number of step-down converters available */
42 #define TPS6507X_NUM_DCDC 3
43 /* Number of LDO voltage regulators available */
44 #define TPS6507X_NUM_LDO 2
45 /* Number of total regulators available */
46 #define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
48 /* Supported voltage values for regulators (in microVolts) */
49 static const unsigned int VDCDCx_VSEL_table
[] = {
50 725000, 750000, 775000, 800000,
51 825000, 850000, 875000, 900000,
52 925000, 950000, 975000, 1000000,
53 1025000, 1050000, 1075000, 1100000,
54 1125000, 1150000, 1175000, 1200000,
55 1225000, 1250000, 1275000, 1300000,
56 1325000, 1350000, 1375000, 1400000,
57 1425000, 1450000, 1475000, 1500000,
58 1550000, 1600000, 1650000, 1700000,
59 1750000, 1800000, 1850000, 1900000,
60 1950000, 2000000, 2050000, 2100000,
61 2150000, 2200000, 2250000, 2300000,
62 2350000, 2400000, 2450000, 2500000,
63 2550000, 2600000, 2650000, 2700000,
64 2750000, 2800000, 2850000, 2900000,
65 3000000, 3100000, 3200000, 3300000,
68 static const unsigned int LDO1_VSEL_table
[] = {
69 1000000, 1100000, 1200000, 1250000,
70 1300000, 1350000, 1400000, 1500000,
71 1600000, 1800000, 2500000, 2750000,
72 2800000, 3000000, 3100000, 3300000,
75 /* The voltage mapping table for LDO2 is the same as VDCDCx */
76 #define LDO2_VSEL_table VDCDCx_VSEL_table
81 const unsigned int *table
;
83 /* Does DCDC high or the low register defines output voltage? */
87 static struct tps_info tps6507x_pmic_regs
[] = {
90 .table_len
= ARRAY_SIZE(VDCDCx_VSEL_table
),
91 .table
= VDCDCx_VSEL_table
,
95 .table_len
= ARRAY_SIZE(VDCDCx_VSEL_table
),
96 .table
= VDCDCx_VSEL_table
,
100 .table_len
= ARRAY_SIZE(VDCDCx_VSEL_table
),
101 .table
= VDCDCx_VSEL_table
,
105 .table_len
= ARRAY_SIZE(LDO1_VSEL_table
),
106 .table
= LDO1_VSEL_table
,
110 .table_len
= ARRAY_SIZE(LDO2_VSEL_table
),
111 .table
= LDO2_VSEL_table
,
115 struct tps6507x_pmic
{
116 struct regulator_desc desc
[TPS6507X_NUM_REGULATOR
];
117 struct tps6507x_dev
*mfd
;
118 struct tps_info
*info
[TPS6507X_NUM_REGULATOR
];
119 struct mutex io_lock
;
121 static inline int tps6507x_pmic_read(struct tps6507x_pmic
*tps
, u8 reg
)
126 err
= tps
->mfd
->read_dev(tps
->mfd
, reg
, 1, &val
);
134 static inline int tps6507x_pmic_write(struct tps6507x_pmic
*tps
, u8 reg
, u8 val
)
136 return tps
->mfd
->write_dev(tps
->mfd
, reg
, 1, &val
);
139 static int tps6507x_pmic_set_bits(struct tps6507x_pmic
*tps
, u8 reg
, u8 mask
)
143 mutex_lock(&tps
->io_lock
);
145 data
= tps6507x_pmic_read(tps
, reg
);
147 dev_err(tps
->mfd
->dev
, "Read from reg 0x%x failed\n", reg
);
153 err
= tps6507x_pmic_write(tps
, reg
, data
);
155 dev_err(tps
->mfd
->dev
, "Write for reg 0x%x failed\n", reg
);
158 mutex_unlock(&tps
->io_lock
);
162 static int tps6507x_pmic_clear_bits(struct tps6507x_pmic
*tps
, u8 reg
, u8 mask
)
166 mutex_lock(&tps
->io_lock
);
168 data
= tps6507x_pmic_read(tps
, reg
);
170 dev_err(tps
->mfd
->dev
, "Read from reg 0x%x failed\n", reg
);
176 err
= tps6507x_pmic_write(tps
, reg
, data
);
178 dev_err(tps
->mfd
->dev
, "Write for reg 0x%x failed\n", reg
);
181 mutex_unlock(&tps
->io_lock
);
185 static int tps6507x_pmic_reg_read(struct tps6507x_pmic
*tps
, u8 reg
)
189 mutex_lock(&tps
->io_lock
);
191 data
= tps6507x_pmic_read(tps
, reg
);
193 dev_err(tps
->mfd
->dev
, "Read from reg 0x%x failed\n", reg
);
195 mutex_unlock(&tps
->io_lock
);
199 static int tps6507x_pmic_reg_write(struct tps6507x_pmic
*tps
, u8 reg
, u8 val
)
203 mutex_lock(&tps
->io_lock
);
205 err
= tps6507x_pmic_write(tps
, reg
, val
);
207 dev_err(tps
->mfd
->dev
, "Write for reg 0x%x failed\n", reg
);
209 mutex_unlock(&tps
->io_lock
);
213 static int tps6507x_pmic_is_enabled(struct regulator_dev
*dev
)
215 struct tps6507x_pmic
*tps
= rdev_get_drvdata(dev
);
216 int data
, rid
= rdev_get_id(dev
);
219 if (rid
< TPS6507X_DCDC_1
|| rid
> TPS6507X_LDO_2
)
222 shift
= TPS6507X_MAX_REG_ID
- rid
;
223 data
= tps6507x_pmic_reg_read(tps
, TPS6507X_REG_CON_CTRL1
);
228 return (data
& 1<<shift
) ? 1 : 0;
231 static int tps6507x_pmic_enable(struct regulator_dev
*dev
)
233 struct tps6507x_pmic
*tps
= rdev_get_drvdata(dev
);
234 int rid
= rdev_get_id(dev
);
237 if (rid
< TPS6507X_DCDC_1
|| rid
> TPS6507X_LDO_2
)
240 shift
= TPS6507X_MAX_REG_ID
- rid
;
241 return tps6507x_pmic_set_bits(tps
, TPS6507X_REG_CON_CTRL1
, 1 << shift
);
244 static int tps6507x_pmic_disable(struct regulator_dev
*dev
)
246 struct tps6507x_pmic
*tps
= rdev_get_drvdata(dev
);
247 int rid
= rdev_get_id(dev
);
250 if (rid
< TPS6507X_DCDC_1
|| rid
> TPS6507X_LDO_2
)
253 shift
= TPS6507X_MAX_REG_ID
- rid
;
254 return tps6507x_pmic_clear_bits(tps
, TPS6507X_REG_CON_CTRL1
,
258 static int tps6507x_pmic_get_voltage_sel(struct regulator_dev
*dev
)
260 struct tps6507x_pmic
*tps
= rdev_get_drvdata(dev
);
261 int data
, rid
= rdev_get_id(dev
);
265 case TPS6507X_DCDC_1
:
266 reg
= TPS6507X_REG_DEFDCDC1
;
267 mask
= TPS6507X_DEFDCDCX_DCDC_MASK
;
269 case TPS6507X_DCDC_2
:
270 if (tps
->info
[rid
]->defdcdc_default
)
271 reg
= TPS6507X_REG_DEFDCDC2_HIGH
;
273 reg
= TPS6507X_REG_DEFDCDC2_LOW
;
274 mask
= TPS6507X_DEFDCDCX_DCDC_MASK
;
276 case TPS6507X_DCDC_3
:
277 if (tps
->info
[rid
]->defdcdc_default
)
278 reg
= TPS6507X_REG_DEFDCDC3_HIGH
;
280 reg
= TPS6507X_REG_DEFDCDC3_LOW
;
281 mask
= TPS6507X_DEFDCDCX_DCDC_MASK
;
284 reg
= TPS6507X_REG_LDO_CTRL1
;
285 mask
= TPS6507X_REG_LDO_CTRL1_LDO1_MASK
;
288 reg
= TPS6507X_REG_DEFLDO2
;
289 mask
= TPS6507X_REG_DEFLDO2_LDO2_MASK
;
295 data
= tps6507x_pmic_reg_read(tps
, reg
);
303 static int tps6507x_pmic_set_voltage_sel(struct regulator_dev
*dev
,
306 struct tps6507x_pmic
*tps
= rdev_get_drvdata(dev
);
307 int data
, rid
= rdev_get_id(dev
);
311 case TPS6507X_DCDC_1
:
312 reg
= TPS6507X_REG_DEFDCDC1
;
313 mask
= TPS6507X_DEFDCDCX_DCDC_MASK
;
315 case TPS6507X_DCDC_2
:
316 if (tps
->info
[rid
]->defdcdc_default
)
317 reg
= TPS6507X_REG_DEFDCDC2_HIGH
;
319 reg
= TPS6507X_REG_DEFDCDC2_LOW
;
320 mask
= TPS6507X_DEFDCDCX_DCDC_MASK
;
322 case TPS6507X_DCDC_3
:
323 if (tps
->info
[rid
]->defdcdc_default
)
324 reg
= TPS6507X_REG_DEFDCDC3_HIGH
;
326 reg
= TPS6507X_REG_DEFDCDC3_LOW
;
327 mask
= TPS6507X_DEFDCDCX_DCDC_MASK
;
330 reg
= TPS6507X_REG_LDO_CTRL1
;
331 mask
= TPS6507X_REG_LDO_CTRL1_LDO1_MASK
;
334 reg
= TPS6507X_REG_DEFLDO2
;
335 mask
= TPS6507X_REG_DEFLDO2_LDO2_MASK
;
341 data
= tps6507x_pmic_reg_read(tps
, reg
);
348 return tps6507x_pmic_reg_write(tps
, reg
, data
);
351 static const struct regulator_ops tps6507x_pmic_ops
= {
352 .is_enabled
= tps6507x_pmic_is_enabled
,
353 .enable
= tps6507x_pmic_enable
,
354 .disable
= tps6507x_pmic_disable
,
355 .get_voltage_sel
= tps6507x_pmic_get_voltage_sel
,
356 .set_voltage_sel
= tps6507x_pmic_set_voltage_sel
,
357 .list_voltage
= regulator_list_voltage_table
,
358 .map_voltage
= regulator_map_voltage_ascend
,
361 static struct of_regulator_match tps6507x_matches
[] = {
369 static struct tps6507x_board
*tps6507x_parse_dt_reg_data(
370 struct platform_device
*pdev
,
371 struct of_regulator_match
**tps6507x_reg_matches
)
373 struct tps6507x_board
*tps_board
;
374 struct device_node
*np
= pdev
->dev
.parent
->of_node
;
375 struct device_node
*regulators
;
376 struct of_regulator_match
*matches
;
377 struct regulator_init_data
*reg_data
;
378 int idx
= 0, count
, ret
;
380 tps_board
= devm_kzalloc(&pdev
->dev
, sizeof(*tps_board
),
385 regulators
= of_get_child_by_name(np
, "regulators");
387 dev_err(&pdev
->dev
, "regulator node not found\n");
391 count
= ARRAY_SIZE(tps6507x_matches
);
392 matches
= tps6507x_matches
;
394 ret
= of_regulator_match(&pdev
->dev
, regulators
, matches
, count
);
395 of_node_put(regulators
);
397 dev_err(&pdev
->dev
, "Error parsing regulator init data: %d\n",
402 *tps6507x_reg_matches
= matches
;
404 reg_data
= devm_kzalloc(&pdev
->dev
, (sizeof(struct regulator_init_data
)
405 * TPS6507X_NUM_REGULATOR
), GFP_KERNEL
);
409 tps_board
->tps6507x_pmic_init_data
= reg_data
;
411 for (idx
= 0; idx
< count
; idx
++) {
412 if (!matches
[idx
].init_data
|| !matches
[idx
].of_node
)
415 memcpy(®_data
[idx
], matches
[idx
].init_data
,
416 sizeof(struct regulator_init_data
));
423 static int tps6507x_pmic_probe(struct platform_device
*pdev
)
425 struct tps6507x_dev
*tps6507x_dev
= dev_get_drvdata(pdev
->dev
.parent
);
426 struct tps_info
*info
= &tps6507x_pmic_regs
[0];
427 struct regulator_config config
= { };
428 struct regulator_init_data
*init_data
;
429 struct regulator_dev
*rdev
;
430 struct tps6507x_pmic
*tps
;
431 struct tps6507x_board
*tps_board
;
432 struct of_regulator_match
*tps6507x_reg_matches
= NULL
;
438 * tps_board points to pmic related constants
439 * coming from the board-evm file.
442 tps_board
= dev_get_platdata(tps6507x_dev
->dev
);
443 if (IS_ENABLED(CONFIG_OF
) && !tps_board
&&
444 tps6507x_dev
->dev
->of_node
)
445 tps_board
= tps6507x_parse_dt_reg_data(pdev
,
446 &tps6507x_reg_matches
);
451 * init_data points to array of regulator_init structures
452 * coming from the board-evm file.
454 init_data
= tps_board
->tps6507x_pmic_init_data
;
458 tps
= devm_kzalloc(&pdev
->dev
, sizeof(*tps
), GFP_KERNEL
);
462 mutex_init(&tps
->io_lock
);
464 /* common for all regulators */
465 tps
->mfd
= tps6507x_dev
;
467 for (i
= 0; i
< TPS6507X_NUM_REGULATOR
; i
++, info
++, init_data
++) {
468 /* Register the regulators */
470 if (init_data
->driver_data
) {
471 struct tps6507x_reg_platform_data
*data
=
472 init_data
->driver_data
;
473 tps
->info
[i
]->defdcdc_default
= data
->defdcdc_default
;
476 tps
->desc
[i
].name
= info
->name
;
478 tps
->desc
[i
].n_voltages
= info
->table_len
;
479 tps
->desc
[i
].volt_table
= info
->table
;
480 tps
->desc
[i
].ops
= &tps6507x_pmic_ops
;
481 tps
->desc
[i
].type
= REGULATOR_VOLTAGE
;
482 tps
->desc
[i
].owner
= THIS_MODULE
;
484 config
.dev
= tps6507x_dev
->dev
;
485 config
.init_data
= init_data
;
486 config
.driver_data
= tps
;
488 if (tps6507x_reg_matches
) {
489 error
= of_property_read_u32(
490 tps6507x_reg_matches
[i
].of_node
,
491 "ti,defdcdc_default", &prop
);
494 tps
->info
[i
]->defdcdc_default
= prop
;
496 config
.of_node
= tps6507x_reg_matches
[i
].of_node
;
499 rdev
= devm_regulator_register(&pdev
->dev
, &tps
->desc
[i
],
502 dev_err(tps6507x_dev
->dev
,
503 "failed to register %s regulator\n",
505 return PTR_ERR(rdev
);
509 tps6507x_dev
->pmic
= tps
;
510 platform_set_drvdata(pdev
, tps6507x_dev
);
515 static struct platform_driver tps6507x_pmic_driver
= {
517 .name
= "tps6507x-pmic",
519 .probe
= tps6507x_pmic_probe
,
522 static int __init
tps6507x_pmic_init(void)
524 return platform_driver_register(&tps6507x_pmic_driver
);
526 subsys_initcall(tps6507x_pmic_init
);
528 static void __exit
tps6507x_pmic_cleanup(void)
530 platform_driver_unregister(&tps6507x_pmic_driver
);
532 module_exit(tps6507x_pmic_cleanup
);
534 MODULE_AUTHOR("Texas Instruments");
535 MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
536 MODULE_LICENSE("GPL v2");
537 MODULE_ALIAS("platform:tps6507x-pmic");