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/i2c.h>
26 #include <linux/delay.h>
27 
28 /* Register definitions */
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 /* CON_CTRL1 bitfields */
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 /* DEFDCDC1 bitfields */
63 #define TPS6507X_DEFDCDC1_DCDC1_EXT_ADJ_EN	BIT(7)
64 #define TPS6507X_DEFDCDC1_DCDC1_MASK		0X3F
65 
66 /* DEFDCDC2_LOW bitfields */
67 #define TPS6507X_DEFDCDC2_LOW_DCDC2_MASK	0X3F
68 
69 /* DEFDCDC2_HIGH bitfields */
70 #define TPS6507X_DEFDCDC2_HIGH_DCDC2_MASK	0X3F
71 
72 /* DEFDCDC3_LOW bitfields */
73 #define TPS6507X_DEFDCDC3_LOW_DCDC3_MASK	0X3F
74 
75 /* DEFDCDC3_HIGH bitfields */
76 #define TPS6507X_DEFDCDC3_HIGH_DCDC3_MASK	0X3F
77 
78 /* TPS6507X_REG_LDO_CTRL1 bitfields */
79 #define TPS6507X_REG_LDO_CTRL1_LDO1_MASK	0X0F
80 
81 /* TPS6507X_REG_DEFLDO2 bitfields */
82 #define TPS6507X_REG_DEFLDO2_LDO2_MASK		0X3F
83 
84 /* VDCDC MASK */
85 #define TPS6507X_DEFDCDCX_DCDC_MASK		0X3F
86 
87 /* DCDC's */
88 #define TPS6507X_DCDC_1				0
89 #define TPS6507X_DCDC_2				1
90 #define TPS6507X_DCDC_3				2
91 /* LDOs */
92 #define TPS6507X_LDO_1				3
93 #define TPS6507X_LDO_2				4
94 
95 #define TPS6507X_MAX_REG_ID			TPS6507X_LDO_2
96 
97 /* Number of step-down converters available */
98 #define TPS6507X_NUM_DCDC			3
99 /* Number of LDO voltage regulators  available */
100 #define TPS6507X_NUM_LDO			2
101 /* Number of total regulators available */
102 #define TPS6507X_NUM_REGULATOR		(TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
103 
104 /* Supported voltage values for regulators (in milliVolts) */
105 static 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 
124 static 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 
131 static 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 
150 static 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 
156 struct tps_info {
157 	const char *name;
158 	unsigned min_uV;
159 	unsigned max_uV;
160 	u8 table_len;
161 	const u16 *table;
162 };
163 
164 struct 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 
172 static inline int tps_6507x_read(struct tps_pmic *tps, u8 reg)
173 {
174 	return i2c_smbus_read_byte_data(tps->client, reg);
175 }
176 
177 static 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 
182 static 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 
200 out:
201 	mutex_unlock(&tps->io_lock);
202 	return err;
203 }
204 
205 static 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 
223 out:
224 	mutex_unlock(&tps->io_lock);
225 	return err;
226 }
227 
228 static 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 
242 static 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 
256 static 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 
274 static 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 
292 static 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 
305 static 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 
318 static 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 
331 static 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 
344 static 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 
372 static 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 		/* Break at the first in-range value */
405 		if (min_uV <= uV && uV <= max_uV)
406 			break;
407 	}
408 
409 	/* write to the register in case we found a match */
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 
423 static 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 
447 static 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 		/* Break at the first in-range value */
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 
491 static 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 
506 static 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 /* Operations permitted on VDCDCx */
522 static 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 /* Operations permitted on LDOx */
532 static 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 
541 static
542 int 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 	 * init_data points to array of regulator_init structures
557 	 * coming from the board-evm file.
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 	/* common for all regulators */
571 	tps->client = client;
572 
573 	for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
574 		/* Register the regulators */
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 			/* Unregister */
591 			while (i)
592 				regulator_unregister(tps->rdev[--i]);
593 
594 			tps->client = NULL;
595 
596 			/* clear the client data in i2c */
597 			i2c_set_clientdata(client, NULL);
598 
599 			kfree(tps);
600 			return PTR_ERR(rdev);
601 		}
602 
603 		/* Save regulator for cleanup */
604 		tps->rdev[i] = rdev;
605 	}
606 
607 	i2c_set_clientdata(client, tps);
608 
609 	return 0;
610 }
611 
612 /**
613  * tps_6507x_remove - TPS6507x driver i2c remove handler
614  * @client: i2c driver client device structure
615  *
616  * Unregister TPS driver as an i2c client device driver
617  */
618 static 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 	/* clear the client data in i2c */
629 	i2c_set_clientdata(client, NULL);
630 	kfree(tps);
631 
632 	return 0;
633 }
634 
635 static 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 
673 static const struct i2c_device_id tps_6507x_id[] = {
674 	{.name = "tps6507x",
675 	.driver_data = (unsigned long) tps6507x_regs,},
676 	{ },
677 };
678 MODULE_DEVICE_TABLE(i2c, tps_6507x_id);
679 
680 static 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  * tps_6507x_init
692  *
693  * Module init function
694  */
695 static int __init tps_6507x_init(void)
696 {
697 	return i2c_add_driver(&tps_6507x_i2c_driver);
698 }
699 subsys_initcall(tps_6507x_init);
700 
701 /**
702  * tps_6507x_cleanup
703  *
704  * Module exit function
705  */
706 static void __exit tps_6507x_cleanup(void)
707 {
708 	i2c_del_driver(&tps_6507x_i2c_driver);
709 }
710 module_exit(tps_6507x_cleanup);
711 
712 MODULE_AUTHOR("Texas Instruments");
713 MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
714 MODULE_LICENSE("GPL v2");
715