regulator: remove use of __devexit_p
[linux-3.10.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/platform_device.h>
32 #include <linux/regmap.h>
33 #include <linux/regulator/driver.h>
34 #include <linux/regulator/machine.h>
35 #include <linux/regulator/tps51632-regulator.h>
36 #include <linux/slab.h>
37
38 /* Register definitions */
39 #define TPS51632_VOLTAGE_SELECT_REG             0x0
40 #define TPS51632_VOLTAGE_BASE_REG               0x1
41 #define TPS51632_OFFSET_REG                     0x2
42 #define TPS51632_IMON_REG                       0x3
43 #define TPS51632_VMAX_REG                       0x4
44 #define TPS51632_DVFS_CONTROL_REG               0x5
45 #define TPS51632_POWER_STATE_REG                0x6
46 #define TPS51632_SLEW_REGS                      0x7
47 #define TPS51632_FAULT_REG                      0x14
48
49 #define TPS51632_MAX_REG                        0x15
50
51 #define TPS51632_VOUT_MASK                      0x7F
52 #define TPS51632_VOUT_OFFSET_MASK               0x1F
53 #define TPS51632_VMAX_MASK                      0x7F
54 #define TPS51632_VMAX_LOCK                      0x80
55
56 /* TPS51632_DVFS_CONTROL_REG */
57 #define TPS51632_DVFS_PWMEN                     0x1
58 #define TPS51632_DVFS_STEP_20                   0x2
59 #define TPS51632_DVFS_VMAX_PG                   0x4
60 #define TPS51632_DVFS_PWMRST                    0x8
61 #define TPS51632_DVFS_OCA_EN                    0x10
62 #define TPS51632_DVFS_FCCM                      0x20
63
64 /* TPS51632_POWER_STATE_REG */
65 #define TPS51632_POWER_STATE_MASK               0x03
66 #define TPS51632_POWER_STATE_MULTI_PHASE_CCM    0x0
67 #define TPS51632_POWER_STATE_SINGLE_PHASE_CCM   0x1
68 #define TPS51632_POWER_STATE_SINGLE_PHASE_DCM   0x2
69
70 #define TPS51632_MIN_VOLATGE                    500000
71 #define TPS51632_MAX_VOLATGE                    1520000
72 #define TPS51632_VOLATGE_STEP_10mV              10000
73 #define TPS51632_VOLATGE_STEP_20mV              20000
74 #define TPS51632_MAX_VSEL                       0x7F
75 #define TPS51632_MIN_VSEL                       0x19
76 #define TPS51632_DEFAULT_RAMP_DELAY             6000
77 #define TPS51632_VOLT_VSEL(uV)                                  \
78                 (DIV_ROUND_UP(uV - TPS51632_MIN_VOLATGE,        \
79                         TPS51632_VOLATGE_STEP_10mV) +           \
80                         TPS51632_MIN_VSEL)
81
82 /* TPS51632 chip information */
83 struct tps51632_chip {
84         struct device *dev;
85         struct regulator_desc desc;
86         struct regulator_dev *rdev;
87         struct regmap *regmap;
88         bool enable_pwm_dvfs;
89 };
90
91 static int tps51632_dcdc_get_voltage_sel(struct regulator_dev *rdev)
92 {
93         struct tps51632_chip *tps = rdev_get_drvdata(rdev);
94         unsigned int data;
95         int ret;
96         unsigned int reg = TPS51632_VOLTAGE_SELECT_REG;
97         int vsel;
98
99         if (tps->enable_pwm_dvfs)
100                 reg = TPS51632_VOLTAGE_BASE_REG;
101
102         ret = regmap_read(tps->regmap, reg, &data);
103         if (ret < 0) {
104                 dev_err(tps->dev, "reg read failed, err %d\n", ret);
105                 return ret;
106         }
107
108         vsel = data & TPS51632_VOUT_MASK;
109
110         if (vsel < TPS51632_MIN_VSEL)
111                 return 0;
112         else
113                 return vsel - TPS51632_MIN_VSEL;
114 }
115
116 static int tps51632_dcdc_set_voltage_sel(struct regulator_dev *rdev,
117                 unsigned selector)
118 {
119         struct tps51632_chip *tps = rdev_get_drvdata(rdev);
120         int vsel;
121         int ret;
122         unsigned int reg = TPS51632_VOLTAGE_SELECT_REG;
123
124         if (tps->enable_pwm_dvfs)
125                 reg = TPS51632_VOLTAGE_BASE_REG;
126
127         vsel = selector + TPS51632_MIN_VSEL;
128         if (vsel > TPS51632_MAX_VSEL)
129                 return -EINVAL;
130
131         ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_SELECT_REG, vsel);
132         if (ret < 0)
133                 dev_err(tps->dev, "reg write failed, err %d\n", ret);
134         return ret;
135 }
136
137 static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
138                 int ramp_delay)
139 {
140         struct tps51632_chip *tps = rdev_get_drvdata(rdev);
141         int bit = ramp_delay/6000;
142         int ret;
143
144         if (bit)
145                 bit--;
146         ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
147         if (ret < 0)
148                 dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
149         return ret;
150 }
151
152 static struct regulator_ops tps51632_dcdc_ops = {
153         .get_voltage_sel        = tps51632_dcdc_get_voltage_sel,
154         .set_voltage_sel        = tps51632_dcdc_set_voltage_sel,
155         .list_voltage           = regulator_list_voltage_linear,
156         .set_voltage_time_sel   = regulator_set_voltage_time_sel,
157         .set_ramp_delay         = tps51632_dcdc_set_ramp_delay,
158 };
159
160 static int __devinit tps51632_init_dcdc(struct tps51632_chip *tps,
161                 struct tps51632_regulator_platform_data *pdata)
162 {
163         int ret;
164         uint8_t control = 0;
165         int vsel;
166
167         if (!pdata->enable_pwm_dvfs)
168                 goto skip_pwm_config;
169
170         control |= TPS51632_DVFS_PWMEN;
171         tps->enable_pwm_dvfs = pdata->enable_pwm_dvfs;
172         vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
173         ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
174         if (ret < 0) {
175                 dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
176                 return ret;
177         }
178
179         if (pdata->dvfs_step_20mV)
180                 control |= TPS51632_DVFS_STEP_20;
181
182         if (pdata->max_voltage_uV) {
183                 unsigned int vmax;
184                 /**
185                  * TPS51632 hw behavior: VMAX register can be write only
186                  * once as it get locked after first write. The lock get
187                  * reset only when device is power-reset.
188                  * Write register only when lock bit is not enabled.
189                  */
190                 ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
191                 if (ret < 0) {
192                         dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
193                         return ret;
194                 }
195                 if (!(vmax & TPS51632_VMAX_LOCK)) {
196                         vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
197                         ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
198                                         vsel);
199                         if (ret < 0) {
200                                 dev_err(tps->dev,
201                                         "VMAX write failed, err %d\n", ret);
202                                 return ret;
203                         }
204                 }
205         }
206
207 skip_pwm_config:
208         ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
209         if (ret < 0)
210                 dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
211         return ret;
212 }
213
214 static bool rd_wr_reg(struct device *dev, unsigned int reg)
215 {
216         if ((reg >= 0x8) && (reg <= 0x10))
217                 return false;
218         return true;
219 }
220
221 static const struct regmap_config tps51632_regmap_config = {
222         .reg_bits               = 8,
223         .val_bits               = 8,
224         .writeable_reg          = rd_wr_reg,
225         .readable_reg           = rd_wr_reg,
226         .max_register           = TPS51632_MAX_REG - 1,
227         .cache_type             = REGCACHE_RBTREE,
228 };
229
230 static int __devinit tps51632_probe(struct i2c_client *client,
231                                 const struct i2c_device_id *id)
232 {
233         struct tps51632_regulator_platform_data *pdata;
234         struct regulator_dev *rdev;
235         struct tps51632_chip *tps;
236         int ret;
237         struct regulator_config config = { };
238
239         pdata = client->dev.platform_data;
240         if (!pdata) {
241                 dev_err(&client->dev, "No Platform data\n");
242                 return -EINVAL;
243         }
244
245         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
246         if (!tps) {
247                 dev_err(&client->dev, "Memory allocation failed\n");
248                 return -ENOMEM;
249         }
250
251         tps->dev = &client->dev;
252         tps->desc.name = id->name;
253         tps->desc.id = 0;
254         tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
255         tps->desc.min_uV = TPS51632_MIN_VOLATGE;
256         tps->desc.uV_step = TPS51632_VOLATGE_STEP_10mV;
257         tps->desc.n_voltages = (TPS51632_MAX_VSEL - TPS51632_MIN_VSEL) + 1;
258         tps->desc.ops = &tps51632_dcdc_ops;
259         tps->desc.type = REGULATOR_VOLTAGE;
260         tps->desc.owner = THIS_MODULE;
261
262         tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
263         if (IS_ERR(tps->regmap)) {
264                 ret = PTR_ERR(tps->regmap);
265                 dev_err(&client->dev, "regmap init failed, err %d\n", ret);
266                 return ret;
267         }
268         i2c_set_clientdata(client, tps);
269
270         ret = tps51632_init_dcdc(tps, pdata);
271         if (ret < 0) {
272                 dev_err(tps->dev, "Init failed, err = %d\n", ret);
273                 return ret;
274         }
275
276         /* Register the regulators */
277         config.dev = &client->dev;
278         config.init_data = pdata->reg_init_data;
279         config.driver_data = tps;
280         config.regmap = tps->regmap;
281         config.of_node = client->dev.of_node;
282
283         rdev = regulator_register(&tps->desc, &config);
284         if (IS_ERR(rdev)) {
285                 dev_err(tps->dev, "regulator register failed\n");
286                 return PTR_ERR(rdev);
287         }
288
289         tps->rdev = rdev;
290         return 0;
291 }
292
293 static int __devexit tps51632_remove(struct i2c_client *client)
294 {
295         struct tps51632_chip *tps = i2c_get_clientdata(client);
296
297         regulator_unregister(tps->rdev);
298         return 0;
299 }
300
301 static const struct i2c_device_id tps51632_id[] = {
302         {.name = "tps51632",},
303         {},
304 };
305
306 MODULE_DEVICE_TABLE(i2c, tps51632_id);
307
308 static struct i2c_driver tps51632_i2c_driver = {
309         .driver = {
310                 .name = "tps51632",
311                 .owner = THIS_MODULE,
312         },
313         .probe = tps51632_probe,
314         .remove = tps51632_remove,
315         .id_table = tps51632_id,
316 };
317
318 static int __init tps51632_init(void)
319 {
320         return i2c_add_driver(&tps51632_i2c_driver);
321 }
322 subsys_initcall(tps51632_init);
323
324 static void __exit tps51632_cleanup(void)
325 {
326         i2c_del_driver(&tps51632_i2c_driver);
327 }
328 module_exit(tps51632_cleanup);
329
330 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
331 MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
332 MODULE_LICENSE("GPL v2");