2 * tps62360.c -- TI tps62360
4 * Driver for processor core supply tps62360, tps62361B, tps62362 and tps62363.
6 * Copyright (c) 2012, NVIDIA Corporation.
8 * Author: Laxman Dewangan <ldewangan@nvidia.com>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation version 2.
14 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
15 * whether express or implied; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/err.h>
30 #include <linux/of_device.h>
31 #include <linux/of_gpio.h>
32 #include <linux/regulator/of_regulator.h>
33 #include <linux/platform_device.h>
34 #include <linux/regulator/driver.h>
35 #include <linux/regulator/machine.h>
36 #include <linux/regulator/tps62360.h>
37 #include <linux/gpio.h>
38 #include <linux/i2c.h>
39 #include <linux/slab.h>
40 #include <linux/regmap.h>
42 /* Register definitions */
49 #define REG_RAMPCTRL 6
52 enum chips
{TPS62360
, TPS62361
, TPS62362
, TPS62363
};
54 #define TPS62360_BASE_VOLTAGE 770000
55 #define TPS62360_N_VOLTAGES 64
57 #define TPS62361_BASE_VOLTAGE 500000
58 #define TPS62361_N_VOLTAGES 128
60 /* tps 62360 chip information */
61 struct tps62360_chip
{
63 struct regulator_desc desc
;
64 struct regulator_dev
*rdev
;
65 struct regmap
*regmap
;
71 bool en_internal_pulldn
;
76 int curr_vset_vsel
[4];
82 * find_voltage_set_register: Find new voltage configuration register
84 * The finding of the new VSET register will be based on the LRU mechanism.
85 * Each VSET register will have different voltage configured . This
86 * Function will look if any of the VSET register have requested voltage set
88 * - If it is already there then it will make that register as most
89 * recently used and return as found so that caller need not to set
90 * the VSET register but need to set the proper gpios to select this
92 * - If requested voltage is not found then it will use the least
93 * recently mechanism to get new VSET register for new configuration
94 * and will return not_found so that caller need to set new VSET
95 * register and then gpios (both).
97 static bool find_voltage_set_register(struct tps62360_chip
*tps
,
98 int req_vsel
, int *vset_reg_id
)
102 int new_vset_reg
= tps
->lru_index
[3];
105 for (i
= 0; i
< 4; ++i
) {
106 if (tps
->curr_vset_vsel
[tps
->lru_index
[i
]] == req_vsel
) {
107 new_vset_reg
= tps
->lru_index
[i
];
110 goto update_lru_index
;
115 for (i
= found_index
; i
> 0; i
--)
116 tps
->lru_index
[i
] = tps
->lru_index
[i
- 1];
118 tps
->lru_index
[0] = new_vset_reg
;
119 *vset_reg_id
= new_vset_reg
;
123 static int tps62360_dcdc_get_voltage_sel(struct regulator_dev
*dev
)
125 struct tps62360_chip
*tps
= rdev_get_drvdata(dev
);
130 ret
= regmap_read(tps
->regmap
, REG_VSET0
+ tps
->curr_vset_id
, &data
);
132 dev_err(tps
->dev
, "%s(): register %d read failed with err %d\n",
133 __func__
, REG_VSET0
+ tps
->curr_vset_id
, ret
);
136 vsel
= (int)data
& tps
->voltage_reg_mask
;
140 static int tps62360_dcdc_set_voltage(struct regulator_dev
*dev
,
141 int min_uV
, int max_uV
, unsigned *selector
)
143 struct tps62360_chip
*tps
= rdev_get_drvdata(dev
);
147 int new_vset_id
= tps
->curr_vset_id
;
149 if ((max_uV
< min_uV
) || (max_uV
< tps
->voltage_base
))
152 if (min_uV
> (tps
->voltage_base
+ (tps
->desc
.n_voltages
- 1) * 10000))
155 vsel
= DIV_ROUND_UP(min_uV
- tps
->voltage_base
, 10000);
157 *selector
= (vsel
& tps
->voltage_reg_mask
);
160 * If gpios are available to select the VSET register then least
161 * recently used register for new configuration.
163 if (tps
->valid_gpios
)
164 found
= find_voltage_set_register(tps
, vsel
, &new_vset_id
);
167 ret
= regmap_update_bits(tps
->regmap
, REG_VSET0
+ new_vset_id
,
168 tps
->voltage_reg_mask
, vsel
);
171 "%s(): register %d update failed with err %d\n",
172 __func__
, REG_VSET0
+ new_vset_id
, ret
);
175 tps
->curr_vset_id
= new_vset_id
;
176 tps
->curr_vset_vsel
[new_vset_id
] = vsel
;
179 /* Select proper VSET register vio gpios */
180 if (tps
->valid_gpios
) {
181 gpio_set_value_cansleep(tps
->vsel0_gpio
, new_vset_id
& 0x1);
182 gpio_set_value_cansleep(tps
->vsel1_gpio
,
183 (new_vset_id
>> 1) & 0x1);
188 static int tps62360_set_voltage_time_sel(struct regulator_dev
*rdev
,
189 unsigned int old_selector
, unsigned int new_selector
)
191 struct tps62360_chip
*tps
= rdev_get_drvdata(rdev
);
194 old_uV
= regulator_list_voltage_linear(rdev
, old_selector
);
198 new_uV
= regulator_list_voltage_linear(rdev
, new_selector
);
202 return DIV_ROUND_UP(abs(old_uV
- new_uV
), tps
->change_uv_per_us
);
205 static struct regulator_ops tps62360_dcdc_ops
= {
206 .get_voltage_sel
= tps62360_dcdc_get_voltage_sel
,
207 .set_voltage
= tps62360_dcdc_set_voltage
,
208 .list_voltage
= regulator_list_voltage_linear
,
209 .set_voltage_time_sel
= tps62360_set_voltage_time_sel
,
212 static int __devinit
tps62360_init_force_pwm(struct tps62360_chip
*tps
,
213 struct tps62360_regulator_platform_data
*pdata
,
219 if (pdata
->en_force_pwm
)
222 ret
= regmap_update_bits(tps
->regmap
, REG_VSET0
+ vset_id
, BIT(7), bit
);
225 "%s(): register %d update failed with err %d\n",
226 __func__
, REG_VSET0
+ vset_id
, ret
);
230 static int __devinit
tps62360_init_dcdc(struct tps62360_chip
*tps
,
231 struct tps62360_regulator_platform_data
*pdata
)
235 unsigned int ramp_ctrl
;
237 /* Initialize internal pull up/down control */
238 if (tps
->en_internal_pulldn
)
239 ret
= regmap_write(tps
->regmap
, REG_CONTROL
, 0xE0);
241 ret
= regmap_write(tps
->regmap
, REG_CONTROL
, 0x0);
244 "%s(): register %d write failed with err %d\n",
245 __func__
, REG_CONTROL
, ret
);
249 /* Initialize force PWM mode */
250 if (tps
->valid_gpios
) {
251 for (i
= 0; i
< 4; ++i
) {
252 ret
= tps62360_init_force_pwm(tps
, pdata
, i
);
257 ret
= tps62360_init_force_pwm(tps
, pdata
, tps
->curr_vset_id
);
262 /* Reset output discharge path to reduce power consumption */
263 ret
= regmap_update_bits(tps
->regmap
, REG_RAMPCTRL
, BIT(2), 0);
266 "%s(): register %d update failed with err %d\n",
267 __func__
, REG_RAMPCTRL
, ret
);
271 /* Get ramp value from ramp control register */
272 ret
= regmap_read(tps
->regmap
, REG_RAMPCTRL
, &ramp_ctrl
);
275 "%s(): register %d read failed with err %d\n",
276 __func__
, REG_RAMPCTRL
, ret
);
279 ramp_ctrl
= (ramp_ctrl
>> 4) & 0x7;
281 /* ramp mV/us = 32/(2^ramp_ctrl) */
282 tps
->change_uv_per_us
= DIV_ROUND_UP(32000, BIT(ramp_ctrl
));
286 static const struct regmap_config tps62360_regmap_config
= {
289 .max_register
= REG_CHIPID
,
290 .cache_type
= REGCACHE_RBTREE
,
293 static struct tps62360_regulator_platform_data
*
294 of_get_tps62360_platform_data(struct device
*dev
)
296 struct tps62360_regulator_platform_data
*pdata
;
297 struct device_node
*np
= dev
->of_node
;
299 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
301 dev_err(dev
, "Memory alloc failed for platform data\n");
305 pdata
->reg_init_data
= of_get_regulator_init_data(dev
, dev
->of_node
);
306 if (!pdata
->reg_init_data
) {
307 dev_err(dev
, "Not able to get OF regulator init data\n");
311 pdata
->vsel0_gpio
= of_get_named_gpio(np
, "vsel0-gpio", 0);
312 pdata
->vsel1_gpio
= of_get_named_gpio(np
, "vsel1-gpio", 0);
314 if (of_find_property(np
, "ti,vsel0-state-high", NULL
))
315 pdata
->vsel0_def_state
= 1;
317 if (of_find_property(np
, "ti,vsel1-state-high", NULL
))
318 pdata
->vsel1_def_state
= 1;
320 if (of_find_property(np
, "ti,enable-pull-down", NULL
))
321 pdata
->en_internal_pulldn
= true;
323 if (of_find_property(np
, "ti,enable-force-pwm", NULL
))
324 pdata
->en_force_pwm
= true;
326 if (of_find_property(np
, "ti,enable-vout-discharge", NULL
))
327 pdata
->en_discharge
= true;
332 #if defined(CONFIG_OF)
333 static const struct of_device_id tps62360_of_match
[] = {
334 { .compatible
= "ti,tps62360", .data
= (void *)TPS62360
},
335 { .compatible
= "ti,tps62361", .data
= (void *)TPS62361
},
336 { .compatible
= "ti,tps62362", .data
= (void *)TPS62362
},
337 { .compatible
= "ti,tps62363", .data
= (void *)TPS62363
},
340 MODULE_DEVICE_TABLE(of
, tps62360_of_match
);
343 static int __devinit
tps62360_probe(struct i2c_client
*client
,
344 const struct i2c_device_id
*id
)
346 struct regulator_config config
= { };
347 struct tps62360_regulator_platform_data
*pdata
;
348 struct regulator_dev
*rdev
;
349 struct tps62360_chip
*tps
;
354 pdata
= client
->dev
.platform_data
;
355 chip_id
= id
->driver_data
;
357 if (client
->dev
.of_node
) {
358 const struct of_device_id
*match
;
359 match
= of_match_device(of_match_ptr(tps62360_of_match
),
362 dev_err(&client
->dev
, "Error: No device match found\n");
365 chip_id
= (int)match
->data
;
367 pdata
= of_get_tps62360_platform_data(&client
->dev
);
371 dev_err(&client
->dev
, "%s(): Platform data not found\n",
376 tps
= devm_kzalloc(&client
->dev
, sizeof(*tps
), GFP_KERNEL
);
378 dev_err(&client
->dev
, "%s(): Memory allocation failed\n",
383 tps
->en_force_pwm
= pdata
->en_force_pwm
;
384 tps
->en_discharge
= pdata
->en_discharge
;
385 tps
->en_internal_pulldn
= pdata
->en_internal_pulldn
;
386 tps
->vsel0_gpio
= pdata
->vsel0_gpio
;
387 tps
->vsel1_gpio
= pdata
->vsel1_gpio
;
388 tps
->dev
= &client
->dev
;
393 tps
->voltage_base
= TPS62360_BASE_VOLTAGE
;
394 tps
->voltage_reg_mask
= 0x3F;
395 tps
->desc
.n_voltages
= TPS62360_N_VOLTAGES
;
399 tps
->voltage_base
= TPS62361_BASE_VOLTAGE
;
400 tps
->voltage_reg_mask
= 0x7F;
401 tps
->desc
.n_voltages
= TPS62361_N_VOLTAGES
;
407 tps
->desc
.name
= id
->name
;
409 tps
->desc
.ops
= &tps62360_dcdc_ops
;
410 tps
->desc
.type
= REGULATOR_VOLTAGE
;
411 tps
->desc
.owner
= THIS_MODULE
;
412 tps
->desc
.min_uV
= tps
->voltage_base
;
413 tps
->desc
.uV_step
= 10000;
415 tps
->regmap
= devm_regmap_init_i2c(client
, &tps62360_regmap_config
);
416 if (IS_ERR(tps
->regmap
)) {
417 ret
= PTR_ERR(tps
->regmap
);
418 dev_err(&client
->dev
,
419 "%s(): regmap allocation failed with err %d\n",
423 i2c_set_clientdata(client
, tps
);
425 tps
->curr_vset_id
= (pdata
->vsel1_def_state
& 1) * 2 +
426 (pdata
->vsel0_def_state
& 1);
427 tps
->lru_index
[0] = tps
->curr_vset_id
;
428 tps
->valid_gpios
= false;
430 if (gpio_is_valid(tps
->vsel0_gpio
) && gpio_is_valid(tps
->vsel1_gpio
)) {
432 gpio_flags
= (pdata
->vsel0_def_state
) ?
433 GPIOF_OUT_INIT_HIGH
: GPIOF_OUT_INIT_LOW
;
434 ret
= gpio_request_one(tps
->vsel0_gpio
,
435 gpio_flags
, "tps62360-vsel0");
437 dev_err(&client
->dev
,
438 "%s(): Could not obtain vsel0 GPIO %d: %d\n",
439 __func__
, tps
->vsel0_gpio
, ret
);
443 gpio_flags
= (pdata
->vsel1_def_state
) ?
444 GPIOF_OUT_INIT_HIGH
: GPIOF_OUT_INIT_LOW
;
445 ret
= gpio_request_one(tps
->vsel1_gpio
,
446 gpio_flags
, "tps62360-vsel1");
448 dev_err(&client
->dev
,
449 "%s(): Could not obtain vsel1 GPIO %d: %d\n",
450 __func__
, tps
->vsel1_gpio
, ret
);
453 tps
->valid_gpios
= true;
456 * Initialize the lru index with vset_reg id
457 * The index 0 will be most recently used and
458 * set with the tps->curr_vset_id */
459 for (i
= 0; i
< 4; ++i
)
460 tps
->lru_index
[i
] = i
;
461 tps
->lru_index
[0] = tps
->curr_vset_id
;
462 tps
->lru_index
[tps
->curr_vset_id
] = 0;
465 ret
= tps62360_init_dcdc(tps
, pdata
);
467 dev_err(tps
->dev
, "%s(): Init failed with err = %d\n",
472 config
.dev
= &client
->dev
;
473 config
.init_data
= pdata
->reg_init_data
;
474 config
.driver_data
= tps
;
476 /* Register the regulators */
477 rdev
= regulator_register(&tps
->desc
, &config
);
480 "%s(): regulator register failed with err %s\n",
490 if (gpio_is_valid(tps
->vsel1_gpio
))
491 gpio_free(tps
->vsel1_gpio
);
493 if (gpio_is_valid(tps
->vsel0_gpio
))
494 gpio_free(tps
->vsel0_gpio
);
500 * tps62360_remove - tps62360 driver i2c remove handler
501 * @client: i2c driver client device structure
503 * Unregister TPS driver as an i2c client device driver
505 static int __devexit
tps62360_remove(struct i2c_client
*client
)
507 struct tps62360_chip
*tps
= i2c_get_clientdata(client
);
509 if (gpio_is_valid(tps
->vsel1_gpio
))
510 gpio_free(tps
->vsel1_gpio
);
512 if (gpio_is_valid(tps
->vsel0_gpio
))
513 gpio_free(tps
->vsel0_gpio
);
515 regulator_unregister(tps
->rdev
);
519 static void tps62360_shutdown(struct i2c_client
*client
)
521 struct tps62360_chip
*tps
= i2c_get_clientdata(client
);
524 if (!tps
->en_discharge
)
527 /* Configure the output discharge path */
528 st
= regmap_update_bits(tps
->regmap
, REG_RAMPCTRL
, BIT(2), BIT(2));
531 "%s(): register %d update failed with err %d\n",
532 __func__
, REG_RAMPCTRL
, st
);
535 static const struct i2c_device_id tps62360_id
[] = {
536 {.name
= "tps62360", .driver_data
= TPS62360
},
537 {.name
= "tps62361", .driver_data
= TPS62361
},
538 {.name
= "tps62362", .driver_data
= TPS62362
},
539 {.name
= "tps62363", .driver_data
= TPS62363
},
543 MODULE_DEVICE_TABLE(i2c
, tps62360_id
);
545 static struct i2c_driver tps62360_i2c_driver
= {
548 .owner
= THIS_MODULE
,
549 .of_match_table
= of_match_ptr(tps62360_of_match
),
551 .probe
= tps62360_probe
,
552 .remove
= __devexit_p(tps62360_remove
),
553 .shutdown
= tps62360_shutdown
,
554 .id_table
= tps62360_id
,
557 static int __init
tps62360_init(void)
559 return i2c_add_driver(&tps62360_i2c_driver
);
561 subsys_initcall(tps62360_init
);
563 static void __exit
tps62360_cleanup(void)
565 i2c_del_driver(&tps62360_i2c_driver
);
567 module_exit(tps62360_cleanup
);
569 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
570 MODULE_DESCRIPTION("TPS6236x voltage regulator driver");
571 MODULE_LICENSE("GPL v2");