Merge remote-tracking branch 'regulator/topic/change' into regulator-next
[linux-3.10.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         unsigned        mode:2; /* bit[1:0] = VID1, VID0 */
57         unsigned        extclk_freq:2;
58         unsigned        extclk:1;
59         unsigned        ramp_timing:3;
60         unsigned        ramp_down:1;
61 };
62
63 /* EN_PD means pulldown on EN input */
64 static int max8649_enable(struct regulator_dev *rdev)
65 {
66         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
67         return regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_EN_PD, 0);
68 }
69
70 /*
71  * Applied internal pulldown resistor on EN input pin.
72  * If pulldown EN pin outside, it would be better.
73  */
74 static int max8649_disable(struct regulator_dev *rdev)
75 {
76         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
77         return regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_EN_PD,
78                                 MAX8649_EN_PD);
79 }
80
81 static int max8649_is_enabled(struct regulator_dev *rdev)
82 {
83         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
84         unsigned int val;
85         int ret;
86
87         ret = regmap_read(info->regmap, MAX8649_CONTROL, &val);
88         if (ret != 0)
89                 return ret;
90         return !((unsigned char)val & MAX8649_EN_PD);
91 }
92
93 static int max8649_enable_time(struct regulator_dev *rdev)
94 {
95         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
96         int voltage, rate, ret;
97         unsigned int val;
98
99         /* get voltage */
100         ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val);
101         if (ret != 0)
102                 return ret;
103         val &= MAX8649_VOL_MASK;
104         voltage = regulator_list_voltage_linear(rdev, (unsigned char)val);
105
106         /* get rate */
107         ret = regmap_read(info->regmap, MAX8649_RAMP, &val);
108         if (ret != 0)
109                 return ret;
110         ret = (val & MAX8649_RAMP_MASK) >> 5;
111         rate = (32 * 1000) >> ret;      /* uV/uS */
112
113         return DIV_ROUND_UP(voltage, rate);
114 }
115
116 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode)
117 {
118         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
119
120         switch (mode) {
121         case REGULATOR_MODE_FAST:
122                 regmap_update_bits(info->regmap, rdev->desc->vsel_reg,
123                                    MAX8649_FORCE_PWM, MAX8649_FORCE_PWM);
124                 break;
125         case REGULATOR_MODE_NORMAL:
126                 regmap_update_bits(info->regmap, rdev->desc->vsel_reg,
127                                    MAX8649_FORCE_PWM, 0);
128                 break;
129         default:
130                 return -EINVAL;
131         }
132         return 0;
133 }
134
135 static unsigned int max8649_get_mode(struct regulator_dev *rdev)
136 {
137         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
138         unsigned int val;
139         int ret;
140
141         ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val);
142         if (ret != 0)
143                 return ret;
144         if (val & MAX8649_FORCE_PWM)
145                 return REGULATOR_MODE_FAST;
146         return REGULATOR_MODE_NORMAL;
147 }
148
149 static struct regulator_ops max8649_dcdc_ops = {
150         .set_voltage_sel = regulator_set_voltage_sel_regmap,
151         .get_voltage_sel = regulator_get_voltage_sel_regmap,
152         .list_voltage   = regulator_list_voltage_linear,
153         .map_voltage    = regulator_map_voltage_linear,
154         .enable         = max8649_enable,
155         .disable        = max8649_disable,
156         .is_enabled     = max8649_is_enabled,
157         .enable_time    = max8649_enable_time,
158         .set_mode       = max8649_set_mode,
159         .get_mode       = max8649_get_mode,
160
161 };
162
163 static struct regulator_desc dcdc_desc = {
164         .name           = "max8649",
165         .ops            = &max8649_dcdc_ops,
166         .type           = REGULATOR_VOLTAGE,
167         .n_voltages     = 1 << 6,
168         .owner          = THIS_MODULE,
169         .vsel_mask      = MAX8649_VOL_MASK,
170         .min_uV         = MAX8649_DCDC_VMIN,
171         .uV_step        = MAX8649_DCDC_STEP,
172 };
173
174 static struct regmap_config max8649_regmap_config = {
175         .reg_bits = 8,
176         .val_bits = 8,
177 };
178
179 static int __devinit max8649_regulator_probe(struct i2c_client *client,
180                                              const struct i2c_device_id *id)
181 {
182         struct max8649_platform_data *pdata = client->dev.platform_data;
183         struct max8649_regulator_info *info = NULL;
184         struct regulator_config config = { };
185         unsigned int val;
186         unsigned char data;
187         int ret;
188
189         info = devm_kzalloc(&client->dev, sizeof(struct max8649_regulator_info),
190                             GFP_KERNEL);
191         if (!info) {
192                 dev_err(&client->dev, "No enough memory\n");
193                 return -ENOMEM;
194         }
195
196         info->regmap = devm_regmap_init_i2c(client, &max8649_regmap_config);
197         if (IS_ERR(info->regmap)) {
198                 ret = PTR_ERR(info->regmap);
199                 dev_err(&client->dev, "Failed to allocate register map: %d\n", ret);
200                 return ret;
201         }
202
203         info->dev = &client->dev;
204         i2c_set_clientdata(client, info);
205
206         info->mode = pdata->mode;
207         switch (info->mode) {
208         case 0:
209                 dcdc_desc.vsel_reg = MAX8649_MODE0;
210                 break;
211         case 1:
212                 dcdc_desc.vsel_reg = MAX8649_MODE1;
213                 break;
214         case 2:
215                 dcdc_desc.vsel_reg = MAX8649_MODE2;
216                 break;
217         case 3:
218                 dcdc_desc.vsel_reg = MAX8649_MODE3;
219                 break;
220         default:
221                 break;
222         }
223
224         ret = regmap_read(info->regmap, MAX8649_CHIP_ID1, &val);
225         if (ret != 0) {
226                 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n",
227                         ret);
228                 return ret;
229         }
230         dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", val);
231
232         /* enable VID0 & VID1 */
233         regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_VID_MASK, 0);
234
235         /* enable/disable external clock synchronization */
236         info->extclk = pdata->extclk;
237         data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
238         regmap_update_bits(info->regmap, dcdc_desc.vsel_reg,
239                            MAX8649_SYNC_EXTCLK, data);
240         if (info->extclk) {
241                 /* set external clock frequency */
242                 info->extclk_freq = pdata->extclk_freq;
243                 regmap_update_bits(info->regmap, MAX8649_SYNC, MAX8649_EXT_MASK,
244                                    info->extclk_freq << 6);
245         }
246
247         if (pdata->ramp_timing) {
248                 info->ramp_timing = pdata->ramp_timing;
249                 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_MASK,
250                                    info->ramp_timing << 5);
251         }
252
253         info->ramp_down = pdata->ramp_down;
254         if (info->ramp_down) {
255                 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_DOWN,
256                                    MAX8649_RAMP_DOWN);
257         }
258
259         config.dev = &client->dev;
260         config.init_data = pdata->regulator;
261         config.driver_data = info;
262         config.regmap = info->regmap;
263
264         info->regulator = regulator_register(&dcdc_desc, &config);
265         if (IS_ERR(info->regulator)) {
266                 dev_err(info->dev, "failed to register regulator %s\n",
267                         dcdc_desc.name);
268                 return PTR_ERR(info->regulator);
269         }
270
271         return 0;
272 }
273
274 static int __devexit max8649_regulator_remove(struct i2c_client *client)
275 {
276         struct max8649_regulator_info *info = i2c_get_clientdata(client);
277
278         if (info) {
279                 if (info->regulator)
280                         regulator_unregister(info->regulator);
281         }
282
283         return 0;
284 }
285
286 static const struct i2c_device_id max8649_id[] = {
287         { "max8649", 0 },
288         { }
289 };
290 MODULE_DEVICE_TABLE(i2c, max8649_id);
291
292 static struct i2c_driver max8649_driver = {
293         .probe          = max8649_regulator_probe,
294         .remove         = __devexit_p(max8649_regulator_remove),
295         .driver         = {
296                 .name   = "max8649",
297         },
298         .id_table       = max8649_id,
299 };
300
301 static int __init max8649_init(void)
302 {
303         return i2c_add_driver(&max8649_driver);
304 }
305 subsys_initcall(max8649_init);
306
307 static void __exit max8649_exit(void)
308 {
309         i2c_del_driver(&max8649_driver);
310 }
311 module_exit(max8649_exit);
312
313 /* Module information */
314 MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver");
315 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
316 MODULE_LICENSE("GPL");