blob: bfc4c5ffdc966f3ab03081259faf52adce239906 [file] [log] [blame]
Haojian Zhuanga71b7972010-01-25 10:24:09 -05001/*
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Haojian Zhuanga71b7972010-01-25 10:24:09 -050018#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
50struct 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
66static 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
82static 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
97static 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
112static 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);
126out:
127 mutex_unlock(&info->io_lock);
128 return ret;
129}
130
131static 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
139static int max8649_list_voltage(struct regulator_dev *rdev, unsigned index)
140{
141 return (MAX8649_DCDC_VMIN + index * MAX8649_DCDC_STEP);
142}
143
144static 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
157static int max8649_set_voltage(struct regulator_dev *rdev,
158 int min_uV, int max_uV)
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
172 return max8649_set_bits(info->i2c, info->vol_reg, mask, data);
173}
174
175/* EN_PD means pulldown on EN input */
176static int max8649_enable(struct regulator_dev *rdev)
177{
178 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
179 return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD, 0);
180}
181
182/*
183 * Applied internal pulldown resistor on EN input pin.
184 * If pulldown EN pin outside, it would be better.
185 */
186static int max8649_disable(struct regulator_dev *rdev)
187{
188 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
189 return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD,
190 MAX8649_EN_PD);
191}
192
193static int max8649_is_enabled(struct regulator_dev *rdev)
194{
195 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
196 int ret;
197
198 ret = max8649_reg_read(info->i2c, MAX8649_CONTROL);
199 if (ret < 0)
200 return ret;
201 return !((unsigned char)ret & MAX8649_EN_PD);
202}
203
204static int max8649_enable_time(struct regulator_dev *rdev)
205{
206 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
207 int voltage, rate, ret;
208
209 /* get voltage */
210 ret = max8649_reg_read(info->i2c, info->vol_reg);
211 if (ret < 0)
212 return ret;
213 ret &= MAX8649_VOL_MASK;
214 voltage = max8649_list_voltage(rdev, (unsigned char)ret); /* uV */
215
216 /* get rate */
217 ret = max8649_reg_read(info->i2c, MAX8649_RAMP);
218 if (ret < 0)
219 return ret;
220 ret = (ret & MAX8649_RAMP_MASK) >> 5;
221 rate = (32 * 1000) >> ret; /* uV/uS */
222
223 return (voltage / rate);
224}
225
226static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode)
227{
228 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
229
230 switch (mode) {
231 case REGULATOR_MODE_FAST:
232 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_FORCE_PWM,
233 MAX8649_FORCE_PWM);
234 break;
235 case REGULATOR_MODE_NORMAL:
236 max8649_set_bits(info->i2c, info->vol_reg,
237 MAX8649_FORCE_PWM, 0);
238 break;
239 default:
240 return -EINVAL;
241 }
242 return 0;
243}
244
245static unsigned int max8649_get_mode(struct regulator_dev *rdev)
246{
247 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
248 int ret;
249
250 ret = max8649_reg_read(info->i2c, info->vol_reg);
251 if (ret & MAX8649_FORCE_PWM)
252 return REGULATOR_MODE_FAST;
253 return REGULATOR_MODE_NORMAL;
254}
255
256static struct regulator_ops max8649_dcdc_ops = {
257 .set_voltage = max8649_set_voltage,
258 .get_voltage = max8649_get_voltage,
259 .list_voltage = max8649_list_voltage,
260 .enable = max8649_enable,
261 .disable = max8649_disable,
262 .is_enabled = max8649_is_enabled,
263 .enable_time = max8649_enable_time,
264 .set_mode = max8649_set_mode,
265 .get_mode = max8649_get_mode,
266
267};
268
269static struct regulator_desc dcdc_desc = {
270 .name = "max8649",
271 .ops = &max8649_dcdc_ops,
272 .type = REGULATOR_VOLTAGE,
273 .n_voltages = 1 << 6,
274 .owner = THIS_MODULE,
275};
276
277static int __devinit max8649_regulator_probe(struct i2c_client *client,
278 const struct i2c_device_id *id)
279{
280 struct max8649_platform_data *pdata = client->dev.platform_data;
281 struct max8649_regulator_info *info = NULL;
282 unsigned char data;
283 int ret;
284
285 info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL);
286 if (!info) {
287 dev_err(&client->dev, "No enough memory\n");
288 return -ENOMEM;
289 }
290
291 info->i2c = client;
292 info->dev = &client->dev;
293 mutex_init(&info->io_lock);
294 i2c_set_clientdata(client, info);
295
296 info->mode = pdata->mode;
297 switch (info->mode) {
298 case 0:
299 info->vol_reg = MAX8649_MODE0;
300 break;
301 case 1:
302 info->vol_reg = MAX8649_MODE1;
303 break;
304 case 2:
305 info->vol_reg = MAX8649_MODE2;
306 break;
307 case 3:
308 info->vol_reg = MAX8649_MODE3;
309 break;
310 default:
311 break;
312 }
313
314 ret = max8649_reg_read(info->i2c, MAX8649_CHIP_ID1);
315 if (ret < 0) {
316 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n",
317 ret);
318 goto out;
319 }
320 dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", ret);
321
322 /* enable VID0 & VID1 */
323 max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_VID_MASK, 0);
324
325 /* enable/disable external clock synchronization */
326 info->extclk = pdata->extclk;
327 data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
328 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_SYNC_EXTCLK, data);
329 if (info->extclk) {
330 /* set external clock frequency */
331 info->extclk_freq = pdata->extclk_freq;
332 max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK,
333 info->extclk_freq);
334 }
335
336 if (pdata->ramp_timing) {
337 info->ramp_timing = pdata->ramp_timing;
338 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_MASK,
339 info->ramp_timing << 5);
340 }
341
342 info->ramp_down = pdata->ramp_down;
343 if (info->ramp_down) {
344 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_DOWN,
345 MAX8649_RAMP_DOWN);
346 }
347
348 info->regulator = regulator_register(&dcdc_desc, &client->dev,
349 pdata->regulator, info);
350 if (IS_ERR(info->regulator)) {
351 dev_err(info->dev, "failed to register regulator %s\n",
352 dcdc_desc.name);
353 ret = PTR_ERR(info->regulator);
354 goto out;
355 }
356
357 dev_info(info->dev, "Max8649 regulator device is detected.\n");
358 return 0;
359out:
Wolfram Sang8b4709e2010-03-20 15:12:58 +0100360 i2c_set_clientdata(client, NULL);
Haojian Zhuanga71b7972010-01-25 10:24:09 -0500361 kfree(info);
362 return ret;
363}
364
365static 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);
Wolfram Sang8b4709e2010-03-20 15:12:58 +0100372 i2c_set_clientdata(client, NULL);
Haojian Zhuanga71b7972010-01-25 10:24:09 -0500373 kfree(info);
374 }
Haojian Zhuanga71b7972010-01-25 10:24:09 -0500375
376 return 0;
377}
378
379static const struct i2c_device_id max8649_id[] = {
380 { "max8649", 0 },
381 { }
382};
383MODULE_DEVICE_TABLE(i2c, max8649_id);
384
385static struct i2c_driver max8649_driver = {
386 .probe = max8649_regulator_probe,
387 .remove = __devexit_p(max8649_regulator_remove),
388 .driver = {
389 .name = "max8649",
390 },
391 .id_table = max8649_id,
392};
393
394static int __init max8649_init(void)
395{
396 return i2c_add_driver(&max8649_driver);
397}
398subsys_initcall(max8649_init);
399
400static void __exit max8649_exit(void)
401{
402 i2c_del_driver(&max8649_driver);
403}
404module_exit(max8649_exit);
405
406/* Module information */
407MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver");
408MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
409MODULE_LICENSE("GPL");
410