1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * tps65023-regulator.c
4 *
5 * Supports TPS65023 Regulator
6 *
7 * Copyright (C) 2009 Texas Instrument Incorporated - https://www.ti.com/
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/err.h>
14 #include <linux/platform_device.h>
15 #include <linux/regulator/driver.h>
16 #include <linux/regulator/machine.h>
17 #include <linux/i2c.h>
18 #include <linux/slab.h>
19 #include <linux/regmap.h>
20
21 /* Register definitions */
22 #define TPS65023_REG_VERSION 0
23 #define TPS65023_REG_PGOODZ 1
24 #define TPS65023_REG_MASK 2
25 #define TPS65023_REG_REG_CTRL 3
26 #define TPS65023_REG_CON_CTRL 4
27 #define TPS65023_REG_CON_CTRL2 5
28 #define TPS65023_REG_DEF_CORE 6
29 #define TPS65023_REG_DEFSLEW 7
30 #define TPS65023_REG_LDO_CTRL 8
31
32 /* PGOODZ bitfields */
33 #define TPS65023_PGOODZ_PWRFAILZ BIT(7)
34 #define TPS65023_PGOODZ_LOWBATTZ BIT(6)
35 #define TPS65023_PGOODZ_VDCDC1 BIT(5)
36 #define TPS65023_PGOODZ_VDCDC2 BIT(4)
37 #define TPS65023_PGOODZ_VDCDC3 BIT(3)
38 #define TPS65023_PGOODZ_LDO2 BIT(2)
39 #define TPS65023_PGOODZ_LDO1 BIT(1)
40
41 /* MASK bitfields */
42 #define TPS65023_MASK_PWRFAILZ BIT(7)
43 #define TPS65023_MASK_LOWBATTZ BIT(6)
44 #define TPS65023_MASK_VDCDC1 BIT(5)
45 #define TPS65023_MASK_VDCDC2 BIT(4)
46 #define TPS65023_MASK_VDCDC3 BIT(3)
47 #define TPS65023_MASK_LDO2 BIT(2)
48 #define TPS65023_MASK_LDO1 BIT(1)
49
50 /* REG_CTRL bitfields */
51 #define TPS65023_REG_CTRL_VDCDC1_EN BIT(5)
52 #define TPS65023_REG_CTRL_VDCDC2_EN BIT(4)
53 #define TPS65023_REG_CTRL_VDCDC3_EN BIT(3)
54 #define TPS65023_REG_CTRL_LDO2_EN BIT(2)
55 #define TPS65023_REG_CTRL_LDO1_EN BIT(1)
56
57 /* REG_CTRL2 bitfields */
58 #define TPS65023_REG_CTRL2_GO BIT(7)
59 #define TPS65023_REG_CTRL2_CORE_ADJ BIT(6)
60 #define TPS65023_REG_CTRL2_DCDC2 BIT(2)
61 #define TPS65023_REG_CTRL2_DCDC1 BIT(1)
62 #define TPS65023_REG_CTRL2_DCDC3 BIT(0)
63
64 /* Number of step-down converters available */
65 #define TPS65023_NUM_DCDC 3
66 /* Number of LDO voltage regulators available */
67 #define TPS65023_NUM_LDO 2
68 /* Number of total regulators available */
69 #define TPS65023_NUM_REGULATOR (TPS65023_NUM_DCDC + TPS65023_NUM_LDO)
70
71 /* DCDCs */
72 #define TPS65023_DCDC_1 0
73 #define TPS65023_DCDC_2 1
74 #define TPS65023_DCDC_3 2
75 /* LDOs */
76 #define TPS65023_LDO_1 3
77 #define TPS65023_LDO_2 4
78
79 #define TPS65023_MAX_REG_ID TPS65023_LDO_2
80
81 #define TPS65023_REGULATOR_DCDC(_num, _t, _em) \
82 { \
83 .name = "VDCDC"#_num, \
84 .of_match = of_match_ptr("VDCDC"#_num), \
85 .regulators_node = of_match_ptr("regulators"), \
86 .id = TPS65023_DCDC_##_num, \
87 .n_voltages = ARRAY_SIZE(_t), \
88 .ops = &tps65023_dcdc_ops, \
89 .type = REGULATOR_VOLTAGE, \
90 .owner = THIS_MODULE, \
91 .volt_table = _t, \
92 .vsel_reg = TPS65023_REG_DEF_CORE, \
93 .vsel_mask = ARRAY_SIZE(_t) - 1, \
94 .enable_mask = _em, \
95 .enable_reg = TPS65023_REG_REG_CTRL, \
96 .apply_reg = TPS65023_REG_CON_CTRL2, \
97 .apply_bit = TPS65023_REG_CTRL2_GO, \
98 } \
99
100 #define TPS65023_REGULATOR_LDO(_num, _t, _vm) \
101 { \
102 .name = "LDO"#_num, \
103 .of_match = of_match_ptr("LDO"#_num), \
104 .regulators_node = of_match_ptr("regulators"), \
105 .id = TPS65023_LDO_##_num, \
106 .n_voltages = ARRAY_SIZE(_t), \
107 .ops = &tps65023_ldo_ops, \
108 .type = REGULATOR_VOLTAGE, \
109 .owner = THIS_MODULE, \
110 .volt_table = _t, \
111 .vsel_reg = TPS65023_REG_LDO_CTRL, \
112 .vsel_mask = _vm, \
113 .enable_mask = 1 << (_num), \
114 .enable_reg = TPS65023_REG_REG_CTRL, \
115 } \
116
117 /* Supported voltage values for regulators */
118 static const unsigned int VCORE_VSEL_table[] = {
119 800000, 825000, 850000, 875000,
120 900000, 925000, 950000, 975000,
121 1000000, 1025000, 1050000, 1075000,
122 1100000, 1125000, 1150000, 1175000,
123 1200000, 1225000, 1250000, 1275000,
124 1300000, 1325000, 1350000, 1375000,
125 1400000, 1425000, 1450000, 1475000,
126 1500000, 1525000, 1550000, 1600000,
127 };
128
129 static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
130 3300000,
131 };
132
133 static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
134 1800000,
135 };
136
137 /* Supported voltage values for LDO regulators for tps65020 */
138 static const unsigned int TPS65020_LDO_VSEL_table[] = {
139 1000000, 1050000, 1100000, 1300000,
140 1800000, 2500000, 3000000, 3300000,
141 };
142
143 /* Supported voltage values for LDO regulators
144 * for tps65021 and tps65023 */
145 static const unsigned int TPS65023_LDO1_VSEL_table[] = {
146 1000000, 1100000, 1300000, 1800000,
147 2200000, 2600000, 2800000, 3150000,
148 };
149
150 static const unsigned int TPS65023_LDO2_VSEL_table[] = {
151 1050000, 1200000, 1300000, 1800000,
152 2500000, 2800000, 3000000, 3300000,
153 };
154
155 /* PMIC details */
156 struct tps_pmic {
157 struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
158 const struct tps_driver_data *driver_data;
159 struct regmap *regmap;
160 };
161
162 /* Struct passed as driver data */
163 struct tps_driver_data {
164 const struct regulator_desc *desc;
165 u8 core_regulator;
166 };
167
tps65023_dcdc_get_voltage_sel(struct regulator_dev * dev)168 static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
169 {
170 struct tps_pmic *tps = rdev_get_drvdata(dev);
171 int dcdc = rdev_get_id(dev);
172
173 if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
174 return -EINVAL;
175
176 if (dcdc != tps->driver_data->core_regulator)
177 return 0;
178
179 return regulator_get_voltage_sel_regmap(dev);
180 }
181
tps65023_dcdc_set_voltage_sel(struct regulator_dev * dev,unsigned selector)182 static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
183 unsigned selector)
184 {
185 struct tps_pmic *tps = rdev_get_drvdata(dev);
186 int dcdc = rdev_get_id(dev);
187
188 if (dcdc != tps->driver_data->core_regulator)
189 return -EINVAL;
190
191 return regulator_set_voltage_sel_regmap(dev, selector);
192 }
193
194 /* Operations permitted on VDCDCx */
195 static const struct regulator_ops tps65023_dcdc_ops = {
196 .is_enabled = regulator_is_enabled_regmap,
197 .enable = regulator_enable_regmap,
198 .disable = regulator_disable_regmap,
199 .get_voltage_sel = tps65023_dcdc_get_voltage_sel,
200 .set_voltage_sel = tps65023_dcdc_set_voltage_sel,
201 .list_voltage = regulator_list_voltage_table,
202 .map_voltage = regulator_map_voltage_ascend,
203 };
204
205 /* Operations permitted on LDOx */
206 static const struct regulator_ops tps65023_ldo_ops = {
207 .is_enabled = regulator_is_enabled_regmap,
208 .enable = regulator_enable_regmap,
209 .disable = regulator_disable_regmap,
210 .get_voltage_sel = regulator_get_voltage_sel_regmap,
211 .set_voltage_sel = regulator_set_voltage_sel_regmap,
212 .list_voltage = regulator_list_voltage_table,
213 .map_voltage = regulator_map_voltage_ascend,
214 };
215
216 static const struct regmap_config tps65023_regmap_config = {
217 .reg_bits = 8,
218 .val_bits = 8,
219 };
220
221 static const struct regulator_desc tps65020_regulators[] = {
222 TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
223 TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
224 TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
225 TPS65023_REGULATOR_LDO(1, TPS65020_LDO_VSEL_table, 0x07),
226 TPS65023_REGULATOR_LDO(2, TPS65020_LDO_VSEL_table, 0x70),
227 };
228
229 static const struct regulator_desc tps65021_regulators[] = {
230 TPS65023_REGULATOR_DCDC(1, DCDC_FIXED_3300000_VSEL_table, 0x20),
231 TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_1800000_VSEL_table, 0x10),
232 TPS65023_REGULATOR_DCDC(3, VCORE_VSEL_table, 0x08),
233 TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
234 TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
235 };
236
237 static const struct regulator_desc tps65023_regulators[] = {
238 TPS65023_REGULATOR_DCDC(1, VCORE_VSEL_table, 0x20),
239 TPS65023_REGULATOR_DCDC(2, DCDC_FIXED_3300000_VSEL_table, 0x10),
240 TPS65023_REGULATOR_DCDC(3, DCDC_FIXED_1800000_VSEL_table, 0x08),
241 TPS65023_REGULATOR_LDO(1, TPS65023_LDO1_VSEL_table, 0x07),
242 TPS65023_REGULATOR_LDO(2, TPS65023_LDO2_VSEL_table, 0x70),
243 };
244
245 static const struct tps_driver_data tps65020_drv_data = {
246 .desc = tps65020_regulators,
247 .core_regulator = TPS65023_DCDC_3,
248 };
249
250 static const struct tps_driver_data tps65021_drv_data = {
251 .desc = tps65021_regulators,
252 .core_regulator = TPS65023_DCDC_3,
253 };
254
255 static const struct tps_driver_data tps65023_drv_data = {
256 .desc = tps65023_regulators,
257 .core_regulator = TPS65023_DCDC_1,
258 };
259
tps_65023_probe(struct i2c_client * client)260 static int tps_65023_probe(struct i2c_client *client)
261 {
262 const struct i2c_device_id *id = i2c_client_get_device_id(client);
263 struct regulator_init_data *init_data = dev_get_platdata(&client->dev);
264 struct regulator_config config = { };
265 struct tps_pmic *tps;
266 int i;
267 int error;
268
269 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
270 if (!tps)
271 return -ENOMEM;
272
273 tps->driver_data = (struct tps_driver_data *)id->driver_data;
274
275 tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
276 if (IS_ERR(tps->regmap)) {
277 error = PTR_ERR(tps->regmap);
278 dev_err(&client->dev, "Failed to allocate register map: %d\n",
279 error);
280 return error;
281 }
282
283 /* common for all regulators */
284 config.dev = &client->dev;
285 config.driver_data = tps;
286 config.regmap = tps->regmap;
287
288 for (i = 0; i < TPS65023_NUM_REGULATOR; i++) {
289 if (init_data)
290 config.init_data = &init_data[i];
291
292 /* Register the regulators */
293 tps->rdev[i] = devm_regulator_register(&client->dev,
294 &tps->driver_data->desc[i], &config);
295 if (IS_ERR(tps->rdev[i])) {
296 dev_err(&client->dev, "failed to register %s\n",
297 id->name);
298 return PTR_ERR(tps->rdev[i]);
299 }
300 }
301
302 i2c_set_clientdata(client, tps);
303
304 /* Enable setting output voltage by I2C */
305 regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
306 TPS65023_REG_CTRL2_CORE_ADJ, 0);
307
308 return 0;
309 }
310
311 static const struct of_device_id __maybe_unused tps65023_of_match[] = {
312 { .compatible = "ti,tps65020", .data = &tps65020_drv_data},
313 { .compatible = "ti,tps65021", .data = &tps65021_drv_data},
314 { .compatible = "ti,tps65023", .data = &tps65023_drv_data},
315 {},
316 };
317 MODULE_DEVICE_TABLE(of, tps65023_of_match);
318
319 static const struct i2c_device_id tps_65023_id[] = {
320 {
321 .name = "tps65023",
322 .driver_data = (kernel_ulong_t)&tps65023_drv_data
323 }, {
324 .name = "tps65021",
325 .driver_data = (kernel_ulong_t)&tps65021_drv_data
326 }, {
327 .name = "tps65020",
328 .driver_data = (kernel_ulong_t)&tps65020_drv_data
329 },
330 { },
331 };
332 MODULE_DEVICE_TABLE(i2c, tps_65023_id);
333
334 static struct i2c_driver tps_65023_i2c_driver = {
335 .driver = {
336 .name = "tps65023",
337 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
338 .of_match_table = of_match_ptr(tps65023_of_match),
339 },
340 .probe = tps_65023_probe,
341 .id_table = tps_65023_id,
342 };
343
tps_65023_init(void)344 static int __init tps_65023_init(void)
345 {
346 return i2c_add_driver(&tps_65023_i2c_driver);
347 }
348 subsys_initcall(tps_65023_init);
349
tps_65023_cleanup(void)350 static void __exit tps_65023_cleanup(void)
351 {
352 i2c_del_driver(&tps_65023_i2c_driver);
353 }
354 module_exit(tps_65023_cleanup);
355
356 MODULE_AUTHOR("Texas Instruments");
357 MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
358 MODULE_LICENSE("GPL v2");
359