Version:  2.0.40 2.2.26 2.4.37 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 3.17 3.18 3.19 4.0

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                                       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
252 static 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 
260 static 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 
355 static const struct i2c_device_id tps51632_id[] = {
356         {.name = "tps51632",},
357         {},
358 };
359 
360 MODULE_DEVICE_TABLE(i2c, tps51632_id);
361 
362 static struct i2c_driver tps51632_i2c_driver = {
363         .driver = {
364                 .name = "tps51632",
365                 .owner = THIS_MODULE,
366                 .of_match_table = of_match_ptr(tps51632_of_match),
367         },
368         .probe = tps51632_probe,
369         .id_table = tps51632_id,
370 };
371 
372 static int __init tps51632_init(void)
373 {
374         return i2c_add_driver(&tps51632_i2c_driver);
375 }
376 subsys_initcall(tps51632_init);
377 
378 static void __exit tps51632_cleanup(void)
379 {
380         i2c_del_driver(&tps51632_i2c_driver);
381 }
382 module_exit(tps51632_cleanup);
383 
384 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
385 MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
386 MODULE_LICENSE("GPL v2");
387 

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