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