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 <jdelvare@suse.de>
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 i2c_client *client;
78 const struct attribute_group *groups[3];
79 struct mutex update_lock;
80 int chip_type;
81 char valid; /* !=0 if following fields are valid */
82 unsigned long last_updated; /* In jiffies */
83 unsigned int update_interval; /* In milliseconds */
84 /*
85 * The chan_select_table contains the possible configurations for
86 * auto fan control.
87 */
88 const auto_chan_table_t *chan_select_table;
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];
103 s8 temp_offset[3];
104 s8 temp_min[3];
105 s8 temp_max[3];
106 s8 temp_crit[3];
107 };
108
adm1031_read_value(struct i2c_client * client,u8 reg)109 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
110 {
111 return i2c_smbus_read_byte_data(client, reg);
112 }
113
114 static inline int
adm1031_write_value(struct i2c_client * client,u8 reg,unsigned int value)115 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
116 {
117 return i2c_smbus_write_byte_data(client, reg, value);
118 }
119
adm1031_update_device(struct device * dev)120 static struct adm1031_data *adm1031_update_device(struct device *dev)
121 {
122 struct adm1031_data *data = dev_get_drvdata(dev);
123 struct i2c_client *client = data->client;
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 }
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
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
222 #define FAN_FROM_REG(reg, div) ((reg) ? \
223 (11250 * 60) / ((reg) * (div)) : 0)
224
FAN_TO_REG(int reg,int div)225 static int FAN_TO_REG(int reg, int div)
226 {
227 int tmp;
228 tmp = FAN_FROM_REG(clamp_val(reg, 0, 65535), div);
229 return tmp > 255 ? 255 : tmp;
230 }
231
232 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
233
234 #define PWM_TO_REG(val) (clamp_val((val), 0, 255) >> 4)
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) \
242 ((((val) / 500) & 0xf8) | ((reg) & 0x7))
243 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7)))
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
AUTO_TEMP_MAX_TO_REG(int val,int reg,int pwm)255 static 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) \
270 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
271
272 /*
273 * The tables below contains the possible values for the auto fan
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 */
278 static 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 */ },
284 };
285
286 static 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 },
292 };
293
294 /*
295 * That function checks if a bitfield is valid and returns the other bitfield
296 * nearest match if no exact match where found.
297 */
298 static int
get_fan_auto_nearest(struct adm1031_data * data,int chan,u8 val,u8 reg)299 get_fan_auto_nearest(struct adm1031_data *data, int chan, u8 val, u8 reg)
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
306 if (val == 0)
307 return 0;
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) {
318 /*
319 * Save the first match in case of an exact match has
320 * not been found
321 */
322 first_match = i;
323 }
324 }
325
326 if (exact_match >= 0)
327 return exact_match;
328 else if (first_match >= 0)
329 return first_match;
330
331 return -EINVAL;
332 }
333
show_fan_auto_channel(struct device * dev,struct device_attribute * attr,char * buf)334 static ssize_t show_fan_auto_channel(struct device *dev,
335 struct device_attribute *attr, char *buf)
336 {
337 int nr = to_sensor_dev_attr(attr)->index;
338 struct adm1031_data *data = adm1031_update_device(dev);
339 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
340 }
341
342 static ssize_t
set_fan_auto_channel(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)343 set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
344 const char *buf, size_t count)
345 {
346 struct adm1031_data *data = dev_get_drvdata(dev);
347 struct i2c_client *client = data->client;
348 int nr = to_sensor_dev_attr(attr)->index;
349 long val;
350 u8 reg;
351 int ret;
352 u8 old_fan_mode;
353
354 ret = kstrtol(buf, 10, &val);
355 if (ret)
356 return ret;
357
358 old_fan_mode = data->conf1;
359
360 mutex_lock(&data->update_lock);
361
362 ret = get_fan_auto_nearest(data, nr, val, data->conf1);
363 if (ret < 0) {
364 mutex_unlock(&data->update_lock);
365 return ret;
366 }
367 reg = ret;
368 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
369 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
370 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
371 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
372 /*
373 * Switch to Auto Fan Mode
374 * Save PWM registers
375 * Set PWM registers to 33% Both
376 */
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 */
385 adm1031_write_value(client, ADM1031_REG_PWM,
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);
391 mutex_unlock(&data->update_lock);
392 return count;
393 }
394
395 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
396 show_fan_auto_channel, set_fan_auto_channel, 0);
397 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
398 show_fan_auto_channel, set_fan_auto_channel, 1);
399
400 /* Auto Temps */
show_auto_temp_off(struct device * dev,struct device_attribute * attr,char * buf)401 static ssize_t show_auto_temp_off(struct device *dev,
402 struct device_attribute *attr, char *buf)
403 {
404 int nr = to_sensor_dev_attr(attr)->index;
405 struct adm1031_data *data = adm1031_update_device(dev);
406 return sprintf(buf, "%d\n",
407 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
408 }
show_auto_temp_min(struct device * dev,struct device_attribute * attr,char * buf)409 static ssize_t show_auto_temp_min(struct device *dev,
410 struct device_attribute *attr, char *buf)
411 {
412 int nr = to_sensor_dev_attr(attr)->index;
413 struct adm1031_data *data = adm1031_update_device(dev);
414 return sprintf(buf, "%d\n",
415 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
416 }
417 static ssize_t
set_auto_temp_min(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)418 set_auto_temp_min(struct device *dev, struct device_attribute *attr,
419 const char *buf, size_t count)
420 {
421 struct adm1031_data *data = dev_get_drvdata(dev);
422 struct i2c_client *client = data->client;
423 int nr = to_sensor_dev_attr(attr)->index;
424 long val;
425 int ret;
426
427 ret = kstrtol(buf, 10, &val);
428 if (ret)
429 return ret;
430
431 val = clamp_val(val, 0, 127000);
432 mutex_lock(&data->update_lock);
433 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
434 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
435 data->auto_temp[nr]);
436 mutex_unlock(&data->update_lock);
437 return count;
438 }
show_auto_temp_max(struct device * dev,struct device_attribute * attr,char * buf)439 static ssize_t show_auto_temp_max(struct device *dev,
440 struct device_attribute *attr, char *buf)
441 {
442 int nr = to_sensor_dev_attr(attr)->index;
443 struct adm1031_data *data = adm1031_update_device(dev);
444 return sprintf(buf, "%d\n",
445 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
446 }
447 static ssize_t
set_auto_temp_max(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)448 set_auto_temp_max(struct device *dev, struct device_attribute *attr,
449 const char *buf, size_t count)
450 {
451 struct adm1031_data *data = dev_get_drvdata(dev);
452 struct i2c_client *client = data->client;
453 int nr = to_sensor_dev_attr(attr)->index;
454 long val;
455 int ret;
456
457 ret = kstrtol(buf, 10, &val);
458 if (ret)
459 return ret;
460
461 val = clamp_val(val, 0, 127000);
462 mutex_lock(&data->update_lock);
463 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
464 data->pwm[nr]);
465 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
466 data->temp_max[nr]);
467 mutex_unlock(&data->update_lock);
468 return count;
469 }
470
471 #define auto_temp_reg(offset) \
472 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
473 show_auto_temp_off, NULL, offset - 1); \
474 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
475 show_auto_temp_min, set_auto_temp_min, offset - 1); \
476 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
477 show_auto_temp_max, set_auto_temp_max, offset - 1)
478
479 auto_temp_reg(1);
480 auto_temp_reg(2);
481 auto_temp_reg(3);
482
483 /* pwm */
show_pwm(struct device * dev,struct device_attribute * attr,char * buf)484 static ssize_t show_pwm(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 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
490 }
set_pwm(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)491 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
492 const char *buf, size_t count)
493 {
494 struct adm1031_data *data = dev_get_drvdata(dev);
495 struct i2c_client *client = data->client;
496 int nr = to_sensor_dev_attr(attr)->index;
497 long val;
498 int ret, reg;
499
500 ret = kstrtol(buf, 10, &val);
501 if (ret)
502 return ret;
503
504 mutex_lock(&data->update_lock);
505 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
506 (((val>>4) & 0xf) != 5)) {
507 /* In automatic mode, the only PWM accepted is 33% */
508 mutex_unlock(&data->update_lock);
509 return -EINVAL;
510 }
511 data->pwm[nr] = PWM_TO_REG(val);
512 reg = adm1031_read_value(client, ADM1031_REG_PWM);
513 adm1031_write_value(client, ADM1031_REG_PWM,
514 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
515 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
516 mutex_unlock(&data->update_lock);
517 return count;
518 }
519
520 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
521 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
522 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
523 show_pwm, set_pwm, 0);
524 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
525 show_pwm, set_pwm, 1);
526
527 /* Fans */
528
529 /*
530 * That function checks the cases where the fan reading is not
531 * relevant. It is used to provide 0 as fan reading when the fan is
532 * not supposed to run
533 */
trust_fan_readings(struct adm1031_data * data,int chan)534 static int trust_fan_readings(struct adm1031_data *data, int chan)
535 {
536 int res = 0;
537
538 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
539 switch (data->conf1 & 0x60) {
540 case 0x00:
541 /*
542 * remote temp1 controls fan1,
543 * remote temp2 controls fan2
544 */
545 res = data->temp[chan+1] >=
546 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
547 break;
548 case 0x20: /* remote temp1 controls both fans */
549 res =
550 data->temp[1] >=
551 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
552 break;
553 case 0x40: /* remote temp2 controls both fans */
554 res =
555 data->temp[2] >=
556 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
557 break;
558 case 0x60: /* max controls both fans */
559 res =
560 data->temp[0] >=
561 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
562 || data->temp[1] >=
563 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
564 || (data->chip_type == adm1031
565 && data->temp[2] >=
566 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
567 break;
568 }
569 } else {
570 res = data->pwm[chan] > 0;
571 }
572 return res;
573 }
574
575
show_fan(struct device * dev,struct device_attribute * attr,char * buf)576 static ssize_t show_fan(struct device *dev,
577 struct device_attribute *attr, char *buf)
578 {
579 int nr = to_sensor_dev_attr(attr)->index;
580 struct adm1031_data *data = adm1031_update_device(dev);
581 int value;
582
583 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
584 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
585 return sprintf(buf, "%d\n", value);
586 }
587
show_fan_div(struct device * dev,struct device_attribute * attr,char * buf)588 static ssize_t show_fan_div(struct device *dev,
589 struct device_attribute *attr, char *buf)
590 {
591 int nr = to_sensor_dev_attr(attr)->index;
592 struct adm1031_data *data = adm1031_update_device(dev);
593 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
594 }
show_fan_min(struct device * dev,struct device_attribute * attr,char * buf)595 static ssize_t show_fan_min(struct device *dev,
596 struct device_attribute *attr, char *buf)
597 {
598 int nr = to_sensor_dev_attr(attr)->index;
599 struct adm1031_data *data = adm1031_update_device(dev);
600 return sprintf(buf, "%d\n",
601 FAN_FROM_REG(data->fan_min[nr],
602 FAN_DIV_FROM_REG(data->fan_div[nr])));
603 }
set_fan_min(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)604 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
605 const char *buf, size_t count)
606 {
607 struct adm1031_data *data = dev_get_drvdata(dev);
608 struct i2c_client *client = data->client;
609 int nr = to_sensor_dev_attr(attr)->index;
610 long val;
611 int ret;
612
613 ret = kstrtol(buf, 10, &val);
614 if (ret)
615 return ret;
616
617 mutex_lock(&data->update_lock);
618 if (val) {
619 data->fan_min[nr] =
620 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
621 } else {
622 data->fan_min[nr] = 0xff;
623 }
624 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
625 mutex_unlock(&data->update_lock);
626 return count;
627 }
set_fan_div(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)628 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
629 const char *buf, size_t count)
630 {
631 struct adm1031_data *data = dev_get_drvdata(dev);
632 struct i2c_client *client = data->client;
633 int nr = to_sensor_dev_attr(attr)->index;
634 long val;
635 u8 tmp;
636 int old_div;
637 int new_min;
638 int ret;
639
640 ret = kstrtol(buf, 10, &val);
641 if (ret)
642 return ret;
643
644 tmp = val == 8 ? 0xc0 :
645 val == 4 ? 0x80 :
646 val == 2 ? 0x40 :
647 val == 1 ? 0x00 :
648 0xff;
649 if (tmp == 0xff)
650 return -EINVAL;
651
652 mutex_lock(&data->update_lock);
653 /* Get fresh readings */
654 data->fan_div[nr] = adm1031_read_value(client,
655 ADM1031_REG_FAN_DIV(nr));
656 data->fan_min[nr] = adm1031_read_value(client,
657 ADM1031_REG_FAN_MIN(nr));
658
659 /* Write the new clock divider and fan min */
660 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
661 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
662 new_min = data->fan_min[nr] * old_div / val;
663 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
664
665 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
666 data->fan_div[nr]);
667 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
668 data->fan_min[nr]);
669
670 /* Invalidate the cache: fan speed is no longer valid */
671 data->valid = 0;
672 mutex_unlock(&data->update_lock);
673 return count;
674 }
675
676 #define fan_offset(offset) \
677 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
678 show_fan, NULL, offset - 1); \
679 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
680 show_fan_min, set_fan_min, offset - 1); \
681 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
682 show_fan_div, set_fan_div, offset - 1)
683
684 fan_offset(1);
685 fan_offset(2);
686
687
688 /* Temps */
show_temp(struct device * dev,struct device_attribute * attr,char * buf)689 static ssize_t show_temp(struct device *dev,
690 struct device_attribute *attr, char *buf)
691 {
692 int nr = to_sensor_dev_attr(attr)->index;
693 struct adm1031_data *data = adm1031_update_device(dev);
694 int ext;
695 ext = nr == 0 ?
696 ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
697 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
698 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
699 }
show_temp_offset(struct device * dev,struct device_attribute * attr,char * buf)700 static ssize_t show_temp_offset(struct device *dev,
701 struct device_attribute *attr, char *buf)
702 {
703 int nr = to_sensor_dev_attr(attr)->index;
704 struct adm1031_data *data = adm1031_update_device(dev);
705 return sprintf(buf, "%d\n",
706 TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
707 }
show_temp_min(struct device * dev,struct device_attribute * attr,char * buf)708 static ssize_t show_temp_min(struct device *dev,
709 struct device_attribute *attr, char *buf)
710 {
711 int nr = to_sensor_dev_attr(attr)->index;
712 struct adm1031_data *data = adm1031_update_device(dev);
713 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
714 }
show_temp_max(struct device * dev,struct device_attribute * attr,char * buf)715 static ssize_t show_temp_max(struct device *dev,
716 struct device_attribute *attr, char *buf)
717 {
718 int nr = to_sensor_dev_attr(attr)->index;
719 struct adm1031_data *data = adm1031_update_device(dev);
720 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
721 }
show_temp_crit(struct device * dev,struct device_attribute * attr,char * buf)722 static ssize_t show_temp_crit(struct device *dev,
723 struct device_attribute *attr, char *buf)
724 {
725 int nr = to_sensor_dev_attr(attr)->index;
726 struct adm1031_data *data = adm1031_update_device(dev);
727 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
728 }
set_temp_offset(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)729 static ssize_t set_temp_offset(struct device *dev,
730 struct device_attribute *attr, const char *buf,
731 size_t count)
732 {
733 struct adm1031_data *data = dev_get_drvdata(dev);
734 struct i2c_client *client = data->client;
735 int nr = to_sensor_dev_attr(attr)->index;
736 long val;
737 int ret;
738
739 ret = kstrtol(buf, 10, &val);
740 if (ret)
741 return ret;
742
743 val = clamp_val(val, -15000, 15000);
744 mutex_lock(&data->update_lock);
745 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
746 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
747 data->temp_offset[nr]);
748 mutex_unlock(&data->update_lock);
749 return count;
750 }
set_temp_min(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)751 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
752 const char *buf, size_t count)
753 {
754 struct adm1031_data *data = dev_get_drvdata(dev);
755 struct i2c_client *client = data->client;
756 int nr = to_sensor_dev_attr(attr)->index;
757 long val;
758 int ret;
759
760 ret = kstrtol(buf, 10, &val);
761 if (ret)
762 return ret;
763
764 val = clamp_val(val, -55000, 127000);
765 mutex_lock(&data->update_lock);
766 data->temp_min[nr] = TEMP_TO_REG(val);
767 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
768 data->temp_min[nr]);
769 mutex_unlock(&data->update_lock);
770 return count;
771 }
set_temp_max(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)772 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
773 const char *buf, size_t count)
774 {
775 struct adm1031_data *data = dev_get_drvdata(dev);
776 struct i2c_client *client = data->client;
777 int nr = to_sensor_dev_attr(attr)->index;
778 long val;
779 int ret;
780
781 ret = kstrtol(buf, 10, &val);
782 if (ret)
783 return ret;
784
785 val = clamp_val(val, -55000, 127000);
786 mutex_lock(&data->update_lock);
787 data->temp_max[nr] = TEMP_TO_REG(val);
788 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
789 data->temp_max[nr]);
790 mutex_unlock(&data->update_lock);
791 return count;
792 }
set_temp_crit(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)793 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
794 const char *buf, size_t count)
795 {
796 struct adm1031_data *data = dev_get_drvdata(dev);
797 struct i2c_client *client = data->client;
798 int nr = to_sensor_dev_attr(attr)->index;
799 long val;
800 int ret;
801
802 ret = kstrtol(buf, 10, &val);
803 if (ret)
804 return ret;
805
806 val = clamp_val(val, -55000, 127000);
807 mutex_lock(&data->update_lock);
808 data->temp_crit[nr] = TEMP_TO_REG(val);
809 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
810 data->temp_crit[nr]);
811 mutex_unlock(&data->update_lock);
812 return count;
813 }
814
815 #define temp_reg(offset) \
816 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
817 show_temp, NULL, offset - 1); \
818 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \
819 show_temp_offset, set_temp_offset, offset - 1); \
820 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
821 show_temp_min, set_temp_min, offset - 1); \
822 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
823 show_temp_max, set_temp_max, offset - 1); \
824 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
825 show_temp_crit, set_temp_crit, offset - 1)
826
827 temp_reg(1);
828 temp_reg(2);
829 temp_reg(3);
830
831 /* Alarms */
show_alarms(struct device * dev,struct device_attribute * attr,char * buf)832 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
833 char *buf)
834 {
835 struct adm1031_data *data = adm1031_update_device(dev);
836 return sprintf(buf, "%d\n", data->alarm);
837 }
838
839 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
840
show_alarm(struct device * dev,struct device_attribute * attr,char * buf)841 static ssize_t show_alarm(struct device *dev,
842 struct device_attribute *attr, char *buf)
843 {
844 int bitnr = to_sensor_dev_attr(attr)->index;
845 struct adm1031_data *data = adm1031_update_device(dev);
846 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
847 }
848
849 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
850 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
851 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
852 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
853 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
854 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
855 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
856 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
857 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
858 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
859 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
860 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
861 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
862 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
863 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
864
865 /* Update Interval */
866 static const unsigned int update_intervals[] = {
867 16000, 8000, 4000, 2000, 1000, 500, 250, 125,
868 };
869
show_update_interval(struct device * dev,struct device_attribute * attr,char * buf)870 static ssize_t show_update_interval(struct device *dev,
871 struct device_attribute *attr, char *buf)
872 {
873 struct adm1031_data *data = dev_get_drvdata(dev);
874
875 return sprintf(buf, "%u\n", data->update_interval);
876 }
877
set_update_interval(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)878 static ssize_t set_update_interval(struct device *dev,
879 struct device_attribute *attr,
880 const char *buf, size_t count)
881 {
882 struct adm1031_data *data = dev_get_drvdata(dev);
883 struct i2c_client *client = data->client;
884 unsigned long val;
885 int i, err;
886 u8 reg;
887
888 err = kstrtoul(buf, 10, &val);
889 if (err)
890 return err;
891
892 /*
893 * Find the nearest update interval from the table.
894 * Use it to determine the matching update rate.
895 */
896 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
897 if (val >= update_intervals[i])
898 break;
899 }
900 /* if not found, we point to the last entry (lowest update interval) */
901
902 /* set the new update rate while preserving other settings */
903 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
904 reg &= ~ADM1031_UPDATE_RATE_MASK;
905 reg |= i << ADM1031_UPDATE_RATE_SHIFT;
906 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
907
908 mutex_lock(&data->update_lock);
909 data->update_interval = update_intervals[i];
910 mutex_unlock(&data->update_lock);
911
912 return count;
913 }
914
915 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
916 set_update_interval);
917
918 static struct attribute *adm1031_attributes[] = {
919 &sensor_dev_attr_fan1_input.dev_attr.attr,
920 &sensor_dev_attr_fan1_div.dev_attr.attr,
921 &sensor_dev_attr_fan1_min.dev_attr.attr,
922 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
923 &sensor_dev_attr_fan1_fault.dev_attr.attr,
924 &sensor_dev_attr_pwm1.dev_attr.attr,
925 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
926 &sensor_dev_attr_temp1_input.dev_attr.attr,
927 &sensor_dev_attr_temp1_offset.dev_attr.attr,
928 &sensor_dev_attr_temp1_min.dev_attr.attr,
929 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
930 &sensor_dev_attr_temp1_max.dev_attr.attr,
931 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
932 &sensor_dev_attr_temp1_crit.dev_attr.attr,
933 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
934 &sensor_dev_attr_temp2_input.dev_attr.attr,
935 &sensor_dev_attr_temp2_offset.dev_attr.attr,
936 &sensor_dev_attr_temp2_min.dev_attr.attr,
937 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
938 &sensor_dev_attr_temp2_max.dev_attr.attr,
939 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
940 &sensor_dev_attr_temp2_crit.dev_attr.attr,
941 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
942 &sensor_dev_attr_temp2_fault.dev_attr.attr,
943
944 &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
945 &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
946 &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
947
948 &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
949 &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
950 &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
951
952 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
953
954 &dev_attr_update_interval.attr,
955 &dev_attr_alarms.attr,
956
957 NULL
958 };
959
960 static const struct attribute_group adm1031_group = {
961 .attrs = adm1031_attributes,
962 };
963
964 static struct attribute *adm1031_attributes_opt[] = {
965 &sensor_dev_attr_fan2_input.dev_attr.attr,
966 &sensor_dev_attr_fan2_div.dev_attr.attr,
967 &sensor_dev_attr_fan2_min.dev_attr.attr,
968 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
969 &sensor_dev_attr_fan2_fault.dev_attr.attr,
970 &sensor_dev_attr_pwm2.dev_attr.attr,
971 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
972 &sensor_dev_attr_temp3_input.dev_attr.attr,
973 &sensor_dev_attr_temp3_offset.dev_attr.attr,
974 &sensor_dev_attr_temp3_min.dev_attr.attr,
975 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
976 &sensor_dev_attr_temp3_max.dev_attr.attr,
977 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
978 &sensor_dev_attr_temp3_crit.dev_attr.attr,
979 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
980 &sensor_dev_attr_temp3_fault.dev_attr.attr,
981 &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
982 &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
983 &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
984 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
985 NULL
986 };
987
988 static const struct attribute_group adm1031_group_opt = {
989 .attrs = adm1031_attributes_opt,
990 };
991
992 /* Return 0 if detection is successful, -ENODEV otherwise */
adm1031_detect(struct i2c_client * client,struct i2c_board_info * info)993 static int adm1031_detect(struct i2c_client *client,
994 struct i2c_board_info *info)
995 {
996 struct i2c_adapter *adapter = client->adapter;
997 const char *name;
998 int id, co;
999
1000 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1001 return -ENODEV;
1002
1003 id = i2c_smbus_read_byte_data(client, 0x3d);
1004 co = i2c_smbus_read_byte_data(client, 0x3e);
1005
1006 if (!((id == 0x31 || id == 0x30) && co == 0x41))
1007 return -ENODEV;
1008 name = (id == 0x30) ? "adm1030" : "adm1031";
1009
1010 strlcpy(info->type, name, I2C_NAME_SIZE);
1011
1012 return 0;
1013 }
1014
adm1031_init_client(struct i2c_client * client)1015 static void adm1031_init_client(struct i2c_client *client)
1016 {
1017 unsigned int read_val;
1018 unsigned int mask;
1019 int i;
1020 struct adm1031_data *data = i2c_get_clientdata(client);
1021
1022 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1023 if (data->chip_type == adm1031) {
1024 mask |= (ADM1031_CONF2_PWM2_ENABLE |
1025 ADM1031_CONF2_TACH2_ENABLE);
1026 }
1027 /* Initialize the ADM1031 chip (enables fan speed reading ) */
1028 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1029 if ((read_val | mask) != read_val)
1030 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1031
1032 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1033 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1034 adm1031_write_value(client, ADM1031_REG_CONF1,
1035 read_val | ADM1031_CONF1_MONITOR_ENABLE);
1036 }
1037
1038 /* Read the chip's update rate */
1039 mask = ADM1031_UPDATE_RATE_MASK;
1040 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1041 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1042 /* Save it as update interval */
1043 data->update_interval = update_intervals[i];
1044 }
1045
adm1031_probe(struct i2c_client * client,const struct i2c_device_id * id)1046 static int adm1031_probe(struct i2c_client *client,
1047 const struct i2c_device_id *id)
1048 {
1049 struct device *dev = &client->dev;
1050 struct device *hwmon_dev;
1051 struct adm1031_data *data;
1052
1053 data = devm_kzalloc(dev, sizeof(struct adm1031_data), GFP_KERNEL);
1054 if (!data)
1055 return -ENOMEM;
1056
1057 i2c_set_clientdata(client, data);
1058 data->client = client;
1059 data->chip_type = id->driver_data;
1060 mutex_init(&data->update_lock);
1061
1062 if (data->chip_type == adm1030)
1063 data->chan_select_table = &auto_channel_select_table_adm1030;
1064 else
1065 data->chan_select_table = &auto_channel_select_table_adm1031;
1066
1067 /* Initialize the ADM1031 chip */
1068 adm1031_init_client(client);
1069
1070 /* sysfs hooks */
1071 data->groups[0] = &adm1031_group;
1072 if (data->chip_type == adm1031)
1073 data->groups[1] = &adm1031_group_opt;
1074
1075 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1076 data, data->groups);
1077 return PTR_ERR_OR_ZERO(hwmon_dev);
1078 }
1079
1080 static const struct i2c_device_id adm1031_id[] = {
1081 { "adm1030", adm1030 },
1082 { "adm1031", adm1031 },
1083 { }
1084 };
1085 MODULE_DEVICE_TABLE(i2c, adm1031_id);
1086
1087 static struct i2c_driver adm1031_driver = {
1088 .class = I2C_CLASS_HWMON,
1089 .driver = {
1090 .name = "adm1031",
1091 },
1092 .probe = adm1031_probe,
1093 .id_table = adm1031_id,
1094 .detect = adm1031_detect,
1095 .address_list = normal_i2c,
1096 };
1097
1098 module_i2c_driver(adm1031_driver);
1099
1100 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1101 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1102 MODULE_LICENSE("GPL");
1103