2 * Voltage and current regulation for AD5398 and AD5821
4 * Copyright 2010 Analog Devices Inc.
6 * Enter bugs at http://blackfin.uclinux.org/
8 * Licensed under the GPL-2 or later.
11 #include <linux/module.h>
12 #include <linux/err.h>
13 #include <linux/i2c.h>
14 #include <linux/slab.h>
15 #include <linux/platform_device.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/regulator/machine.h>
19 #define AD5398_CURRENT_EN_MASK 0x8000
21 struct ad5398_chip_info
{
22 struct i2c_client
*client
;
25 unsigned int current_level
;
26 unsigned int current_mask
;
27 unsigned int current_offset
;
28 struct regulator_dev
*rdev
;
31 static int ad5398_calc_current(struct ad5398_chip_info
*chip
,
34 unsigned range_uA
= chip
->max_uA
- chip
->min_uA
;
36 return chip
->min_uA
+ (selector
* range_uA
/ chip
->current_level
);
39 static int ad5398_read_reg(struct i2c_client
*client
, unsigned short *data
)
44 ret
= i2c_master_recv(client
, (char *)&val
, 2);
46 dev_err(&client
->dev
, "I2C read error\n");
49 *data
= be16_to_cpu(val
);
54 static int ad5398_write_reg(struct i2c_client
*client
, const unsigned short data
)
59 val
= cpu_to_be16(data
);
60 ret
= i2c_master_send(client
, (char *)&val
, 2);
62 dev_err(&client
->dev
, "I2C write error\n");
67 static int ad5398_get_current_limit(struct regulator_dev
*rdev
)
69 struct ad5398_chip_info
*chip
= rdev_get_drvdata(rdev
);
70 struct i2c_client
*client
= chip
->client
;
74 ret
= ad5398_read_reg(client
, &data
);
78 ret
= (data
& chip
->current_mask
) >> chip
->current_offset
;
80 return ad5398_calc_current(chip
, ret
);
83 static int ad5398_set_current_limit(struct regulator_dev
*rdev
, int min_uA
, int max_uA
)
85 struct ad5398_chip_info
*chip
= rdev_get_drvdata(rdev
);
86 struct i2c_client
*client
= chip
->client
;
87 unsigned range_uA
= chip
->max_uA
- chip
->min_uA
;
92 if (min_uA
< chip
->min_uA
)
93 min_uA
= chip
->min_uA
;
94 if (max_uA
> chip
->max_uA
)
95 max_uA
= chip
->max_uA
;
97 if (min_uA
> chip
->max_uA
|| max_uA
< chip
->min_uA
)
100 selector
= DIV_ROUND_UP((min_uA
- chip
->min_uA
) * chip
->current_level
,
102 if (ad5398_calc_current(chip
, selector
) > max_uA
)
105 dev_dbg(&client
->dev
, "changing current %duA\n",
106 ad5398_calc_current(chip
, selector
));
108 /* read chip enable bit */
109 ret
= ad5398_read_reg(client
, &data
);
113 /* prepare register data */
114 selector
= (selector
<< chip
->current_offset
) & chip
->current_mask
;
115 data
= (unsigned short)selector
| (data
& AD5398_CURRENT_EN_MASK
);
117 /* write the new current value back as well as enable bit */
118 ret
= ad5398_write_reg(client
, data
);
123 static int ad5398_is_enabled(struct regulator_dev
*rdev
)
125 struct ad5398_chip_info
*chip
= rdev_get_drvdata(rdev
);
126 struct i2c_client
*client
= chip
->client
;
130 ret
= ad5398_read_reg(client
, &data
);
134 if (data
& AD5398_CURRENT_EN_MASK
)
140 static int ad5398_enable(struct regulator_dev
*rdev
)
142 struct ad5398_chip_info
*chip
= rdev_get_drvdata(rdev
);
143 struct i2c_client
*client
= chip
->client
;
147 ret
= ad5398_read_reg(client
, &data
);
151 if (data
& AD5398_CURRENT_EN_MASK
)
154 data
|= AD5398_CURRENT_EN_MASK
;
156 ret
= ad5398_write_reg(client
, data
);
161 static int ad5398_disable(struct regulator_dev
*rdev
)
163 struct ad5398_chip_info
*chip
= rdev_get_drvdata(rdev
);
164 struct i2c_client
*client
= chip
->client
;
168 ret
= ad5398_read_reg(client
, &data
);
172 if (!(data
& AD5398_CURRENT_EN_MASK
))
175 data
&= ~AD5398_CURRENT_EN_MASK
;
177 ret
= ad5398_write_reg(client
, data
);
182 static struct regulator_ops ad5398_ops
= {
183 .get_current_limit
= ad5398_get_current_limit
,
184 .set_current_limit
= ad5398_set_current_limit
,
185 .enable
= ad5398_enable
,
186 .disable
= ad5398_disable
,
187 .is_enabled
= ad5398_is_enabled
,
190 static const struct regulator_desc ad5398_reg
= {
194 .type
= REGULATOR_CURRENT
,
195 .owner
= THIS_MODULE
,
198 struct ad5398_current_data_format
{
205 static const struct ad5398_current_data_format df_10_4_120
= {10, 4, 0, 120000};
207 static const struct i2c_device_id ad5398_id
[] = {
208 { "ad5398", (kernel_ulong_t
)&df_10_4_120
},
209 { "ad5821", (kernel_ulong_t
)&df_10_4_120
},
212 MODULE_DEVICE_TABLE(i2c
, ad5398_id
);
214 static int ad5398_probe(struct i2c_client
*client
,
215 const struct i2c_device_id
*id
)
217 struct regulator_init_data
*init_data
= dev_get_platdata(&client
->dev
);
218 struct regulator_config config
= { };
219 struct ad5398_chip_info
*chip
;
220 const struct ad5398_current_data_format
*df
=
221 (struct ad5398_current_data_format
*)id
->driver_data
;
227 chip
= devm_kzalloc(&client
->dev
, sizeof(*chip
), GFP_KERNEL
);
231 config
.dev
= &client
->dev
;
232 config
.init_data
= init_data
;
233 config
.driver_data
= chip
;
235 chip
->client
= client
;
237 chip
->min_uA
= df
->min_uA
;
238 chip
->max_uA
= df
->max_uA
;
239 chip
->current_level
= 1 << df
->current_bits
;
240 chip
->current_offset
= df
->current_offset
;
241 chip
->current_mask
= (chip
->current_level
- 1) << chip
->current_offset
;
243 chip
->rdev
= regulator_register(&ad5398_reg
, &config
);
244 if (IS_ERR(chip
->rdev
)) {
245 ret
= PTR_ERR(chip
->rdev
);
246 dev_err(&client
->dev
, "failed to register %s %s\n",
247 id
->name
, ad5398_reg
.name
);
251 i2c_set_clientdata(client
, chip
);
252 dev_dbg(&client
->dev
, "%s regulator driver is registered.\n", id
->name
);
259 static int ad5398_remove(struct i2c_client
*client
)
261 struct ad5398_chip_info
*chip
= i2c_get_clientdata(client
);
263 regulator_unregister(chip
->rdev
);
267 static struct i2c_driver ad5398_driver
= {
268 .probe
= ad5398_probe
,
269 .remove
= ad5398_remove
,
273 .id_table
= ad5398_id
,
276 static int __init
ad5398_init(void)
278 return i2c_add_driver(&ad5398_driver
);
280 subsys_initcall(ad5398_init
);
282 static void __exit
ad5398_exit(void)
284 i2c_del_driver(&ad5398_driver
);
286 module_exit(ad5398_exit
);
288 MODULE_DESCRIPTION("AD5398 and AD5821 current regulator driver");
289 MODULE_AUTHOR("Sonic Zhang");
290 MODULE_LICENSE("GPL");
291 MODULE_ALIAS("i2c:ad5398-regulator");