← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/regulator/tps6586x-regulator.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/init.h>
 
18
#include <linux/err.h>
 
19
#include <linux/slab.h>
 
20
#include <linux/platform_device.h>
 
21
#include <linux/regulator/driver.h>
 
22
#include <linux/regulator/machine.h>
 
23
#include <linux/mfd/tps6586x.h>
 
24
 
 
25
/* supply control and voltage setting  */
 
26
#define TPS6586X_SUPPLYENA      0x10
 
27
#define TPS6586X_SUPPLYENB      0x11
 
28
#define TPS6586X_SUPPLYENC      0x12
 
29
#define TPS6586X_SUPPLYEND      0x13
 
30
#define TPS6586X_SUPPLYENE      0x14
 
31
#define TPS6586X_VCC1           0x20
 
32
#define TPS6586X_VCC2           0x21
 
33
#define TPS6586X_SM1V1          0x23
 
34
#define TPS6586X_SM1V2          0x24
 
35
#define TPS6586X_SM1SL          0x25
 
36
#define TPS6586X_SM0V1          0x26
 
37
#define TPS6586X_SM0V2          0x27
 
38
#define TPS6586X_SM0SL          0x28
 
39
#define TPS6586X_LDO2AV1        0x29
 
40
#define TPS6586X_LDO2AV2        0x2A
 
41
#define TPS6586X_LDO2BV1        0x2F
 
42
#define TPS6586X_LDO2BV2        0x30
 
43
#define TPS6586X_LDO4V1         0x32
 
44
#define TPS6586X_LDO4V2         0x33
 
45
 
 
46
/* converter settings  */
 
47
#define TPS6586X_SUPPLYV1       0x41
 
48
#define TPS6586X_SUPPLYV2       0x42
 
49
#define TPS6586X_SUPPLYV3       0x43
 
50
#define TPS6586X_SUPPLYV4       0x44
 
51
#define TPS6586X_SUPPLYV5       0x45
 
52
#define TPS6586X_SUPPLYV6       0x46
 
53
#define TPS6586X_SMODE1         0x47
 
54
#define TPS6586X_SMODE2         0x48
 
55
 
 
56
struct tps6586x_regulator {
 
57
        struct regulator_desc desc;
 
58
 
 
59
        int volt_reg;
 
60
        int volt_shift;
 
61
        int volt_nbits;
 
62
        int enable_bit[2];
 
63
        int enable_reg[2];
 
64
 
 
65
        int *voltages;
 
66
 
 
67
        /* for DVM regulators */
 
68
        int go_reg;
 
69
        int go_bit;
 
70
};
 
71
 
 
72
static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
 
73
{
 
74
        return rdev_get_dev(rdev)->parent->parent;
 
75
}
 
76
 
 
77
static int tps6586x_ldo_list_voltage(struct regulator_dev *rdev,
 
78
                                     unsigned selector)
 
79
{
 
80
        struct tps6586x_regulator *info = rdev_get_drvdata(rdev);
 
81
 
 
82
        return info->voltages[selector] * 1000;
 
83
}
 
84
 
 
85
 
 
86
static int __tps6586x_ldo_set_voltage(struct device *parent,
 
87
                                      struct tps6586x_regulator *ri,
 
88
                                      int min_uV, int max_uV,
 
89
                                      unsigned *selector)
 
90
{
 
91
        int val, uV;
 
92
        uint8_t mask;
 
93
 
 
94
        for (val = 0; val < ri->desc.n_voltages; val++) {
 
95
                uV = ri->voltages[val] * 1000;
 
96
 
 
97
                /* LDO0 has minimal voltage 1.2 rather than 1.25 */
 
98
                if (ri->desc.id == TPS6586X_ID_LDO_0 && val == 0)
 
99
                        uV -= 50 * 1000;
 
100
 
 
101
                /* use the first in-range value */
 
102
                if (min_uV <= uV && uV <= max_uV) {
 
103
 
 
104
                        *selector = val;
 
105
 
 
106
                        val <<= ri->volt_shift;
 
107
                        mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
 
108
 
 
109
                        return tps6586x_update(parent, ri->volt_reg, val, mask);
 
110
                }
 
111
        }
 
112
 
 
113
        return -EINVAL;
 
114
}
 
