Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[linux-2.6-microblaze.git] / drivers / regulator / tps51632-regulator.c
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 */
86 struct tps51632_chip {
87         struct device *dev;
88         struct regulator_desc desc;
89         struct regulator_dev *rdev;
90         struct regmap *regmap;
91 };
92
93 static 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;
98         int ret;
99
100         if (ramp_delay == 0)
101                 bit = 0;
102         else
103                 bit = DIV_ROUND_UP(ramp_delay, 6000) - 1;
104
105         ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
106         if (ret < 0)
107                 dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
108         return ret;
109 }
110
111 static struct regulator_ops tps51632_dcdc_ops = {
112         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
113         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
114         .list_voltage           = regulator_list_voltage_linear,
115         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
116         .set_ramp_delay         = tps51632_dcdc_set_ramp_delay,
117 };
118
119 static int tps51632_init_dcdc(struct tps51632_chip *tps,
120                 struct tps51632_regulator_platform_data *pdata)
121 {
122         int ret;
123         uint8_t control = 0;
124         int vsel;
125
126         if (!pdata->enable_pwm_dvfs)
127                 goto skip_pwm_config;
128
129         control |= TPS51632_DVFS_PWMEN;
130         vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
131         ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
132         if (ret < 0) {
133                 dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
134                 return ret;
135         }
136
137         if (pdata->dvfs_step_20mV)
138                 control |= TPS51632_DVFS_STEP_20;
139
140         if (pdata->max_voltage_uV) {
141                 unsigned int vmax;
142                 /**
143                  * TPS51632 hw behavior: VMAX register can be write only
144                  * once as it get locked after first write. The lock get
145                  * reset only when device is power-reset.
146                  * Write register only when lock bit is not enabled.
147                  */
148                 ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
149                 if (ret < 0) {
150                         dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
151                         return ret;
152                 }
153                 if (!(vmax & TPS51632_VMAX_LOCK)) {
154                         vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
155                         ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
156                                         vsel);
157                         if (ret < 0) {
158                                 dev_err(tps->dev,
159                                         "VMAX write failed, err %d\n", ret);
160                                 return ret;
161                         }
162                 }
163         }
164
165 skip_pwm_config:
166         ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
167         if (ret < 0)
168                 dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
169         return ret;
170 }
171
172 static bool is_volatile_reg(struct device *dev, unsigned int reg)
173 {
174         switch (reg) {
175         case TPS51632_OFFSET_REG:
176         case TPS51632_FAULT_REG:
177         case TPS51632_IMON_REG:
178                 return true;
179         default:
180                 return false;
181         }
182 }
183
184 static bool is_read_reg(struct device *dev, unsigned int reg)
185 {
186         switch (reg) {
187         case 0x08 ... 0x0F:
188                 return false;
189         default:
190                 return true;
191         }
192 }
193
194 static bool is_write_reg(struct device *dev, unsigned int reg)
195 {
196         switch (reg) {
197         case TPS51632_VOLTAGE_SELECT_REG:
198         case TPS51632_VOLTAGE_BASE_REG:
199         case TPS51632_VMAX_REG:
200         case TPS51632_DVFS_CONTROL_REG:
201         case TPS51632_POWER_STATE_REG:
202         case TPS51632_SLEW_REGS:
203                 return true;
204         default:
205                 return false;
206         }
207 }
208
209 static const struct regmap_config tps51632_regmap_config = {
210         .reg_bits               = 8,
211         .val_bits               = 8,
212         .writeable_reg          = is_write_reg,
213         .readable_reg           = is_read_reg,
214         .volatile_reg           = is_volatile_reg,
215         .max_register           = TPS51632_MAX_REG - 1,
216         .cache_type             = REGCACHE_RBTREE,
217 };
218
219 #if defined(CONFIG_OF)
220 static const struct of_device_id tps51632_of_match[] = {
221         { .compatible = "ti,tps51632",},
222         {},
223 };
224 MODULE_DEVICE_TABLE(of, tps51632_of_match);
225
226 static struct tps51632_regulator_platform_data *
227         of_get_tps51632_platform_data(struct device *dev,
228                                       const struct regulator_desc *desc)
229 {
230         struct tps51632_regulator_platform_data *pdata;
231         struct device_node *np = dev->of_node;
232
233         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
234         if (!pdata)
235                 return NULL;
236
237         pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
238                                                           desc);
239         if (!pdata->reg_init_data) {
240                 dev_err(dev, "Not able to get OF regulator init data\n");
241                 return NULL;
242         }
243
244         pdata->enable_pwm_dvfs =
245                         of_property_read_bool(np, "ti,enable-pwm-dvfs");
246         pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
247
248         pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
249                                         TPS51632_MIN_VOLTAGE;
250         pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
251                                         TPS51632_MAX_VOLTAGE;
252         return pdata;
253 }
254 #else
255 static struct tps51632_regulator_platform_data *
256         of_get_tps51632_platform_data(struct device *dev,
257                                       const struct regulator_desc *desc)
258 {
259         return NULL;
260 }
261 #endif
262
263 static int tps51632_probe(struct i2c_client *client,
264                                 const struct i2c_device_id *id)
265 {
266         struct tps51632_regulator_platform_data *pdata;
267         struct regulator_dev *rdev;
268         struct tps51632_chip *tps;
269         int ret;
270         struct regulator_config config = { };
271
272         if (client->dev.of_node) {
273                 const struct of_device_id *match;
274                 match = of_match_device(of_match_ptr(tps51632_of_match),
275                                 &client->dev);
276                 if (!match) {
277                         dev_err(&client->dev, "Error: No device match found\n");
278                         return -ENODEV;
279                 }
280         }
281
282         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
283         if (!tps)
284                 return -ENOMEM;
285
286         tps->dev = &client->dev;
287         tps->desc.name = client->name;
288         tps->desc.id = 0;
289         tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
290         tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
291         tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
292         tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
293         tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
294         tps->desc.ops = &tps51632_dcdc_ops;
295         tps->desc.type = REGULATOR_VOLTAGE;
296         tps->desc.owner = THIS_MODULE;
297
298         pdata = dev_get_platdata(&client->dev);
299         if (!pdata && client->dev.of_node)
300                 pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
301         if (!pdata) {
302                 dev_err(&client->dev, "No Platform data\n");
303                 return -EINVAL;
304         }
305
306         if (pdata->enable_pwm_dvfs) {
307                 if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
308                     (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
309                         dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
310                         return -EINVAL;
311                 }
312
313                 if ((pdata->max_voltage_uV) &&
314                     ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
315                      (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
316                         dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
317                         return -EINVAL;
318                 }
319         }
320
321         if (pdata->enable_pwm_dvfs)
322                 tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
323         else
324                 tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
325         tps->desc.vsel_mask = TPS51632_VOUT_MASK;
326
327         tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
328         if (IS_ERR(tps->regmap)) {
329                 ret = PTR_ERR(tps->regmap);
330                 dev_err(&client->dev, "regmap init failed, err %d\n", ret);
331                 return ret;
332         }
333         i2c_set_clientdata(client, tps);
334
335         ret = tps51632_init_dcdc(tps, pdata);
336         if (ret < 0) {
337                 dev_err(tps->dev, "Init failed, err = %d\n", ret);
338                 return ret;
339         }
340
341         /* Register the regulators */
342         config.dev = &client->dev;
343         config.init_data = pdata->reg_init_data;
344         config.driver_data = tps;
345         config.regmap = tps->regmap;
346         config.of_node = client->dev.of_node;
347
348         rdev = devm_regulator_register(&client->dev, &tps->desc, &config);
349         if (IS_ERR(rdev)) {
350                 dev_err(tps->dev, "regulator register failed\n");
351                 return PTR_ERR(rdev);
352         }
353
354         tps->rdev = rdev;
355         return 0;
356 }
357
358 static const struct i2c_device_id tps51632_id[] = {
359         {.name = "tps51632",},
360         {},
361 };
362
363 MODULE_DEVICE_TABLE(i2c, tps51632_id);
364
365 static struct i2c_driver tps51632_i2c_driver = {
366         .driver = {
367                 .name = "tps51632",
368                 .of_match_table = of_match_ptr(tps51632_of_match),
369         },
370         .probe = tps51632_probe,
371         .id_table = tps51632_id,
372 };
373
374 static int __init tps51632_init(void)
375 {
376         return i2c_add_driver(&tps51632_i2c_driver);
377 }
378 subsys_initcall(tps51632_init);
379
380 static void __exit tps51632_cleanup(void)
381 {
382         i2c_del_driver(&tps51632_i2c_driver);
383 }
384 module_exit(tps51632_cleanup);
385
386 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
387 MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
388 MODULE_LICENSE("GPL v2");