Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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 = 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 
108 static 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 
116 static 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 
162 skip_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 
169 static 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 
181 static 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 
191 static 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 
206 static 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)
217 static const struct of_device_id tps51632_of_match[] = {
218         { .compatible = "ti,tps51632",},
219         {},
220 };
221 MODULE_DEVICE_TABLE(of, tps51632_of_match);
222 
223 static 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
250 static struct tps51632_regulator_platform_data *
251         of_get_tps51632_platform_data(struct device *dev)
252 {
253         return NULL;
254 }
255 #endif
256 
257 static 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 
352 static const struct i2c_device_id tps51632_id[] = {
353         {.name = "tps51632",},
354         {},
355 };
356 
357 MODULE_DEVICE_TABLE(i2c, tps51632_id);
358 
359 static 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 
369 static int __init tps51632_init(void)
370 {
371         return i2c_add_driver(&tps51632_i2c_driver);
372 }
373 subsys_initcall(tps51632_init);
374 
375 static void __exit tps51632_cleanup(void)
376 {
377         i2c_del_driver(&tps51632_i2c_driver);
378 }
379 module_exit(tps51632_cleanup);
380 
381 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
382 MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
383 MODULE_LICENSE("GPL v2");
384 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us