115
 
 
116
static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev,
 
117
                                    int min_uV, int max_uV, unsigned *selector)
 
118
{
 
119
        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 
120
        struct device *parent = to_tps6586x_dev(rdev);
 
121
 
 
122
        return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
 
123
                                          selector);
 
124
}
 
125
 
 
126
static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
 
127
{
 
128
        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 
129
        struct device *parent = to_tps6586x_dev(rdev);
 
130
        uint8_t val, mask;
 
131
        int ret;
 
132
 
 
133
        ret = tps6586x_read(parent, ri->volt_reg, &val);
 
134
        if (ret)
 
135
                return ret;
 
136
 
 
137
        mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
 
138
        val = (val & mask) >> ri->volt_shift;
 
139
 
 
140
        if (val >= ri->desc.n_voltages)
 
141
                BUG();
 
142
 
 
143
        return ri->voltages[val] * 1000;
 
144
}
 
145
 
 
146
static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev,
 
147
                                    int min_uV, int max_uV, unsigned *selector)
 
148
{
 
149
        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 
150
        struct device *parent = to_tps6586x_dev(rdev);
 
151
        int ret;
 
152
 
 
153
        ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
 
154
                                         selector);
 
155
        if (ret)
 
156
                return ret;
 
157
 
 
158
        return tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit);
 
159
}
 
160
 
 
161
static int tps6586x_regulator_enable(struct regulator_dev *rdev)
 
162
{
 
163
        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 
164
        struct device *parent = to_tps6586x_dev(rdev);
 
165
 
 
166
        return tps6586x_set_bits(parent, ri->enable_reg[0],
 
167
                                 1 << ri->enable_bit[0]);
 
168
}
 
169
 
 
170
static int tps6586x_regulator_disable(struct regulator_dev *rdev)
 
171
{
 
172
        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 
173
        struct device *parent = to_tps6586x_dev(rdev);
 
174
 
 
175
        return tps6586x_clr_bits(parent, ri->enable_reg[0],
 
176
                                 1 << ri->enable_bit[0]);
 
177
}
 
178
 
 
179
static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
 
180
{
 
181
        struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
 
182
        struct device *parent = to_tps6586x_dev(rdev);
 
183
        uint8_t reg_val;
 
184
        int ret;
 
185
 
 
186
        ret = tps6586x_read(parent, ri->enable_reg[0], &reg_val);
 
187
        if (ret)
 
188
                return ret;
 
189
 
 
190
        return !!(reg_val & (1 << ri->enable_bit[0]));
 
191
}
 
192
 
 
193
static struct regulator_ops tps6586x_regulator_ldo_ops = {
 
194
        .list_voltage = tps6586x_ldo_list_voltage,
 
195
        .get_voltage = tps6586x_ldo_get_voltage,
 
196
        .set_voltage = tps6586x_ldo_set_voltage,
 
197
 
 
198
        .is_enabled = tps6586x_regulator_is_enabled,
 
199
        .enable = tps6586x_regulator_enable,
 
200
        .disable = tps6586x_regulator_disable,
 
201
};
 
202
 
 
203
static struct regulator_ops tps6586x_regulator_dvm_ops = {
 
204
        .list_voltage = tps6586x_ldo_list_voltage,
 
205
        .get_voltage = tps6586x_ldo_get_voltage,
 
206
        .set_voltage = tps6586x_dvm_set_voltage,
 
207
 
 
208
        .is_enabled = tps6586x_regulator_is_enabled,
 
209
        .enable = tps6586x_regulator_enable,
 
210
        .disable = tps6586x_regulator_disable,
 
211
};
 
