Root/drivers/regulator/tps65912-regulator.c

1/*
2 * tps65912.c -- TI tps65912
3 *
4 * Copyright 2011 Texas Instruments Inc.
5 *
6 * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 * This driver is based on wm8350 implementation.
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/platform_device.h>
21#include <linux/regulator/driver.h>
22#include <linux/regulator/machine.h>
23#include <linux/slab.h>
24#include <linux/gpio.h>
25#include <linux/mfd/tps65912.h>
26
27/* DCDC's */
28#define TPS65912_REG_DCDC1 0
29#define TPS65912_REG_DCDC2 1
30#define TPS65912_REG_DCDC3 2
31#define TPS65912_REG_DCDC4 3
32
33/* LDOs */
34#define TPS65912_REG_LDO1 4
35#define TPS65912_REG_LDO2 5
36#define TPS65912_REG_LDO3 6
37#define TPS65912_REG_LDO4 7
38#define TPS65912_REG_LDO5 8
39#define TPS65912_REG_LDO6 9
40#define TPS65912_REG_LDO7 10
41#define TPS65912_REG_LDO8 11
42#define TPS65912_REG_LDO9 12
43#define TPS65912_REG_LDO10 13
44
45/* Number of step-down converters available */
46#define TPS65912_NUM_DCDC 4
47
48/* Number of LDO voltage regulators available */
49#define TPS65912_NUM_LDO 10
50
51/* Number of total regulators available */
52#define TPS65912_NUM_REGULATOR (TPS65912_NUM_DCDC + TPS65912_NUM_LDO)
53
54#define TPS65912_REG_ENABLED 0x80
55#define OP_SELREG_MASK 0x40
56#define OP_SELREG_SHIFT 6
57
58struct tps_info {
59    const char *name;
60};
61
62static struct tps_info tps65912_regs[] = {
63    {
64        .name = "DCDC1",
65    },
66    {
67        .name = "DCDC2",
68    },
69    {
70        .name = "DCDC3",
71    },
72    {
73        .name = "DCDC4",
74    },
75    {
76        .name = "LDO1",
77    },
78    {
79        .name = "LDO2",
80    },
81    {
82        .name = "LDO3",
83    },
84    {
85        .name = "LDO4",
86    },
87    {
88        .name = "LDO5",
89    },
90    {
91        .name = "LDO6",
92    },
93    {
94        .name = "LDO7",
95    },
96    {
97        .name = "LDO8",
98    },
99    {
100        .name = "LDO9",
101    },
102    {
103        .name = "LDO10",
104    },
105};
106
107struct tps65912_reg {
108    struct regulator_desc desc[TPS65912_NUM_REGULATOR];
109    struct tps65912 *mfd;
110    struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
111    struct tps_info *info[TPS65912_NUM_REGULATOR];
112    /* for read/write access */
113    struct mutex io_lock;
114    int mode;
115    int (*get_ctrl_reg)(int);
116    int dcdc_range[TPS65912_NUM_DCDC];
117    int pwm_mode_reg;
118    int eco_reg;
119};
120
121static int tps65912_get_range(struct tps65912_reg *pmic, int id)
122{
123    struct tps65912 *mfd = pmic->mfd;
124    int range;
125
126    switch (id) {
127    case TPS65912_REG_DCDC1:
128        range = tps65912_reg_read(mfd, TPS65912_DCDC1_LIMIT);
129        break;
130    case TPS65912_REG_DCDC2:
131        range = tps65912_reg_read(mfd, TPS65912_DCDC2_LIMIT);
132        break;
133    case TPS65912_REG_DCDC3:
134        range = tps65912_reg_read(mfd, TPS65912_DCDC3_LIMIT);
135        break;
136    case TPS65912_REG_DCDC4:
137        range = tps65912_reg_read(mfd, TPS65912_DCDC4_LIMIT);
138        break;
139    default:
140        return 0;
141    }
142
143    if (range >= 0)
144        range = (range & DCDC_LIMIT_RANGE_MASK)
145            >> DCDC_LIMIT_RANGE_SHIFT;
146
147    pmic->dcdc_range[id] = range;
148    return range;
149}
150
151static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
152{
153    unsigned long uv;
154
155    uv = ((vsel * 12500) + 500000);
156    return uv;
157}
158
159static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
160{
161    unsigned long uv;
162
163     uv = ((vsel * 12500) + 700000);
164    return uv;
165}
166
167static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
168{
169    unsigned long uv;
170
171    uv = ((vsel * 25000) + 500000);
172    return uv;
173}
174
175static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
176{
177    unsigned long uv;
178
179    if (vsel == 0x3f)
180        uv = 3800000;
181    else
182        uv = ((vsel * 50000) + 500000);
183
184    return uv;
185}
186
187static unsigned long tps65912_vsel_to_uv_ldo(u8 vsel)
188{
189    unsigned long uv = 0;
190
191    if (vsel <= 32)
192        uv = ((vsel * 25000) + 800000);
193    else if (vsel > 32 && vsel <= 60)
194        uv = (((vsel - 32) * 50000) + 1600000);
195    else if (vsel > 60)
196        uv = (((vsel - 60) * 100000) + 3000000);
197
198    return uv;
199}
200
201static int tps65912_get_ctrl_register(int id)
202{
203    if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4)
204        return id * 3 + TPS65912_DCDC1_AVS;
205    else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10)
206        return id - TPS65912_REG_LDO5 + TPS65912_LDO5;
207    else
208        return -EINVAL;
209}
210
211static int tps65912_get_sel_register(struct tps65912_reg *pmic, int id)
212{
213    struct tps65912 *mfd = pmic->mfd;
214    int opvsel;
215    u8 reg = 0;
216
217    if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4) {
218        opvsel = tps65912_reg_read(mfd, id * 3 + TPS65912_DCDC1_OP);
219        if (opvsel & OP_SELREG_MASK)
220            reg = id * 3 + TPS65912_DCDC1_AVS;
221        else
222            reg = id * 3 + TPS65912_DCDC1_OP;
223    } else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10) {
224        reg = id - TPS65912_REG_LDO5 + TPS65912_LDO5;
225    } else {
226        return -EINVAL;
227    }
228
229    return reg;
230}
231
232static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
233{
234    switch (id) {
235    case TPS65912_REG_DCDC1:
236        pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
237        pmic->eco_reg = TPS65912_DCDC1_AVS;
238        break;
239    case TPS65912_REG_DCDC2:
240        pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
241        pmic->eco_reg = TPS65912_DCDC2_AVS;
242        break;
243    case TPS65912_REG_DCDC3:
244        pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
245        pmic->eco_reg = TPS65912_DCDC3_AVS;
246        break;
247    case TPS65912_REG_DCDC4:
248        pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
249        pmic->eco_reg = TPS65912_DCDC4_AVS;
250        break;
251    default:
252        return -EINVAL;
253    }
254
255    return 0;
256}
257
258static int tps65912_reg_is_enabled(struct regulator_dev *dev)
259{
260    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
261    struct tps65912 *mfd = pmic->mfd;
262    int reg, value, id = rdev_get_id(dev);
263
264    if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
265        return -EINVAL;
266
267    reg = pmic->get_ctrl_reg(id);
268    if (reg < 0)
269        return reg;
270
271    value = tps65912_reg_read(mfd, reg);
272    if (value < 0)
273        return value;
274
275    return value & TPS65912_REG_ENABLED;
276}
277
278static int tps65912_reg_enable(struct regulator_dev *dev)
279{
280    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
281    struct tps65912 *mfd = pmic->mfd;
282    int id = rdev_get_id(dev);
283    int reg;
284
285    if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
286        return -EINVAL;
287
288    reg = pmic->get_ctrl_reg(id);
289    if (reg < 0)
290        return reg;
291
292    return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
293}
294
295static int tps65912_reg_disable(struct regulator_dev *dev)
296{
297    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
298    struct tps65912 *mfd = pmic->mfd;
299    int id = rdev_get_id(dev), reg;
300
301    reg = pmic->get_ctrl_reg(id);
302    if (reg < 0)
303        return reg;
304
305    return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
306}
307
308static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
309{
310    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
311    struct tps65912 *mfd = pmic->mfd;
312    int pwm_mode, eco, id = rdev_get_id(dev);
313
314    tps65912_get_mode_regiters(pmic, id);
315
316    pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
317    eco = tps65912_reg_read(mfd, pmic->eco_reg);
318
319    pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
320    eco &= DCDC_AVS_ECO_MASK;
321
322    switch (mode) {
323    case REGULATOR_MODE_FAST:
324        /* Verify if mode alredy set */
325        if (pwm_mode && !eco)
326            break;
327        tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
328        tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
329        break;
330    case REGULATOR_MODE_NORMAL:
331    case REGULATOR_MODE_IDLE:
332        if (!pwm_mode && !eco)
333            break;
334        tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
335        tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
336        break;
337    case REGULATOR_MODE_STANDBY:
338        if (!pwm_mode && eco)
339            break;
340        tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
341        tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
342        break;
343    default:
344        return -EINVAL;
345    }
346
347    return 0;
348}
349
350static unsigned int tps65912_get_mode(struct regulator_dev *dev)
351{
352    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
353    struct tps65912 *mfd = pmic->mfd;
354    int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);
355
356    tps65912_get_mode_regiters(pmic, id);
357
358    pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
359    eco = tps65912_reg_read(mfd, pmic->eco_reg);
360
361    pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
362    eco &= DCDC_AVS_ECO_MASK;
363
364    if (pwm_mode && !eco)
365        mode = REGULATOR_MODE_FAST;
366    else if (!pwm_mode && !eco)
367        mode = REGULATOR_MODE_NORMAL;
368    else if (!pwm_mode && eco)
369        mode = REGULATOR_MODE_STANDBY;
370
371    return mode;
372}
373
374static int tps65912_list_voltage(struct regulator_dev *dev, unsigned selector)
375{
376    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
377    int range, voltage = 0, id = rdev_get_id(dev);
378
379    if (id >= TPS65912_REG_LDO1 && id <= TPS65912_REG_LDO10)
380        return tps65912_vsel_to_uv_ldo(selector);
381
382    if (id > TPS65912_REG_DCDC4)
383        return -EINVAL;
384
385    range = pmic->dcdc_range[id];
386
387    switch (range) {
388    case 0:
389        /* 0.5 - 1.2875V in 12.5mV steps */
390        voltage = tps65912_vsel_to_uv_range0(selector);
391        break;
392    case 1:
393        /* 0.7 - 1.4875V in 12.5mV steps */
394        voltage = tps65912_vsel_to_uv_range1(selector);
395        break;
396    case 2:
397        /* 0.5 - 2.075V in 25mV steps */
398        voltage = tps65912_vsel_to_uv_range2(selector);
399        break;
400    case 3:
401        /* 0.5 - 3.8V in 50mV steps */
402        voltage = tps65912_vsel_to_uv_range3(selector);
403        break;
404    }
405    return voltage;
406}
407
408static int tps65912_get_voltage_sel(struct regulator_dev *dev)
409{
410    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
411    struct tps65912 *mfd = pmic->mfd;
412    int id = rdev_get_id(dev);
413    int reg, vsel;
414
415    reg = tps65912_get_sel_register(pmic, id);
416    if (reg < 0)
417        return reg;
418
419    vsel = tps65912_reg_read(mfd, reg);
420    vsel &= 0x3F;
421
422    return vsel;
423}
424
425static int tps65912_set_voltage_sel(struct regulator_dev *dev,
426                     unsigned selector)
427{
428    struct tps65912_reg *pmic = rdev_get_drvdata(dev);
429    struct tps65912 *mfd = pmic->mfd;
430    int id = rdev_get_id(dev);
431    int value;
432    u8 reg;
433
434    reg = tps65912_get_sel_register(pmic, id);
435    value = tps65912_reg_read(mfd, reg);
436    value &= 0xC0;
437    return tps65912_reg_write(mfd, reg, selector | value);
438}
439
440/* Operations permitted on DCDCx */
441static struct regulator_ops tps65912_ops_dcdc = {
442    .is_enabled = tps65912_reg_is_enabled,
443    .enable = tps65912_reg_enable,
444    .disable = tps65912_reg_disable,
445    .set_mode = tps65912_set_mode,
446    .get_mode = tps65912_get_mode,
447    .get_voltage_sel = tps65912_get_voltage_sel,
448    .set_voltage_sel = tps65912_set_voltage_sel,
449    .list_voltage = tps65912_list_voltage,
450};
451
452/* Operations permitted on LDOx */
453static struct regulator_ops tps65912_ops_ldo = {
454    .is_enabled = tps65912_reg_is_enabled,
455    .enable = tps65912_reg_enable,
456    .disable = tps65912_reg_disable,
457    .get_voltage_sel = tps65912_get_voltage_sel,
458    .set_voltage_sel = tps65912_set_voltage_sel,
459    .list_voltage = tps65912_list_voltage,
460};
461
462static __devinit int tps65912_probe(struct platform_device *pdev)
463{
464    struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
465    struct regulator_config config = { };
466    struct tps_info *info;
467    struct regulator_init_data *reg_data;
468    struct regulator_dev *rdev;
469    struct tps65912_reg *pmic;
470    struct tps65912_board *pmic_plat_data;
471    int i, err;
472
473    pmic_plat_data = dev_get_platdata(tps65912->dev);
474    if (!pmic_plat_data)
475        return -EINVAL;
476
477    reg_data = pmic_plat_data->tps65912_pmic_init_data;
478
479    pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
480    if (!pmic)
481        return -ENOMEM;
482
483    mutex_init(&pmic->io_lock);
484    pmic->mfd = tps65912;
485    platform_set_drvdata(pdev, pmic);
486
487    pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
488    info = tps65912_regs;
489
490    for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
491        int range = 0;
492        /* Register the regulators */
493        pmic->info[i] = info;
494
495        pmic->desc[i].name = info->name;
496        pmic->desc[i].id = i;
497        pmic->desc[i].n_voltages = 64;
498        pmic->desc[i].ops = (i > TPS65912_REG_DCDC4 ?
499            &tps65912_ops_ldo : &tps65912_ops_dcdc);
500        pmic->desc[i].type = REGULATOR_VOLTAGE;
501        pmic->desc[i].owner = THIS_MODULE;
502        range = tps65912_get_range(pmic, i);
503
504        config.dev = tps65912->dev;
505        config.init_data = reg_data;
506        config.driver_data = pmic;
507
508        rdev = regulator_register(&pmic->desc[i], &config);
509        if (IS_ERR(rdev)) {
510            dev_err(tps65912->dev,
511                "failed to register %s regulator\n",
512                pdev->name);
513            err = PTR_ERR(rdev);
514            goto err;
515        }
516
517        /* Save regulator for cleanup */
518        pmic->rdev[i] = rdev;
519    }
520    return 0;
521
522err:
523    while (--i >= 0)
524        regulator_unregister(pmic->rdev[i]);
525    return err;
526}
527
528static int __devexit tps65912_remove(struct platform_device *pdev)
529{
530    struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
531    int i;
532
533    for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
534        regulator_unregister(tps65912_reg->rdev[i]);
535    return 0;
536}
537
538static struct platform_driver tps65912_driver = {
539    .driver = {
540        .name = "tps65912-pmic",
541        .owner = THIS_MODULE,
542    },
543    .probe = tps65912_probe,
544    .remove = __devexit_p(tps65912_remove),
545};
546
547static int __init tps65912_init(void)
548{
549    return platform_driver_register(&tps65912_driver);
550}
551subsys_initcall(tps65912_init);
552
553static void __exit tps65912_cleanup(void)
554{
555    platform_driver_unregister(&tps65912_driver);
556}
557module_exit(tps65912_cleanup);
558
559MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
560MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
561MODULE_LICENSE("GPL v2");
562MODULE_ALIAS("platform:tps65912-pmic");
563

Archive Download this file



interactive