2 * Regulators driver for Maxim max8649
4 * Copyright (C) 2009-2010 Marvell International Ltd.
5 * Haojian Zhuang <haojian.zhuang@marvell.com>
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.
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/regulator/max8649.h>
19 #define MAX8649_DCDC_VMIN 750000 /* uV */
20 #define MAX8649_DCDC_VMAX 1380000 /* uV */
21 #define MAX8649_DCDC_STEP 10000 /* uV */
22 #define MAX8649_VOL_MASK 0x3f
25 #define MAX8649_MODE0 0x00
26 #define MAX8649_MODE1 0x01
27 #define MAX8649_MODE2 0x02
28 #define MAX8649_MODE3 0x03
29 #define MAX8649_CONTROL 0x04
30 #define MAX8649_SYNC 0x05
31 #define MAX8649_RAMP 0x06
32 #define MAX8649_CHIP_ID1 0x08
33 #define MAX8649_CHIP_ID2 0x09
36 #define MAX8649_EN_PD (1 << 7)
37 #define MAX8649_VID0_PD (1 << 6)
38 #define MAX8649_VID1_PD (1 << 5)
39 #define MAX8649_VID_MASK (3 << 5)
41 #define MAX8649_FORCE_PWM (1 << 7)
42 #define MAX8649_SYNC_EXTCLK (1 << 6)
44 #define MAX8649_EXT_MASK (3 << 6)
46 #define MAX8649_RAMP_MASK (7 << 5)
47 #define MAX8649_RAMP_DOWN (1 << 1)
49 struct max8649_regulator_info {
50 struct regulator_dev *regulator;
51 struct i2c_client *i2c;
56 unsigned mode:2; /* bit[1:0] = VID1, VID0 */
57 unsigned extclk_freq:2;
59 unsigned ramp_timing:3;
65 static inline int max8649_read_device(struct i2c_client *i2c,
66 int reg, int bytes, void *dest)
71 data = (unsigned char)reg;
72 ret = i2c_master_send(i2c, &data, 1);
75 ret = i2c_master_recv(i2c, dest, bytes);
81 static inline int max8649_write_device(struct i2c_client *i2c,
82 int reg, int bytes, void *src)
84 unsigned char buf[bytes + 1];
87 buf[0] = (unsigned char)reg;
88 memcpy(&buf[1], src, bytes);
90 ret = i2c_master_send(i2c, buf, bytes + 1);
96 static int max8649_reg_read(struct i2c_client *i2c, int reg)
98 struct max8649_regulator_info *info = i2c_get_clientdata(i2c);
102 mutex_lock(&info->io_lock);
103 ret = max8649_read_device(i2c, reg, 1, &data);
104 mutex_unlock(&info->io_lock);
111 static int max8649_set_bits(struct i2c_client *i2c, int reg,
112 unsigned char mask, unsigned char data)
114 struct max8649_regulator_info *info = i2c_get_clientdata(i2c);
118 mutex_lock(&info->io_lock);
119 ret = max8649_read_device(i2c, reg, 1, &value);
124 ret = max8649_write_device(i2c, reg, 1, &value);
126 mutex_unlock(&info->io_lock);
130 static inline int check_range(int min_uV, int max_uV)
132 if ((min_uV < MAX8649_DCDC_VMIN) || (max_uV > MAX8649_DCDC_VMAX)
133 || (min_uV > max_uV))
138 static int max8649_list_voltage(struct regulator_dev *rdev, unsigned index)
140 return (MAX8649_DCDC_VMIN + index * MAX8649_DCDC_STEP);
143 static int max8649_get_voltage(struct regulator_dev *rdev)
145 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
149 ret = max8649_reg_read(info->i2c, info->vol_reg);
152 data = (unsigned char)ret & MAX8649_VOL_MASK;
153 return max8649_list_voltage(rdev, data);
156 static int max8649_set_voltage(struct regulator_dev *rdev,
157 int min_uV, int max_uV)
159 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
160 unsigned char data, mask;
162 if (check_range(min_uV, max_uV)) {
163 dev_err(info->dev, "invalid voltage range (%d, %d) uV\n",
167 data = (min_uV - MAX8649_DCDC_VMIN + MAX8649_DCDC_STEP - 1)
169 mask = MAX8649_VOL_MASK;
171 return max8649_set_bits(info->i2c, info->vol_reg, mask, data);
174 /* EN_PD means pulldown on EN input */
175 static int max8649_enable(struct regulator_dev *rdev)
177 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
178 return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD, 0);
182 * Applied internal pulldown resistor on EN input pin.
183 * If pulldown EN pin outside, it would be better.
185 static int max8649_disable(struct regulator_dev *rdev)
187 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
188 return max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_EN_PD,
192 static int max8649_is_enabled(struct regulator_dev *rdev)
194 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
197 ret = max8649_reg_read(info->i2c, MAX8649_CONTROL);
200 return !((unsigned char)ret & MAX8649_EN_PD);
203 static int max8649_enable_time(struct regulator_dev *rdev)
205 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
206 int voltage, rate, ret;
209 ret = max8649_reg_read(info->i2c, info->vol_reg);
212 ret &= MAX8649_VOL_MASK;
213 voltage = max8649_list_voltage(rdev, (unsigned char)ret); /* uV */
216 ret = max8649_reg_read(info->i2c, MAX8649_RAMP);
219 ret = (ret & MAX8649_RAMP_MASK) >> 5;
220 rate = (32 * 1000) >> ret; /* uV/uS */
222 return (voltage / rate);
225 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode)
227 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
230 case REGULATOR_MODE_FAST:
231 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_FORCE_PWM,
234 case REGULATOR_MODE_NORMAL:
235 max8649_set_bits(info->i2c, info->vol_reg,
236 MAX8649_FORCE_PWM, 0);
244 static unsigned int max8649_get_mode(struct regulator_dev *rdev)
246 struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
249 ret = max8649_reg_read(info->i2c, info->vol_reg);
250 if (ret & MAX8649_FORCE_PWM)
251 return REGULATOR_MODE_FAST;
252 return REGULATOR_MODE_NORMAL;
255 static struct regulator_ops max8649_dcdc_ops = {
256 .set_voltage = max8649_set_voltage,
257 .get_voltage = max8649_get_voltage,
258 .list_voltage = max8649_list_voltage,
259 .enable = max8649_enable,
260 .disable = max8649_disable,
261 .is_enabled = max8649_is_enabled,
262 .enable_time = max8649_enable_time,
263 .set_mode = max8649_set_mode,
264 .get_mode = max8649_get_mode,
268 static struct regulator_desc dcdc_desc = {
270 .ops = &max8649_dcdc_ops,
271 .type = REGULATOR_VOLTAGE,
272 .n_voltages = 1 << 6,
273 .owner = THIS_MODULE,
276 static int __devinit max8649_regulator_probe(struct i2c_client *client,
277 const struct i2c_device_id *id)
279 struct max8649_platform_data *pdata = client->dev.platform_data;
280 struct max8649_regulator_info *info = NULL;
284 info = kzalloc(sizeof(struct max8649_regulator_info), GFP_KERNEL);
286 dev_err(&client->dev, "No enough memory\n");
291 info->dev = &client->dev;
292 mutex_init(&info->io_lock);
293 i2c_set_clientdata(client, info);
295 info->mode = pdata->mode;
296 switch (info->mode) {
298 info->vol_reg = MAX8649_MODE0;
301 info->vol_reg = MAX8649_MODE1;
304 info->vol_reg = MAX8649_MODE2;
307 info->vol_reg = MAX8649_MODE3;
313 ret = max8649_reg_read(info->i2c, MAX8649_CHIP_ID1);
315 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n",
319 dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", ret);
321 /* enable VID0 & VID1 */
322 max8649_set_bits(info->i2c, MAX8649_CONTROL, MAX8649_VID_MASK, 0);
324 /* enable/disable external clock synchronization */
325 info->extclk = pdata->extclk;
326 data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
327 max8649_set_bits(info->i2c, info->vol_reg, MAX8649_SYNC_EXTCLK, data);
329 /* set external clock frequency */
330 info->extclk_freq = pdata->extclk_freq;
331 max8649_set_bits(info->i2c, MAX8649_SYNC, MAX8649_EXT_MASK,
335 if (pdata->ramp_timing) {
336 info->ramp_timing = pdata->ramp_timing;
337 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_MASK,
338 info->ramp_timing << 5);
341 info->ramp_down = pdata->ramp_down;
342 if (info->ramp_down) {
343 max8649_set_bits(info->i2c, MAX8649_RAMP, MAX8649_RAMP_DOWN,
347 info->regulator = regulator_register(&dcdc_desc, &client->dev,
348 pdata->regulator, info);
349 if (IS_ERR(info->regulator)) {
350 dev_err(info->dev, "failed to register regulator %s\n",
352 ret = PTR_ERR(info->regulator);
356 dev_info(info->dev, "Max8649 regulator device is detected.\n");
359 i2c_set_clientdata(client, NULL);
364 static int __devexit max8649_regulator_remove(struct i2c_client *client)
366 struct max8649_regulator_info *info = i2c_get_clientdata(client);
370 regulator_unregister(info->regulator);
371 i2c_set_clientdata(client, NULL);
378 static const struct i2c_device_id max8649_id[] = {
382 MODULE_DEVICE_TABLE(i2c, max8649_id);
384 static struct i2c_driver max8649_driver = {
385 .probe = max8649_regulator_probe,
386 .remove = __devexit_p(max8649_regulator_remove),
390 .id_table = max8649_id,
393 static int __init max8649_init(void)
395 return i2c_add_driver(&max8649_driver);
397 subsys_initcall(max8649_init);
399 static void __exit max8649_exit(void)
401 i2c_del_driver(&max8649_driver);
403 module_exit(max8649_exit);
405 /* Module information */
406 MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver");
407 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
408 MODULE_LICENSE("GPL");