212
 
 
213
static int tps6586x_ldo_voltages[] = {
 
214
        1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
 
215
};
 
216
 
 
217
static int tps6586x_ldo4_voltages[] = {
 
218
        1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
 
219
        1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
 
220
        2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
 
221
        2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
 
222
};
 
223
 
 
224
static int tps6586x_sm2_voltages[] = {
 
225
        3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
 
226
        3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
 
227
        3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
 
228
        4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
 
229
};
 
230
 
 
231
static int tps6586x_dvm_voltages[] = {
 
232
         725,  750,  775,  800,  825,  850,  875,  900,
 
233
         925,  950,  975, 1000, 1025, 1050, 1075, 1100,
 
234
        1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
 
235
        1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
 
236
};
 
237
 
 
238
#define TPS6586X_REGULATOR(_id, vdata, _ops, vreg, shift, nbits,        \
 
239
                           ereg0, ebit0, ereg1, ebit1)                  \
 
240
        .desc   = {                                                     \
 
241
                .name   = "REG-" #_id,                                  \
 
242
                .ops    = &tps6586x_regulator_##_ops,                   \
 
243
                .type   = REGULATOR_VOLTAGE,                            \
 
244
                .id     = TPS6586X_ID_##_id,                            \
 
245
                .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
 
246
                .owner  = THIS_MODULE,                                  \
 
247
        },                                                              \
 
248
        .volt_reg       = TPS6586X_##vreg,                              \
 
249
        .volt_shift     = (shift),                                      \
 
250
        .volt_nbits     = (nbits),                                      \
 
251
        .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
 
252
        .enable_bit[0]  = (ebit0),                                      \
 
253
        .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
 
254
        .enable_bit[1]  = (ebit1),                                      \
 
255
        .voltages       = tps6586x_##vdata##_voltages,
 
256
 
 
257
#define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
 
258
        .go_reg = TPS6586X_##goreg,                                     \
 
259
        .go_bit = (gobit),
 
260
 
 
261
#define TPS6586X_LDO(_id, vdata, vreg, shift, nbits,                    \
 
262
                     ereg0, ebit0, ereg1, ebit1)                        \
 
263
{                                                                       \
 
264
        TPS6586X_REGULATOR(_id, vdata, ldo_ops, vreg, shift, nbits,     \
 
265
                           ereg0, ebit0, ereg1, ebit1)                  \
 
266
}
 
267
 
 
268
#define TPS6586X_DVM(_id, vdata, vreg, shift, nbits,                    \
 
269
                     ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
 
270
{                                                                       \
 
271
        TPS6586X_REGULATOR(_id, vdata, dvm_ops, vreg, shift, nbits,     \
 
272
                           ereg0, ebit0, ereg1, ebit1)                  \
 
273
        TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
 
274
}
 
275
 
 
276
static struct tps6586x_regulator tps6586x_regulator[] = {
 
277
        TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
 
278
        TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
 
279
        TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
 
280
        TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
 
281
        TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
 
282
        TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
 
283
        TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
 
284
        TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
 
285
        TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
 
286
        TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
 
287
 
 
288
        TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
 
289
        TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
 
290
        TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
 
291
        TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
 
292
};
 
293
 
 
294
/*
 
295
 * TPS6586X has 2 enable bits that are OR'ed to determine the actual
 
296
 * regulator state. Clearing one of this bits allows switching
 
297
 * regulator on and of with single register write.
 
298
 */
 
299
static inline int tps6586x_regulator_preinit(struct device *parent,
 
300
                                             struct tps6586x_regulator *ri)
 
