regulator: palma: Disable smps10 boost during suspend
[linux-2.6.git] / drivers / regulator / max8649.c
1 /*
2  * Regulators driver for Maxim max8649
3  *
4  * Copyright (C) 2009-2010 Marvell International Ltd.
5  *      Haojian Zhuang <haojian.zhuang@marvell.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/i2c.h>
15 #include <linux/platform_device.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/slab.h>
18 #include <linux/regulator/max8649.h>
19 #include <linux/regmap.h>
20
21 #define MAX8649_DCDC_VMIN       750000          /* uV */
22 #define MAX8649_DCDC_VMAX       1380000         /* uV */
23 #define MAX8649_DCDC_STEP       10000           /* uV */
24 #define MAX8649_VOL_MASK        0x3f
25
26 /* Registers */
27 #define MAX8649_MODE0           0x00
28 #define MAX8649_MODE1           0x01
29 #define MAX8649_MODE2           0x02
30 #define MAX8649_MODE3           0x03
31 #define MAX8649_CONTROL         0x04
32 #define MAX8649_SYNC            0x05
33 #define MAX8649_RAMP            0x06
34 #define MAX8649_CHIP_ID1        0x08
35 #define MAX8649_CHIP_ID2        0x09
36
37 /* Bits */
38 #define MAX8649_EN_PD           (1 << 7)
39 #define MAX8649_VID0_PD         (1 << 6)
40 #define MAX8649_VID1_PD         (1 << 5)
41 #define MAX8649_VID_MASK        (3 << 5)
42
43 #define MAX8649_FORCE_PWM       (1 << 7)
44 #define MAX8649_SYNC_EXTCLK     (1 << 6)
45
46 #define MAX8649_EXT_MASK        (3 << 6)
47
48 #define MAX8649_RAMP_MASK       (7 << 5)
49 #define MAX8649_RAMP_DOWN       (1 << 1)
50
51 struct max8649_regulator_info {
52         struct regulator_dev    *regulator;
53         struct device           *dev;
54         struct regmap           *regmap;
55
56         int             vol_reg;
57         unsigned        mode:2; /* bit[1:0] = VID1, VID0 */
58         unsigned        extclk_freq:2;
59         unsigned        extclk:1;
60         unsigned        ramp_timing:3;
61         unsigned        ramp_down:1;
62 };
63
64 /* I2C operations */
65
66 static inline int check_range(int min_uV, int max_uV)
67 {
68         if ((min_uV < MAX8649_DCDC_VMIN) || (max_uV > MAX8649_DCDC_VMAX)
69                 || (min_uV > max_uV))
70                 return -EINVAL;
71         return 0;
72 }
73
74 static int max8649_list_voltage(struct regulator_dev *rdev, unsigned index)
75 {
76         return (MAX8649_DCDC_VMIN + index * MAX8649_DCDC_STEP);
77 }
78
79 static int max8649_get_voltage(struct regulator_dev *rdev)
80 {
81         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
82         unsigned int val;
83         unsigned char data;
84         int ret;
85
86         ret = regmap_read(info->regmap, info->vol_reg, &val);
87         if (ret != 0)
88                 return ret;
89         data = (unsigned char)val & MAX8649_VOL_MASK;
90         return max8649_list_voltage(rdev, data);
91 }
92
93 static int max8649_set_voltage(struct regulator_dev *rdev,
94                                int min_uV, int max_uV, unsigned *selector)
95 {
96         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
97         unsigned char data, mask;
98
99         if (check_range(min_uV, max_uV)) {
100                 dev_err(info->dev, "invalid voltage range (%d, %d) uV\n",
101                         min_uV, max_uV);
102                 return -EINVAL;
103         }
104         data = DIV_ROUND_UP(min_uV - MAX8649_DCDC_VMIN, MAX8649_DCDC_STEP);
105         mask = MAX8649_VOL_MASK;
106         *selector = data & mask;
107
108         return regmap_update_bits(info->regmap, info->vol_reg, mask, data);
109 }
110
111 /* EN_PD means pulldown on EN input */
112 static int max8649_enable(struct regulator_dev *rdev)
113 {
114         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
115         return regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_EN_PD, 0);
116 }
117
118 /*
119  * Applied internal pulldown resistor on EN input pin.
120  * If pulldown EN pin outside, it would be better.
121  */
122 static int max8649_disable(struct regulator_dev *rdev)
123 {
124         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
125         return regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_EN_PD,
126                                 MAX8649_EN_PD);
127 }
128
129 static int max8649_is_enabled(struct regulator_dev *rdev)
130 {
131         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
132         unsigned int val;
133         int ret;
134
135         ret = regmap_read(info->regmap, MAX8649_CONTROL, &val);
136         if (ret != 0)
137                 return ret;
138         return !((unsigned char)val & MAX8649_EN_PD);
139 }
140
141 static int max8649_enable_time(struct regulator_dev *rdev)
142 {
143         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
144         int voltage, rate, ret;
145         unsigned int val;
146
147         /* get voltage */
148         ret = regmap_read(info->regmap, info->vol_reg, &val);
149         if (ret != 0)
150                 return ret;
151         val &= MAX8649_VOL_MASK;
152         voltage = max8649_list_voltage(rdev, (unsigned char)val); /* uV */
153
154         /* get rate */
155         ret = regmap_read(info->regmap, MAX8649_RAMP, &val);
156         if (ret != 0)
157                 return ret;
158         ret = (val & MAX8649_RAMP_MASK) >> 5;
159         rate = (32 * 1000) >> ret;      /* uV/uS */
160
161         return DIV_ROUND_UP(voltage, rate);
162 }
163
164 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode)
165 {
166         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
167
168         switch (mode) {
169         case REGULATOR_MODE_FAST:
170                 regmap_update_bits(info->regmap, info->vol_reg, MAX8649_FORCE_PWM,
171                                    MAX8649_FORCE_PWM);
172                 break;
173         case REGULATOR_MODE_NORMAL:
174                 regmap_update_bits(info->regmap, info->vol_reg,
175                                    MAX8649_FORCE_PWM, 0);
176                 break;
177         default:
178                 return -EINVAL;
179         }
180         return 0;
181 }
182
183 static unsigned int max8649_get_mode(struct regulator_dev *rdev)
184 {
185         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
186         unsigned int val;
187         int ret;
188
189         ret = regmap_read(info->regmap, info->vol_reg, &val);
190         if (ret != 0)
191                 return ret;
192         if (val & MAX8649_FORCE_PWM)
193                 return REGULATOR_MODE_FAST;
194         return REGULATOR_MODE_NORMAL;
195 }
196
197 static struct regulator_ops max8649_dcdc_ops = {
198         .set_voltage    = max8649_set_voltage,
199         .get_voltage    = max8649_get_voltage,
200         .list_voltage   = max8649_list_voltage,
201         .enable         = max8649_enable,
202         .disable        = max8649_disable,
203         .is_enabled     = max8649_is_enabled,
204         .enable_time    = max8649_enable_time,
205         .set_mode       = max8649_set_mode,
206         .get_mode       = max8649_get_mode,
207
208 };
209
210 static struct regulator_desc dcdc_desc = {
211         .name           = "max8649",
212         .ops            = &max8649_dcdc_ops,
213         .type           = REGULATOR_VOLTAGE,
214         .n_voltages     = 1 << 6,
215         .owner          = THIS_MODULE,
216 };
217
218 static struct regmap_config max8649_regmap_config = {
219         .reg_bits = 8,
220         .val_bits = 8,
221 };
222
223 static int __devinit max8649_regulator_probe(struct i2c_client *client,
224                                              const struct i2c_device_id *id)
225 {
226         struct max8649_platform_data *pdata = client->dev.platform_data;
227         struct max8649_regulator_info *info = NULL;
228         unsigned int val;
229         unsigned char data;
230         int ret;
231
232         info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL);
233         if (!info) {
234                 dev_err(&client->dev, "No enough memory\n");
235                 return -ENOMEM;
236         }
237
238         info->regmap = regmap_init_i2c(client, &max8649_regmap_config);
239         if (IS_ERR(info->regmap)) {
240                 ret = PTR_ERR(info->regmap);
241                 dev_err(&client->dev, "Failed to allocate register map: %d\n", ret);
242                 goto fail;
243         }
244
245         info->dev = &client->dev;
246         i2c_set_clientdata(client, info);
247
248         info->mode = pdata->mode;
249         switch (info->mode) {
250         case 0:
251                 info->vol_reg = MAX8649_MODE0;
252                 break;
253         case 1:
254                 info->vol_reg = MAX8649_MODE1;
255                 break;
256         case 2:
257                 info->vol_reg = MAX8649_MODE2;
258                 break;
259         case 3:
260                 info->vol_reg = MAX8649_MODE3;
261                 break;
262         default:
263                 break;
264         }
265
266         ret = regmap_read(info->regmap, MAX8649_CHIP_ID1, &val);
267         if (ret != 0) {
268                 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n",
269                         ret);
270                 goto out;
271         }
272         dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", val);
273
274         /* enable VID0 & VID1 */
275         regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_VID_MASK, 0);
276
277         /* enable/disable external clock synchronization */
278         info->extclk = pdata->extclk;
279         data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
280         regmap_update_bits(info->regmap, info->vol_reg, MAX8649_SYNC_EXTCLK, data);
281         if (info->extclk) {
282                 /* set external clock frequency */
283                 info->extclk_freq = pdata->extclk_freq;
284                 regmap_update_bits(info->regmap, MAX8649_SYNC, MAX8649_EXT_MASK,
285                                    info->extclk_freq << 6);
286         }
287
288         if (pdata->ramp_timing) {
289                 info->ramp_timing = pdata->ramp_timing;
290                 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_MASK,
291                                    info->ramp_timing << 5);
292         }
293
294         info->ramp_down = pdata->ramp_down;
295         if (info->ramp_down) {
296                 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_DOWN,
297                                    MAX8649_RAMP_DOWN);
298         }
299
300         info->regulator = regulator_register(&dcdc_desc, &client->dev,
301                                              pdata->regulator, info, NULL);
302         if (IS_ERR(info->regulator)) {
303                 dev_err(info->dev, "failed to register regulator %s\n",
304                         dcdc_desc.name);
305                 ret = PTR_ERR(info->regulator);
306                 goto out;
307         }
308
309         dev_info(info->dev, "Max8649 regulator device is detected.\n");
310         return 0;
311 out:
312         regmap_exit(info->regmap);
313 fail:
314         kfree(info);
315         return ret;
316 }
317
318 static int __devexit max8649_regulator_remove(struct i2c_client *client)
319 {
320         struct max8649_regulator_info *info = i2c_get_clientdata(client);
321
322         if (info) {
323                 if (info->regulator)
324                         regulator_unregister(info->regulator);
325                 regmap_exit(info->regmap);
326                 kfree(info);
327         }
328
329         return 0;
330 }
331
332 static const struct i2c_device_id max8649_id[] = {
333         { "max8649", 0 },
334         { }
335 };
336 MODULE_DEVICE_TABLE(i2c, max8649_id);
337
338 static struct i2c_driver max8649_driver = {
339         .probe          = max8649_regulator_probe,
340         .remove         = __devexit_p(max8649_regulator_remove),
341         .driver         = {
342                 .name   = "max8649",
343         },
344         .id_table       = max8649_id,
345 };
346
347 static int __init max8649_init(void)
348 {
349         return i2c_add_driver(&max8649_driver);
350 }
351 subsys_initcall(max8649_init);
352
353 static void __exit max8649_exit(void)
354 {
355         i2c_del_driver(&max8649_driver);
356 }
357 module_exit(max8649_exit);
358
359 /* Module information */
360 MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver");
361 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
362 MODULE_LICENSE("GPL");
363