Loading...
1/*
2 * tps51632-regulator.c -- TI TPS51632
3 *
4 * Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless
5 * Controller with serial VID control and DVFS.
6 *
7 * Copyright (c) 2012, NVIDIA Corporation.
8 *
9 * Author: Laxman Dewangan <ldewangan@nvidia.com>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation version 2.
14 *
15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
16 * whether express or implied; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
23 * 02111-1307, USA
24 */
25
26#include <linux/err.h>
27#include <linux/i2c.h>
28#include <linux/init.h>
29#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/of.h>
32#include <linux/of_device.h>
33#include <linux/platform_device.h>
34#include <linux/regmap.h>
35#include <linux/regulator/driver.h>
36#include <linux/regulator/machine.h>
37#include <linux/regulator/of_regulator.h>
38#include <linux/regulator/tps51632-regulator.h>
39#include <linux/slab.h>
40
41/* Register definitions */
42#define TPS51632_VOLTAGE_SELECT_REG 0x0
43#define TPS51632_VOLTAGE_BASE_REG 0x1
44#define TPS51632_OFFSET_REG 0x2
45#define TPS51632_IMON_REG 0x3
46#define TPS51632_VMAX_REG 0x4
47#define TPS51632_DVFS_CONTROL_REG 0x5
48#define TPS51632_POWER_STATE_REG 0x6
49#define TPS51632_SLEW_REGS 0x7
50#define TPS51632_FAULT_REG 0x14
51
52#define TPS51632_MAX_REG 0x15
53
54#define TPS51632_VOUT_MASK 0x7F
55#define TPS51632_VOUT_OFFSET_MASK 0x1F
56#define TPS51632_VMAX_MASK 0x7F
57#define TPS51632_VMAX_LOCK 0x80
58
59/* TPS51632_DVFS_CONTROL_REG */
60#define TPS51632_DVFS_PWMEN 0x1
61#define TPS51632_DVFS_STEP_20 0x2
62#define TPS51632_DVFS_VMAX_PG 0x4
63#define TPS51632_DVFS_PWMRST 0x8
64#define TPS51632_DVFS_OCA_EN 0x10
65#define TPS51632_DVFS_FCCM 0x20
66
67/* TPS51632_POWER_STATE_REG */
68#define TPS51632_POWER_STATE_MASK 0x03
69#define TPS51632_POWER_STATE_MULTI_PHASE_CCM 0x0
70#define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1
71#define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2
72
73#define TPS51632_MIN_VOLTAGE 500000
74#define TPS51632_MAX_VOLTAGE 1520000
75#define TPS51632_VOLTAGE_STEP_10mV 10000
76#define TPS51632_VOLTAGE_STEP_20mV 20000
77#define TPS51632_MAX_VSEL 0x7F
78#define TPS51632_MIN_VSEL 0x19
79#define TPS51632_DEFAULT_RAMP_DELAY 6000
80#define TPS51632_VOLT_VSEL(uV) \
81 (DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE, \
82 TPS51632_VOLTAGE_STEP_10mV) + \
83 TPS51632_MIN_VSEL)
84
85/* TPS51632 chip information */
86struct tps51632_chip {
87 struct device *dev;
88 struct regulator_desc desc;
89 struct regulator_dev *rdev;
90 struct regmap *regmap;
91};
92
93static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
94 int ramp_delay)
95{
96 struct tps51632_chip *tps = rdev_get_drvdata(rdev);
97 int bit = ramp_delay/6000;
98 int ret;
99
100 if (bit)
101 bit--;
102 ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
103 if (ret < 0)
104 dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
105 return ret;
106}
107
108static struct regulator_ops tps51632_dcdc_ops = {
109 .get_voltage_sel = regulator_get_voltage_sel_regmap,
110 .set_voltage_sel = regulator_set_voltage_sel_regmap,
111 .list_voltage = regulator_list_voltage_linear,
112 .set_voltage_time_sel = regulator_set_voltage_time_sel,
113 .set_ramp_delay = tps51632_dcdc_set_ramp_delay,
114};
115
116static int tps51632_init_dcdc(struct tps51632_chip *tps,
117 struct tps51632_regulator_platform_data *pdata)
118{
119 int ret;
120 uint8_t control = 0;
121 int vsel;
122
123 if (!pdata->enable_pwm_dvfs)
124 goto skip_pwm_config;
125
126 control |= TPS51632_DVFS_PWMEN;
127 vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
128 ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
129 if (ret < 0) {
130 dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
131 return ret;
132 }
133
134 if (pdata->dvfs_step_20mV)
135 control |= TPS51632_DVFS_STEP_20;
136
137 if (pdata->max_voltage_uV) {
138 unsigned int vmax;
139 /**
140 * TPS51632 hw behavior: VMAX register can be write only
141 * once as it get locked after first write. The lock get
142 * reset only when device is power-reset.
143 * Write register only when lock bit is not enabled.
144 */
145 ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
146 if (ret < 0) {
147 dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
148 return ret;
149 }
150 if (!(vmax & TPS51632_VMAX_LOCK)) {
151 vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
152 ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
153 vsel);
154 if (ret < 0) {
155 dev_err(tps->dev,
156 "VMAX write failed, err %d\n", ret);
157 return ret;
158 }
159 }
160 }
161
162skip_pwm_config:
163 ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
164 if (ret < 0)
165 dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
166 return ret;
167}
168
169static bool is_volatile_reg(struct device *dev, unsigned int reg)
170{
171 switch (reg) {
172 case TPS51632_OFFSET_REG:
173 case TPS51632_FAULT_REG:
174 case TPS51632_IMON_REG:
175 return true;
176 default:
177 return false;
178 }
179}
180
181static bool is_read_reg(struct device *dev, unsigned int reg)
182{
183 switch (reg) {
184 case 0x08 ... 0x0F:
185 return false;
186 default:
187 return true;
188 }
189}
190
191static bool is_write_reg(struct device *dev, unsigned int reg)
192{
193 switch (reg) {
194 case TPS51632_VOLTAGE_SELECT_REG:
195 case TPS51632_VOLTAGE_BASE_REG:
196 case TPS51632_VMAX_REG:
197 case TPS51632_DVFS_CONTROL_REG:
198 case TPS51632_POWER_STATE_REG:
199 case TPS51632_SLEW_REGS:
200 return true;
201 default:
202 return false;
203 }
204}
205
206static const struct regmap_config tps51632_regmap_config = {
207 .reg_bits = 8,
208 .val_bits = 8,
209 .writeable_reg = is_write_reg,
210 .readable_reg = is_read_reg,
211 .volatile_reg = is_volatile_reg,
212 .max_register = TPS51632_MAX_REG - 1,
213 .cache_type = REGCACHE_RBTREE,
214};
215
216#if defined(CONFIG_OF)
217static const struct of_device_id tps51632_of_match[] = {
218 { .compatible = "ti,tps51632",},
219 {},
220};
221MODULE_DEVICE_TABLE(of, tps51632_of_match);
222
223static struct tps51632_regulator_platform_data *
224 of_get_tps51632_platform_data(struct device *dev)
225{
226 struct tps51632_regulator_platform_data *pdata;
227 struct device_node *np = dev->of_node;
228
229 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
230 if (!pdata)
231 return NULL;
232
233 pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node);
234 if (!pdata->reg_init_data) {
235 dev_err(dev, "Not able to get OF regulator init data\n");
236 return NULL;
237 }
238
239 pdata->enable_pwm_dvfs =
240 of_property_read_bool(np, "ti,enable-pwm-dvfs");
241 pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
242
243 pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
244 TPS51632_MIN_VOLTAGE;
245 pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
246 TPS51632_MAX_VOLTAGE;
247 return pdata;
248}
249#else
250static struct tps51632_regulator_platform_data *
251 of_get_tps51632_platform_data(struct device *dev)
252{
253 return NULL;
254}
255#endif
256
257static int tps51632_probe(struct i2c_client *client,
258 const struct i2c_device_id *id)
259{
260 struct tps51632_regulator_platform_data *pdata;
261 struct regulator_dev *rdev;
262 struct tps51632_chip *tps;
263 int ret;
264 struct regulator_config config = { };
265
266 if (client->dev.of_node) {
267 const struct of_device_id *match;
268 match = of_match_device(of_match_ptr(tps51632_of_match),
269 &client->dev);
270 if (!match) {
271 dev_err(&client->dev, "Error: No device match found\n");
272 return -ENODEV;
273 }
274 }
275
276 pdata = dev_get_platdata(&client->dev);
277 if (!pdata && client->dev.of_node)
278 pdata = of_get_tps51632_platform_data(&client->dev);
279 if (!pdata) {
280 dev_err(&client->dev, "No Platform data\n");
281 return -EINVAL;
282 }
283
284 if (pdata->enable_pwm_dvfs) {
285 if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
286 (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
287 dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
288 return -EINVAL;
289 }
290
291 if ((pdata->max_voltage_uV) &&
292 ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
293 (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
294 dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
295 return -EINVAL;
296 }
297 }
298
299 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
300 if (!tps)
301 return -ENOMEM;
302
303 tps->dev = &client->dev;
304 tps->desc.name = client->name;
305 tps->desc.id = 0;
306 tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
307 tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
308 tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
309 tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
310 tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
311 tps->desc.ops = &tps51632_dcdc_ops;
312 tps->desc.type = REGULATOR_VOLTAGE;
313 tps->desc.owner = THIS_MODULE;
314
315 if (pdata->enable_pwm_dvfs)
316 tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
317 else
318 tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
319 tps->desc.vsel_mask = TPS51632_VOUT_MASK;
320
321 tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
322 if (IS_ERR(tps->regmap)) {
323 ret = PTR_ERR(tps->regmap);
324 dev_err(&client->dev, "regmap init failed, err %d\n", ret);
325 return ret;
326 }
327 i2c_set_clientdata(client, tps);
328
329 ret = tps51632_init_dcdc(tps, pdata);
330 if (ret < 0) {
331 dev_err(tps->dev, "Init failed, err = %d\n", ret);
332 return ret;
333 }
334
335 /* Register the regulators */
336 config.dev = &client->dev;
337 config.init_data = pdata->reg_init_data;
338 config.driver_data = tps;
339 config.regmap = tps->regmap;
340 config.of_node = client->dev.of_node;
341
342 rdev = devm_regulator_register(&client->dev, &tps->desc, &config);
343 if (IS_ERR(rdev)) {
344 dev_err(tps->dev, "regulator register failed\n");
345 return PTR_ERR(rdev);
346 }
347
348 tps->rdev = rdev;
349 return 0;
350}
351
352static const struct i2c_device_id tps51632_id[] = {
353 {.name = "tps51632",},
354 {},
355};
356
357MODULE_DEVICE_TABLE(i2c, tps51632_id);
358
359static struct i2c_driver tps51632_i2c_driver = {
360 .driver = {
361 .name = "tps51632",
362 .owner = THIS_MODULE,
363 .of_match_table = of_match_ptr(tps51632_of_match),
364 },
365 .probe = tps51632_probe,
366 .id_table = tps51632_id,
367};
368
369static int __init tps51632_init(void)
370{
371 return i2c_add_driver(&tps51632_i2c_driver);
372}
373subsys_initcall(tps51632_init);
374
375static void __exit tps51632_cleanup(void)
376{
377 i2c_del_driver(&tps51632_i2c_driver);
378}
379module_exit(tps51632_cleanup);
380
381MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
382MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
383MODULE_LICENSE("GPL v2");
1/*
2 * tps51632-regulator.c -- TI TPS51632
3 *
4 * Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless
5 * Controller with serial VID control and DVFS.
6 *
7 * Copyright (c) 2012, NVIDIA Corporation.
8 *
9 * Author: Laxman Dewangan <ldewangan@nvidia.com>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation version 2.
14 *
15 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
16 * whether express or implied; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
23 * 02111-1307, USA
24 */
25
26#include <linux/err.h>
27#include <linux/i2c.h>
28#include <linux/init.h>
29#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/of.h>
32#include <linux/of_device.h>
33#include <linux/platform_device.h>
34#include <linux/regmap.h>
35#include <linux/regulator/driver.h>
36#include <linux/regulator/machine.h>
37#include <linux/regulator/of_regulator.h>
38#include <linux/regulator/tps51632-regulator.h>
39#include <linux/slab.h>
40
41/* Register definitions */
42#define TPS51632_VOLTAGE_SELECT_REG 0x0
43#define TPS51632_VOLTAGE_BASE_REG 0x1
44#define TPS51632_OFFSET_REG 0x2
45#define TPS51632_IMON_REG 0x3
46#define TPS51632_VMAX_REG 0x4
47#define TPS51632_DVFS_CONTROL_REG 0x5
48#define TPS51632_POWER_STATE_REG 0x6
49#define TPS51632_SLEW_REGS 0x7
50#define TPS51632_FAULT_REG 0x14
51
52#define TPS51632_MAX_REG 0x15
53
54#define TPS51632_VOUT_MASK 0x7F
55#define TPS51632_VOUT_OFFSET_MASK 0x1F
56#define TPS51632_VMAX_MASK 0x7F
57#define TPS51632_VMAX_LOCK 0x80
58
59/* TPS51632_DVFS_CONTROL_REG */
60#define TPS51632_DVFS_PWMEN 0x1
61#define TPS51632_DVFS_STEP_20 0x2
62#define TPS51632_DVFS_VMAX_PG 0x4
63#define TPS51632_DVFS_PWMRST 0x8
64#define TPS51632_DVFS_OCA_EN 0x10
65#define TPS51632_DVFS_FCCM 0x20
66
67/* TPS51632_POWER_STATE_REG */
68#define TPS51632_POWER_STATE_MASK 0x03
69#define TPS51632_POWER_STATE_MULTI_PHASE_CCM 0x0
70#define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1
71#define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2
72
73#define TPS51632_MIN_VOLTAGE 500000
74#define TPS51632_MAX_VOLTAGE 1520000
75#define TPS51632_VOLTAGE_STEP_10mV 10000
76#define TPS51632_VOLTAGE_STEP_20mV 20000
77#define TPS51632_MAX_VSEL 0x7F
78#define TPS51632_MIN_VSEL 0x19
79#define TPS51632_DEFAULT_RAMP_DELAY 6000
80#define TPS51632_VOLT_VSEL(uV) \
81 (DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE, \
82 TPS51632_VOLTAGE_STEP_10mV) + \
83 TPS51632_MIN_VSEL)
84
85/* TPS51632 chip information */
86struct tps51632_chip {
87 struct device *dev;
88 struct regulator_desc desc;
89 struct regulator_dev *rdev;
90 struct regmap *regmap;
91};
92
93static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
94 int ramp_delay)
95{
96 struct tps51632_chip *tps = rdev_get_drvdata(rdev);
97 int bit = ramp_delay/6000;
98 int ret;
99
100 if (bit)
101 bit--;
102 ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
103 if (ret < 0)
104 dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
105 return ret;
106}
107
108static struct regulator_ops tps51632_dcdc_ops = {
109 .get_voltage_sel = regulator_get_voltage_sel_regmap,
110 .set_voltage_sel = regulator_set_voltage_sel_regmap,
111 .list_voltage = regulator_list_voltage_linear,
112 .set_voltage_time_sel = regulator_set_voltage_time_sel,
113 .set_ramp_delay = tps51632_dcdc_set_ramp_delay,
114};
115
116static int tps51632_init_dcdc(struct tps51632_chip *tps,
117 struct tps51632_regulator_platform_data *pdata)
118{
119 int ret;
120 uint8_t control = 0;
121 int vsel;
122
123 if (!pdata->enable_pwm_dvfs)
124 goto skip_pwm_config;
125
126 control |= TPS51632_DVFS_PWMEN;
127 vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
128 ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
129 if (ret < 0) {
130 dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
131 return ret;
132 }
133
134 if (pdata->dvfs_step_20mV)
135 control |= TPS51632_DVFS_STEP_20;
136
137 if (pdata->max_voltage_uV) {
138 unsigned int vmax;
139 /**
140 * TPS51632 hw behavior: VMAX register can be write only
141 * once as it get locked after first write. The lock get
142 * reset only when device is power-reset.
143 * Write register only when lock bit is not enabled.
144 */
145 ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
146 if (ret < 0) {
147 dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
148 return ret;
149 }
150 if (!(vmax & TPS51632_VMAX_LOCK)) {
151 vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
152 ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
153 vsel);
154 if (ret < 0) {
155 dev_err(tps->dev,
156 "VMAX write failed, err %d\n", ret);
157 return ret;
158 }
159 }
160 }
161
162skip_pwm_config:
163 ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
164 if (ret < 0)
165 dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
166 return ret;
167}
168
169static bool is_volatile_reg(struct device *dev, unsigned int reg)
170{
171 switch (reg) {
172 case TPS51632_OFFSET_REG:
173 case TPS51632_FAULT_REG:
174 case TPS51632_IMON_REG:
175 return true;
176 default:
177 return false;
178 }
179}
180
181static bool is_read_reg(struct device *dev, unsigned int reg)
182{
183 switch (reg) {
184 case 0x08 ... 0x0F:
185 return false;
186 default:
187 return true;
188 }
189}
190
191static bool is_write_reg(struct device *dev, unsigned int reg)
192{
193 switch (reg) {
194 case TPS51632_VOLTAGE_SELECT_REG:
195 case TPS51632_VOLTAGE_BASE_REG:
196 case TPS51632_VMAX_REG:
197 case TPS51632_DVFS_CONTROL_REG:
198 case TPS51632_POWER_STATE_REG:
199 case TPS51632_SLEW_REGS:
200 return true;
201 default:
202 return false;
203 }
204}
205
206static const struct regmap_config tps51632_regmap_config = {
207 .reg_bits = 8,
208 .val_bits = 8,
209 .writeable_reg = is_write_reg,
210 .readable_reg = is_read_reg,
211 .volatile_reg = is_volatile_reg,
212 .max_register = TPS51632_MAX_REG - 1,
213 .cache_type = REGCACHE_RBTREE,
214};
215
216#if defined(CONFIG_OF)
217static const struct of_device_id tps51632_of_match[] = {
218 { .compatible = "ti,tps51632",},
219 {},
220};
221MODULE_DEVICE_TABLE(of, tps51632_of_match);
222
223static struct tps51632_regulator_platform_data *
224 of_get_tps51632_platform_data(struct device *dev,
225 const struct regulator_desc *desc)
226{
227 struct tps51632_regulator_platform_data *pdata;
228 struct device_node *np = dev->of_node;
229
230 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
231 if (!pdata)
232 return NULL;
233
234 pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
235 desc);
236 if (!pdata->reg_init_data) {
237 dev_err(dev, "Not able to get OF regulator init data\n");
238 return NULL;
239 }
240
241 pdata->enable_pwm_dvfs =
242 of_property_read_bool(np, "ti,enable-pwm-dvfs");
243 pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
244
245 pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
246 TPS51632_MIN_VOLTAGE;
247 pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
248 TPS51632_MAX_VOLTAGE;
249 return pdata;
250}
251#else
252static struct tps51632_regulator_platform_data *
253 of_get_tps51632_platform_data(struct device *dev,
254 const struct regulator_desc *desc)
255{
256 return NULL;
257}
258#endif
259
260static int tps51632_probe(struct i2c_client *client,
261 const struct i2c_device_id *id)
262{
263 struct tps51632_regulator_platform_data *pdata;
264 struct regulator_dev *rdev;
265 struct tps51632_chip *tps;
266 int ret;
267 struct regulator_config config = { };
268
269 if (client->dev.of_node) {
270 const struct of_device_id *match;
271 match = of_match_device(of_match_ptr(tps51632_of_match),
272 &client->dev);
273 if (!match) {
274 dev_err(&client->dev, "Error: No device match found\n");
275 return -ENODEV;
276 }
277 }
278
279 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
280 if (!tps)
281 return -ENOMEM;
282
283 tps->dev = &client->dev;
284 tps->desc.name = client->name;
285 tps->desc.id = 0;
286 tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
287 tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
288 tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
289 tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
290 tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
291 tps->desc.ops = &tps51632_dcdc_ops;
292 tps->desc.type = REGULATOR_VOLTAGE;
293 tps->desc.owner = THIS_MODULE;
294
295 pdata = dev_get_platdata(&client->dev);
296 if (!pdata && client->dev.of_node)
297 pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
298 if (!pdata) {
299 dev_err(&client->dev, "No Platform data\n");
300 return -EINVAL;
301 }
302
303 if (pdata->enable_pwm_dvfs) {
304 if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
305 (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
306 dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
307 return -EINVAL;
308 }
309
310 if ((pdata->max_voltage_uV) &&
311 ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
312 (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
313 dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
314 return -EINVAL;
315 }
316 }
317
318 if (pdata->enable_pwm_dvfs)
319 tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
320 else
321 tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
322 tps->desc.vsel_mask = TPS51632_VOUT_MASK;
323
324 tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
325 if (IS_ERR(tps->regmap)) {
326 ret = PTR_ERR(tps->regmap);
327 dev_err(&client->dev, "regmap init failed, err %d\n", ret);
328 return ret;
329 }
330 i2c_set_clientdata(client, tps);
331
332 ret = tps51632_init_dcdc(tps, pdata);
333 if (ret < 0) {
334 dev_err(tps->dev, "Init failed, err = %d\n", ret);
335 return ret;
336 }
337
338 /* Register the regulators */
339 config.dev = &client->dev;
340 config.init_data = pdata->reg_init_data;
341 config.driver_data = tps;
342 config.regmap = tps->regmap;
343 config.of_node = client->dev.of_node;
344
345 rdev = devm_regulator_register(&client->dev, &tps->desc, &config);
346 if (IS_ERR(rdev)) {
347 dev_err(tps->dev, "regulator register failed\n");
348 return PTR_ERR(rdev);
349 }
350
351 tps->rdev = rdev;
352 return 0;
353}
354
355static const struct i2c_device_id tps51632_id[] = {
356 {.name = "tps51632",},
357 {},
358};
359
360MODULE_DEVICE_TABLE(i2c, tps51632_id);
361
362static struct i2c_driver tps51632_i2c_driver = {
363 .driver = {
364 .name = "tps51632",
365 .of_match_table = of_match_ptr(tps51632_of_match),
366 },
367 .probe = tps51632_probe,
368 .id_table = tps51632_id,
369};
370
371static int __init tps51632_init(void)
372{
373 return i2c_add_driver(&tps51632_i2c_driver);
374}
375subsys_initcall(tps51632_init);
376
377static void __exit tps51632_cleanup(void)
378{
379 i2c_del_driver(&tps51632_i2c_driver);
380}
381module_exit(tps51632_cleanup);
382
383MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
384MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
385MODULE_LICENSE("GPL v2");