301
{
 
302
        uint8_t val1, val2;
 
303
        int ret;
 
304
 
 
305
        if (ri->enable_reg[0] == ri->enable_reg[1] &&
 
306
            ri->enable_bit[0] == ri->enable_bit[1])
 
307
                        return 0;
 
308
 
 
309
        ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
 
310
        if (ret)
 
311
                return ret;
 
312
 
 
313
        ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
 
314
        if (ret)
 
315
                return ret;
 
316
 
 
317
        if (!(val2 & (1 << ri->enable_bit[1])))
 
318
                return 0;
 
319
 
 
320
        /*
 
321
         * The regulator is on, but it's enabled with the bit we don't
 
322
         * want to use, so we switch the enable bits
 
323
         */
 
324
        if (!(val1 & (1 << ri->enable_bit[0]))) {
 
325
                ret = tps6586x_set_bits(parent, ri->enable_reg[0],
 
326
                                        1 << ri->enable_bit[0]);
 
327
                if (ret)
 
328
                        return ret;
 
329
        }
 
330
 
 
331
        return tps6586x_clr_bits(parent, ri->enable_reg[1],
 
332
                                 1 << ri->enable_bit[1]);
 
333
}
 
334
 
 
335
static inline struct tps6586x_regulator *find_regulator_info(int id)
 
336
{
 
337
        struct tps6586x_regulator *ri;
 
338
        int i;
 
339
 
 
340
        for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
 
341
                ri = &tps6586x_regulator[i];
 
342
                if (ri->desc.id == id)
 
343
                        return ri;
 
344
        }
 
345
        return NULL;
 
346
}
 
347
 
 
348
static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
 
349
{
 
350
        struct tps6586x_regulator *ri = NULL;
 
351
        struct regulator_dev *rdev;
 
352
        int id = pdev->id;
 
353
        int err;
 
354
 
 
355
        dev_dbg(&pdev->dev, "Probing reulator %d\n", id);
 
356
 
 
357
        ri = find_regulator_info(id);
 
358
        if (ri == NULL) {
 
359
                dev_err(&pdev->dev, "invalid regulator ID specified\n");
 
360
                return -EINVAL;
 
361
        }
 
362
 
 
363
        err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
 
364
        if (err)
 
365
                return err;
 
366
 
 
367
        rdev = regulator_register(&ri->desc, &pdev->dev,
 
368
                                  pdev->dev.platform_data, ri);
 
369
        if (IS_ERR(rdev)) {
 
370
                dev_err(&pdev->dev, "failed to register regulator %s\n",
 
371
                                ri->desc.name);
 
372
                return PTR_ERR(rdev);
 
373
        }
 
374
 
 
375
        platform_set_drvdata(pdev, rdev);
 
376
 
 
377
        return 0;
 
378
}
 
379
 
 
380
static int __devexit tps6586x_regulator_remove(struct platform_device *pdev)
 
381
{
 
382
        struct regulator_dev *rdev = platform_get_drvdata(pdev);
 
383
 
 
384
        regulator_unregister(rdev);
 
385
        return 0;
 
386
}
 
387
 
 
388
static struct platform_driver tps6586x_regulator_driver = {
 
389
        .driver = {
 
390
                .name   = "tps6586x-regulator",
 
391
                .owner  = THIS_MODULE,
 
392
        },
 
393
        .probe          = tps6586x_regulator_probe,
 
394
        .remove         = __devexit_p(tps6586x_regulator_remove),
 
395
};
 
396
 
 
397
static int __init tps6586x_regulator_init(void)
 
398
{
 
399
        return platform_driver_register(&tps6586x_regulator_driver);
 
400
}
 
401
subsys_initcall(tps6586x_regulator_init);
 
402
 
 
403
static void __exit tps6586x_regulator_exit(void)
 
404
{
 
405
        platform_driver_unregister(&tps6586x_regulator_driver);
 
406
}
 
407
module_exit(tps6586x_regulator_exit);
 
408
 
 
409
MODULE_LICENSE("GPL");
 
410
MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 
411
MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
 
412
MODULE_ALIAS("platform:tps6586x-regulator");