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