tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * tps6507x-regulator.c
3 *
4 * Regulator driver for TPS65073 PMIC
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/delay.h>
26#include <linux/slab.h>
27#include <linux/mfd/tps6507x.h>
28
29/* DCDC's */
30#define TPS6507X_DCDC_1 0
31#define TPS6507X_DCDC_2 1
32#define TPS6507X_DCDC_3 2
33/* LDOs */
34#define TPS6507X_LDO_1 3
35#define TPS6507X_LDO_2 4
36
37#define TPS6507X_MAX_REG_ID TPS6507X_LDO_2
38
39/* Number of step-down converters available */
40#define TPS6507X_NUM_DCDC 3
41/* Number of LDO voltage regulators available */
42#define TPS6507X_NUM_LDO 2
43/* Number of total regulators available */
44#define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
45
46/* Supported voltage values for regulators (in milliVolts) */
47static const u16 VDCDCx_VSEL_table[] = {
48 725, 750, 775, 800,
49 825, 850, 875, 900,
50 925, 950, 975, 1000,
51 1025, 1050, 1075, 1100,
52 1125, 1150, 1175, 1200,
53 1225, 1250, 1275, 1300,
54 1325, 1350, 1375, 1400,
55 1425, 1450, 1475, 1500,
56 1550, 1600, 1650, 1700,
57 1750, 1800, 1850, 1900,
58 1950, 2000, 2050, 2100,
59 2150, 2200, 2250, 2300,
60 2350, 2400, 2450, 2500,
61 2550, 2600, 2650, 2700,
62 2750, 2800, 2850, 2900,
63 3000, 3100, 3200, 3300,
64};
65
66static const u16 LDO1_VSEL_table[] = {
67 1000, 1100, 1200, 1250,
68 1300, 1350, 1400, 1500,
69 1600, 1800, 2500, 2750,
70 2800, 3000, 3100, 3300,
71};
72
73static const u16 LDO2_VSEL_table[] = {
74 725, 750, 775, 800,
75 825, 850, 875, 900,
76 925, 950, 975, 1000,
77 1025, 1050, 1075, 1100,
78 1125, 1150, 1175, 1200,
79 1225, 1250, 1275, 1300,
80 1325, 1350, 1375, 1400,
81 1425, 1450, 1475, 1500,
82 1550, 1600, 1650, 1700,
83 1750, 1800, 1850, 1900,
84 1950, 2000, 2050, 2100,
85 2150, 2200, 2250, 2300,
86 2350, 2400, 2450, 2500,
87 2550, 2600, 2650, 2700,
88 2750, 2800, 2850, 2900,
89 3000, 3100, 3200, 3300,
90};
91
92static unsigned int num_voltages[] = {ARRAY_SIZE(VDCDCx_VSEL_table),
93 ARRAY_SIZE(VDCDCx_VSEL_table),
94 ARRAY_SIZE(VDCDCx_VSEL_table),
95 ARRAY_SIZE(LDO1_VSEL_table),
96 ARRAY_SIZE(LDO2_VSEL_table)};
97
98struct tps_info {
99 const char *name;
100 unsigned min_uV;
101 unsigned max_uV;
102 u8 table_len;
103 const u16 *table;
104};
105
106static const struct tps_info tps6507x_pmic_regs[] = {
107 {
108 .name = "VDCDC1",
109 .min_uV = 725000,
110 .max_uV = 3300000,
111 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
112 .table = VDCDCx_VSEL_table,
113 },
114 {
115 .name = "VDCDC2",
116 .min_uV = 725000,
117 .max_uV = 3300000,
118 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
119 .table = VDCDCx_VSEL_table,
120 },
121 {
122 .name = "VDCDC3",
123 .min_uV = 725000,
124 .max_uV = 3300000,
125 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
126 .table = VDCDCx_VSEL_table,
127 },
128 {
129 .name = "LDO1",
130 .min_uV = 1000000,
131 .max_uV = 3300000,
132 .table_len = ARRAY_SIZE(LDO1_VSEL_table),
133 .table = LDO1_VSEL_table,
134 },
135 {
136 .name = "LDO2",
137 .min_uV = 725000,
138 .max_uV = 3300000,
139 .table_len = ARRAY_SIZE(LDO2_VSEL_table),
140 .table = LDO2_VSEL_table,
141 },
142};
143
144struct tps6507x_pmic {
145 struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
146 struct tps6507x_dev *mfd;
147 struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
148 const struct tps_info *info[TPS6507X_NUM_REGULATOR];
149 struct mutex io_lock;
150};
151static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg)
152{
153 u8 val;
154 int err;
155
156 err = tps->mfd->read_dev(tps->mfd, reg, 1, &val);
157
158 if (err)
159 return err;
160
161 return val;
162}
163
164static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
165{
166 return tps->mfd->write_dev(tps->mfd, reg, 1, &val);
167}
168
169static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
170{
171 int err, data;
172
173 mutex_lock(&tps->io_lock);
174
175 data = tps6507x_pmic_read(tps, reg);
176 if (data < 0) {
177 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
178 err = data;
179 goto out;
180 }
181
182 data |= mask;
183 err = tps6507x_pmic_write(tps, reg, data);
184 if (err)
185 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
186
187out:
188 mutex_unlock(&tps->io_lock);
189 return err;
190}
191
192static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
193{
194 int err, data;
195
196 mutex_lock(&tps->io_lock);
197
198 data = tps6507x_pmic_read(tps, reg);
199 if (data < 0) {
200 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
201 err = data;
202 goto out;
203 }
204
205 data &= ~mask;
206 err = tps6507x_pmic_write(tps, reg, data);
207 if (err)
208 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
209
210out:
211 mutex_unlock(&tps->io_lock);
212 return err;
213}
214
215static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg)
216{
217 int data;
218
219 mutex_lock(&tps->io_lock);
220
221 data = tps6507x_pmic_read(tps, reg);
222 if (data < 0)
223 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
224
225 mutex_unlock(&tps->io_lock);
226 return data;
227}
228
229static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
230{
231 int err;
232
233 mutex_lock(&tps->io_lock);
234
235 err = tps6507x_pmic_write(tps, reg, val);
236 if (err < 0)
237 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
238
239 mutex_unlock(&tps->io_lock);
240 return err;
241}
242
243static int tps6507x_pmic_dcdc_is_enabled(struct regulator_dev *dev)
244{
245 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
246 int data, dcdc = rdev_get_id(dev);
247 u8 shift;
248
249 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
250 return -EINVAL;
251
252 shift = TPS6507X_MAX_REG_ID - dcdc;
253 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1);
254
255 if (data < 0)
256 return data;
257 else
258 return (data & 1<<shift) ? 1 : 0;
259}
260
261static int tps6507x_pmic_ldo_is_enabled(struct regulator_dev *dev)
262{
263 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
264 int data, ldo = rdev_get_id(dev);
265 u8 shift;
266
267 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
268 return -EINVAL;
269
270 shift = TPS6507X_MAX_REG_ID - ldo;
271 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1);
272
273 if (data < 0)
274 return data;
275 else
276 return (data & 1<<shift) ? 1 : 0;
277}
278
279static int tps6507x_pmic_dcdc_enable(struct regulator_dev *dev)
280{
281 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
282 int dcdc = rdev_get_id(dev);
283 u8 shift;
284
285 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
286 return -EINVAL;
287
288 shift = TPS6507X_MAX_REG_ID - dcdc;
289 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
290}
291
292static int tps6507x_pmic_dcdc_disable(struct regulator_dev *dev)
293{
294 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
295 int dcdc = rdev_get_id(dev);
296 u8 shift;
297
298 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
299 return -EINVAL;
300
301 shift = TPS6507X_MAX_REG_ID - dcdc;
302 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1,
303 1 << shift);
304}
305
306static int tps6507x_pmic_ldo_enable(struct regulator_dev *dev)
307{
308 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
309 int ldo = rdev_get_id(dev);
310 u8 shift;
311
312 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
313 return -EINVAL;
314
315 shift = TPS6507X_MAX_REG_ID - ldo;
316 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
317}
318
319static int tps6507x_pmic_ldo_disable(struct regulator_dev *dev)
320{
321 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
322 int ldo = rdev_get_id(dev);
323 u8 shift;
324
325 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
326 return -EINVAL;
327
328 shift = TPS6507X_MAX_REG_ID - ldo;
329 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1,
330 1 << shift);
331}
332
333static int tps6507x_pmic_dcdc_get_voltage(struct regulator_dev *dev)
334{
335 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
336 int data, dcdc = rdev_get_id(dev);
337 u8 reg;
338
339 switch (dcdc) {
340 case TPS6507X_DCDC_1:
341 reg = TPS6507X_REG_DEFDCDC1;
342 break;
343 case TPS6507X_DCDC_2:
344 reg = TPS6507X_REG_DEFDCDC2_LOW;
345 break;
346 case TPS6507X_DCDC_3:
347 reg = TPS6507X_REG_DEFDCDC3_LOW;
348 break;
349 default:
350 return -EINVAL;
351 }
352
353 data = tps6507x_pmic_reg_read(tps, reg);
354 if (data < 0)
355 return data;
356
357 data &= TPS6507X_DEFDCDCX_DCDC_MASK;
358 return tps->info[dcdc]->table[data] * 1000;
359}
360
361static int tps6507x_pmic_dcdc_set_voltage(struct regulator_dev *dev,
362 int min_uV, int max_uV)
363{
364 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
365 int data, vsel, dcdc = rdev_get_id(dev);
366 u8 reg;
367
368 switch (dcdc) {
369 case TPS6507X_DCDC_1:
370 reg = TPS6507X_REG_DEFDCDC1;
371 break;
372 case TPS6507X_DCDC_2:
373 reg = TPS6507X_REG_DEFDCDC2_LOW;
374 break;
375 case TPS6507X_DCDC_3:
376 reg = TPS6507X_REG_DEFDCDC3_LOW;
377 break;
378 default:
379 return -EINVAL;
380 }
381
382 if (min_uV < tps->info[dcdc]->min_uV
383 || min_uV > tps->info[dcdc]->max_uV)
384 return -EINVAL;
385 if (max_uV < tps->info[dcdc]->min_uV
386 || max_uV > tps->info[dcdc]->max_uV)
387 return -EINVAL;
388
389 for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) {
390 int mV = tps->info[dcdc]->table[vsel];
391 int uV = mV * 1000;
392
393 /* Break at the first in-range value */
394 if (min_uV <= uV && uV <= max_uV)
395 break;
396 }
397
398 /* write to the register in case we found a match */
399 if (vsel == tps->info[dcdc]->table_len)
400 return -EINVAL;
401
402 data = tps6507x_pmic_reg_read(tps, reg);
403 if (data < 0)
404 return data;
405
406 data &= ~TPS6507X_DEFDCDCX_DCDC_MASK;
407 data |= vsel;
408
409 return tps6507x_pmic_reg_write(tps, reg, data);
410}
411
412static int tps6507x_pmic_ldo_get_voltage(struct regulator_dev *dev)
413{
414 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
415 int data, ldo = rdev_get_id(dev);
416 u8 reg, mask;
417
418 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
419 return -EINVAL;
420 else {
421 reg = (ldo == TPS6507X_LDO_1 ?
422 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
423 mask = (ldo == TPS6507X_LDO_1 ?
424 TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
425 TPS6507X_REG_DEFLDO2_LDO2_MASK);
426 }
427
428 data = tps6507x_pmic_reg_read(tps, reg);
429 if (data < 0)
430 return data;
431
432 data &= mask;
433 return tps->info[ldo]->table[data] * 1000;
434}
435
436static int tps6507x_pmic_ldo_set_voltage(struct regulator_dev *dev,
437 int min_uV, int max_uV)
438{
439 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
440 int data, vsel, ldo = rdev_get_id(dev);
441 u8 reg, mask;
442
443 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
444 return -EINVAL;
445 else {
446 reg = (ldo == TPS6507X_LDO_1 ?
447 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
448 mask = (ldo == TPS6507X_LDO_1 ?
449 TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
450 TPS6507X_REG_DEFLDO2_LDO2_MASK);
451 }
452
453 if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV)
454 return -EINVAL;
455 if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV)
456 return -EINVAL;
457
458 for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) {
459 int mV = tps->info[ldo]->table[vsel];
460 int uV = mV * 1000;
461
462 /* Break at the first in-range value */
463 if (min_uV <= uV && uV <= max_uV)
464 break;
465 }
466
467 if (vsel == tps->info[ldo]->table_len)
468 return -EINVAL;
469
470 data = tps6507x_pmic_reg_read(tps, reg);
471 if (data < 0)
472 return data;
473
474 data &= ~mask;
475 data |= vsel;
476
477 return tps6507x_pmic_reg_write(tps, reg, data);
478}
479
480static int tps6507x_pmic_dcdc_list_voltage(struct regulator_dev *dev,
481 unsigned selector)
482{
483 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
484 int dcdc = rdev_get_id(dev);
485
486 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
487 return -EINVAL;
488
489 if (selector >= tps->info[dcdc]->table_len)
490 return -EINVAL;
491 else
492 return tps->info[dcdc]->table[selector] * 1000;
493}
494
495static int tps6507x_pmic_ldo_list_voltage(struct regulator_dev *dev,
496 unsigned selector)
497{
498 struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
499 int ldo = rdev_get_id(dev);
500
501 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
502 return -EINVAL;
503
504 if (selector >= tps->info[ldo]->table_len)
505 return -EINVAL;
506 else
507 return tps->info[ldo]->table[selector] * 1000;
508}
509
510/* Operations permitted on VDCDCx */
511static struct regulator_ops tps6507x_pmic_dcdc_ops = {
512 .is_enabled = tps6507x_pmic_dcdc_is_enabled,
513 .enable = tps6507x_pmic_dcdc_enable,
514 .disable = tps6507x_pmic_dcdc_disable,
515 .get_voltage = tps6507x_pmic_dcdc_get_voltage,
516 .set_voltage = tps6507x_pmic_dcdc_set_voltage,
517 .list_voltage = tps6507x_pmic_dcdc_list_voltage,
518};
519
520/* Operations permitted on LDOx */
521static struct regulator_ops tps6507x_pmic_ldo_ops = {
522 .is_enabled = tps6507x_pmic_ldo_is_enabled,
523 .enable = tps6507x_pmic_ldo_enable,
524 .disable = tps6507x_pmic_ldo_disable,
525 .get_voltage = tps6507x_pmic_ldo_get_voltage,
526 .set_voltage = tps6507x_pmic_ldo_set_voltage,
527 .list_voltage = tps6507x_pmic_ldo_list_voltage,
528};
529
530static __devinit
531int tps6507x_pmic_probe(struct platform_device *pdev)
532{
533 struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
534 static int desc_id;
535 const struct tps_info *info = &tps6507x_pmic_regs[0];
536 struct regulator_init_data *init_data;
537 struct regulator_dev *rdev;
538 struct tps6507x_pmic *tps;
539 struct tps6507x_board *tps_board;
540 int i;
541 int error;
542
543 /**
544 * tps_board points to pmic related constants
545 * coming from the board-evm file.
546 */
547
548 tps_board = dev_get_platdata(tps6507x_dev->dev);
549 if (!tps_board)
550 return -EINVAL;
551
552 /**
553 * init_data points to array of regulator_init structures
554 * coming from the board-evm file.
555 */
556 init_data = tps_board->tps6507x_pmic_init_data;
557 if (!init_data)
558 return -EINVAL;
559
560 tps = kzalloc(sizeof(*tps), GFP_KERNEL);
561 if (!tps)
562 return -ENOMEM;
563
564 mutex_init(&tps->io_lock);
565
566 /* common for all regulators */
567 tps->mfd = tps6507x_dev;
568
569 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
570 /* Register the regulators */
571 tps->info[i] = info;
572 tps->desc[i].name = info->name;
573 tps->desc[i].id = desc_id++;
574 tps->desc[i].n_voltages = num_voltages[i];
575 tps->desc[i].ops = (i > TPS6507X_DCDC_3 ?
576 &tps6507x_pmic_ldo_ops : &tps6507x_pmic_dcdc_ops);
577 tps->desc[i].type = REGULATOR_VOLTAGE;
578 tps->desc[i].owner = THIS_MODULE;
579
580 rdev = regulator_register(&tps->desc[i],
581 tps6507x_dev->dev, init_data, tps);
582 if (IS_ERR(rdev)) {
583 dev_err(tps6507x_dev->dev,
584 "failed to register %s regulator\n",
585 pdev->name);
586 error = PTR_ERR(rdev);
587 goto fail;
588 }
589
590 /* Save regulator for cleanup */
591 tps->rdev[i] = rdev;
592 }
593
594 tps6507x_dev->pmic = tps;
595
596 return 0;
597
598fail:
599 while (--i >= 0)
600 regulator_unregister(tps->rdev[i]);
601
602 kfree(tps);
603 return error;
604}
605
606/**
607 * tps6507x_remove - TPS6507x driver i2c remove handler
608 * @client: i2c driver client device structure
609 *
610 * Unregister TPS driver as an i2c client device driver
611 */
612static int __devexit tps6507x_pmic_remove(struct platform_device *pdev)
613{
614 struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev);
615 struct tps6507x_pmic *tps = tps6507x_dev->pmic;
616 int i;
617
618 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++)
619 regulator_unregister(tps->rdev[i]);
620
621 kfree(tps);
622
623 return 0;
624}
625
626static struct platform_driver tps6507x_pmic_driver = {
627 .driver = {
628 .name = "tps6507x-pmic",
629 .owner = THIS_MODULE,
630 },
631 .probe = tps6507x_pmic_probe,
632 .remove = __devexit_p(tps6507x_pmic_remove),
633};
634
635/**
636 * tps6507x_pmic_init
637 *
638 * Module init function
639 */
640static int __init tps6507x_pmic_init(void)
641{
642 return platform_driver_register(&tps6507x_pmic_driver);
643}
644subsys_initcall(tps6507x_pmic_init);
645
646/**
647 * tps6507x_pmic_cleanup
648 *
649 * Module exit function
650 */
651static void __exit tps6507x_pmic_cleanup(void)
652{
653 platform_driver_unregister(&tps6507x_pmic_driver);
654}
655module_exit(tps6507x_pmic_cleanup);
656
657MODULE_AUTHOR("Texas Instruments");
658MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
659MODULE_LICENSE("GPL v2");
660MODULE_ALIAS("platform:tps6507x-pmic");