Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/regulator/tps6586x-regulator.c

  1 /*
  2  * Regulator driver for TI TPS6586x
  3  *
  4  * Copyright (C) 2010 Compulab Ltd.
  5  * Author: Mike Rapoport <mike@compulab.co.il>
  6  *
  7  * Based on da903x
  8  * Copyright (C) 2006-2008 Marvell International Ltd.
  9  * Copyright (C) 2008 Compulab Ltd.
 10  *
 11  * This program is free software; you can redistribute it and/or modify
 12  * it under the terms of the GNU General Public License version 2 as
 13  * published by the Free Software Foundation.
 14  */
 15 
 16 #include <linux/kernel.h>
 17 #include <linux/module.h>
 18 #include <linux/init.h>
 19 #include <linux/err.h>
 20 #include <linux/of.h>
 21 #include <linux/slab.h>
 22 #include <linux/platform_device.h>
 23 #include <linux/regulator/driver.h>
 24 #include <linux/regulator/machine.h>
 25 #include <linux/regulator/of_regulator.h>
 26 #include <linux/mfd/tps6586x.h>
 27 
 28 /* supply control and voltage setting  */
 29 #define TPS6586X_SUPPLYENA      0x10
 30 #define TPS6586X_SUPPLYENB      0x11
 31 #define TPS6586X_SUPPLYENC      0x12
 32 #define TPS6586X_SUPPLYEND      0x13
 33 #define TPS6586X_SUPPLYENE      0x14
 34 #define TPS6586X_VCC1           0x20
 35 #define TPS6586X_VCC2           0x21
 36 #define TPS6586X_SM1V1          0x23
 37 #define TPS6586X_SM1V2          0x24
 38 #define TPS6586X_SM1SL          0x25
 39 #define TPS6586X_SM0V1          0x26
 40 #define TPS6586X_SM0V2          0x27
 41 #define TPS6586X_SM0SL          0x28
 42 #define TPS6586X_LDO2AV1        0x29
 43 #define TPS6586X_LDO2AV2        0x2A
 44 #define TPS6586X_LDO2BV1        0x2F
 45 #define TPS6586X_LDO2BV2        0x30
 46 #define TPS6586X_LDO4V1         0x32
 47 #define TPS6586X_LDO4V2         0x33
 48 
 49 /* converter settings  */
 50 #define TPS6586X_SUPPLYV1       0x41
 51 #define TPS6586X_SUPPLYV2       0x42
 52 #define TPS6586X_SUPPLYV3       0x43
 53 #define TPS6586X_SUPPLYV4       0x44
 54 #define TPS6586X_SUPPLYV5       0x45
 55 #define TPS6586X_SUPPLYV6       0x46
 56 #define TPS6586X_SMODE1         0x47
 57 #define TPS6586X_SMODE2         0x48
 58 
 59 struct tps6586x_regulator {
 60         struct regulator_desc desc;
 61 
 62         int enable_bit[2];
 63         int enable_reg[2];
 64 };
 65 
 66 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
 67 {
 68         return rdev_get_dev(rdev)->parent;
 69 }
 70 
 71 static struct regulator_ops tps6586x_regulator_ops = {
 72         .list_voltage = regulator_list_voltage_table,
 73         .map_voltage = regulator_map_voltage_ascend,
 74         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 75         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 76 
 77         .is_enabled = regulator_is_enabled_regmap,
 78         .enable = regulator_enable_regmap,
 79         .disable = regulator_disable_regmap,
 80 };
 81 
 82 static struct regulator_ops tps6586x_sys_regulator_ops = {
 83 };
 84 
 85 static const unsigned int tps6586x_ldo0_voltages[] = {
 86         1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
 87 };
 88 
 89 static const unsigned int tps6586x_ldo4_voltages[] = {
 90         1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
 91         1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
 92         2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
 93         2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
 94 };
 95 
 96 #define tps658623_sm2_voltages tps6586x_ldo4_voltages
 97 
 98 static const unsigned int tps6586x_ldo_voltages[] = {
 99         1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
100 };
101 
102 static const unsigned int tps6586x_sm2_voltages[] = {
103         3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
104         3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
105         3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
106         4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
107 };
108 
109 static const unsigned int tps658643_sm2_voltages[] = {
110         1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000,
111         1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000,
112         1425000, 1450000, 1475000, 1500000, 1525000, 1550000, 1575000, 1600000,
113         1625000, 1650000, 1675000, 1700000, 1725000, 1750000, 1775000, 1800000,
114 };
115 
116 static const unsigned int tps6586x_dvm_voltages[] = {
117          725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
118          925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
119         1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
120         1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
121 };
122 
123 #define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,   \
124                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
125         .desc   = {                                                     \
126                 .supply_name = _pin_name,                               \
127                 .name   = "REG-" #_id,                                  \
128                 .ops    = &tps6586x_regulator_ops,                      \
129                 .type   = REGULATOR_VOLTAGE,                            \
130                 .id     = TPS6586X_ID_##_id,                            \
131                 .n_voltages = ARRAY_SIZE(vdata##_voltages),             \
132                 .volt_table = vdata##_voltages,                         \
133                 .owner  = THIS_MODULE,                                  \
134                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
135                 .enable_mask = 1 << (ebit0),                            \
136                 .vsel_reg = TPS6586X_##vreg,                            \
137                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
138                 .apply_reg = (goreg),                           \
139                 .apply_bit = (gobit),                           \
140         },                                                              \
141         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
142         .enable_bit[0]  = (ebit0),                                      \
143         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
144         .enable_bit[1]  = (ebit1),
145 
146 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
147                      ereg0, ebit0, ereg1, ebit1)                        \
148 {                                                                       \
149         TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
150                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
151 }
152 
153 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
154                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
155 {                                                                       \
156         TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
157                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
158 }
159 
160 #define TPS6586X_SYS_REGULATOR()                                        \
161 {                                                                       \
162         .desc   = {                                                     \
163                 .supply_name = "sys",                                   \
164                 .name   = "REG-SYS",                                    \
165                 .ops    = &tps6586x_sys_regulator_ops,                  \
166                 .type   = REGULATOR_VOLTAGE,                            \
167                 .id     = TPS6586X_ID_SYS,                              \
168                 .owner  = THIS_MODULE,                                  \
169         },                                                              \
170 }
171 
172 static struct tps6586x_regulator tps6586x_regulator[] = {
173         TPS6586X_SYS_REGULATOR(),
174         TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
175                                         END, 0),
176         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
177                                         END, 2),
178         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
179                                         ENE, 6),
180         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
181                                         END, 4),
182         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
183                                         END, 5),
184         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
185                                         END, 6),
186         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
187                                         ENE, 7),
188         TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
189                                         V4, 7),
190         TPS6586X_LDO(LDO_1, "vinldo01", tps6586x_dvm, SUPPLYV1, 0, 5, ENC, 1,
191                                         END, 1),
192         TPS6586X_LDO(SM_2, "vin-sm2", tps6586x_sm2, SUPPLYV2, 0, 5, ENC, 7,
193                                         END, 7),
194 
195         TPS6586X_DVM(LDO_2, "vinldo23", tps6586x_dvm, LDO2BV1, 0, 5, ENA, 3,
196                                         ENB, 3, TPS6586X_VCC2, BIT(6)),
197         TPS6586X_DVM(LDO_4, "vinldo4", tps6586x_ldo4, LDO4V1, 0, 5, ENC, 3,
198                                         END, 3, TPS6586X_VCC1, BIT(6)),
199         TPS6586X_DVM(SM_0, "vin-sm0", tps6586x_dvm, SM0V1, 0, 5, ENA, 1,
200                                         ENB, 1, TPS6586X_VCC1, BIT(2)),
201         TPS6586X_DVM(SM_1, "vin-sm1", tps6586x_dvm, SM1V1, 0, 5, ENA, 0,
202                                         ENB, 0, TPS6586X_VCC1, BIT(0)),
203 };
204 
205 static struct tps6586x_regulator tps658623_regulator[] = {
206         TPS6586X_LDO(SM_2, "vin-sm2", tps658623_sm2, SUPPLYV2, 0, 5, ENC, 7,
207                                         END, 7),
208 };
209 
210 static struct tps6586x_regulator tps658643_regulator[] = {
211         TPS6586X_LDO(SM_2, "vin-sm2", tps658643_sm2, SUPPLYV2, 0, 5, ENC, 7,
212                                         END, 7),
213 };
214 
215 /*
216  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
217  * regulator state. Clearing one of this bits allows switching
218  * regulator on and of with single register write.
219  */
220 static inline int tps6586x_regulator_preinit(struct device *parent,
221                                              struct tps6586x_regulator *ri)
222 {
223         uint8_t val1, val2;
224         int ret;
225 
226         if (ri->enable_reg[0] == ri->enable_reg[1] &&
227             ri->enable_bit[0] == ri->enable_bit[1])
228                         return 0;
229 
230         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
231         if (ret)
232                 return ret;
233 
234         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
235         if (ret)
236                 return ret;
237 
238         if (!(val2 & (1 << ri->enable_bit[1])))
239                 return 0;
240 
241         /*
242          * The regulator is on, but it's enabled with the bit we don't
243          * want to use, so we switch the enable bits
244          */
245         if (!(val1 & (1 << ri->enable_bit[0]))) {
246                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
247                                         1 << ri->enable_bit[0]);
248                 if (ret)
249                         return ret;
250         }
251 
252         return tps6586x_clr_bits(parent, ri->enable_reg[1],
253                                  1 << ri->enable_bit[1]);
254 }
255 
256 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
257                         int id, struct regulator_init_data *p)
258 {
259         struct device *parent = pdev->dev.parent;
260         struct tps6586x_settings *setting = p->driver_data;
261         uint8_t reg;
262 
263         if (setting == NULL)
264                 return 0;
265 
266         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
267                 return 0;
268 
269         /* only SM0 and SM1 can have the slew rate settings */
270         switch (id) {
271         case TPS6586X_ID_SM_0:
272                 reg = TPS6586X_SM0SL;
273                 break;
274         case TPS6586X_ID_SM_1:
275                 reg = TPS6586X_SM1SL;
276                 break;
277         default:
278                 dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
279                 return -EINVAL;
280         }
281 
282         return tps6586x_write(parent, reg,
283                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
284 }
285 
286 static struct tps6586x_regulator *find_regulator_info(int id, int version)
287 {
288         struct tps6586x_regulator *ri;
289         struct tps6586x_regulator *table = NULL;
290         int num;
291         int i;
292 
293         switch (version) {
294         case TPS658623:
295                 table = tps658623_regulator;
296                 num = ARRAY_SIZE(tps658623_regulator);
297                 break;
298         case TPS658643:
299                 table = tps658643_regulator;
300                 num = ARRAY_SIZE(tps658643_regulator);
301                 break;
302         }
303 
304         /* Search version specific table first */
305         if (table) {
306                 for (i = 0; i < num; i++) {
307                         ri = &table[i];
308                         if (ri->desc.id == id)
309                                 return ri;
310                 }
311         }
312 
313         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
314                 ri = &tps6586x_regulator[i];
315                 if (ri->desc.id == id)
316                         return ri;
317         }
318         return NULL;
319 }
320 
321 #ifdef CONFIG_OF
322 static struct of_regulator_match tps6586x_matches[] = {
323         { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
324         { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
325         { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
326         { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
327         { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
328         { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
329         { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
330         { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
331         { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
332         { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
333         { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
334         { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
335         { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
336         { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
337         { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
338 };
339 
340 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
341                 struct platform_device *pdev,
342                 struct of_regulator_match **tps6586x_reg_matches)
343 {
344         const unsigned int num = ARRAY_SIZE(tps6586x_matches);
345         struct device_node *np = pdev->dev.parent->of_node;
346         struct device_node *regs;
347         const char *sys_rail = NULL;
348         unsigned int i;
349         struct tps6586x_platform_data *pdata;
350         int err;
351 
352         regs = of_get_child_by_name(np, "regulators");
353         if (!regs) {
354                 dev_err(&pdev->dev, "regulator node not found\n");
355                 return NULL;
356         }
357 
358         err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
359         of_node_put(regs);
360         if (err < 0) {
361                 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
362                 return NULL;
363         }
364 
365         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
366         if (!pdata)
367                 return NULL;
368 
369         for (i = 0; i < num; i++) {
370                 int id;
371                 if (!tps6586x_matches[i].init_data)
372                         continue;
373 
374                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
375                 id = (int)tps6586x_matches[i].driver_data;
376                 if (id == TPS6586X_ID_SYS)
377                         sys_rail = pdata->reg_init_data[i]->constraints.name;
378 
379                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
380                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
381         }
382         *tps6586x_reg_matches = tps6586x_matches;
383         return pdata;
384 }
385 #else
386 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
387                 struct platform_device *pdev,
388                 struct of_regulator_match **tps6586x_reg_matches)
389 {
390         *tps6586x_reg_matches = NULL;
391         return NULL;
392 }
393 #endif
394 
395 static int tps6586x_regulator_probe(struct platform_device *pdev)
396 {
397         struct tps6586x_regulator *ri = NULL;
398         struct regulator_config config = { };
399         struct regulator_dev *rdev;
400         struct regulator_init_data *reg_data;
401         struct tps6586x_platform_data *pdata;
402         struct of_regulator_match *tps6586x_reg_matches = NULL;
403         int version;
404         int id;
405         int err;
406 
407         dev_dbg(&pdev->dev, "Probing regulator\n");
408 
409         pdata = dev_get_platdata(pdev->dev.parent);
410         if ((!pdata) && (pdev->dev.parent->of_node))
411                 pdata = tps6586x_parse_regulator_dt(pdev,
412                                         &tps6586x_reg_matches);
413 
414         if (!pdata) {
415                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
416                 return -ENODEV;
417         }
418 
419         version = tps6586x_get_version(pdev->dev.parent);
420 
421         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
422                 reg_data = pdata->reg_init_data[id];
423 
424                 ri = find_regulator_info(id, version);
425 
426                 if (!ri) {
427                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
428                         return -EINVAL;
429                 }
430 
431                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
432                 if (err) {
433                         dev_err(&pdev->dev,
434                                 "regulator %d preinit failed, e %d\n", id, err);
435                         return err;
436                 }
437 
438                 config.dev = pdev->dev.parent;
439                 config.init_data = reg_data;
440                 config.driver_data = ri;
441 
442                 if (tps6586x_reg_matches)
443                         config.of_node = tps6586x_reg_matches[id].of_node;
444 
445                 rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
446                 if (IS_ERR(rdev)) {
447                         dev_err(&pdev->dev, "failed to register regulator %s\n",
448                                         ri->desc.name);
449                         return PTR_ERR(rdev);
450                 }
451 
452                 if (reg_data) {
453                         err = tps6586x_regulator_set_slew_rate(pdev, id,
454                                         reg_data);
455                         if (err < 0) {
456                                 dev_err(&pdev->dev,
457                                         "Slew rate config failed, e %d\n", err);
458                                 return err;
459                         }
460                 }
461         }
462 
463         platform_set_drvdata(pdev, rdev);
464         return 0;
465 }
466 
467 static struct platform_driver tps6586x_regulator_driver = {
468         .driver = {
469                 .name   = "tps6586x-regulator",
470                 .owner  = THIS_MODULE,
471         },
472         .probe          = tps6586x_regulator_probe,
473 };
474 
475 static int __init tps6586x_regulator_init(void)
476 {
477         return platform_driver_register(&tps6586x_regulator_driver);
478 }
479 subsys_initcall(tps6586x_regulator_init);
480 
481 static void __exit tps6586x_regulator_exit(void)
482 {
483         platform_driver_unregister(&tps6586x_regulator_driver);
484 }
485 module_exit(tps6586x_regulator_exit);
486 
487 MODULE_LICENSE("GPL");
488 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
489 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
490 MODULE_ALIAS("platform:tps6586x-regulator");
491 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us