Commit | Line | Data |
---|---|---|
8b385d9b SZ |
1 | /* |
2 | * Voltage and current regulation for AD5398 and AD5821 | |
3 | * | |
4 | * Copyright 2010 Analog Devices Inc. | |
5 | * | |
6 | * Enter bugs at http://blackfin.uclinux.org/ | |
7 | * | |
8 | * Licensed under the GPL-2 or later. | |
9 | */ | |
10 | ||
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> | |
18 | ||
19 | #define AD5398_CURRENT_EN_MASK 0x8000 | |
20 | ||
21 | struct ad5398_chip_info { | |
22 | struct i2c_client *client; | |
23 | int min_uA; | |
24 | int max_uA; | |
25 | unsigned int current_level; | |
26 | unsigned int current_mask; | |
27 | unsigned int current_offset; | |
58d463ee | 28 | struct regulator_dev *rdev; |
8b385d9b SZ |
29 | }; |
30 | ||
31 | static int ad5398_calc_current(struct ad5398_chip_info *chip, | |
32 | unsigned selector) | |
33 | { | |
34 | unsigned range_uA = chip->max_uA - chip->min_uA; | |
35 | ||
36 | return chip->min_uA + (selector * range_uA / chip->current_level); | |
37 | } | |
38 | ||
39 | static int ad5398_read_reg(struct i2c_client *client, unsigned short *data) | |
40 | { | |
41 | unsigned short val; | |
42 | int ret; | |
43 | ||
44 | ret = i2c_master_recv(client, (char *)&val, 2); | |
45 | if (ret < 0) { | |
46 | dev_err(&client->dev, "I2C read error\n"); | |
47 | return ret; | |
48 | } | |
49 | *data = be16_to_cpu(val); | |
50 | ||
51 | return ret; | |
52 | } | |
53 | ||
54 | static int ad5398_write_reg(struct i2c_client *client, const unsigned short data) | |
55 | { | |
56 | unsigned short val; | |
57 | int ret; | |
58 | ||
59 | val = cpu_to_be16(data); | |
60 | ret = i2c_master_send(client, (char *)&val, 2); | |
61 | if (ret < 0) | |
62 | dev_err(&client->dev, "I2C write error\n"); | |
63 | ||
64 | return ret; | |
65 | } | |
66 | ||
67 | static int ad5398_get_current_limit(struct regulator_dev *rdev) | |
68 | { | |
69 | struct ad5398_chip_info *chip = rdev_get_drvdata(rdev); | |
70 | struct i2c_client *client = chip->client; | |
71 | unsigned short data; | |
72 | int ret; | |
73 | ||
74 | ret = ad5398_read_reg(client, &data); | |
75 | if (ret < 0) | |
76 | return ret; | |
77 | ||
78 | ret = (data & chip->current_mask) >> chip->current_offset; | |
79 | ||
80 | return ad5398_calc_current(chip, ret); | |
81 | } | |
82 | ||
83 | static int ad5398_set_current_limit(struct regulator_dev *rdev, int min_uA, int max_uA) | |
84 | { | |
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; | |
88 | unsigned selector; | |
89 | unsigned short data; | |
90 | int ret; | |
91 | ||
9c6a74c5 AL |
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; | |
96 | ||
97 | if (min_uA > chip->max_uA || max_uA < chip->min_uA) | |
8b385d9b SZ |
98 | return -EINVAL; |
99 | ||
8148ed6e AL |
100 | selector = DIV_ROUND_UP((min_uA - chip->min_uA) * chip->current_level, |
101 | range_uA); | |
8b385d9b SZ |
102 | if (ad5398_calc_current(chip, selector) > max_uA) |
103 | return -EINVAL; | |
104 | ||
935c14a2 AL |
105 | dev_dbg(&client->dev, "changing current %duA\n", |
106 | ad5398_calc_current(chip, selector)); | |
8b385d9b SZ |
107 | |
108 | /* read chip enable bit */ | |
109 | ret = ad5398_read_reg(client, &data); | |
110 | if (ret < 0) | |
111 | return ret; | |
112 | ||
113 | /* prepare register data */ | |
114 | selector = (selector << chip->current_offset) & chip->current_mask; | |
115 | data = (unsigned short)selector | (data & AD5398_CURRENT_EN_MASK); | |
116 | ||
117 | /* write the new current value back as well as enable bit */ | |
118 | ret = ad5398_write_reg(client, data); | |
119 | ||
120 | return ret; | |
121 | } | |
122 | ||
123 | static int ad5398_is_enabled(struct regulator_dev *rdev) | |
124 | { | |
125 | struct ad5398_chip_info *chip = rdev_get_drvdata(rdev); | |
126 | struct i2c_client *client = chip->client; | |
127 | unsigned short data; | |
128 | int ret; | |
129 | ||
130 | ret = ad5398_read_reg(client, &data); | |
131 | if (ret < 0) | |
132 | return ret; | |
133 | ||
134 | if (data & AD5398_CURRENT_EN_MASK) | |
135 | return 1; | |
136 | else | |
137 | return 0; | |
138 | } | |
139 | ||
140 | static int ad5398_enable(struct regulator_dev *rdev) | |
141 | { | |
142 | struct ad5398_chip_info *chip = rdev_get_drvdata(rdev); | |
143 | struct i2c_client *client = chip->client; | |
144 | unsigned short data; | |
145 | int ret; | |
146 | ||
147 | ret = ad5398_read_reg(client, &data); | |
148 | if (ret < 0) | |
149 | return ret; | |
150 | ||
151 | if (data & AD5398_CURRENT_EN_MASK) | |
152 | return 0; | |
153 | ||
154 | data |= AD5398_CURRENT_EN_MASK; | |
155 | ||
156 | ret = ad5398_write_reg(client, data); | |
157 | ||
158 | return ret; | |
159 | } | |
160 | ||
161 | static int ad5398_disable(struct regulator_dev *rdev) | |
162 | { | |
163 | struct ad5398_chip_info *chip = rdev_get_drvdata(rdev); | |
164 | struct i2c_client *client = chip->client; | |
165 | unsigned short data; | |
166 | int ret; | |
167 | ||
168 | ret = ad5398_read_reg(client, &data); | |
169 | if (ret < 0) | |
170 | return ret; | |
171 | ||
172 | if (!(data & AD5398_CURRENT_EN_MASK)) | |
173 | return 0; | |
174 | ||
175 | data &= ~AD5398_CURRENT_EN_MASK; | |
176 | ||
177 | ret = ad5398_write_reg(client, data); | |
178 | ||
179 | return ret; | |
180 | } | |
181 | ||
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, | |
188 | }; | |
189 | ||
487f71e6 | 190 | static const struct regulator_desc ad5398_reg = { |
8b385d9b SZ |
191 | .name = "isink", |
192 | .id = 0, | |
193 | .ops = &ad5398_ops, | |
194 | .type = REGULATOR_CURRENT, | |
195 | .owner = THIS_MODULE, | |
196 | }; | |
197 | ||
198 | struct ad5398_current_data_format { | |
199 | int current_bits; | |
200 | int current_offset; | |
201 | int min_uA; | |
202 | int max_uA; | |
203 | }; | |
204 | ||
205 | static const struct ad5398_current_data_format df_10_4_120 = {10, 4, 0, 120000}; | |
206 | ||
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 }, | |
210 | { } | |
211 | }; | |
212 | MODULE_DEVICE_TABLE(i2c, ad5398_id); | |
213 | ||
a5023574 | 214 | static int ad5398_probe(struct i2c_client *client, |
8b385d9b SZ |
215 | const struct i2c_device_id *id) |
216 | { | |
dff91d0b | 217 | struct regulator_init_data *init_data = dev_get_platdata(&client->dev); |
c172708d | 218 | struct regulator_config config = { }; |
8b385d9b SZ |
219 | struct ad5398_chip_info *chip; |
220 | const struct ad5398_current_data_format *df = | |
221 | (struct ad5398_current_data_format *)id->driver_data; | |
8b385d9b SZ |
222 | |
223 | if (!init_data) | |
224 | return -EINVAL; | |
225 | ||
0df8c96f | 226 | chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); |
8b385d9b SZ |
227 | if (!chip) |
228 | return -ENOMEM; | |
229 | ||
c172708d MB |
230 | config.dev = &client->dev; |
231 | config.init_data = init_data; | |
232 | config.driver_data = chip; | |
233 | ||
8b385d9b SZ |
234 | chip->client = client; |
235 | ||
236 | chip->min_uA = df->min_uA; | |
237 | chip->max_uA = df->max_uA; | |
238 | chip->current_level = 1 << df->current_bits; | |
239 | chip->current_offset = df->current_offset; | |
240 | chip->current_mask = (chip->current_level - 1) << chip->current_offset; | |
241 | ||
9b2cdac7 AL |
242 | chip->rdev = devm_regulator_register(&client->dev, &ad5398_reg, |
243 | &config); | |
58d463ee | 244 | if (IS_ERR(chip->rdev)) { |
8b385d9b SZ |
245 | dev_err(&client->dev, "failed to register %s %s\n", |
246 | id->name, ad5398_reg.name); | |
9b2cdac7 | 247 | return PTR_ERR(chip->rdev); |
8b385d9b SZ |
248 | } |
249 | ||
250 | i2c_set_clientdata(client, chip); | |
251 | dev_dbg(&client->dev, "%s regulator driver is registered.\n", id->name); | |
252 | return 0; | |
8b385d9b SZ |
253 | } |
254 | ||
255 | static struct i2c_driver ad5398_driver = { | |
256 | .probe = ad5398_probe, | |
8b385d9b SZ |
257 | .driver = { |
258 | .name = "ad5398", | |
259 | }, | |
260 | .id_table = ad5398_id, | |
261 | }; | |
262 | ||
263 | static int __init ad5398_init(void) | |
264 | { | |
265 | return i2c_add_driver(&ad5398_driver); | |
266 | } | |
839b8362 | 267 | subsys_initcall(ad5398_init); |
8b385d9b SZ |
268 | |
269 | static void __exit ad5398_exit(void) | |
270 | { | |
271 | i2c_del_driver(&ad5398_driver); | |
272 | } | |
273 | module_exit(ad5398_exit); | |
274 | ||
275 | MODULE_DESCRIPTION("AD5398 and AD5821 current regulator driver"); | |
276 | MODULE_AUTHOR("Sonic Zhang"); | |
277 | MODULE_LICENSE("GPL"); |