Root/drivers/regulator/tps65023-regulator.c

1/*
2 * tps65023-regulator.c
3 *
4 * Supports TPS65023 Regulator
5 *
6 * Copyright (C) 2009 Texas Instrument Incorporated - http://www.ti.com/
7 *
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.
11 *
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.
16 */
17
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/i2c.h>
26#include <linux/slab.h>
27#include <linux/regmap.h>
28
29/* Register definitions */
30#define TPS65023_REG_VERSION 0
31#define TPS65023_REG_PGOODZ 1
32#define TPS65023_REG_MASK 2
33#define TPS65023_REG_REG_CTRL 3
34#define TPS65023_REG_CON_CTRL 4
35#define TPS65023_REG_CON_CTRL2 5
36#define TPS65023_REG_DEF_CORE 6
37#define TPS65023_REG_DEFSLEW 7
38#define TPS65023_REG_LDO_CTRL 8
39
40/* PGOODZ bitfields */
41#define TPS65023_PGOODZ_PWRFAILZ BIT(7)
42#define TPS65023_PGOODZ_LOWBATTZ BIT(6)
43#define TPS65023_PGOODZ_VDCDC1 BIT(5)
44#define TPS65023_PGOODZ_VDCDC2 BIT(4)
45#define TPS65023_PGOODZ_VDCDC3 BIT(3)
46#define TPS65023_PGOODZ_LDO2 BIT(2)
47#define TPS65023_PGOODZ_LDO1 BIT(1)
48
49/* MASK bitfields */
50#define TPS65023_MASK_PWRFAILZ BIT(7)
51#define TPS65023_MASK_LOWBATTZ BIT(6)
52#define TPS65023_MASK_VDCDC1 BIT(5)
53#define TPS65023_MASK_VDCDC2 BIT(4)
54#define TPS65023_MASK_VDCDC3 BIT(3)
55#define TPS65023_MASK_LDO2 BIT(2)
56#define TPS65023_MASK_LDO1 BIT(1)
57
58/* REG_CTRL bitfields */
59#define TPS65023_REG_CTRL_VDCDC1_EN BIT(5)
60#define TPS65023_REG_CTRL_VDCDC2_EN BIT(4)
61#define TPS65023_REG_CTRL_VDCDC3_EN BIT(3)
62#define TPS65023_REG_CTRL_LDO2_EN BIT(2)
63#define TPS65023_REG_CTRL_LDO1_EN BIT(1)
64
65/* REG_CTRL2 bitfields */
66#define TPS65023_REG_CTRL2_GO BIT(7)
67#define TPS65023_REG_CTRL2_CORE_ADJ BIT(6)
68#define TPS65023_REG_CTRL2_DCDC2 BIT(2)
69#define TPS65023_REG_CTRL2_DCDC1 BIT(1)
70#define TPS65023_REG_CTRL2_DCDC3 BIT(0)
71
72/* Number of step-down converters available */
73#define TPS65023_NUM_DCDC 3
74/* Number of LDO voltage regulators available */
75#define TPS65023_NUM_LDO 2
76/* Number of total regulators available */
77#define TPS65023_NUM_REGULATOR (TPS65023_NUM_DCDC + TPS65023_NUM_LDO)
78
79/* DCDCs */
80#define TPS65023_DCDC_1 0
81#define TPS65023_DCDC_2 1
82#define TPS65023_DCDC_3 2
83/* LDOs */
84#define TPS65023_LDO_1 3
85#define TPS65023_LDO_2 4
86
87#define TPS65023_MAX_REG_ID TPS65023_LDO_2
88
89/* Supported voltage values for regulators */
90static const unsigned int VCORE_VSEL_table[] = {
91    800000, 825000, 850000, 875000,
92    900000, 925000, 950000, 975000,
93    1000000, 1025000, 1050000, 1075000,
94    1100000, 1125000, 1150000, 1175000,
95    1200000, 1225000, 1250000, 1275000,
96    1300000, 1325000, 1350000, 1375000,
97    1400000, 1425000, 1450000, 1475000,
98    1500000, 1525000, 1550000, 1600000,
99};
100
101static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
102    3300000,
103};
104
105static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
106    1800000,
107};
108
109/* Supported voltage values for LDO regulators for tps65020 */
110static const unsigned int TPS65020_LDO1_VSEL_table[] = {
111    1000000, 1050000, 1100000, 1300000,
112    1800000, 2500000, 3000000, 3300000,
113};
114
115static const unsigned int TPS65020_LDO2_VSEL_table[] = {
116    1000000, 1050000, 1100000, 1300000,
117    1800000, 2500000, 3000000, 3300000,
118};
119
120/* Supported voltage values for LDO regulators
121 * for tps65021 and tps65023 */
122static const unsigned int TPS65023_LDO1_VSEL_table[] = {
123    1000000, 1100000, 1300000, 1800000,
124    2200000, 2600000, 2800000, 3150000,
125};
126
127static const unsigned int TPS65023_LDO2_VSEL_table[] = {
128    1050000, 1200000, 1300000, 1800000,
129    2500000, 2800000, 3000000, 3300000,
130};
131
132/* Regulator specific details */
133struct tps_info {
134    const char *name;
135    u8 table_len;
136    const unsigned int *table;
137};
138
139/* PMIC details */
140struct tps_pmic {
141    struct regulator_desc desc[TPS65023_NUM_REGULATOR];
142    struct regulator_dev *rdev[TPS65023_NUM_REGULATOR];
143    const struct tps_info *info[TPS65023_NUM_REGULATOR];
144    struct regmap *regmap;
145    u8 core_regulator;
146};
147
148/* Struct passed as driver data */
149struct tps_driver_data {
150    const struct tps_info *info;
151    u8 core_regulator;
152};
153
154static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
155{
156    struct tps_pmic *tps = rdev_get_drvdata(dev);
157    int ret;
158    int data, dcdc = rdev_get_id(dev);
159
160    if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
161        return -EINVAL;
162
163    if (dcdc == tps->core_regulator) {
164        ret = regmap_read(tps->regmap, TPS65023_REG_DEF_CORE, &data);
165        if (ret != 0)
166            return ret;
167        data &= (tps->info[dcdc]->table_len - 1);
168        return data;
169    } else
170        return 0;
171}
172
173static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
174                     unsigned selector)
175{
176    struct tps_pmic *tps = rdev_get_drvdata(dev);
177    int dcdc = rdev_get_id(dev);
178    int ret;
179
180    if (dcdc != tps->core_regulator)
181        return -EINVAL;
182
183    ret = regmap_write(tps->regmap, TPS65023_REG_DEF_CORE, selector);
184    if (ret)
185        goto out;
186
187    /* Tell the chip that we have changed the value in DEFCORE
188     * and its time to update the core voltage
189     */
190    ret = regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
191                 TPS65023_REG_CTRL2_GO, TPS65023_REG_CTRL2_GO);
192
193out:
194    return ret;
195}
196
197/* Operations permitted on VDCDCx */
198static struct regulator_ops tps65023_dcdc_ops = {
199    .is_enabled = regulator_is_enabled_regmap,
200    .enable = regulator_enable_regmap,
201    .disable = regulator_disable_regmap,
202    .get_voltage_sel = tps65023_dcdc_get_voltage_sel,
203    .set_voltage_sel = tps65023_dcdc_set_voltage_sel,
204    .list_voltage = regulator_list_voltage_table,
205};
206
207/* Operations permitted on LDOx */
208static struct regulator_ops tps65023_ldo_ops = {
209    .is_enabled = regulator_is_enabled_regmap,
210    .enable = regulator_enable_regmap,
211    .disable = regulator_disable_regmap,
212    .get_voltage_sel = regulator_get_voltage_sel_regmap,
213    .set_voltage_sel = regulator_set_voltage_sel_regmap,
214    .list_voltage = regulator_list_voltage_table,
215};
216
217static struct regmap_config tps65023_regmap_config = {
218    .reg_bits = 8,
219    .val_bits = 8,
220};
221
222static int __devinit tps_65023_probe(struct i2c_client *client,
223                     const struct i2c_device_id *id)
224{
225    const struct tps_driver_data *drv_data = (void *)id->driver_data;
226    const struct tps_info *info = drv_data->info;
227    struct regulator_config config = { };
228    struct regulator_init_data *init_data;
229    struct regulator_dev *rdev;
230    struct tps_pmic *tps;
231    int i;
232    int error;
233
234    if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
235        return -EIO;
236
237    /**
238     * init_data points to array of regulator_init structures
239     * coming from the board-evm file.
240     */
241    init_data = client->dev.platform_data;
242    if (!init_data)
243        return -EIO;
244
245    tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
246    if (!tps)
247        return -ENOMEM;
248
249    tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config);
250    if (IS_ERR(tps->regmap)) {
251        error = PTR_ERR(tps->regmap);
252        dev_err(&client->dev, "Failed to allocate register map: %d\n",
253            error);
254        return error;
255    }
256
257    /* common for all regulators */
258    tps->core_regulator = drv_data->core_regulator;
259
260    for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) {
261        /* Store regulator specific information */
262        tps->info[i] = info;
263
264        tps->desc[i].name = info->name;
265        tps->desc[i].id = i;
266        tps->desc[i].n_voltages = info->table_len;
267        tps->desc[i].volt_table = info->table;
268        tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
269                    &tps65023_ldo_ops : &tps65023_dcdc_ops);
270        tps->desc[i].type = REGULATOR_VOLTAGE;
271        tps->desc[i].owner = THIS_MODULE;
272
273        tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL;
274        switch (i) {
275        case TPS65023_LDO_1:
276            tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
277            tps->desc[i].vsel_mask = 0x07;
278            tps->desc[i].enable_mask = 1 << 1;
279            break;
280        case TPS65023_LDO_2:
281            tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
282            tps->desc[i].vsel_mask = 0x70;
283            tps->desc[i].enable_mask = 1 << 2;
284            break;
285        default: /* DCDCx */
286            tps->desc[i].enable_mask =
287                    1 << (TPS65023_NUM_REGULATOR - i);
288        }
289
290        config.dev = &client->dev;
291        config.init_data = init_data;
292        config.driver_data = tps;
293        config.regmap = tps->regmap;
294
295        /* Register the regulators */
296        rdev = regulator_register(&tps->desc[i], &config);
297        if (IS_ERR(rdev)) {
298            dev_err(&client->dev, "failed to register %s\n",
299                id->name);
300            error = PTR_ERR(rdev);
301            goto fail;
302        }
303
304        /* Save regulator for cleanup */
305        tps->rdev[i] = rdev;
306    }
307
308    i2c_set_clientdata(client, tps);
309
310    /* Enable setting output voltage by I2C */
311    regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2,
312            TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ);
313
314    return 0;
315
316 fail:
317    while (--i >= 0)
318        regulator_unregister(tps->rdev[i]);
319    return error;
320}
321
322static int __devexit tps_65023_remove(struct i2c_client *client)
323{
324    struct tps_pmic *tps = i2c_get_clientdata(client);
325    int i;
326
327    for (i = 0; i < TPS65023_NUM_REGULATOR; i++)
328        regulator_unregister(tps->rdev[i]);
329    return 0;
330}
331
332static const struct tps_info tps65020_regs[] = {
333    {
334        .name = "VDCDC1",
335        .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
336        .table = DCDC_FIXED_3300000_VSEL_table,
337    },
338    {
339        .name = "VDCDC2",
340        .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
341        .table = DCDC_FIXED_1800000_VSEL_table,
342    },
343    {
344        .name = "VDCDC3",
345        .table_len = ARRAY_SIZE(VCORE_VSEL_table),
346        .table = VCORE_VSEL_table,
347    },
348    {
349        .name = "LDO1",
350        .table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
351        .table = TPS65020_LDO1_VSEL_table,
352    },
353    {
354        .name = "LDO2",
355        .table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
356        .table = TPS65020_LDO2_VSEL_table,
357    },
358};
359
360static const struct tps_info tps65021_regs[] = {
361    {
362        .name = "VDCDC1",
363        .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
364        .table = DCDC_FIXED_3300000_VSEL_table,
365    },
366    {
367        .name = "VDCDC2",
368        .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
369        .table = DCDC_FIXED_1800000_VSEL_table,
370    },
371    {
372        .name = "VDCDC3",
373        .table_len = ARRAY_SIZE(VCORE_VSEL_table),
374        .table = VCORE_VSEL_table,
375    },
376    {
377        .name = "LDO1",
378        .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
379        .table = TPS65023_LDO1_VSEL_table,
380    },
381    {
382        .name = "LDO2",
383        .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
384        .table = TPS65023_LDO2_VSEL_table,
385    },
386};
387
388static const struct tps_info tps65023_regs[] = {
389    {
390        .name = "VDCDC1",
391        .table_len = ARRAY_SIZE(VCORE_VSEL_table),
392        .table = VCORE_VSEL_table,
393    },
394    {
395        .name = "VDCDC2",
396        .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
397        .table = DCDC_FIXED_3300000_VSEL_table,
398    },
399    {
400        .name = "VDCDC3",
401        .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
402        .table = DCDC_FIXED_1800000_VSEL_table,
403    },
404    {
405        .name = "LDO1",
406        .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
407        .table = TPS65023_LDO1_VSEL_table,
408    },
409    {
410        .name = "LDO2",
411        .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
412        .table = TPS65023_LDO2_VSEL_table,
413    },
414};
415
416static struct tps_driver_data tps65020_drv_data = {
417    .info = tps65020_regs,
418    .core_regulator = TPS65023_DCDC_3,
419};
420
421static struct tps_driver_data tps65021_drv_data = {
422    .info = tps65021_regs,
423    .core_regulator = TPS65023_DCDC_3,
424};
425
426static struct tps_driver_data tps65023_drv_data = {
427    .info = tps65023_regs,
428    .core_regulator = TPS65023_DCDC_1,
429};
430
431static const struct i2c_device_id tps_65023_id[] = {
432    {.name = "tps65023",
433    .driver_data = (unsigned long) &tps65023_drv_data},
434    {.name = "tps65021",
435    .driver_data = (unsigned long) &tps65021_drv_data,},
436    {.name = "tps65020",
437    .driver_data = (unsigned long) &tps65020_drv_data},
438    { },
439};
440
441MODULE_DEVICE_TABLE(i2c, tps_65023_id);
442
443static struct i2c_driver tps_65023_i2c_driver = {
444    .driver = {
445        .name = "tps65023",
446        .owner = THIS_MODULE,
447    },
448    .probe = tps_65023_probe,
449    .remove = __devexit_p(tps_65023_remove),
450    .id_table = tps_65023_id,
451};
452
453static int __init tps_65023_init(void)
454{
455    return i2c_add_driver(&tps_65023_i2c_driver);
456}
457subsys_initcall(tps_65023_init);
458
459static void __exit tps_65023_cleanup(void)
460{
461    i2c_del_driver(&tps_65023_i2c_driver);
462}
463module_exit(tps_65023_cleanup);
464
465MODULE_AUTHOR("Texas Instruments");
466MODULE_DESCRIPTION("TPS65023 voltage regulator driver");
467MODULE_LICENSE("GPL v2");
468

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive