d4bc114572de2d8232497d394204c1cfc0e28d10
[linux-3.10.git] / drivers / hwmon / pmbus / lm25066.c
1 /*
2  * Hardware monitoring driver for LM25066 / LM5064 / LM5066
3  *
4  * Copyright (c) 2011 Ericsson AB.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/err.h>
25 #include <linux/slab.h>
26 #include <linux/i2c.h>
27 #include "pmbus.h"
28
29 enum chips { lm25066, lm5064, lm5066 };
30
31 #define LM25066_READ_VAUX               0xd0
32 #define LM25066_MFR_READ_IIN            0xd1
33 #define LM25066_MFR_READ_PIN            0xd2
34 #define LM25066_MFR_IIN_OC_WARN_LIMIT   0xd3
35 #define LM25066_MFR_PIN_OP_WARN_LIMIT   0xd4
36 #define LM25066_READ_PIN_PEAK           0xd5
37 #define LM25066_CLEAR_PIN_PEAK          0xd6
38 #define LM25066_DEVICE_SETUP            0xd9
39 #define LM25066_READ_AVG_VIN            0xdc
40 #define LM25066_READ_AVG_VOUT           0xdd
41 #define LM25066_READ_AVG_IIN            0xde
42 #define LM25066_READ_AVG_PIN            0xdf
43
44 #define LM25066_DEV_SETUP_CL            (1 << 4)        /* Current limit */
45
46 struct lm25066_data {
47         int id;
48         struct pmbus_driver_info info;
49 };
50
51 #define to_lm25066_data(x)  container_of(x, struct lm25066_data, info)
52
53 static int lm25066_read_word_data(struct i2c_client *client, int page, int reg)
54 {
55         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
56         const struct lm25066_data *data = to_lm25066_data(info);
57         int ret;
58
59         if (page > 1)
60                 return -EINVAL;
61
62         /* Map READ_VAUX into READ_VOUT register on page 1 */
63         if (page == 1) {
64                 switch (reg) {
65                 case PMBUS_READ_VOUT:
66                         ret = pmbus_read_word_data(client, 0,
67                                                    LM25066_READ_VAUX);
68                         if (ret < 0)
69                                 break;
70                         /* Adjust returned value to match VOUT coefficients */
71                         switch (data->id) {
72                         case lm25066:
73                                 /* VOUT: 4.54 mV VAUX: 283.2 uV LSB */
74                                 ret = DIV_ROUND_CLOSEST(ret * 2832, 45400);
75                                 break;
76                         case lm5064:
77                                 /* VOUT: 4.53 mV VAUX: 700 uV LSB */
78                                 ret = DIV_ROUND_CLOSEST(ret * 70, 453);
79                                 break;
80                         case lm5066:
81                                 /* VOUT: 2.18 mV VAUX: 725 uV LSB */
82                                 ret = DIV_ROUND_CLOSEST(ret * 725, 2180);
83                                 break;
84                         }
85                         break;
86                 default:
87                         /* No other valid registers on page 1 */
88                         ret = -EINVAL;
89                         break;
90                 }
91                 goto done;
92         }
93
94         switch (reg) {
95         case PMBUS_READ_IIN:
96                 ret = pmbus_read_word_data(client, 0, LM25066_MFR_READ_IIN);
97                 break;
98         case PMBUS_READ_PIN:
99                 ret = pmbus_read_word_data(client, 0, LM25066_MFR_READ_PIN);
100                 break;
101         case PMBUS_IIN_OC_WARN_LIMIT:
102                 ret = pmbus_read_word_data(client, 0,
103                                            LM25066_MFR_IIN_OC_WARN_LIMIT);
104                 break;
105         case PMBUS_PIN_OP_WARN_LIMIT:
106                 ret = pmbus_read_word_data(client, 0,
107                                            LM25066_MFR_PIN_OP_WARN_LIMIT);
108                 break;
109         case PMBUS_VIRT_READ_VIN_AVG:
110                 ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_VIN);
111                 break;
112         case PMBUS_VIRT_READ_VOUT_AVG:
113                 ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_VOUT);
114                 break;
115         case PMBUS_VIRT_READ_IIN_AVG:
116                 ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_IIN);
117                 break;
118         case PMBUS_VIRT_READ_PIN_AVG:
119                 ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_PIN);
120                 break;
121         case PMBUS_VIRT_READ_PIN_MAX:
122                 ret = pmbus_read_word_data(client, 0, LM25066_READ_PIN_PEAK);
123                 break;
124         case PMBUS_VIRT_RESET_PIN_HISTORY:
125                 ret = 0;
126                 break;
127         default:
128                 ret = -ENODATA;
129                 break;
130         }
131 done:
132         return ret;
133 }
134
135 static int lm25066_write_word_data(struct i2c_client *client, int page, int reg,
136                                    u16 word)
137 {
138         int ret;
139
140         if (page > 1)
141                 return -EINVAL;
142
143         switch (reg) {
144         case PMBUS_IIN_OC_WARN_LIMIT:
145                 ret = pmbus_write_word_data(client, 0,
146                                             LM25066_MFR_IIN_OC_WARN_LIMIT,
147                                             word);
148                 break;
149         case PMBUS_PIN_OP_WARN_LIMIT:
150                 ret = pmbus_write_word_data(client, 0,
151                                             LM25066_MFR_PIN_OP_WARN_LIMIT,
152                                             word);
153                 break;
154         case PMBUS_VIRT_RESET_PIN_HISTORY:
155                 ret = pmbus_write_byte(client, 0, LM25066_CLEAR_PIN_PEAK);
156                 break;
157         default:
158                 ret = -ENODATA;
159                 break;
160         }
161         return ret;
162 }
163
164 static int lm25066_probe(struct i2c_client *client,
165                           const struct i2c_device_id *id)
166 {
167         int config;
168         int ret;
169         struct lm25066_data *data;
170         struct pmbus_driver_info *info;
171
172         if (!i2c_check_functionality(client->adapter,
173                                      I2C_FUNC_SMBUS_READ_BYTE_DATA))
174                 return -ENODEV;
175
176         data = kzalloc(sizeof(struct lm25066_data), GFP_KERNEL);
177         if (!data)
178                 return -ENOMEM;
179
180         config = i2c_smbus_read_byte_data(client, LM25066_DEVICE_SETUP);
181         if (config < 0) {
182                 ret = config;
183                 goto err_mem;
184         }
185
186         data->id = id->driver_data;
187         info = &data->info;
188
189         info->pages = 2;
190         info->format[PSC_VOLTAGE_IN] = direct;
191         info->format[PSC_VOLTAGE_OUT] = direct;
192         info->format[PSC_CURRENT_IN] = direct;
193         info->format[PSC_TEMPERATURE] = direct;
194         info->format[PSC_POWER] = direct;
195
196         info->m[PSC_TEMPERATURE] = 16;
197         info->b[PSC_TEMPERATURE] = 0;
198         info->R[PSC_TEMPERATURE] = 0;
199
200         info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT
201           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_PIN | PMBUS_HAVE_IIN
202           | PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
203         info->func[1] = PMBUS_HAVE_VOUT;
204
205         info->read_word_data = lm25066_read_word_data;
206         info->write_word_data = lm25066_write_word_data;
207
208         switch (id->driver_data) {
209         case lm25066:
210                 info->m[PSC_VOLTAGE_IN] = 22070;
211                 info->b[PSC_VOLTAGE_IN] = 0;
212                 info->R[PSC_VOLTAGE_IN] = -2;
213                 info->m[PSC_VOLTAGE_OUT] = 22070;
214                 info->b[PSC_VOLTAGE_OUT] = 0;
215                 info->R[PSC_VOLTAGE_OUT] = -2;
216
217                 if (config & LM25066_DEV_SETUP_CL) {
218                         info->m[PSC_CURRENT_IN] = 6852;
219                         info->b[PSC_CURRENT_IN] = 0;
220                         info->R[PSC_CURRENT_IN] = -2;
221                         info->m[PSC_POWER] = 369;
222                         info->b[PSC_POWER] = 0;
223                         info->R[PSC_POWER] = -2;
224                 } else {
225                         info->m[PSC_CURRENT_IN] = 13661;
226                         info->b[PSC_CURRENT_IN] = 0;
227                         info->R[PSC_CURRENT_IN] = -2;
228                         info->m[PSC_POWER] = 736;
229                         info->b[PSC_POWER] = 0;
230                         info->R[PSC_POWER] = -2;
231                 }
232                 break;
233         case lm5064:
234                 info->m[PSC_VOLTAGE_IN] = 22075;
235                 info->b[PSC_VOLTAGE_IN] = 0;
236                 info->R[PSC_VOLTAGE_IN] = -2;
237                 info->m[PSC_VOLTAGE_OUT] = 22075;
238                 info->b[PSC_VOLTAGE_OUT] = 0;
239                 info->R[PSC_VOLTAGE_OUT] = -2;
240
241                 if (config & LM25066_DEV_SETUP_CL) {
242                         info->m[PSC_CURRENT_IN] = 6713;
243                         info->b[PSC_CURRENT_IN] = 0;
244                         info->R[PSC_CURRENT_IN] = -2;
245                         info->m[PSC_POWER] = 3619;
246                         info->b[PSC_POWER] = 0;
247                         info->R[PSC_POWER] = -3;
248                 } else {
249                         info->m[PSC_CURRENT_IN] = 13426;
250                         info->b[PSC_CURRENT_IN] = 0;
251                         info->R[PSC_CURRENT_IN] = -2;
252                         info->m[PSC_POWER] = 7238;
253                         info->b[PSC_POWER] = 0;
254                         info->R[PSC_POWER] = -3;
255                 }
256                 break;
257         case lm5066:
258                 info->m[PSC_VOLTAGE_IN] = 4587;
259                 info->b[PSC_VOLTAGE_IN] = 0;
260                 info->R[PSC_VOLTAGE_IN] = -2;
261                 info->m[PSC_VOLTAGE_OUT] = 4587;
262                 info->b[PSC_VOLTAGE_OUT] = 0;
263                 info->R[PSC_VOLTAGE_OUT] = -2;
264
265                 if (config & LM25066_DEV_SETUP_CL) {
266                         info->m[PSC_CURRENT_IN] = 10753;
267                         info->b[PSC_CURRENT_IN] = 0;
268                         info->R[PSC_CURRENT_IN] = -2;
269                         info->m[PSC_POWER] = 1204;
270                         info->b[PSC_POWER] = 0;
271                         info->R[PSC_POWER] = -3;
272                 } else {
273                         info->m[PSC_CURRENT_IN] = 5405;
274                         info->b[PSC_CURRENT_IN] = 0;
275                         info->R[PSC_CURRENT_IN] = -2;
276                         info->m[PSC_POWER] = 605;
277                         info->b[PSC_POWER] = 0;
278                         info->R[PSC_POWER] = -3;
279                 }
280                 break;
281         default:
282                 ret = -ENODEV;
283                 goto err_mem;
284         }
285
286         ret = pmbus_do_probe(client, id, info);
287         if (ret)
288                 goto err_mem;
289         return 0;
290
291 err_mem:
292         kfree(data);
293         return ret;
294 }
295
296 static int lm25066_remove(struct i2c_client *client)
297 {
298         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
299         const struct lm25066_data *data = to_lm25066_data(info);
300         int ret;
301
302         ret = pmbus_do_remove(client);
303         kfree(data);
304         return ret;
305 }
306
307 static const struct i2c_device_id lm25066_id[] = {
308         {"lm25066", lm25066},
309         {"lm5064", lm5064},
310         {"lm5066", lm5066},
311         { }
312 };
313
314 MODULE_DEVICE_TABLE(i2c, lm25066_id);
315
316 /* This is the driver that will be inserted */
317 static struct i2c_driver lm25066_driver = {
318         .driver = {
319                    .name = "lm25066",
320                    },
321         .probe = lm25066_probe,
322         .remove = lm25066_remove,
323         .id_table = lm25066_id,
324 };
325
326 static int __init lm25066_init(void)
327 {
328         return i2c_add_driver(&lm25066_driver);
329 }
330
331 static void __exit lm25066_exit(void)
332 {
333         i2c_del_driver(&lm25066_driver);
334 }
335
336 MODULE_AUTHOR("Guenter Roeck");
337 MODULE_DESCRIPTION("PMBus driver for LM25066/LM5064/LM5066");
338 MODULE_LICENSE("GPL");
339 module_init(lm25066_init);
340 module_exit(lm25066_exit);