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