1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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/delay.h>
27
28
29#define TPS6507X_REG_PPATH1 0X01
30#define TPS6507X_REG_INT 0X02
31#define TPS6507X_REG_CHGCONFIG0 0X03
32#define TPS6507X_REG_CHGCONFIG1 0X04
33#define TPS6507X_REG_CHGCONFIG2 0X05
34#define TPS6507X_REG_CHGCONFIG3 0X06
35#define TPS6507X_REG_REG_ADCONFIG 0X07
36#define TPS6507X_REG_TSCMODE 0X08
37#define TPS6507X_REG_ADRESULT_1 0X09
38#define TPS6507X_REG_ADRESULT_2 0X0A
39#define TPS6507X_REG_PGOOD 0X0B
40#define TPS6507X_REG_PGOODMASK 0X0C
41#define TPS6507X_REG_CON_CTRL1 0X0D
42#define TPS6507X_REG_CON_CTRL2 0X0E
43#define TPS6507X_REG_CON_CTRL3 0X0F
44#define TPS6507X_REG_DEFDCDC1 0X10
45#define TPS6507X_REG_DEFDCDC2_LOW 0X11
46#define TPS6507X_REG_DEFDCDC2_HIGH 0X12
47#define TPS6507X_REG_DEFDCDC3_LOW 0X13
48#define TPS6507X_REG_DEFDCDC3_HIGH 0X14
49#define TPS6507X_REG_DEFSLEW 0X15
50#define TPS6507X_REG_LDO_CTRL1 0X16
51#define TPS6507X_REG_DEFLDO2 0X17
52#define TPS6507X_REG_WLED_CTRL1 0X18
53#define TPS6507X_REG_WLED_CTRL2 0X19
54
55
56#define TPS6507X_CON_CTRL1_DCDC1_ENABLE BIT(4)
57#define TPS6507X_CON_CTRL1_DCDC2_ENABLE BIT(3)
58#define TPS6507X_CON_CTRL1_DCDC3_ENABLE BIT(2)
59#define TPS6507X_CON_CTRL1_LDO1_ENABLE BIT(1)
60#define TPS6507X_CON_CTRL1_LDO2_ENABLE BIT(0)
61
62
63#define TPS6507X_DEFDCDC1_DCDC1_EXT_ADJ_EN BIT(7)
64#define TPS6507X_DEFDCDC1_DCDC1_MASK 0X3F
65
66
67#define TPS6507X_DEFDCDC2_LOW_DCDC2_MASK 0X3F
68
69
70#define TPS6507X_DEFDCDC2_HIGH_DCDC2_MASK 0X3F
71
72
73#define TPS6507X_DEFDCDC3_LOW_DCDC3_MASK 0X3F
74
75
76#define TPS6507X_DEFDCDC3_HIGH_DCDC3_MASK 0X3F
77
78
79#define TPS6507X_REG_LDO_CTRL1_LDO1_MASK 0X0F
80
81
82#define TPS6507X_REG_DEFLDO2_LDO2_MASK 0X3F
83
84
85#define TPS6507X_DEFDCDCX_DCDC_MASK 0X3F
86
87
88#define TPS6507X_DCDC_1 0
89#define TPS6507X_DCDC_2 1
90#define TPS6507X_DCDC_3 2
91
92#define TPS6507X_LDO_1 3
93#define TPS6507X_LDO_2 4
94
95#define TPS6507X_MAX_REG_ID TPS6507X_LDO_2
96
97
98#define TPS6507X_NUM_DCDC 3
99
100#define TPS6507X_NUM_LDO 2
101
102#define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
103
104
105static const u16 VDCDCx_VSEL_table[] = {
106 725, 750, 775, 800,
107 825, 850, 875, 900,
108 925, 950, 975, 1000,
109 1025, 1050, 1075, 1100,
110 1125, 1150, 1175, 1200,
111 1225, 1250, 1275, 1300,
112 1325, 1350, 1375, 1400,
113 1425, 1450, 1475, 1500,
114 1550, 1600, 1650, 1700,
115 1750, 1800, 1850, 1900,
116 1950, 2000, 2050, 2100,
117 2150, 2200, 2250, 2300,
118 2350, 2400, 2450, 2500,
119 2550, 2600, 2650, 2700,
120 2750, 2800, 2850, 2900,
121 3000, 3100, 3200, 3300,
122};
123
124static const u16 LDO1_VSEL_table[] = {
125 1000, 1100, 1200, 1250,
126 1300, 1350, 1400, 1500,
127 1600, 1800, 2500, 2750,
128 2800, 3000, 3100, 3300,
129};
130
131static const u16 LDO2_VSEL_table[] = {
132 725, 750, 775, 800,
133 825, 850, 875, 900,
134 925, 950, 975, 1000,
135 1025, 1050, 1075, 1100,
136 1125, 1150, 1175, 1200,
137 1225, 1250, 1275, 1300,
138 1325, 1350, 1375, 1400,
139 1425, 1450, 1475, 1500,
140 1550, 1600, 1650, 1700,
141 1750, 1800, 1850, 1900,
142 1950, 2000, 2050, 2100,
143 2150, 2200, 2250, 2300,
144 2350, 2400, 2450, 2500,
145 2550, 2600, 2650, 2700,
146 2750, 2800, 2850, 2900,
147 3000, 3100, 3200, 3300,
148};
149
150static unsigned int num_voltages[] = {ARRAY_SIZE(VDCDCx_VSEL_table),
151 ARRAY_SIZE(VDCDCx_VSEL_table),
152 ARRAY_SIZE(VDCDCx_VSEL_table),
153 ARRAY_SIZE(LDO1_VSEL_table),
154 ARRAY_SIZE(LDO2_VSEL_table)};
155
156struct tps_info {
157 const char *name;
158 unsigned min_uV;
159 unsigned max_uV;
160 u8 table_len;
161 const u16 *table;
162};
163
164struct tps_pmic {
165 struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
166 struct i2c_client *client;
167 struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
168 const struct tps_info *info[TPS6507X_NUM_REGULATOR];
169 struct mutex io_lock;
170};
171
172static inline int tps_6507x_read(struct tps_pmic *tps, u8 reg)
173{
174 return i2c_smbus_read_byte_data(tps->client, reg);
175}
176
177static inline int tps_6507x_write(struct tps_pmic *tps, u8 reg, u8 val)
178{
179 return i2c_smbus_write_byte_data(tps->client, reg, val);
180}
181
182static int tps_6507x_set_bits(struct tps_pmic *tps, u8 reg, u8 mask)
183{
184 int err, data;
185
186 mutex_lock(&tps->io_lock);
187
188 data = tps_6507x_read(tps, reg);
189 if (data < 0) {
190 dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
191 err = data;
192 goto out;
193 }
194
195 data |= mask;
196 err = tps_6507x_write(tps, reg, data);
197 if (err)
198 dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
199
200out:
201 mutex_unlock(&tps->io_lock);
202 return err;
203}
204
205static int tps_6507x_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask)
206{
207 int err, data;
208
209 mutex_lock(&tps->io_lock);
210
211 data = tps_6507x_read(tps, reg);
212 if (data < 0) {
213 dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
214 err = data;
215 goto out;
216 }
217
218 data &= ~mask;
219 err = tps_6507x_write(tps, reg, data);
220 if (err)
221 dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
222
223out:
224 mutex_unlock(&tps->io_lock);
225 return err;
226}
227
228static int tps_6507x_reg_read(struct tps_pmic *tps, u8 reg)
229{
230 int data;
231
232 mutex_lock(&tps->io_lock);
233
234 data = tps_6507x_read(tps, reg);
235 if (data < 0)
236 dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
237
238 mutex_unlock(&tps->io_lock);
239 return data;
240}
241
242static int tps_6507x_reg_write(struct tps_pmic *tps, u8 reg, u8 val)
243{
244 int err;
245
246 mutex_lock(&tps->io_lock);
247
248 err = tps_6507x_write(tps, reg, val);
249 if (err < 0)
250 dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
251
252 mutex_unlock(&tps->io_lock);
253 return err;
254}
255
256static int tps6507x_dcdc_is_enabled(struct regulator_dev *dev)
257{
258 struct tps_pmic *tps = rdev_get_drvdata(dev);
259 int data, dcdc = rdev_get_id(dev);
260 u8 shift;
261
262 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
263 return -EINVAL;
264
265 shift = TPS6507X_MAX_REG_ID - dcdc;
266 data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);
267
268 if (data < 0)
269 return data;
270 else
271 return (data & 1<<shift) ? 1 : 0;
272}
273
274static int tps6507x_ldo_is_enabled(struct regulator_dev *dev)
275{
276 struct tps_pmic *tps = rdev_get_drvdata(dev);
277 int data, ldo = rdev_get_id(dev);
278 u8 shift;
279
280 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
281 return -EINVAL;
282
283 shift = TPS6507X_MAX_REG_ID - ldo;
284 data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);
285
286 if (data < 0)
287 return data;
288 else
289 return (data & 1<<shift) ? 1 : 0;
290}
291
292static int tps6507x_dcdc_enable(struct regulator_dev *dev)
293{
294 struct tps_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 tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
303}
304
305static int tps6507x_dcdc_disable(struct regulator_dev *dev)
306{
307 struct tps_pmic *tps = rdev_get_drvdata(dev);
308 int dcdc = rdev_get_id(dev);
309 u8 shift;
310
311 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
312 return -EINVAL;
313
314 shift = TPS6507X_MAX_REG_ID - dcdc;
315 return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
316}
317
318static int tps6507x_ldo_enable(struct regulator_dev *dev)
319{
320 struct tps_pmic *tps = rdev_get_drvdata(dev);
321 int ldo = rdev_get_id(dev);
322 u8 shift;
323
324 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
325 return -EINVAL;
326
327 shift = TPS6507X_MAX_REG_ID - ldo;
328 return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
329}
330
331static int tps6507x_ldo_disable(struct regulator_dev *dev)
332{
333 struct tps_pmic *tps = rdev_get_drvdata(dev);
334 int ldo = rdev_get_id(dev);
335 u8 shift;
336
337 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
338 return -EINVAL;
339
340 shift = TPS6507X_MAX_REG_ID - ldo;
341 return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
342}
343
344static int tps6507x_dcdc_get_voltage(struct regulator_dev *dev)
345{
346 struct tps_pmic *tps = rdev_get_drvdata(dev);
347 int data, dcdc = rdev_get_id(dev);
348 u8 reg;
349
350 switch (dcdc) {
351 case TPS6507X_DCDC_1:
352 reg = TPS6507X_REG_DEFDCDC1;
353 break;
354 case TPS6507X_DCDC_2:
355 reg = TPS6507X_REG_DEFDCDC2_LOW;
356 break;
357 case TPS6507X_DCDC_3:
358 reg = TPS6507X_REG_DEFDCDC3_LOW;
359 break;
360 default:
361 return -EINVAL;
362 }
363
364 data = tps_6507x_reg_read(tps, reg);
365 if (data < 0)
366 return data;
367
368 data &= TPS6507X_DEFDCDCX_DCDC_MASK;
369 return tps->info[dcdc]->table[data] * 1000;
370}
371
372static int tps6507x_dcdc_set_voltage(struct regulator_dev *dev,
373 int min_uV, int max_uV)
374{
375 struct tps_pmic *tps = rdev_get_drvdata(dev);
376 int data, vsel, dcdc = rdev_get_id(dev);
377 u8 reg;
378
379 switch (dcdc) {
380 case TPS6507X_DCDC_1:
381 reg = TPS6507X_REG_DEFDCDC1;
382 break;
383 case TPS6507X_DCDC_2:
384 reg = TPS6507X_REG_DEFDCDC2_LOW;
385 break;
386 case TPS6507X_DCDC_3:
387 reg = TPS6507X_REG_DEFDCDC3_LOW;
388 break;
389 default:
390 return -EINVAL;
391 }
392
393 if (min_uV < tps->info[dcdc]->min_uV
394 || min_uV > tps->info[dcdc]->max_uV)
395 return -EINVAL;
396 if (max_uV < tps->info[dcdc]->min_uV
397 || max_uV > tps->info[dcdc]->max_uV)
398 return -EINVAL;
399
400 for (vsel = 0; vsel < tps->info[dcdc]->table_len; vsel++) {
401 int mV = tps->info[dcdc]->table[vsel];
402 int uV = mV * 1000;
403
404
405 if (min_uV <= uV && uV <= max_uV)
406 break;
407 }
408
409
410 if (vsel == tps->info[dcdc]->table_len)
411 return -EINVAL;
412
413 data = tps_6507x_reg_read(tps, reg);
414 if (data < 0)
415 return data;
416
417 data &= ~TPS6507X_DEFDCDCX_DCDC_MASK;
418 data |= vsel;
419
420 return tps_6507x_reg_write(tps, reg, data);
421}
422
423static int tps6507x_ldo_get_voltage(struct regulator_dev *dev)
424{
425 struct tps_pmic *tps = rdev_get_drvdata(dev);
426 int data, ldo = rdev_get_id(dev);
427 u8 reg, mask;
428
429 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
430 return -EINVAL;
431 else {
432 reg = (ldo == TPS6507X_LDO_1 ?
433 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
434 mask = (ldo == TPS6507X_LDO_1 ?
435 TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
436 TPS6507X_REG_DEFLDO2_LDO2_MASK);
437 }
438
439 data = tps_6507x_reg_read(tps, reg);
440 if (data < 0)
441 return data;
442
443 data &= mask;
444 return tps->info[ldo]->table[data] * 1000;
445}
446
447static int tps6507x_ldo_set_voltage(struct regulator_dev *dev,
448 int min_uV, int max_uV)
449{
450 struct tps_pmic *tps = rdev_get_drvdata(dev);
451 int data, vsel, ldo = rdev_get_id(dev);
452 u8 reg, mask;
453
454 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
455 return -EINVAL;
456 else {
457 reg = (ldo == TPS6507X_LDO_1 ?
458 TPS6507X_REG_LDO_CTRL1 : TPS6507X_REG_DEFLDO2);
459 mask = (ldo == TPS6507X_LDO_1 ?
460 TPS6507X_REG_LDO_CTRL1_LDO1_MASK :
461 TPS6507X_REG_DEFLDO2_LDO2_MASK);
462 }
463
464 if (min_uV < tps->info[ldo]->min_uV || min_uV > tps->info[ldo]->max_uV)
465 return -EINVAL;
466 if (max_uV < tps->info[ldo]->min_uV || max_uV > tps->info[ldo]->max_uV)
467 return -EINVAL;
468
469 for (vsel = 0; vsel < tps->info[ldo]->table_len; vsel++) {
470 int mV = tps->info[ldo]->table[vsel];
471 int uV = mV * 1000;
472
473
474 if (min_uV <= uV && uV <= max_uV)
475 break;
476 }
477
478 if (vsel == tps->info[ldo]->table_len)
479 return -EINVAL;
480
481 data = tps_6507x_reg_read(tps, reg);
482 if (data < 0)
483 return data;
484
485 data &= ~mask;
486 data |= vsel;
487
488 return tps_6507x_reg_write(tps, reg, data);
489}
490
491static int tps6507x_dcdc_list_voltage(struct regulator_dev *dev,
492 unsigned selector)
493{
494 struct tps_pmic *tps = rdev_get_drvdata(dev);
495 int dcdc = rdev_get_id(dev);
496
497 if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
498 return -EINVAL;
499
500 if (selector >= tps->info[dcdc]->table_len)
501 return -EINVAL;
502 else
503 return tps->info[dcdc]->table[selector] * 1000;
504}
505
506static int tps6507x_ldo_list_voltage(struct regulator_dev *dev,
507 unsigned selector)
508{
509 struct tps_pmic *tps = rdev_get_drvdata(dev);
510 int ldo = rdev_get_id(dev);
511
512 if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
513 return -EINVAL;
514
515 if (selector >= tps->info[ldo]->table_len)
516 return -EINVAL;
517 else
518 return tps->info[ldo]->table[selector] * 1000;
519}
520
521
522static struct regulator_ops tps6507x_dcdc_ops = {
523 .is_enabled = tps6507x_dcdc_is_enabled,
524 .enable = tps6507x_dcdc_enable,
525 .disable = tps6507x_dcdc_disable,
526 .get_voltage = tps6507x_dcdc_get_voltage,
527 .set_voltage = tps6507x_dcdc_set_voltage,
528 .list_voltage = tps6507x_dcdc_list_voltage,
529};
530
531
532static struct regulator_ops tps6507x_ldo_ops = {
533 .is_enabled = tps6507x_ldo_is_enabled,
534 .enable = tps6507x_ldo_enable,
535 .disable = tps6507x_ldo_disable,
536 .get_voltage = tps6507x_ldo_get_voltage,
537 .set_voltage = tps6507x_ldo_set_voltage,
538 .list_voltage = tps6507x_ldo_list_voltage,
539};
540
541static
542int tps_6507x_probe(struct i2c_client *client, const struct i2c_device_id *id)
543{
544 static int desc_id;
545 const struct tps_info *info = (void *)id->driver_data;
546 struct regulator_init_data *init_data;
547 struct regulator_dev *rdev;
548 struct tps_pmic *tps;
549 int i;
550
551 if (!i2c_check_functionality(client->adapter,
552 I2C_FUNC_SMBUS_BYTE_DATA))
553 return -EIO;
554
555
556
557
558
559 init_data = client->dev.platform_data;
560
561 if (!init_data)
562 return -EIO;
563
564 tps = kzalloc(sizeof(*tps), GFP_KERNEL);
565 if (!tps)
566 return -ENOMEM;
567
568 mutex_init(&tps->io_lock);
569
570
571 tps->client = client;
572
573 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
574
575 tps->info[i] = info;
576 tps->desc[i].name = info->name;
577 tps->desc[i].id = desc_id++;
578 tps->desc[i].n_voltages = num_voltages[i];
579 tps->desc[i].ops = (i > TPS6507X_DCDC_3 ?
580 &tps6507x_ldo_ops : &tps6507x_dcdc_ops);
581 tps->desc[i].type = REGULATOR_VOLTAGE;
582 tps->desc[i].owner = THIS_MODULE;
583
584 rdev = regulator_register(&tps->desc[i],
585 &client->dev, init_data, tps);
586 if (IS_ERR(rdev)) {
587 dev_err(&client->dev, "failed to register %s\n",
588 id->name);
589
590
591 while (i)
592 regulator_unregister(tps->rdev[--i]);
593
594 tps->client = NULL;
595
596
597 i2c_set_clientdata(client, NULL);
598
599 kfree(tps);
600 return PTR_ERR(rdev);
601 }
602
603
604 tps->rdev[i] = rdev;
605 }
606
607 i2c_set_clientdata(client, tps);
608
609 return 0;
610}
611
612
613
614
615
616
617
618static int __devexit tps_6507x_remove(struct i2c_client *client)
619{
620 struct tps_pmic *tps = i2c_get_clientdata(client);
621 int i;
622
623 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++)
624 regulator_unregister(tps->rdev[i]);
625
626 tps->client = NULL;
627
628
629 i2c_set_clientdata(client, NULL);
630 kfree(tps);
631
632 return 0;
633}
634
635static const struct tps_info tps6507x_regs[] = {
636 {
637 .name = "VDCDC1",
638 .min_uV = 725000,
639 .max_uV = 3300000,
640 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
641 .table = VDCDCx_VSEL_table,
642 },
643 {
644 .name = "VDCDC2",
645 .min_uV = 725000,
646 .max_uV = 3300000,
647 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
648 .table = VDCDCx_VSEL_table,
649 },
650 {
651 .name = "VDCDC3",
652 .min_uV = 725000,
653 .max_uV = 3300000,
654 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
655 .table = VDCDCx_VSEL_table,
656 },
657 {
658 .name = "LDO1",
659 .min_uV = 1000000,
660 .max_uV = 3300000,
661 .table_len = ARRAY_SIZE(LDO1_VSEL_table),
662 .table = LDO1_VSEL_table,
663 },
664 {
665 .name = "LDO2",
666 .min_uV = 725000,
667 .max_uV = 3300000,
668 .table_len = ARRAY_SIZE(LDO2_VSEL_table),
669 .table = LDO2_VSEL_table,
670 },
671};
672
673static const struct i2c_device_id tps_6507x_id[] = {
674 {.name = "tps6507x",
675 .driver_data = (unsigned long) tps6507x_regs,},
676 { },
677};
678MODULE_DEVICE_TABLE(i2c, tps_6507x_id);
679
680static struct i2c_driver tps_6507x_i2c_driver = {
681 .driver = {
682 .name = "tps6507x",
683 .owner = THIS_MODULE,
684 },
685 .probe = tps_6507x_probe,
686 .remove = __devexit_p(tps_6507x_remove),
687 .id_table = tps_6507x_id,
688};
689
690
691
692
693
694
695static int __init tps_6507x_init(void)
696{
697 return i2c_add_driver(&tps_6507x_i2c_driver);
698}
699subsys_initcall(tps_6507x_init);
700
701
702
703
704
705
706static void __exit tps_6507x_cleanup(void)
707{
708 i2c_del_driver(&tps_6507x_i2c_driver);
709}
710module_exit(tps_6507x_cleanup);
711
712MODULE_AUTHOR("Texas Instruments");
713MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
714MODULE_LICENSE("GPL v2");
715
