arch: arm: regulator: Fix LDK kernel build break
[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
20 #define MAX8649_DCDC_VMIN       750000          /* uV */
21 #define MAX8649_DCDC_VMAX       1380000         /* uV */
22 #define MAX8649_DCDC_STEP       10000           /* uV */
23 #define MAX8649_VOL_MASK        0x3f
24
25 /* Registers */
26 #define MAX8649_MODE0           0x00
27 #define MAX8649_MODE1           0x01
28 #define MAX8649_MODE2           0x02
29 #define MAX8649_MODE3           0x03
30 #define MAX8649_CONTROL         0x04
31 #define MAX8649_SYNC            0x05
32 #define MAX8649_RAMP            0x06
33 #define MAX8649_CHIP_ID1        0x08
34 #define MAX8649_CHIP_ID2        0x09
35
36 /* Bits */
37 #define MAX8649_EN_PD           (1 << 7)
38 #define MAX8649_VID0_PD         (1 << 6)
39 #define MAX8649_VID1_PD         (1 << 5)
40 #define MAX8649_VID_MASK        (3 << 5)
41
42 #define MAX8649_FORCE_PWM       (1 << 7)
43 #define MAX8649_SYNC_EXTCLK     (1 << 6)
44
45 #define MAX8649_EXT_MASK        (3 << 6)
46
47 #define MAX8649_RAMP_MASK       (7 << 5)
48 #define MAX8649_RAMP_DOWN       (1 << 1)
49
50 struct max8649_regulator_info {
51         struct regulator_dev    *regulator;
52         struct i2c_client       *i2c;
53         struct device           *dev;
54         struct mutex            io_lock;
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 max8649_read_device(struct i2c_client *i2c,
67                                       int reg, int bytes, void *dest)
68 {
69         unsigned char data;
70         int ret;
71
72         data = (unsigned char)reg;
73         ret = i2c_master_send(i2c, &data, 1);
74         if (ret < 0)
75                 return ret;
76         ret = i2c_master_recv(i2c, dest, bytes);
77         if (ret < 0)
78                 return ret;
79         return 0;
80 }
81
82 static inline int max8649_write_device(struct i2c_client *i2c,
83                                        int reg, int bytes, void *src)
84 {
85         unsigned char buf[bytes + 1];
86         int ret;
87
88         buf[0] = (unsigned char)reg;
89         memcpy(&buf[1], src, bytes);
90
91         ret = i2c_master_send(i2c, buf, bytes + 1);
92         if (ret < 0)
93                 return ret;
94         return 0;
95 }
96
97 static int max8649_reg_read(struct i2c_client *i2c, int reg)
98 {
99         struct max8649_regulator_info *info = i2c_get_clientdata(i2c);
100         unsigned char data;
101         int ret;
102
103         mutex_lock(&info->io_lock);
104         ret = max8649_read_device(i2c, reg, 1, &data);
105         mutex_unlock(&info->io_lock);
106
107         if (ret < 0)
108                 return ret;
109         return (int)data;
110 }
111
112 static int max8649_set_bits(struct i2c_client *i2c, int reg,
113                             unsigned char mask, unsigned char data)
114 {
115         struct max8649_regulator_info *info = i2c_get_clientdata(i2c);
116         unsigned char value;
117         int ret;
118
119         mutex_lock(&info->io_lock);
120         ret = max8649_read_device(i2c, reg, 1, &value);
121         if (ret < 0)
122                 goto out;
123         value &= ~mask;
124         value |= data;
125         ret = max8649_write_device(i2c, reg, 1, &value);
126 out:
127         mutex_unlock(&info->io_lock);
128         return ret;
129 }
130
131 static inline int check_range(int min_uV, int max_uV)
132 {
133         if ((min_uV < MAX8649_DCDC_VMIN) || (max_uV > MAX8649_DCDC_VMAX)
134                 || (min_uV > max_uV))
135                 return -EINVAL;
136         return 0;
137 }
138
139 static int max8649_list_voltage(struct regulator_dev *rdev, unsigned index)
140 {
141         return (MAX8649_DCDC_VMIN + index * MAX8649_DCDC_STEP);
142 }
143
144 static int max8649_get_voltage(struct regulator_dev *rdev)
145 {
146         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
147         unsigned char data;
148         int ret;
149
150         ret = max8649_reg_read(info->i2c, info->vol_reg);
151         if (ret < 0)
152                 return ret;
153         data = (unsigned char)ret & MAX8649_VOL_MASK;
154         return max8649_list_voltage(rdev, data);
155 }
156
157 static int max8649_set_voltage(struct regulator_dev *rdev,
158                                int min_uV, int max_uV, unsigned *selector)
159 {
160         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
161         unsigned char data, mask;
162
163         if (check_range(min_uV, max_uV)) {
164                 dev_err(info->dev, "invalid voltage range (%d, %d) uV\n",
165                         min_uV, max_uV);
166                 return -EINVAL;
167         }
168         data = (min_uV - MAX8649_DCDC_VMIN + MAX8649_DCDC_STEP - 1)
169                 / MAX8649_DCDC_STEP;
170         mask = MAX8649_VOL_MASK;
171         *selector = data & mask;
172
173         return max8649_set_bits(info->i2c, info->vol_reg, mask, data);
174 }
175
176 /* EN_PD means pulldown on EN input */
177 static int max8649_enable(struct regulator_dev *rdev)
178 {
179         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
180         return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD, 0);
181 }
182
183 /*
184  * Applied internal pulldown resistor on EN input pin.
185  * If pulldown EN pin outside, it would be better.
186  */
187 static int max8649_disable(struct regulator_dev *rdev)
188 {
189         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
190         return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD,
191                                 MAX8649_EN_PD);
192 }
193
194 static int max8649_is_enabled(struct regulator_dev *rdev)
195 {
196         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
197         int ret;
198
199         ret = max8649_reg_read(info->i2c, MAX8649_CONTROL);
200         if (ret < 0)
201                 return ret;
202         return !((unsigned char)ret & MAX8649_EN_PD);
203 }
204
205 static int max8649_enable_time(struct regulator_dev *rdev)
206 {
207         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
208         int voltage, rate, ret;
209
210         /* get voltage */
211         ret = max8649_reg_read(info->i2c, info->vol_reg);
212         if (ret < 0)
213                 return ret;
214         ret &= MAX8649_VOL_MASK;
215         voltage = max8649_list_voltage(rdev, (unsigned char)ret); /* uV */
216
217         /* get rate */
218         ret = max8649_reg_read(info->i2c, MAX8649_RAMP);
219         if (ret < 0)
220                 return ret;
221         ret = (ret & MAX8649_RAMP_MASK) >> 5;
222         rate = (32 * 1000) >> ret;      /* uV/uS */
223
224         return (voltage / rate);
225 }
226
227 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode)
228 {
229         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
230
231         switch (mode) {
232         case REGULATOR_MODE_FAST:
233                 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_FORCE_PWM,
234                                  MAX8649_FORCE_PWM);
235                 break;
236         case REGULATOR_MODE_NORMAL:
237                 max8649_set_bits(info->i2c, info->vol_reg,
238                                  MAX8649_FORCE_PWM, 0);
239                 break;
240         default:
241                 return -EINVAL;
242         }
243         return 0;
244 }
245
246 static unsigned int max8649_get_mode(struct regulator_dev *rdev)
247 {
248         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
249         int ret;
250
251         ret = max8649_reg_read(info->i2c, info->vol_reg);
252         if (ret & MAX8649_FORCE_PWM)
253                 return REGULATOR_MODE_FAST;
254         return REGULATOR_MODE_NORMAL;
255 }
256
257 static struct regulator_ops max8649_dcdc_ops = {
258         .set_voltage    = max8649_set_voltage,
259         .get_voltage    = max8649_get_voltage,
260         .list_voltage   = max8649_list_voltage,
261         .enable         = max8649_enable,
262         .disable        = max8649_disable,
263         .is_enabled     = max8649_is_enabled,
264         .enable_time    = max8649_enable_time,
265         .set_mode       = max8649_set_mode,
266         .get_mode       = max8649_get_mode,
267
268 };
269
270 static struct regulator_desc dcdc_desc = {
271         .name           = "max8649",
272         .ops            = &max8649_dcdc_ops,
273         .type           = REGULATOR_VOLTAGE,
274         .n_voltages     = 1 << 6,
275         .owner          = THIS_MODULE,
276 };
277
278 static int __devinit max8649_regulator_probe(struct i2c_client *client,
279                                              const struct i2c_device_id *id)
280 {
281         struct max8649_platform_data *pdata = client->dev.platform_data;
282         struct max8649_regulator_info *info = NULL;
283         unsigned char data;
284         int ret;
285
286         info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL);
287         if (!info) {
288                 dev_err(&client->dev, "No enough memory\n");
289                 return -ENOMEM;
290         }
291
292         info->i2c = client;
293         info->dev = &client->dev;
294         mutex_init(&info->io_lock);
295         i2c_set_clientdata(client, info);
296
297         info->mode = pdata->mode;
298         switch (info->mode) {
299         case 0:
300                 info->vol_reg = MAX8649_MODE0;
301                 break;
302         case 1:
303                 info->vol_reg = MAX8649_MODE1;
304                 break;
305         case 2:
306                 info->vol_reg = MAX8649_MODE2;
307                 break;
308         case 3:
309                 info->vol_reg = MAX8649_MODE3;
310                 break;
311         default:
312                 break;
313         }
314
315         ret = max8649_reg_read(info->i2c, MAX8649_CHIP_ID1);
316         if (ret < 0) {
317                 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n",
318                         ret);
319                 goto out;
320         }
321         dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", ret);
322
323         /* enable VID0 & VID1 */
324         max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_VID_MASK, 0);
325
326         /* enable/disable external clock synchronization */
327         info->extclk = pdata->extclk;
328         data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
329         max8649_set_bits(info->i2c, info->vol_reg, MAX8649_SYNC_EXTCLK, data);
330         if (info->extclk) {
331                 /* set external clock frequency */
332                 info->extclk_freq = pdata->extclk_freq;
333                 max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK,
334                                  info->extclk_freq << 6);
335         }
336
337         if (pdata->ramp_timing) {
338                 info->ramp_timing = pdata->ramp_timing;
339                 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_MASK,
340                                  info->ramp_timing << 5);
341         }
342
343         info->ramp_down = pdata->ramp_down;
344         if (info->ramp_down) {
345                 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_DOWN,
346                                  MAX8649_RAMP_DOWN);
347         }
348
349         info->regulator = regulator_register(&dcdc_desc, &client->dev,
350                                              pdata->regulator, info);
351         if (IS_ERR(info->regulator)) {
352                 dev_err(info->dev, "failed to register regulator %s\n",
353                         dcdc_desc.name);
354                 ret = PTR_ERR(info->regulator);
355                 goto out;
356         }
357
358         dev_info(info->dev, "Max8649 regulator device is detected.\n");
359         return 0;
360 out:
361         kfree(info);
362         return ret;
363 }
364
365 static int __devexit max8649_regulator_remove(struct i2c_client *client)
366 {
367         struct max8649_regulator_info *info = i2c_get_clientdata(client);
368
369         if (info) {
370                 if (info->regulator)
371                         regulator_unregister(info->regulator);
372                 kfree(info);
373         }
374
375         return 0;
376 }
377
378 static const struct i2c_device_id max8649_id[] = {
379         { "max8649", 0 },
380         { }
381 };
382 MODULE_DEVICE_TABLE(i2c, max8649_id);
383
384 static struct i2c_driver max8649_driver = {
385         .probe          = max8649_regulator_probe,
386         .remove         = __devexit_p(max8649_regulator_remove),
387         .driver         = {
388                 .name   = "max8649",
389         },
390         .id_table       = max8649_id,
391 };
392
393 static int __init max8649_init(void)
394 {
395         return i2c_add_driver(&max8649_driver);
396 }
397 subsys_initcall(max8649_init);
398
399 static void __exit max8649_exit(void)
400 {
401         i2c_del_driver(&max8649_driver);
402 }
403 module_exit(max8649_exit);
404
405 /* Module information */
406 MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver");
407 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
408 MODULE_LICENSE("GPL");
409