2 * Regulators driver for Maxim max8925
4 * Copyright (C) 2009 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/init.h>
14 #include <linux/err.h>
15 #include <linux/i2c.h>
16 #include <linux/platform_device.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/machine.h>
19 #include <linux/mfd/max8925.h>
21 #define SD1_DVM_VMIN 850000
22 #define SD1_DVM_VMAX 1000000
23 #define SD1_DVM_STEP 50000
24 #define SD1_DVM_SHIFT 5 /* SDCTL1 bit5 */
25 #define SD1_DVM_EN 6 /* SDV1 bit 6 */
27 /* bit definitions in LDO control registers */
28 #define LDO_SEQ_I2C 0x7 /* Power U/D by i2c */
29 #define LDO_SEQ_MASK 0x7 /* Power U/D sequence mask */
30 #define LDO_SEQ_SHIFT 2 /* Power U/D sequence offset */
31 #define LDO_I2C_EN 0x1 /* Enable by i2c */
32 #define LDO_I2C_EN_MASK 0x1 /* Enable mask by i2c */
33 #define LDO_I2C_EN_SHIFT 0 /* Enable offset by i2c */
35 struct max8925_regulator_info
{
36 struct regulator_desc desc
;
37 struct regulator_dev
*regulator
;
38 struct i2c_client
*i2c
;
39 struct max8925_chip
*chip
;
48 static inline int check_range(struct max8925_regulator_info
*info
,
49 int min_uV
, int max_uV
)
51 if (min_uV
< info
->min_uV
|| min_uV
> info
->max_uV
)
57 static int max8925_list_voltage(struct regulator_dev
*rdev
, unsigned index
)
59 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
60 return info
->min_uV
+ index
* info
->step_uV
;
63 static int max8925_set_voltage(struct regulator_dev
*rdev
,
64 int min_uV
, int max_uV
, unsigned int *selector
)
66 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
67 unsigned char data
, mask
;
69 if (check_range(info
, min_uV
, max_uV
)) {
70 dev_err(info
->chip
->dev
, "invalid voltage range (%d, %d) uV\n",
74 data
= DIV_ROUND_UP(min_uV
- info
->min_uV
, info
->step_uV
);
76 mask
= rdev
->desc
->n_voltages
- 1;
78 return max8925_set_bits(info
->i2c
, info
->vol_reg
, mask
, data
);
81 static int max8925_get_voltage(struct regulator_dev
*rdev
)
83 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
84 unsigned char data
, mask
;
87 ret
= max8925_reg_read(info
->i2c
, info
->vol_reg
);
90 mask
= rdev
->desc
->n_voltages
- 1;
93 return max8925_list_voltage(rdev
, data
);
96 static int max8925_enable(struct regulator_dev
*rdev
)
98 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
100 return max8925_set_bits(info
->i2c
, info
->enable_reg
,
101 LDO_SEQ_MASK
<< LDO_SEQ_SHIFT
|
102 LDO_I2C_EN_MASK
<< LDO_I2C_EN_SHIFT
,
103 LDO_SEQ_I2C
<< LDO_SEQ_SHIFT
|
104 LDO_I2C_EN
<< LDO_I2C_EN_SHIFT
);
107 static int max8925_disable(struct regulator_dev
*rdev
)
109 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
111 return max8925_set_bits(info
->i2c
, info
->enable_reg
,
112 LDO_SEQ_MASK
<< LDO_SEQ_SHIFT
|
113 LDO_I2C_EN_MASK
<< LDO_I2C_EN_SHIFT
,
114 LDO_SEQ_I2C
<< LDO_SEQ_SHIFT
);
117 static int max8925_is_enabled(struct regulator_dev
*rdev
)
119 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
122 ret
= max8925_reg_read(info
->i2c
, info
->enable_reg
);
125 ldo_seq
= (ret
>> LDO_SEQ_SHIFT
) & LDO_SEQ_MASK
;
126 if (ldo_seq
!= LDO_SEQ_I2C
)
129 return ret
& (LDO_I2C_EN_MASK
<< LDO_I2C_EN_SHIFT
);
132 static int max8925_set_dvm_voltage(struct regulator_dev
*rdev
, int uV
)
134 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
135 unsigned char data
, mask
;
137 if (uV
< SD1_DVM_VMIN
|| uV
> SD1_DVM_VMAX
)
140 data
= DIV_ROUND_UP(uV
- SD1_DVM_VMIN
, SD1_DVM_STEP
);
141 data
<<= SD1_DVM_SHIFT
;
142 mask
= 3 << SD1_DVM_SHIFT
;
144 return max8925_set_bits(info
->i2c
, info
->enable_reg
, mask
, data
);
147 static int max8925_set_dvm_enable(struct regulator_dev
*rdev
)
149 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
151 return max8925_set_bits(info
->i2c
, info
->vol_reg
, 1 << SD1_DVM_EN
,
155 static int max8925_set_dvm_disable(struct regulator_dev
*rdev
)
157 struct max8925_regulator_info
*info
= rdev_get_drvdata(rdev
);
159 return max8925_set_bits(info
->i2c
, info
->vol_reg
, 1 << SD1_DVM_EN
, 0);
162 static struct regulator_ops max8925_regulator_sdv_ops
= {
163 .list_voltage
= max8925_list_voltage
,
164 .set_voltage
= max8925_set_voltage
,
165 .get_voltage
= max8925_get_voltage
,
166 .enable
= max8925_enable
,
167 .disable
= max8925_disable
,
168 .is_enabled
= max8925_is_enabled
,
169 .set_suspend_voltage
= max8925_set_dvm_voltage
,
170 .set_suspend_enable
= max8925_set_dvm_enable
,
171 .set_suspend_disable
= max8925_set_dvm_disable
,
174 static struct regulator_ops max8925_regulator_ldo_ops
= {
175 .list_voltage
= max8925_list_voltage
,
176 .set_voltage
= max8925_set_voltage
,
177 .get_voltage
= max8925_get_voltage
,
178 .enable
= max8925_enable
,
179 .disable
= max8925_disable
,
180 .is_enabled
= max8925_is_enabled
,
183 #define MAX8925_SDV(_id, min, max, step) \
186 .name = "SDV" #_id, \
187 .ops = &max8925_regulator_sdv_ops, \
188 .type = REGULATOR_VOLTAGE, \
189 .id = MAX8925_ID_SD##_id, \
190 .owner = THIS_MODULE, \
193 .min_uV = min * 1000, \
194 .max_uV = max * 1000, \
195 .step_uV = step * 1000, \
196 .vol_reg = MAX8925_SDV##_id, \
197 .enable_reg = MAX8925_SDCTL##_id, \
200 #define MAX8925_LDO(_id, min, max, step) \
203 .name = "LDO" #_id, \
204 .ops = &max8925_regulator_ldo_ops, \
205 .type = REGULATOR_VOLTAGE, \
206 .id = MAX8925_ID_LDO##_id, \
207 .owner = THIS_MODULE, \
210 .min_uV = min * 1000, \
211 .max_uV = max * 1000, \
212 .step_uV = step * 1000, \
213 .vol_reg = MAX8925_LDOVOUT##_id, \
214 .enable_reg = MAX8925_LDOCTL##_id, \
217 static struct max8925_regulator_info max8925_regulator_info
[] = {
218 MAX8925_SDV(1, 637.5, 1425, 12.5),
219 MAX8925_SDV(2, 650, 2225, 25),
220 MAX8925_SDV(3, 750, 3900, 50),
222 MAX8925_LDO(1, 750, 3900, 50),
223 MAX8925_LDO(2, 650, 2250, 25),
224 MAX8925_LDO(3, 650, 2250, 25),
225 MAX8925_LDO(4, 750, 3900, 50),
226 MAX8925_LDO(5, 750, 3900, 50),
227 MAX8925_LDO(6, 750, 3900, 50),
228 MAX8925_LDO(7, 750, 3900, 50),
229 MAX8925_LDO(8, 750, 3900, 50),
230 MAX8925_LDO(9, 750, 3900, 50),
231 MAX8925_LDO(10, 750, 3900, 50),
232 MAX8925_LDO(11, 750, 3900, 50),
233 MAX8925_LDO(12, 750, 3900, 50),
234 MAX8925_LDO(13, 750, 3900, 50),
235 MAX8925_LDO(14, 750, 3900, 50),
236 MAX8925_LDO(15, 750, 3900, 50),
237 MAX8925_LDO(16, 750, 3900, 50),
238 MAX8925_LDO(17, 650, 2250, 25),
239 MAX8925_LDO(18, 650, 2250, 25),
240 MAX8925_LDO(19, 750, 3900, 50),
241 MAX8925_LDO(20, 750, 3900, 50),
244 static struct max8925_regulator_info
* __devinit
find_regulator_info(int id
)
246 struct max8925_regulator_info
*ri
;
249 for (i
= 0; i
< ARRAY_SIZE(max8925_regulator_info
); i
++) {
250 ri
= &max8925_regulator_info
[i
];
251 if (ri
->desc
.id
== id
)
257 static int __devinit
max8925_regulator_probe(struct platform_device
*pdev
)
259 struct max8925_chip
*chip
= dev_get_drvdata(pdev
->dev
.parent
);
260 struct max8925_platform_data
*pdata
= chip
->dev
->platform_data
;
261 struct regulator_config config
= { };
262 struct max8925_regulator_info
*ri
;
263 struct regulator_dev
*rdev
;
265 ri
= find_regulator_info(pdev
->id
);
267 dev_err(&pdev
->dev
, "invalid regulator ID specified\n");
273 config
.dev
= &pdev
->dev
;
274 config
.init_data
= pdata
->regulator
[pdev
->id
];
275 config
.driver_data
= ri
;
277 rdev
= regulator_register(&ri
->desc
, &config
);
279 dev_err(&pdev
->dev
, "failed to register regulator %s\n",
281 return PTR_ERR(rdev
);
284 platform_set_drvdata(pdev
, rdev
);
288 static int __devexit
max8925_regulator_remove(struct platform_device
*pdev
)
290 struct regulator_dev
*rdev
= platform_get_drvdata(pdev
);
292 platform_set_drvdata(pdev
, NULL
);
293 regulator_unregister(rdev
);
298 static struct platform_driver max8925_regulator_driver
= {
300 .name
= "max8925-regulator",
301 .owner
= THIS_MODULE
,
303 .probe
= max8925_regulator_probe
,
304 .remove
= __devexit_p(max8925_regulator_remove
),
307 static int __init
max8925_regulator_init(void)
309 return platform_driver_register(&max8925_regulator_driver
);
311 subsys_initcall(max8925_regulator_init
);
313 static void __exit
max8925_regulator_exit(void)
315 platform_driver_unregister(&max8925_regulator_driver
);
317 module_exit(max8925_regulator_exit
);
319 MODULE_LICENSE("GPL");
320 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
321 MODULE_DESCRIPTION("Regulator Driver for Maxim 8925 PMIC");
322 MODULE_ALIAS("platform:max8925-regulator");