blob: 49a15eefe5fe25390bdaf52cd0455675565cb516 [file] [log] [blame]
Axel Lin5976f092010-09-16 16:48:49 +08001/*
2 * Regulator driver for National Semiconductors LP3972 PMIC chip
3 *
4 * Based on lp3971.c
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 */
11
12#include <linux/bug.h>
13#include <linux/err.h>
14#include <linux/i2c.h>
Paul Gortmaker65602c32011-07-17 16:28:23 -040015#include <linux/module.h>
Axel Lin5976f092010-09-16 16:48:49 +080016#include <linux/kernel.h>
17#include <linux/regulator/driver.h>
18#include <linux/regulator/lp3972.h>
19#include <linux/slab.h>
20
21struct lp3972 {
22 struct device *dev;
23 struct mutex io_lock;
24 struct i2c_client *i2c;
25 int num_regulators;
26 struct regulator_dev **rdev;
27};
28
29/* LP3972 Control Registers */
30#define LP3972_SCR_REG 0x07
31#define LP3972_OVER1_REG 0x10
32#define LP3972_OVSR1_REG 0x11
33#define LP3972_OVER2_REG 0x12
34#define LP3972_OVSR2_REG 0x13
35#define LP3972_VCC1_REG 0x20
36#define LP3972_ADTV1_REG 0x23
37#define LP3972_ADTV2_REG 0x24
38#define LP3972_AVRC_REG 0x25
39#define LP3972_CDTC1_REG 0x26
40#define LP3972_CDTC2_REG 0x27
41#define LP3972_SDTV1_REG 0x29
42#define LP3972_SDTV2_REG 0x2A
43#define LP3972_MDTV1_REG 0x32
44#define LP3972_MDTV2_REG 0x33
45#define LP3972_L2VCR_REG 0x39
46#define LP3972_L34VCR_REG 0x3A
47#define LP3972_SCR1_REG 0x80
48#define LP3972_SCR2_REG 0x81
49#define LP3972_OEN3_REG 0x82
50#define LP3972_OSR3_REG 0x83
51#define LP3972_LOER4_REG 0x84
52#define LP3972_B2TV_REG 0x85
53#define LP3972_B3TV_REG 0x86
54#define LP3972_B32RC_REG 0x87
55#define LP3972_ISRA_REG 0x88
56#define LP3972_BCCR_REG 0x89
57#define LP3972_II1RR_REG 0x8E
58#define LP3972_II2RR_REG 0x8F
59
60#define LP3972_SYS_CONTROL1_REG LP3972_SCR1_REG
61/* System control register 1 initial value,
62 * bits 5, 6 and 7 are EPROM programmable */
63#define SYS_CONTROL1_INIT_VAL 0x02
64#define SYS_CONTROL1_INIT_MASK 0x1F
65
66#define LP3972_VOL_CHANGE_REG LP3972_VCC1_REG
67#define LP3972_VOL_CHANGE_FLAG_GO 0x01
68#define LP3972_VOL_CHANGE_FLAG_MASK 0x03
69
70/* LDO output enable mask */
71#define LP3972_OEN3_L1EN BIT(0)
72#define LP3972_OVER2_LDO2_EN BIT(2)
73#define LP3972_OVER2_LDO3_EN BIT(3)
74#define LP3972_OVER2_LDO4_EN BIT(4)
75#define LP3972_OVER1_S_EN BIT(2)
76
77static const int ldo1_voltage_map[] = {
78 1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
79 1900, 1925, 1950, 1975, 2000,
80};
81
82static const int ldo23_voltage_map[] = {
83 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
84 2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
85};
86
87static const int ldo4_voltage_map[] = {
88 1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
89 1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
90};
91
92static const int ldo5_voltage_map[] = {
93 0, 0, 0, 0, 0, 850, 875, 900,
94 925, 950, 975, 1000, 1025, 1050, 1075, 1100,
95 1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
96 1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
97};
98
99static const int buck1_voltage_map[] = {
100 725, 750, 775, 800, 825, 850, 875, 900,
101 925, 950, 975, 1000, 1025, 1050, 1075, 1100,
102 1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
103 1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
104};
105
106static const int buck23_voltage_map[] = {
107 0, 800, 850, 900, 950, 1000, 1050, 1100,
108 1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
109 1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
110 3000, 3300,
111};
112
113static const int *ldo_voltage_map[] = {
114 ldo1_voltage_map,
115 ldo23_voltage_map,
116 ldo23_voltage_map,
117 ldo4_voltage_map,
118 ldo5_voltage_map,
119};
120
121static const int *buck_voltage_map[] = {
122 buck1_voltage_map,
123 buck23_voltage_map,
124 buck23_voltage_map,
125};
126
127static const int ldo_output_enable_mask[] = {
128 LP3972_OEN3_L1EN,
129 LP3972_OVER2_LDO2_EN,
130 LP3972_OVER2_LDO3_EN,
131 LP3972_OVER2_LDO4_EN,
132 LP3972_OVER1_S_EN,
133};
134
135static const int ldo_output_enable_addr[] = {
136 LP3972_OEN3_REG,
137 LP3972_OVER2_REG,
138 LP3972_OVER2_REG,
139 LP3972_OVER2_REG,
140 LP3972_OVER1_REG,
141};
142
143static const int ldo_vol_ctl_addr[] = {
144 LP3972_MDTV1_REG,
145 LP3972_L2VCR_REG,
146 LP3972_L34VCR_REG,
147 LP3972_L34VCR_REG,
148 LP3972_SDTV1_REG,
149};
150
151static const int buck_vol_enable_addr[] = {
152 LP3972_OVER1_REG,
153 LP3972_OEN3_REG,
154 LP3972_OEN3_REG,
155};
156
157static const int buck_base_addr[] = {
158 LP3972_ADTV1_REG,
159 LP3972_B2TV_REG,
160 LP3972_B3TV_REG,
161};
162
163#define LP3972_LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[x])
164#define LP3972_LDO_OUTPUT_ENABLE_MASK(x) (ldo_output_enable_mask[x])
165#define LP3972_LDO_OUTPUT_ENABLE_REG(x) (ldo_output_enable_addr[x])
166
167/* LDO voltage control registers shift:
168 LP3972_LDO1 -> 0, LP3972_LDO2 -> 4
169 LP3972_LDO3 -> 0, LP3972_LDO4 -> 4
170 LP3972_LDO5 -> 0
171*/
172#define LP3972_LDO_VOL_CONTR_SHIFT(x) (((x) & 1) << 2)
173#define LP3972_LDO_VOL_CONTR_REG(x) (ldo_vol_ctl_addr[x])
174#define LP3972_LDO_VOL_CHANGE_SHIFT(x) ((x) ? 4 : 6)
175
176#define LP3972_LDO_VOL_MASK(x) (((x) % 4) ? 0x0f : 0x1f)
177#define LP3972_LDO_VOL_MIN_IDX(x) (((x) == 4) ? 0x05 : 0x00)
178#define LP3972_LDO_VOL_MAX_IDX(x) ((x) ? (((x) == 4) ? 0x1f : 0x0f) : 0x0c)
179
180#define LP3972_BUCK_VOL_VALUE_MAP(x) (buck_voltage_map[x])
181#define LP3972_BUCK_VOL_ENABLE_REG(x) (buck_vol_enable_addr[x])
182#define LP3972_BUCK_VOL1_REG(x) (buck_base_addr[x])
183#define LP3972_BUCK_VOL_MASK 0x1f
184#define LP3972_BUCK_VOL_MIN_IDX(x) ((x) ? 0x01 : 0x00)
185#define LP3972_BUCK_VOL_MAX_IDX(x) ((x) ? 0x19 : 0x1f)
186
187static int lp3972_i2c_read(struct i2c_client *i2c, char reg, int count,
188 u16 *dest)
189{
190 int ret;
191
192 if (count != 1)
193 return -EIO;
194 ret = i2c_smbus_read_byte_data(i2c, reg);
195 if (ret < 0)
Axel Lin993af7c2010-09-18 13:13:28 +0800196 return ret;
Axel Lin5976f092010-09-16 16:48:49 +0800197
198 *dest = ret;
199 return 0;
200}
201
202static int lp3972_i2c_write(struct i2c_client *i2c, char reg, int count,
203 const u16 *src)
204{
205 if (count != 1)
206 return -EIO;
207 return i2c_smbus_write_byte_data(i2c, reg, *src);
208}
209
210static u8 lp3972_reg_read(struct lp3972 *lp3972, u8 reg)
211{
212 u16 val = 0;
213
214 mutex_lock(&lp3972->io_lock);
215
216 lp3972_i2c_read(lp3972->i2c, reg, 1, &val);
217
218 dev_dbg(lp3972->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
Axel Lin993af7c2010-09-18 13:13:28 +0800219 (unsigned)val & 0xff);
Axel Lin5976f092010-09-16 16:48:49 +0800220
221 mutex_unlock(&lp3972->io_lock);
222
223 return val & 0xff;
224}
225
226static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val)
227{
228 u16 tmp;
229 int ret;
230
231 mutex_lock(&lp3972->io_lock);
232
233 ret = lp3972_i2c_read(lp3972->i2c, reg, 1, &tmp);
234 tmp = (tmp & ~mask) | val;
235 if (ret == 0) {
236 ret = lp3972_i2c_write(lp3972->i2c, reg, 1, &tmp);
237 dev_dbg(lp3972->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
Axel Lin993af7c2010-09-18 13:13:28 +0800238 (unsigned)val & 0xff);
Axel Lin5976f092010-09-16 16:48:49 +0800239 }
240 mutex_unlock(&lp3972->io_lock);
241
242 return ret;
243}
244
245static int lp3972_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
246{
247 int ldo = rdev_get_id(dev) - LP3972_LDO1;
248 return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[index];
249}
250
251static int lp3972_ldo_is_enabled(struct regulator_dev *dev)
252{
253 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
254 int ldo = rdev_get_id(dev) - LP3972_LDO1;
255 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
256 u16 val;
257
258 val = lp3972_reg_read(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo));
259 return !!(val & mask);
260}
261
262static int lp3972_ldo_enable(struct regulator_dev *dev)
263{
264 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
265 int ldo = rdev_get_id(dev) - LP3972_LDO1;
266 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
267
268 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
269 mask, mask);
270}
271
272static int lp3972_ldo_disable(struct regulator_dev *dev)
273{
274 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
275 int ldo = rdev_get_id(dev) - LP3972_LDO1;
276 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
277
278 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
279 mask, 0);
280}
281
282static int lp3972_ldo_get_voltage(struct regulator_dev *dev)
283{
284 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
285 int ldo = rdev_get_id(dev) - LP3972_LDO1;
286 u16 mask = LP3972_LDO_VOL_MASK(ldo);
287 u16 val, reg;
288
289 reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo));
290 val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask;
291
292 return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[val];
293}
294
295static int lp3972_ldo_set_voltage(struct regulator_dev *dev,
Mark Brown3a93f2a2010-11-10 14:38:29 +0000296 int min_uV, int max_uV,
297 unsigned int *selector)
Axel Lin5976f092010-09-16 16:48:49 +0800298{
299 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
300 int ldo = rdev_get_id(dev) - LP3972_LDO1;
301 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
302 const int *vol_map = LP3972_LDO_VOL_VALUE_MAP(ldo);
303 u16 val;
304 int shift, ret;
305
306 if (min_vol < vol_map[LP3972_LDO_VOL_MIN_IDX(ldo)] ||
307 min_vol > vol_map[LP3972_LDO_VOL_MAX_IDX(ldo)])
308 return -EINVAL;
309
310 for (val = LP3972_LDO_VOL_MIN_IDX(ldo);
311 val <= LP3972_LDO_VOL_MAX_IDX(ldo); val++)
312 if (vol_map[val] >= min_vol)
313 break;
314
315 if (val > LP3972_LDO_VOL_MAX_IDX(ldo) || vol_map[val] > max_vol)
316 return -EINVAL;
317
Mark Brown3a93f2a2010-11-10 14:38:29 +0000318 *selector = val;
319
Axel Lin5976f092010-09-16 16:48:49 +0800320 shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo);
321 ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo),
322 LP3972_LDO_VOL_MASK(ldo) << shift, val << shift);
323
324 if (ret)
325 return ret;
326
Axel Lin993af7c2010-09-18 13:13:28 +0800327 /*
328 * LDO1 and LDO5 support voltage control by either target voltage1
329 * or target voltage2 register.
330 * We use target voltage1 register for LDO1 and LDO5 in this driver.
331 * We need to update voltage change control register(0x20) to enable
332 * LDO1 and LDO5 to change to their programmed target values.
333 */
Axel Lin5976f092010-09-16 16:48:49 +0800334 switch (ldo) {
335 case LP3972_LDO1:
336 case LP3972_LDO5:
337 shift = LP3972_LDO_VOL_CHANGE_SHIFT(ldo);
338 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
339 LP3972_VOL_CHANGE_FLAG_MASK << shift,
340 LP3972_VOL_CHANGE_FLAG_GO << shift);
341 if (ret)
342 return ret;
343
344 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
345 LP3972_VOL_CHANGE_FLAG_MASK << shift, 0);
346 break;
347 }
348
349 return ret;
350}
351
352static struct regulator_ops lp3972_ldo_ops = {
353 .list_voltage = lp3972_ldo_list_voltage,
354 .is_enabled = lp3972_ldo_is_enabled,
355 .enable = lp3972_ldo_enable,
356 .disable = lp3972_ldo_disable,
357 .get_voltage = lp3972_ldo_get_voltage,
358 .set_voltage = lp3972_ldo_set_voltage,
359};
360
361static int lp3972_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
362{
363 int buck = rdev_get_id(dev) - LP3972_DCDC1;
364 return 1000 * buck_voltage_map[buck][index];
365}
366
367static int lp3972_dcdc_is_enabled(struct regulator_dev *dev)
368{
369 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
370 int buck = rdev_get_id(dev) - LP3972_DCDC1;
371 u16 mask = 1 << (buck * 2);
372 u16 val;
373
374 val = lp3972_reg_read(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck));
375 return !!(val & mask);
376}
377
378static int lp3972_dcdc_enable(struct regulator_dev *dev)
379{
380 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
381 int buck = rdev_get_id(dev) - LP3972_DCDC1;
382 u16 mask = 1 << (buck * 2);
383 u16 val;
384
385 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
386 mask, mask);
387 return val;
388}
389
390static int lp3972_dcdc_disable(struct regulator_dev *dev)
391{
392 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
393 int buck = rdev_get_id(dev) - LP3972_DCDC1;
394 u16 mask = 1 << (buck * 2);
395 u16 val;
396
397 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
398 mask, 0);
399 return val;
400}
401
402static int lp3972_dcdc_get_voltage(struct regulator_dev *dev)
403{
404 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
405 int buck = rdev_get_id(dev) - LP3972_DCDC1;
406 u16 reg;
407 int val;
408
409 reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck));
410 reg &= LP3972_BUCK_VOL_MASK;
411 if (reg <= LP3972_BUCK_VOL_MAX_IDX(buck))
412 val = 1000 * buck_voltage_map[buck][reg];
413 else {
414 val = 0;
Axel Lin993af7c2010-09-18 13:13:28 +0800415 dev_warn(&dev->dev, "chip reported incorrect voltage value."
416 " reg = %d\n", reg);
Axel Lin5976f092010-09-16 16:48:49 +0800417 }
418
419 return val;
420}
421
422static int lp3972_dcdc_set_voltage(struct regulator_dev *dev,
Mark Brown3a93f2a2010-11-10 14:38:29 +0000423 int min_uV, int max_uV,
424 unsigned int *selector)
Axel Lin5976f092010-09-16 16:48:49 +0800425{
426 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
427 int buck = rdev_get_id(dev) - LP3972_DCDC1;
428 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
429 const int *vol_map = buck_voltage_map[buck];
430 u16 val;
431 int ret;
432
433 if (min_vol < vol_map[LP3972_BUCK_VOL_MIN_IDX(buck)] ||
434 min_vol > vol_map[LP3972_BUCK_VOL_MAX_IDX(buck)])
435 return -EINVAL;
436
437 for (val = LP3972_BUCK_VOL_MIN_IDX(buck);
438 val <= LP3972_BUCK_VOL_MAX_IDX(buck); val++)
439 if (vol_map[val] >= min_vol)
440 break;
441
442 if (val > LP3972_BUCK_VOL_MAX_IDX(buck) ||
443 vol_map[val] > max_vol)
444 return -EINVAL;
445
Mark Brown3a93f2a2010-11-10 14:38:29 +0000446 *selector = val;
447
Axel Lin5976f092010-09-16 16:48:49 +0800448 ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck),
449 LP3972_BUCK_VOL_MASK, val);
450 if (ret)
451 return ret;
452
453 if (buck != 0)
454 return ret;
455
456 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
457 LP3972_VOL_CHANGE_FLAG_MASK, LP3972_VOL_CHANGE_FLAG_GO);
458 if (ret)
459 return ret;
460
461 return lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
462 LP3972_VOL_CHANGE_FLAG_MASK, 0);
463}
464
465static struct regulator_ops lp3972_dcdc_ops = {
466 .list_voltage = lp3972_dcdc_list_voltage,
467 .is_enabled = lp3972_dcdc_is_enabled,
468 .enable = lp3972_dcdc_enable,
469 .disable = lp3972_dcdc_disable,
470 .get_voltage = lp3972_dcdc_get_voltage,
471 .set_voltage = lp3972_dcdc_set_voltage,
472};
473
474static struct regulator_desc regulators[] = {
475 {
476 .name = "LDO1",
477 .id = LP3972_LDO1,
478 .ops = &lp3972_ldo_ops,
479 .n_voltages = ARRAY_SIZE(ldo1_voltage_map),
480 .type = REGULATOR_VOLTAGE,
481 .owner = THIS_MODULE,
482 },
483 {
484 .name = "LDO2",
485 .id = LP3972_LDO2,
486 .ops = &lp3972_ldo_ops,
487 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
488 .type = REGULATOR_VOLTAGE,
489 .owner = THIS_MODULE,
490 },
491 {
492 .name = "LDO3",
493 .id = LP3972_LDO3,
494 .ops = &lp3972_ldo_ops,
495 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
496 .type = REGULATOR_VOLTAGE,
497 .owner = THIS_MODULE,
498 },
499 {
500 .name = "LDO4",
501 .id = LP3972_LDO4,
502 .ops = &lp3972_ldo_ops,
503 .n_voltages = ARRAY_SIZE(ldo4_voltage_map),
504 .type = REGULATOR_VOLTAGE,
505 .owner = THIS_MODULE,
506 },
507 {
508 .name = "LDO5",
509 .id = LP3972_LDO5,
510 .ops = &lp3972_ldo_ops,
511 .n_voltages = ARRAY_SIZE(ldo5_voltage_map),
512 .type = REGULATOR_VOLTAGE,
513 .owner = THIS_MODULE,
514 },
515 {
516 .name = "DCDC1",
517 .id = LP3972_DCDC1,
518 .ops = &lp3972_dcdc_ops,
519 .n_voltages = ARRAY_SIZE(buck1_voltage_map),
520 .type = REGULATOR_VOLTAGE,
521 .owner = THIS_MODULE,
522 },
523 {
524 .name = "DCDC2",
525 .id = LP3972_DCDC2,
526 .ops = &lp3972_dcdc_ops,
527 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
528 .type = REGULATOR_VOLTAGE,
529 .owner = THIS_MODULE,
530 },
531 {
532 .name = "DCDC3",
533 .id = LP3972_DCDC3,
534 .ops = &lp3972_dcdc_ops,
535 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
536 .type = REGULATOR_VOLTAGE,
537 .owner = THIS_MODULE,
538 },
539};
540
Axel Lin993af7c2010-09-18 13:13:28 +0800541static int __devinit setup_regulators(struct lp3972 *lp3972,
Axel Lin5976f092010-09-16 16:48:49 +0800542 struct lp3972_platform_data *pdata)
543{
544 int i, err;
545
546 lp3972->num_regulators = pdata->num_regulators;
547 lp3972->rdev = kcalloc(pdata->num_regulators,
548 sizeof(struct regulator_dev *), GFP_KERNEL);
549 if (!lp3972->rdev) {
550 err = -ENOMEM;
551 goto err_nomem;
552 }
553
554 /* Instantiate the regulators */
555 for (i = 0; i < pdata->num_regulators; i++) {
556 struct lp3972_regulator_subdev *reg = &pdata->regulators[i];
557 lp3972->rdev[i] = regulator_register(&regulators[reg->id],
Rajendra Nayak2c043bc2011-11-18 16:47:19 +0530558 lp3972->dev, reg->initdata, lp3972, NULL);
Axel Lin5976f092010-09-16 16:48:49 +0800559
560 if (IS_ERR(lp3972->rdev[i])) {
561 err = PTR_ERR(lp3972->rdev[i]);
562 dev_err(lp3972->dev, "regulator init failed: %d\n",
563 err);
564 goto error;
565 }
566 }
567
568 return 0;
569error:
570 while (--i >= 0)
571 regulator_unregister(lp3972->rdev[i]);
572 kfree(lp3972->rdev);
573 lp3972->rdev = NULL;
574err_nomem:
575 return err;
576}
577
578static int __devinit lp3972_i2c_probe(struct i2c_client *i2c,
579 const struct i2c_device_id *id)
580{
581 struct lp3972 *lp3972;
582 struct lp3972_platform_data *pdata = i2c->dev.platform_data;
583 int ret;
584 u16 val;
585
586 if (!pdata) {
587 dev_dbg(&i2c->dev, "No platform init data supplied\n");
588 return -ENODEV;
589 }
590
591 lp3972 = kzalloc(sizeof(struct lp3972), GFP_KERNEL);
592 if (!lp3972)
593 return -ENOMEM;
594
595 lp3972->i2c = i2c;
596 lp3972->dev = &i2c->dev;
597
598 mutex_init(&lp3972->io_lock);
599
600 /* Detect LP3972 */
601 ret = lp3972_i2c_read(i2c, LP3972_SYS_CONTROL1_REG, 1, &val);
Axel Lin993af7c2010-09-18 13:13:28 +0800602 if (ret == 0 &&
603 (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL) {
Axel Lin5976f092010-09-16 16:48:49 +0800604 ret = -ENODEV;
Axel Lin993af7c2010-09-18 13:13:28 +0800605 dev_err(&i2c->dev, "chip reported: val = 0x%x\n", val);
606 }
Axel Lin5976f092010-09-16 16:48:49 +0800607 if (ret < 0) {
Axel Lin993af7c2010-09-18 13:13:28 +0800608 dev_err(&i2c->dev, "failed to detect device. ret = %d\n", ret);
Axel Lin5976f092010-09-16 16:48:49 +0800609 goto err_detect;
610 }
611
612 ret = setup_regulators(lp3972, pdata);
613 if (ret < 0)
614 goto err_detect;
615
616 i2c_set_clientdata(i2c, lp3972);
617 return 0;
618
619err_detect:
620 kfree(lp3972);
621 return ret;
622}
623
624static int __devexit lp3972_i2c_remove(struct i2c_client *i2c)
625{
626 struct lp3972 *lp3972 = i2c_get_clientdata(i2c);
627 int i;
628
629 for (i = 0; i < lp3972->num_regulators; i++)
630 regulator_unregister(lp3972->rdev[i]);
631 kfree(lp3972->rdev);
632 kfree(lp3972);
633
634 return 0;
635}
636
637static const struct i2c_device_id lp3972_i2c_id[] = {
638 { "lp3972", 0 },
639 { }
640};
641MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id);
642
643static struct i2c_driver lp3972_i2c_driver = {
644 .driver = {
645 .name = "lp3972",
646 .owner = THIS_MODULE,
647 },
648 .probe = lp3972_i2c_probe,
649 .remove = __devexit_p(lp3972_i2c_remove),
650 .id_table = lp3972_i2c_id,
651};
652
653static int __init lp3972_module_init(void)
654{
655 return i2c_add_driver(&lp3972_i2c_driver);
656}
657subsys_initcall(lp3972_module_init);
658
659static void __exit lp3972_module_exit(void)
660{
661 i2c_del_driver(&lp3972_i2c_driver);
662}
663module_exit(lp3972_module_exit);
664
665MODULE_LICENSE("GPL");
666MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>");
667MODULE_DESCRIPTION("LP3972 PMIC driver");