?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
procfs: do not confuse jiffies with cputime64_t
[zen-stable.git] / drivers / hwmon / adm1031.c
blob0683e6be662cfe28e803cac2b6ddd6501f06ef29
1 /*
2 adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Based on lm75.c and lm85.c
5 Supports adm1030 / adm1031
6 Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
7 Reworked by Jean Delvare <khali@linux-fr.org>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/err.h>
32 #include <linux/mutex.h>
33
34 /* Following macros takes channel parameter starting from 0 to 2 */
35 #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
36 #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
37 #define ADM1031_REG_PWM (0x22)
38 #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
39 #define ADM1031_REG_FAN_FILTER (0x23)
40
41 #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr))
42 #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr))
43 #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr))
44 #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr))
45
46 #define ADM1031_REG_TEMP(nr) (0x0a + (nr))
47 #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
48
49 #define ADM1031_REG_STATUS(nr) (0x2 + (nr))
50
51 #define ADM1031_REG_CONF1 0x00
52 #define ADM1031_REG_CONF2 0x01
53 #define ADM1031_REG_EXT_TEMP 0x06
54
55 #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
56 #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
57 #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
58
59 #define ADM1031_CONF2_PWM1_ENABLE 0x01
60 #define ADM1031_CONF2_PWM2_ENABLE 0x02
61 #define ADM1031_CONF2_TACH1_ENABLE 0x04
62 #define ADM1031_CONF2_TACH2_ENABLE 0x08
63 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
64
65 #define ADM1031_UPDATE_RATE_MASK 0x1c
66 #define ADM1031_UPDATE_RATE_SHIFT 2
67
68 /* Addresses to scan */
69 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
70
71 enum chips { adm1030, adm1031 };
72
73 typedef u8 auto_chan_table_t[8][2];
74
75 /* Each client has this additional data */
76 struct adm1031_data {
77 struct device *hwmon_dev;
78 struct mutex update_lock;
79 int chip_type;
80 char valid; /* !=0 if following fields are valid */
81 unsigned long last_updated; /* In jiffies */
82 unsigned int update_interval; /* In milliseconds */
83 /* The chan_select_table contains the possible configurations for
84 * auto fan control.
85 */
86 const auto_chan_table_t *chan_select_table;
87 u16 alarm;
88 u8 conf1;
89 u8 conf2;
90 u8 fan[2];
91 u8 fan_div[2];
92 u8 fan_min[2];
93 u8 pwm[2];
94 u8 old_pwm[2];
95 s8 temp[3];
96 u8 ext_temp[3];
97 u8 auto_temp[3];
98 u8 auto_temp_min[3];
99 u8 auto_temp_off[3];
100 u8 auto_temp_max[3];
101 s8 temp_offset[3];
102 s8 temp_min[3];
103 s8 temp_max[3];
104 s8 temp_crit[3];
105 };
106
107 static int adm1031_probe(struct i2c_client *client,
108 const struct i2c_device_id *id);
109 static int adm1031_detect(struct i2c_client *client,
110 struct i2c_board_info *info);
111 static void adm1031_init_client(struct i2c_client *client);
112 static int adm1031_remove(struct i2c_client *client);
113 static struct adm1031_data *adm1031_update_device(struct device *dev);
114
115 static const struct i2c_device_id adm1031_id[] = {
116 { "adm1030", adm1030 },
117 { "adm1031", adm1031 },
118 { }
119 };
120 MODULE_DEVICE_TABLE(i2c, adm1031_id);
121
122 /* This is the driver that will be inserted */
123 static struct i2c_driver adm1031_driver = {
124 .class = I2C_CLASS_HWMON,
125 .driver = {
126 .name = "adm1031",
127 },
128 .probe = adm1031_probe,
129 .remove = adm1031_remove,
130 .id_table = adm1031_id,
131 .detect = adm1031_detect,
132 .address_list = normal_i2c,
133 };
134
135 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
136 {
137 return i2c_smbus_read_byte_data(client, reg);
138 }
139
140 static inline int
141 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
142 {
143 return i2c_smbus_write_byte_data(client, reg, value);
144 }
145
146
147 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
148 ((val + 500) / 1000)))
149
150 #define TEMP_FROM_REG(val) ((val) * 1000)
151
152 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
153
154 #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)
155 #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \
156 (val) | 0x70 : (val))
157
158 #define FAN_FROM_REG(reg, div) ((reg) ? (11250 * 60) / ((reg) * (div)) : 0)
159
160 static int FAN_TO_REG(int reg, int div)
161 {
162 int tmp;
163 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
164 return tmp > 255 ? 255 : tmp;
165 }
166
167 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
168
169 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4)
170 #define PWM_FROM_REG(val) ((val) << 4)
171
172 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
173 #define FAN_CHAN_TO_REG(val, reg) \
174 (((reg) & 0x1F) | (((val) << 5) & 0xe0))
175
176 #define AUTO_TEMP_MIN_TO_REG(val, reg) \
177 ((((val)/500) & 0xf8)|((reg) & 0x7))
178 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1<< ((reg)&0x7)))
179 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
180
181 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
182
183 #define AUTO_TEMP_OFF_FROM_REG(reg) \
184 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
185
186 #define AUTO_TEMP_MAX_FROM_REG(reg) \
187 (AUTO_TEMP_RANGE_FROM_REG(reg) + \
188 AUTO_TEMP_MIN_FROM_REG(reg))
189
190 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
191 {
192 int ret;
193 int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
194
195 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
196 ret = ((reg & 0xf8) |
197 (range < 10000 ? 0 :
198 range < 20000 ? 1 :
199 range < 40000 ? 2 : range < 80000 ? 3 : 4));
200 return ret;
201 }
202
203 /* FAN auto control */
204 #define GET_FAN_AUTO_BITFIELD(data, idx) \
205 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx%2]
206
207 /* The tables below contains the possible values for the auto fan
208 * control bitfields. the index in the table is the register value.
209 * MSb is the auto fan control enable bit, so the four first entries
210 * in the table disables auto fan control when both bitfields are zero.
211 */
212 static const auto_chan_table_t auto_channel_select_table_adm1031 = {
213 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
214 { 2 /* 0b010 */ , 4 /* 0b100 */ },
215 { 2 /* 0b010 */ , 2 /* 0b010 */ },
216 { 4 /* 0b100 */ , 4 /* 0b100 */ },
217 { 7 /* 0b111 */ , 7 /* 0b111 */ },
218 };
219
220 static const auto_chan_table_t auto_channel_select_table_adm1030 = {
221 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
222 { 2 /* 0b10 */ , 0 },
223 { 0xff /* invalid */ , 0 },
224 { 0xff /* invalid */ , 0 },
225 { 3 /* 0b11 */ , 0 },
226 };
227
228 /* That function checks if a bitfield is valid and returns the other bitfield
229 * nearest match if no exact match where found.
230 */
231 static int
232 get_fan_auto_nearest(struct adm1031_data *data,
233 int chan, u8 val, u8 reg, u8 * new_reg)
234 {
235 int i;
236 int first_match = -1, exact_match = -1;
237 u8 other_reg_val =
238 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
239
240 if (val == 0) {
241 *new_reg = 0;
242 return 0;
243 }
244
245 for (i = 0; i < 8; i++) {
246 if ((val == (*data->chan_select_table)[i][chan]) &&
247 ((*data->chan_select_table)[i][chan ? 0 : 1] ==
248 other_reg_val)) {
249 /* We found an exact match */
250 exact_match = i;
251 break;
252 } else if (val == (*data->chan_select_table)[i][chan] &&
253 first_match == -1) {
254 /* Save the first match in case of an exact match has
255 * not been found
256 */
257 first_match = i;
258 }
259 }
260
261 if (exact_match >= 0) {
262 *new_reg = exact_match;
263 } else if (first_match >= 0) {
264 *new_reg = first_match;
265 } else {
266 return -EINVAL;
267 }
268 return 0;
269 }
270
271 static ssize_t show_fan_auto_channel(struct device *dev,
272 struct device_attribute *attr, char *buf)
273 {
274 int nr = to_sensor_dev_attr(attr)->index;
275 struct adm1031_data *data = adm1031_update_device(dev);
276 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
277 }
278
279 static ssize_t
280 set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
281 const char *buf, size_t count)
282 {
283 struct i2c_client *client = to_i2c_client(dev);
284 struct adm1031_data *data = i2c_get_clientdata(client);
285 int nr = to_sensor_dev_attr(attr)->index;
286 int val = simple_strtol(buf, NULL, 10);
287 u8 reg;
288 int ret;
289 u8 old_fan_mode;
290
291 old_fan_mode = data->conf1;
292
293 mutex_lock(&data->update_lock);
294
295 if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, &reg))) {
296 mutex_unlock(&data->update_lock);
297 return ret;
298 }
299 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
300 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
301 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
302 if (data->conf1 & ADM1031_CONF1_AUTO_MODE){
303 /* Switch to Auto Fan Mode
304 * Save PWM registers
305 * Set PWM registers to 33% Both */
306 data->old_pwm[0] = data->pwm[0];
307 data->old_pwm[1] = data->pwm[1];
308 adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
309 } else {
310 /* Switch to Manual Mode */
311 data->pwm[0] = data->old_pwm[0];
312 data->pwm[1] = data->old_pwm[1];
313 /* Restore PWM registers */
314 adm1031_write_value(client, ADM1031_REG_PWM,
315 data->pwm[0] | (data->pwm[1] << 4));
316 }
317 }
318 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
319 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
320 mutex_unlock(&data->update_lock);
321 return count;
322 }
323
324 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
325 show_fan_auto_channel, set_fan_auto_channel, 0);
326 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
327 show_fan_auto_channel, set_fan_auto_channel, 1);
328
329 /* Auto Temps */
330 static ssize_t show_auto_temp_off(struct device *dev,
331 struct device_attribute *attr, char *buf)
332 {
333 int nr = to_sensor_dev_attr(attr)->index;
334 struct adm1031_data *data = adm1031_update_device(dev);
335 return sprintf(buf, "%d\n",
336 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
337 }
338 static ssize_t show_auto_temp_min(struct device *dev,
339 struct device_attribute *attr, char *buf)
340 {
341 int nr = to_sensor_dev_attr(attr)->index;
342 struct adm1031_data *data = adm1031_update_device(dev);
343 return sprintf(buf, "%d\n",
344 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
345 }
346 static ssize_t
347 set_auto_temp_min(struct device *dev, struct device_attribute *attr,
348 const char *buf, size_t count)
349 {
350 struct i2c_client *client = to_i2c_client(dev);
351 struct adm1031_data *data = i2c_get_clientdata(client);
352 int nr = to_sensor_dev_attr(attr)->index;
353 int val = simple_strtol(buf, NULL, 10);
354
355 mutex_lock(&data->update_lock);
356 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
357 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
358 data->auto_temp[nr]);
359 mutex_unlock(&data->update_lock);
360 return count;
361 }
362 static ssize_t show_auto_temp_max(struct device *dev,
363 struct device_attribute *attr, char *buf)
364 {
365 int nr = to_sensor_dev_attr(attr)->index;
366 struct adm1031_data *data = adm1031_update_device(dev);
367 return sprintf(buf, "%d\n",
368 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
369 }
370 static ssize_t
371 set_auto_temp_max(struct device *dev, struct device_attribute *attr,
372 const char *buf, size_t count)
373 {
374 struct i2c_client *client = to_i2c_client(dev);
375 struct adm1031_data *data = i2c_get_clientdata(client);
376 int nr = to_sensor_dev_attr(attr)->index;
377 int val = simple_strtol(buf, NULL, 10);
378
379 mutex_lock(&data->update_lock);
380 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]);
381 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
382 data->temp_max[nr]);
383 mutex_unlock(&data->update_lock);
384 return count;
385 }
386
387 #define auto_temp_reg(offset) \
388 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
389 show_auto_temp_off, NULL, offset - 1); \
390 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
391 show_auto_temp_min, set_auto_temp_min, offset - 1); \
392 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
393 show_auto_temp_max, set_auto_temp_max, offset - 1)
394
395 auto_temp_reg(1);
396 auto_temp_reg(2);
397 auto_temp_reg(3);
398
399 /* pwm */
400 static ssize_t show_pwm(struct device *dev,
401 struct device_attribute *attr, char *buf)
402 {
403 int nr = to_sensor_dev_attr(attr)->index;
404 struct adm1031_data *data = adm1031_update_device(dev);
405 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
406 }
407 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
408 const char *buf, size_t count)
409 {
410 struct i2c_client *client = to_i2c_client(dev);
411 struct adm1031_data *data = i2c_get_clientdata(client);
412 int nr = to_sensor_dev_attr(attr)->index;
413 int val = simple_strtol(buf, NULL, 10);
414 int reg;
415
416 mutex_lock(&data->update_lock);
417 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
418 (((val>>4) & 0xf) != 5)) {
419 /* In automatic mode, the only PWM accepted is 33% */
420 mutex_unlock(&data->update_lock);
421 return -EINVAL;
422 }
423 data->pwm[nr] = PWM_TO_REG(val);
424 reg = adm1031_read_value(client, ADM1031_REG_PWM);
425 adm1031_write_value(client, ADM1031_REG_PWM,
426 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
427 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
428 mutex_unlock(&data->update_lock);
429 return count;
430 }
431
432 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
433 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
434 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
435 show_pwm, set_pwm, 0);
436 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
437 show_pwm, set_pwm, 1);
438
439 /* Fans */
440
441 /*
442 * That function checks the cases where the fan reading is not
443 * relevant. It is used to provide 0 as fan reading when the fan is
444 * not supposed to run
445 */
446 static int trust_fan_readings(struct adm1031_data *data, int chan)
447 {
448 int res = 0;
449
450 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
451 switch (data->conf1 & 0x60) {
452 case 0x00: /* remote temp1 controls fan1 remote temp2 controls fan2 */
453 res = data->temp[chan+1] >=
454 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
455 break;
456 case 0x20: /* remote temp1 controls both fans */
457 res =
458 data->temp[1] >=
459 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
460 break;
461 case 0x40: /* remote temp2 controls both fans */
462 res =
463 data->temp[2] >=
464 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
465 break;
466 case 0x60: /* max controls both fans */
467 res =
468 data->temp[0] >=
469 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
470 || data->temp[1] >=
471 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
472 || (data->chip_type == adm1031
473 && data->temp[2] >=
474 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
475 break;
476 }
477 } else {
478 res = data->pwm[chan] > 0;
479 }
480 return res;
481 }
482
483
484 static ssize_t show_fan(struct device *dev,
485 struct device_attribute *attr, char *buf)
486 {
487 int nr = to_sensor_dev_attr(attr)->index;
488 struct adm1031_data *data = adm1031_update_device(dev);
489 int value;
490
491 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
492 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
493 return sprintf(buf, "%d\n", value);
494 }
495
496 static ssize_t show_fan_div(struct device *dev,
497 struct device_attribute *attr, char *buf)
498 {
499 int nr = to_sensor_dev_attr(attr)->index;
500 struct adm1031_data *data = adm1031_update_device(dev);
501 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
502 }
503 static ssize_t show_fan_min(struct device *dev,
504 struct device_attribute *attr, char *buf)
505 {
506 int nr = to_sensor_dev_attr(attr)->index;
507 struct adm1031_data *data = adm1031_update_device(dev);
508 return sprintf(buf, "%d\n",
509 FAN_FROM_REG(data->fan_min[nr],
510 FAN_DIV_FROM_REG(data->fan_div[nr])));
511 }
512 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
513 const char *buf, size_t count)
514 {
515 struct i2c_client *client = to_i2c_client(dev);
516 struct adm1031_data *data = i2c_get_clientdata(client);
517 int nr = to_sensor_dev_attr(attr)->index;
518 int val = simple_strtol(buf, NULL, 10);
519
520 mutex_lock(&data->update_lock);
521 if (val) {
522 data->fan_min[nr] =
523 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
524 } else {
525 data->fan_min[nr] = 0xff;
526 }
527 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
528 mutex_unlock(&data->update_lock);
529 return count;
530 }
531 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
532 const char *buf, size_t count)
533 {
534 struct i2c_client *client = to_i2c_client(dev);
535 struct adm1031_data *data = i2c_get_clientdata(client);
536 int nr = to_sensor_dev_attr(attr)->index;
537 int val = simple_strtol(buf, NULL, 10);
538 u8 tmp;
539 int old_div;
540 int new_min;
541
542 tmp = val == 8 ? 0xc0 :
543 val == 4 ? 0x80 :
544 val == 2 ? 0x40 :
545 val == 1 ? 0x00 :
546 0xff;
547 if (tmp == 0xff)
548 return -EINVAL;
549
550 mutex_lock(&data->update_lock);
551 /* Get fresh readings */
552 data->fan_div[nr] = adm1031_read_value(client,
553 ADM1031_REG_FAN_DIV(nr));
554 data->fan_min[nr] = adm1031_read_value(client,
555 ADM1031_REG_FAN_MIN(nr));
556
557 /* Write the new clock divider and fan min */
558 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
559 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
560 new_min = data->fan_min[nr] * old_div / val;
561 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
562
563 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
564 data->fan_div[nr]);
565 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
566 data->fan_min[nr]);
567
568 /* Invalidate the cache: fan speed is no longer valid */
569 data->valid = 0;
570 mutex_unlock(&data->update_lock);
571 return count;
572 }
573
574 #define fan_offset(offset) \
575 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
576 show_fan, NULL, offset - 1); \
577 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
578 show_fan_min, set_fan_min, offset - 1); \
579 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
580 show_fan_div, set_fan_div, offset - 1)
581
582 fan_offset(1);
583 fan_offset(2);
584
585
586 /* Temps */
587 static ssize_t show_temp(struct device *dev,
588 struct device_attribute *attr, char *buf)
589 {
590 int nr = to_sensor_dev_attr(attr)->index;
591 struct adm1031_data *data = adm1031_update_device(dev);
592 int ext;
593 ext = nr == 0 ?
594 ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
595 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
596 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
597 }
598 static ssize_t show_temp_offset(struct device *dev,
599 struct device_attribute *attr, char *buf)
600 {
601 int nr = to_sensor_dev_attr(attr)->index;
602 struct adm1031_data *data = adm1031_update_device(dev);
603 return sprintf(buf, "%d\n",
604 TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
605 }
606 static ssize_t show_temp_min(struct device *dev,
607 struct device_attribute *attr, char *buf)
608 {
609 int nr = to_sensor_dev_attr(attr)->index;
610 struct adm1031_data *data = adm1031_update_device(dev);
611 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
612 }
613 static ssize_t show_temp_max(struct device *dev,
614 struct device_attribute *attr, char *buf)
615 {
616 int nr = to_sensor_dev_attr(attr)->index;
617 struct adm1031_data *data = adm1031_update_device(dev);
618 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
619 }
620 static ssize_t show_temp_crit(struct device *dev,
621 struct device_attribute *attr, char *buf)
622 {
623 int nr = to_sensor_dev_attr(attr)->index;
624 struct adm1031_data *data = adm1031_update_device(dev);
625 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
626 }
627 static ssize_t set_temp_offset(struct device *dev,
628 struct device_attribute *attr, const char *buf,
629 size_t count)
630 {
631 struct i2c_client *client = to_i2c_client(dev);
632 struct adm1031_data *data = i2c_get_clientdata(client);
633 int nr = to_sensor_dev_attr(attr)->index;
634 int val;
635
636 val = simple_strtol(buf, NULL, 10);
637 val = SENSORS_LIMIT(val, -15000, 15000);
638 mutex_lock(&data->update_lock);
639 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
640 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
641 data->temp_offset[nr]);
642 mutex_unlock(&data->update_lock);
643 return count;
644 }
645 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
646 const char *buf, size_t count)
647 {
648 struct i2c_client *client = to_i2c_client(dev);
649 struct adm1031_data *data = i2c_get_clientdata(client);
650 int nr = to_sensor_dev_attr(attr)->index;
651 int val;
652
653 val = simple_strtol(buf, NULL, 10);
654 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
655 mutex_lock(&data->update_lock);
656 data->temp_min[nr] = TEMP_TO_REG(val);
657 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
658 data->temp_min[nr]);
659 mutex_unlock(&data->update_lock);
660 return count;
661 }
662 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
663 const char *buf, size_t count)
664 {
665 struct i2c_client *client = to_i2c_client(dev);
666 struct adm1031_data *data = i2c_get_clientdata(client);
667 int nr = to_sensor_dev_attr(attr)->index;
668 int val;
669
670 val = simple_strtol(buf, NULL, 10);
671 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
672 mutex_lock(&data->update_lock);
673 data->temp_max[nr] = TEMP_TO_REG(val);
674 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
675 data->temp_max[nr]);
676 mutex_unlock(&data->update_lock);
677 return count;
678 }
679 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
680 const char *buf, size_t count)
681 {
682 struct i2c_client *client = to_i2c_client(dev);
683 struct adm1031_data *data = i2c_get_clientdata(client);
684 int nr = to_sensor_dev_attr(attr)->index;
685 int val;
686
687 val = simple_strtol(buf, NULL, 10);
688 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
689 mutex_lock(&data->update_lock);
690 data->temp_crit[nr] = TEMP_TO_REG(val);
691 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
692 data->temp_crit[nr]);
693 mutex_unlock(&data->update_lock);
694 return count;
695 }
696
697 #define temp_reg(offset) \
698 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
699 show_temp, NULL, offset - 1); \
700 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \
701 show_temp_offset, set_temp_offset, offset - 1); \
702 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
703 show_temp_min, set_temp_min, offset - 1); \
704 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
705 show_temp_max, set_temp_max, offset - 1); \
706 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
707 show_temp_crit, set_temp_crit, offset - 1)
708
709 temp_reg(1);
710 temp_reg(2);
711 temp_reg(3);
712
713 /* Alarms */
714 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
715 {
716 struct adm1031_data *data = adm1031_update_device(dev);
717 return sprintf(buf, "%d\n", data->alarm);
718 }
719
720 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
721
722 static ssize_t show_alarm(struct device *dev,
723 struct device_attribute *attr, char *buf)
724 {
725 int bitnr = to_sensor_dev_attr(attr)->index;
726 struct adm1031_data *data = adm1031_update_device(dev);
727 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
728 }
729
730 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
731 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
732 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
733 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
734 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
735 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
736 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
737 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
738 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
739 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
740 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
741 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
742 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
743 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
744 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
745
746 /* Update Interval */
747 static const unsigned int update_intervals[] = {
748 16000, 8000, 4000, 2000, 1000, 500, 250, 125,
749 };
750
751 static ssize_t show_update_interval(struct device *dev,
752 struct device_attribute *attr, char *buf)
753 {
754 struct i2c_client *client = to_i2c_client(dev);
755 struct adm1031_data *data = i2c_get_clientdata(client);
756
757 return sprintf(buf, "%u\n", data->update_interval);
758 }
759
760 static ssize_t set_update_interval(struct device *dev,
761 struct device_attribute *attr,
762 const char *buf, size_t count)
763 {
764 struct i2c_client *client = to_i2c_client(dev);
765 struct adm1031_data *data = i2c_get_clientdata(client);
766 unsigned long val;
767 int i, err;
768 u8 reg;
769
770 err = strict_strtoul(buf, 10, &val);
771 if (err)
772 return err;
773
774 /*
775 * Find the nearest update interval from the table.
776 * Use it to determine the matching update rate.
777 */
778 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
779 if (val >= update_intervals[i])
780 break;
781 }
782 /* if not found, we point to the last entry (lowest update interval) */
783
784 /* set the new update rate while preserving other settings */
785 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
786 reg &= ~ADM1031_UPDATE_RATE_MASK;
787 reg |= i << ADM1031_UPDATE_RATE_SHIFT;
788 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
789
790 mutex_lock(&data->update_lock);
791 data->update_interval = update_intervals[i];
792 mutex_unlock(&data->update_lock);
793
794 return count;
795 }
796
797 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
798 set_update_interval);
799
800 static struct attribute *adm1031_attributes[] = {
801 &sensor_dev_attr_fan1_input.dev_attr.attr,
802 &sensor_dev_attr_fan1_div.dev_attr.attr,
803 &sensor_dev_attr_fan1_min.dev_attr.attr,
804 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
805 &sensor_dev_attr_fan1_fault.dev_attr.attr,
806 &sensor_dev_attr_pwm1.dev_attr.attr,
807 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
808 &sensor_dev_attr_temp1_input.dev_attr.attr,
809 &sensor_dev_attr_temp1_offset.dev_attr.attr,
810 &sensor_dev_attr_temp1_min.dev_attr.attr,
811 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
812 &sensor_dev_attr_temp1_max.dev_attr.attr,
813 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
814 &sensor_dev_attr_temp1_crit.dev_attr.attr,
815 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
816 &sensor_dev_attr_temp2_input.dev_attr.attr,
817 &sensor_dev_attr_temp2_offset.dev_attr.attr,
818 &sensor_dev_attr_temp2_min.dev_attr.attr,
819 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
820 &sensor_dev_attr_temp2_max.dev_attr.attr,
821 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
822 &sensor_dev_attr_temp2_crit.dev_attr.attr,
823 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
824 &sensor_dev_attr_temp2_fault.dev_attr.attr,
825
826 &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
827 &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
828 &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
829
830 &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
831 &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
832 &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
833
834 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
835
836 &dev_attr_update_interval.attr,
837 &dev_attr_alarms.attr,
838
839 NULL
840 };
841
842 static const struct attribute_group adm1031_group = {
843 .attrs = adm1031_attributes,
844 };
845
846 static struct attribute *adm1031_attributes_opt[] = {
847 &sensor_dev_attr_fan2_input.dev_attr.attr,
848 &sensor_dev_attr_fan2_div.dev_attr.attr,
849 &sensor_dev_attr_fan2_min.dev_attr.attr,
850 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
851 &sensor_dev_attr_fan2_fault.dev_attr.attr,
852 &sensor_dev_attr_pwm2.dev_attr.attr,
853 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
854 &sensor_dev_attr_temp3_input.dev_attr.attr,
855 &sensor_dev_attr_temp3_offset.dev_attr.attr,
856 &sensor_dev_attr_temp3_min.dev_attr.attr,
857 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
858 &sensor_dev_attr_temp3_max.dev_attr.attr,
859 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
860 &sensor_dev_attr_temp3_crit.dev_attr.attr,
861 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
862 &sensor_dev_attr_temp3_fault.dev_attr.attr,
863 &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
864 &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
865 &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
866 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
867 NULL
868 };
869
870 static const struct attribute_group adm1031_group_opt = {
871 .attrs = adm1031_attributes_opt,
872 };
873
874 /* Return 0 if detection is successful, -ENODEV otherwise */
875 static int adm1031_detect(struct i2c_client *client,
876 struct i2c_board_info *info)
877 {
878 struct i2c_adapter *adapter = client->adapter;
879 const char *name;
880 int id, co;
881
882 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
883 return -ENODEV;
884
885 id = i2c_smbus_read_byte_data(client, 0x3d);
886 co = i2c_smbus_read_byte_data(client, 0x3e);
887
888 if (!((id == 0x31 || id == 0x30) && co == 0x41))
889 return -ENODEV;
890 name = (id == 0x30) ? "adm1030" : "adm1031";
891
892 strlcpy(info->type, name, I2C_NAME_SIZE);
893
894 return 0;
895 }
896
897 static int adm1031_probe(struct i2c_client *client,
898 const struct i2c_device_id *id)
899 {
900 struct adm1031_data *data;
901 int err;
902
903 data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL);
904 if (!data) {
905 err = -ENOMEM;
906 goto exit;
907 }
908
909 i2c_set_clientdata(client, data);
910 data->chip_type = id->driver_data;
911 mutex_init(&data->update_lock);
912
913 if (data->chip_type == adm1030)
914 data->chan_select_table = &auto_channel_select_table_adm1030;
915 else
916 data->chan_select_table = &auto_channel_select_table_adm1031;
917
918 /* Initialize the ADM1031 chip */
919 adm1031_init_client(client);
920
921 /* Register sysfs hooks */
922 if ((err = sysfs_create_group(&client->dev.kobj, &adm1031_group)))
923 goto exit_free;
924
925 if (data->chip_type == adm1031) {
926 if ((err = sysfs_create_group(&client->dev.kobj,
927 &adm1031_group_opt)))
928 goto exit_remove;
929 }
930
931 data->hwmon_dev = hwmon_device_register(&client->dev);
932 if (IS_ERR(data->hwmon_dev)) {
933 err = PTR_ERR(data->hwmon_dev);
934 goto exit_remove;
935 }
936
937 return 0;
938
939 exit_remove:
940 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
941 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
942 exit_free:
943 kfree(data);
944 exit:
945 return err;
946 }
947
948 static int adm1031_remove(struct i2c_client *client)
949 {
950 struct adm1031_data *data = i2c_get_clientdata(client);
951
952 hwmon_device_unregister(data->hwmon_dev);
953 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
954 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
955 kfree(data);
956 return 0;
957 }
958
959 static void adm1031_init_client(struct i2c_client *client)
960 {
961 unsigned int read_val;
962 unsigned int mask;
963 int i;
964 struct adm1031_data *data = i2c_get_clientdata(client);
965
966 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
967 if (data->chip_type == adm1031) {
968 mask |= (ADM1031_CONF2_PWM2_ENABLE |
969 ADM1031_CONF2_TACH2_ENABLE);
970 }
971 /* Initialize the ADM1031 chip (enables fan speed reading ) */
972 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
973 if ((read_val | mask) != read_val) {
974 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
975 }
976
977 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
978 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
979 adm1031_write_value(client, ADM1031_REG_CONF1, read_val |
980 ADM1031_CONF1_MONITOR_ENABLE);
981 }
982
983 /* Read the chip's update rate */
984 mask = ADM1031_UPDATE_RATE_MASK;
985 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
986 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
987 /* Save it as update interval */
988 data->update_interval = update_intervals[i];
989 }
990
991 static struct adm1031_data *adm1031_update_device(struct device *dev)
992 {
993 struct i2c_client *client = to_i2c_client(dev);
994 struct adm1031_data *data = i2c_get_clientdata(client);
995 unsigned long next_update;
996 int chan;
997
998 mutex_lock(&data->update_lock);
999
1000 next_update = data->last_updated
1001 + msecs_to_jiffies(data->update_interval);
1002 if (time_after(jiffies, next_update) || !data->valid) {
1003
1004 dev_dbg(&client->dev, "Starting adm1031 update\n");
1005 for (chan = 0;
1006 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1007 u8 oldh, newh;
1008
1009 oldh =
1010 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1011 data->ext_temp[chan] =
1012 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1013 newh =
1014 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1015 if (newh != oldh) {
1016 data->ext_temp[chan] =
1017 adm1031_read_value(client,
1018 ADM1031_REG_EXT_TEMP);
1019 #ifdef DEBUG
1020 oldh =
1021 adm1031_read_value(client,
1022 ADM1031_REG_TEMP(chan));
1023
1024 /* oldh is actually newer */
1025 if (newh != oldh)
1026 dev_warn(&client->dev,
1027 "Remote temperature may be "
1028 "wrong.\n");
1029 #endif
1030 }
1031 data->temp[chan] = newh;
1032
1033 data->temp_offset[chan] =
1034 adm1031_read_value(client,
1035 ADM1031_REG_TEMP_OFFSET(chan));
1036 data->temp_min[chan] =
1037 adm1031_read_value(client,
1038 ADM1031_REG_TEMP_MIN(chan));
1039 data->temp_max[chan] =
1040 adm1031_read_value(client,
1041 ADM1031_REG_TEMP_MAX(chan));
1042 data->temp_crit[chan] =
1043 adm1031_read_value(client,
1044 ADM1031_REG_TEMP_CRIT(chan));
1045 data->auto_temp[chan] =
1046 adm1031_read_value(client,
1047 ADM1031_REG_AUTO_TEMP(chan));
1048
1049 }
1050
1051 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1052 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1053
1054 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1055 | (adm1031_read_value(client, ADM1031_REG_STATUS(1))
1056 << 8);
1057 if (data->chip_type == adm1030) {
1058 data->alarm &= 0xc0ff;
1059 }
1060
1061 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) {
1062 data->fan_div[chan] =
1063 adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan));
1064 data->fan_min[chan] =
1065 adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan));
1066 data->fan[chan] =
1067 adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan));
1068 data->pwm[chan] =
1069 0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >>
1070 (4*chan));
1071 }
1072 data->last_updated = jiffies;
1073 data->valid = 1;
1074 }
1075
1076 mutex_unlock(&data->update_lock);
1077
1078 return data;
1079 }
1080
1081 static int __init sensors_adm1031_init(void)
1082 {
1083 return i2c_add_driver(&adm1031_driver);
1084 }
1085
1086 static void __exit sensors_adm1031_exit(void)
1087 {
1088 i2c_del_driver(&adm1031_driver);
1089 }
1090
1091 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1092 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1093 MODULE_LICENSE("GPL");
1094
1095 module_init(sensors_adm1031_init);
1096 module_exit(sensors_adm1031_exit);