hwmon: (pmbus/lm25066) Ignore byte writes to non-zero pages
[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_write_byte(struct i2c_client *client, int page, u8 value)
165 {
166         if (page > 1)
167                 return -EINVAL;
168
169         if (page == 0)
170                 return pmbus_write_byte(client, 0, value);
171
172         return 0;
173 }
174
175 static int lm25066_probe(struct i2c_client *client,
176                           const struct i2c_device_id *id)
177 {
178         int config;
179         int ret;
180         struct lm25066_data *data;
181         struct pmbus_driver_info *info;
182
183         if (!i2c_check_functionality(client->adapter,
184                                      I2C_FUNC_SMBUS_READ_BYTE_DATA))
185                 return -ENODEV;
186
187         data = kzalloc(sizeof(struct lm25066_data), GFP_KERNEL);
188         if (!data)
189                 return -ENOMEM;
190
191         config = i2c_smbus_read_byte_data(client, LM25066_DEVICE_SETUP);
192         if (config < 0) {
193                 ret = config;
194                 goto err_mem;
195         }
196
197         data->id = id->driver_data;
198         info = &data->info;
199
200         info->pages = 2;
201         info->format[PSC_VOLTAGE_IN] = direct;
202         info->format[PSC_VOLTAGE_OUT] = direct;
203         info->format[PSC_CURRENT_IN] = direct;
204         info->format[PSC_TEMPERATURE] = direct;
205         info->format[PSC_POWER] = direct;
206
207         info->m[PSC_TEMPERATURE] = 16;
208         info->b[PSC_TEMPERATURE] = 0;
209         info->R[PSC_TEMPERATURE] = 0;
210
211         info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT
212           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_PIN | PMBUS_HAVE_IIN
213           | PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
214         info->func[1] = PMBUS_HAVE_VOUT;
215
216         info->read_word_data = lm25066_read_word_data;
217         info->write_word_data = lm25066_write_word_data;
218         info->write_byte = lm25066_write_byte;
219
220         switch (id->driver_data) {
221         case lm25066:
222                 info->m[PSC_VOLTAGE_IN] = 22070;
223                 info->b[PSC_VOLTAGE_IN] = 0;
224                 info->R[PSC_VOLTAGE_IN] = -2;
225                 info->m[PSC_VOLTAGE_OUT] = 22070;
226                 info->b[PSC_VOLTAGE_OUT] = 0;
227                 info->R[PSC_VOLTAGE_OUT] = -2;
228
229                 if (config & LM25066_DEV_SETUP_CL) {
230                         info->m[PSC_CURRENT_IN] = 6852;
231                         info->b[PSC_CURRENT_IN] = 0;
232                         info->R[PSC_CURRENT_IN] = -2;
233                         info->m[PSC_POWER] = 369;
234                         info->b[PSC_POWER] = 0;
235                         info->R[PSC_POWER] = -2;
236                 } else {
237                         info->m[PSC_CURRENT_IN] = 13661;
238                         info->b[PSC_CURRENT_IN] = 0;
239                         info->R[PSC_CURRENT_IN] = -2;
240                         info->m[PSC_POWER] = 736;
241                         info->b[PSC_POWER] = 0;
242                         info->R[PSC_POWER] = -2;
243                 }
244                 break;
245         case lm5064:
246                 info->m[PSC_VOLTAGE_IN] = 22075;
247                 info->b[PSC_VOLTAGE_IN] = 0;
248                 info->R[PSC_VOLTAGE_IN] = -2;
249                 info->m[PSC_VOLTAGE_OUT] = 22075;
250                 info->b[PSC_VOLTAGE_OUT] = 0;
251                 info->R[PSC_VOLTAGE_OUT] = -2;
252
253                 if (config & LM25066_DEV_SETUP_CL) {
254                         info->m[PSC_CURRENT_IN] = 6713;
255                         info->b[PSC_CURRENT_IN] = 0;
256                         info->R[PSC_CURRENT_IN] = -2;
257                         info->m[PSC_POWER] = 3619;
258                         info->b[PSC_POWER] = 0;
259                         info->R[PSC_POWER] = -3;
260                 } else {
261                         info->m[PSC_CURRENT_IN] = 13426;
262                         info->b[PSC_CURRENT_IN] = 0;
263                         info->R[PSC_CURRENT_IN] = -2;
264                         info->m[PSC_POWER] = 7238;
265                         info->b[PSC_POWER] = 0;
266                         info->R[PSC_POWER] = -3;
267                 }
268                 break;
269         case lm5066:
270                 info->m[PSC_VOLTAGE_IN] = 4587;
271                 info->b[PSC_VOLTAGE_IN] = 0;
272                 info->R[PSC_VOLTAGE_IN] = -2;
273                 info->m[PSC_VOLTAGE_OUT] = 4587;
274                 info->b[PSC_VOLTAGE_OUT] = 0;
275                 info->R[PSC_VOLTAGE_OUT] = -2;
276
277                 if (config & LM25066_DEV_SETUP_CL) {
278                         info->m[PSC_CURRENT_IN] = 10753;
279                         info->b[PSC_CURRENT_IN] = 0;
280                         info->R[PSC_CURRENT_IN] = -2;
281                         info->m[PSC_POWER] = 1204;
282                         info->b[PSC_POWER] = 0;
283                         info->R[PSC_POWER] = -3;
284                 } else {
285                         info->m[PSC_CURRENT_IN] = 5405;
286                         info->b[PSC_CURRENT_IN] = 0;
287                         info->R[PSC_CURRENT_IN] = -2;
288                         info->m[PSC_POWER] = 605;
289                         info->b[PSC_POWER] = 0;
290                         info->R[PSC_POWER] = -3;
291                 }
292                 break;
293         default:
294                 ret = -ENODEV;
295                 goto err_mem;
296         }
297
298         ret = pmbus_do_probe(client, id, info);
299         if (ret)
300                 goto err_mem;
301         return 0;
302
303 err_mem:
304         kfree(data);
305         return ret;
306 }
307
308 static int lm25066_remove(struct i2c_client *client)
309 {
310         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
311         const struct lm25066_data *data = to_lm25066_data(info);
312         int ret;
313
314         ret = pmbus_do_remove(client);
315         kfree(data);
316         return ret;
317 }
318
319 static const struct i2c_device_id lm25066_id[] = {
320         {"lm25066", lm25066},
321         {"lm5064", lm5064},
322         {"lm5066", lm5066},
323         { }
324 };
325
326 MODULE_DEVICE_TABLE(i2c, lm25066_id);
327
328 /* This is the driver that will be inserted */
329 static struct i2c_driver lm25066_driver = {
330         .driver = {
331                    .name = "lm25066",
332                    },
333         .probe = lm25066_probe,
334         .remove = lm25066_remove,
335         .id_table = lm25066_id,
336 };
337
338 static int __init lm25066_init(void)
339 {
340         return i2c_add_driver(&lm25066_driver);
341 }
342
343 static void __exit lm25066_exit(void)
344 {
345         i2c_del_driver(&lm25066_driver);
346 }
347
348 MODULE_AUTHOR("Guenter Roeck");
349 MODULE_DESCRIPTION("PMBus driver for LM25066/LM5064/LM5066");
350 MODULE_LICENSE("GPL");
351 module_init(lm25066_init);
352 module_exit(lm25066_exit);