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