2 * lm78.c - Part of lm_sensors, Linux kernel modules for hardware
4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 * Copyright (c) 2007, 2011 Jean Delvare <khali@linux-fr.org>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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-vid.h>
31 #include <linux/hwmon-sysfs.h>
32 #include <linux/err.h>
33 #include <linux/mutex.h>
36 #include <linux/platform_device.h>
37 #include <linux/ioport.h>
41 /* Addresses to scan */
42 static const unsigned short normal_i2c
[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
43 0x2e, 0x2f, I2C_CLIENT_END
};
44 enum chips
{ lm78
, lm79
};
46 /* Many LM78 constants specified below */
48 /* Length of ISA address segment */
51 /* Where are the ISA address/data registers relative to the base address */
52 #define LM78_ADDR_REG_OFFSET 5
53 #define LM78_DATA_REG_OFFSET 6
55 /* The LM78 registers */
56 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
57 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
58 #define LM78_REG_IN(nr) (0x20 + (nr))
60 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
61 #define LM78_REG_FAN(nr) (0x28 + (nr))
63 #define LM78_REG_TEMP 0x27
64 #define LM78_REG_TEMP_OVER 0x39
65 #define LM78_REG_TEMP_HYST 0x3a
67 #define LM78_REG_ALARM1 0x41
68 #define LM78_REG_ALARM2 0x42
70 #define LM78_REG_VID_FANDIV 0x47
72 #define LM78_REG_CONFIG 0x40
73 #define LM78_REG_CHIPID 0x49
74 #define LM78_REG_I2C_ADDR 0x48
78 * Conversions. Rounding and limit checking is only done on the TO_REG
83 * IN: mV (0V to 4.08V)
86 static inline u8
IN_TO_REG(unsigned long val
)
88 unsigned long nval
= clamp_val(val
, 0, 4080);
89 return (nval
+ 8) / 16;
91 #define IN_FROM_REG(val) ((val) * 16)
93 static inline u8
FAN_TO_REG(long rpm
, int div
)
97 return clamp_val((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1, 254);
100 static inline int FAN_FROM_REG(u8 val
, int div
)
102 return val
== 0 ? -1 : val
== 255 ? 0 : 1350000 / (val
* div
);
106 * TEMP: mC (-128C to +127C)
107 * REG: 1C/bit, two's complement
109 static inline s8
TEMP_TO_REG(int val
)
111 int nval
= clamp_val(val
, -128000, 127000) ;
112 return nval
< 0 ? (nval
- 500) / 1000 : (nval
+ 500) / 1000;
115 static inline int TEMP_FROM_REG(s8 val
)
120 #define DIV_FROM_REG(val) (1 << (val))
123 struct i2c_client
*client
;
124 struct device
*hwmon_dev
;
128 /* For ISA device only */
132 struct mutex update_lock
;
133 char valid
; /* !=0 if following fields are valid */
134 unsigned long last_updated
; /* In jiffies */
136 u8 in
[7]; /* Register value */
137 u8 in_max
[7]; /* Register value */
138 u8 in_min
[7]; /* Register value */
139 u8 fan
[3]; /* Register value */
140 u8 fan_min
[3]; /* Register value */
141 s8 temp
; /* Register value */
142 s8 temp_over
; /* Register value */
143 s8 temp_hyst
; /* Register value */
144 u8 fan_div
[3]; /* Register encoding, shifted right */
145 u8 vid
; /* Register encoding, combined */
146 u16 alarms
; /* Register encoding, combined */
150 static int lm78_read_value(struct lm78_data
*data
, u8 reg
);
151 static int lm78_write_value(struct lm78_data
*data
, u8 reg
, u8 value
);
152 static struct lm78_data
*lm78_update_device(struct device
*dev
);
153 static void lm78_init_device(struct lm78_data
*data
);
157 static ssize_t
show_in(struct device
*dev
, struct device_attribute
*da
,
160 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
161 struct lm78_data
*data
= lm78_update_device(dev
);
162 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in
[attr
->index
]));
165 static ssize_t
show_in_min(struct device
*dev
, struct device_attribute
*da
,
168 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
169 struct lm78_data
*data
= lm78_update_device(dev
);
170 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_min
[attr
->index
]));
173 static ssize_t
show_in_max(struct device
*dev
, struct device_attribute
*da
,
176 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
177 struct lm78_data
*data
= lm78_update_device(dev
);
178 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_max
[attr
->index
]));
181 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
*da
,
182 const char *buf
, size_t count
)
184 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
185 struct lm78_data
*data
= dev_get_drvdata(dev
);
186 int nr
= attr
->index
;
190 err
= kstrtoul(buf
, 10, &val
);
194 mutex_lock(&data
->update_lock
);
195 data
->in_min
[nr
] = IN_TO_REG(val
);
196 lm78_write_value(data
, LM78_REG_IN_MIN(nr
), data
->in_min
[nr
]);
197 mutex_unlock(&data
->update_lock
);
201 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
*da
,
202 const char *buf
, size_t count
)
204 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
205 struct lm78_data
*data
= dev_get_drvdata(dev
);
206 int nr
= attr
->index
;
210 err
= kstrtoul(buf
, 10, &val
);
214 mutex_lock(&data
->update_lock
);
215 data
->in_max
[nr
] = IN_TO_REG(val
);
216 lm78_write_value(data
, LM78_REG_IN_MAX(nr
), data
->in_max
[nr
]);
217 mutex_unlock(&data
->update_lock
);
221 #define show_in_offset(offset) \
222 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
223 show_in, NULL, offset); \
224 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
225 show_in_min, set_in_min, offset); \
226 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
227 show_in_max, set_in_max, offset);
238 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*da
,
241 struct lm78_data
*data
= lm78_update_device(dev
);
242 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp
));
245 static ssize_t
show_temp_over(struct device
*dev
, struct device_attribute
*da
,
248 struct lm78_data
*data
= lm78_update_device(dev
);
249 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_over
));
252 static ssize_t
set_temp_over(struct device
*dev
, struct device_attribute
*da
,
253 const char *buf
, size_t count
)
255 struct lm78_data
*data
= dev_get_drvdata(dev
);
259 err
= kstrtol(buf
, 10, &val
);
263 mutex_lock(&data
->update_lock
);
264 data
->temp_over
= TEMP_TO_REG(val
);
265 lm78_write_value(data
, LM78_REG_TEMP_OVER
, data
->temp_over
);
266 mutex_unlock(&data
->update_lock
);
270 static ssize_t
show_temp_hyst(struct device
*dev
, struct device_attribute
*da
,
273 struct lm78_data
*data
= lm78_update_device(dev
);
274 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_hyst
));
277 static ssize_t
set_temp_hyst(struct device
*dev
, struct device_attribute
*da
,
278 const char *buf
, size_t count
)
280 struct lm78_data
*data
= dev_get_drvdata(dev
);
284 err
= kstrtol(buf
, 10, &val
);
288 mutex_lock(&data
->update_lock
);
289 data
->temp_hyst
= TEMP_TO_REG(val
);
290 lm78_write_value(data
, LM78_REG_TEMP_HYST
, data
->temp_hyst
);
291 mutex_unlock(&data
->update_lock
);
295 static DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
);
296 static DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
,
297 show_temp_over
, set_temp_over
);
298 static DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
299 show_temp_hyst
, set_temp_hyst
);
302 static ssize_t
show_fan(struct device
*dev
, struct device_attribute
*da
,
305 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
306 struct lm78_data
*data
= lm78_update_device(dev
);
307 int nr
= attr
->index
;
308 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[nr
],
309 DIV_FROM_REG(data
->fan_div
[nr
])));
312 static ssize_t
show_fan_min(struct device
*dev
, struct device_attribute
*da
,
315 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
316 struct lm78_data
*data
= lm78_update_device(dev
);
317 int nr
= attr
->index
;
318 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_min
[nr
],
319 DIV_FROM_REG(data
->fan_div
[nr
])));
322 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*da
,
323 const char *buf
, size_t count
)
325 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
326 struct lm78_data
*data
= dev_get_drvdata(dev
);
327 int nr
= attr
->index
;
331 err
= kstrtoul(buf
, 10, &val
);
335 mutex_lock(&data
->update_lock
);
336 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
337 lm78_write_value(data
, LM78_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
338 mutex_unlock(&data
->update_lock
);
342 static ssize_t
show_fan_div(struct device
*dev
, struct device_attribute
*da
,
345 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
346 struct lm78_data
*data
= lm78_update_device(dev
);
347 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[attr
->index
]));
351 * Note: we save and restore the fan minimum here, because its value is
352 * determined in part by the fan divisor. This follows the principle of
353 * least surprise; the user doesn't expect the fan minimum to change just
354 * because the divisor changed.
356 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*da
,
357 const char *buf
, size_t count
)
359 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(da
);
360 struct lm78_data
*data
= dev_get_drvdata(dev
);
361 int nr
= attr
->index
;
367 err
= kstrtoul(buf
, 10, &val
);
371 mutex_lock(&data
->update_lock
);
372 min
= FAN_FROM_REG(data
->fan_min
[nr
],
373 DIV_FROM_REG(data
->fan_div
[nr
]));
377 data
->fan_div
[nr
] = 0;
380 data
->fan_div
[nr
] = 1;
383 data
->fan_div
[nr
] = 2;
386 data
->fan_div
[nr
] = 3;
390 "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
392 mutex_unlock(&data
->update_lock
);
396 reg
= lm78_read_value(data
, LM78_REG_VID_FANDIV
);
399 reg
= (reg
& 0xcf) | (data
->fan_div
[nr
] << 4);
402 reg
= (reg
& 0x3f) | (data
->fan_div
[nr
] << 6);
405 lm78_write_value(data
, LM78_REG_VID_FANDIV
, reg
);
408 FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
409 lm78_write_value(data
, LM78_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
410 mutex_unlock(&data
->update_lock
);
415 #define show_fan_offset(offset) \
416 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
417 show_fan, NULL, offset - 1); \
418 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
419 show_fan_min, set_fan_min, offset - 1);
425 /* Fan 3 divisor is locked in H/W */
426 static SENSOR_DEVICE_ATTR(fan1_div
, S_IRUGO
| S_IWUSR
,
427 show_fan_div
, set_fan_div
, 0);
428 static SENSOR_DEVICE_ATTR(fan2_div
, S_IRUGO
| S_IWUSR
,
429 show_fan_div
, set_fan_div
, 1);
430 static SENSOR_DEVICE_ATTR(fan3_div
, S_IRUGO
, show_fan_div
, NULL
, 2);
433 static ssize_t
show_vid(struct device
*dev
, struct device_attribute
*da
,
436 struct lm78_data
*data
= lm78_update_device(dev
);
437 return sprintf(buf
, "%d\n", vid_from_reg(data
->vid
, 82));
439 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid
, NULL
);
442 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*da
,
445 struct lm78_data
*data
= lm78_update_device(dev
);
446 return sprintf(buf
, "%u\n", data
->alarms
);
448 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
450 static ssize_t
show_alarm(struct device
*dev
, struct device_attribute
*da
,
453 struct lm78_data
*data
= lm78_update_device(dev
);
454 int nr
= to_sensor_dev_attr(da
)->index
;
455 return sprintf(buf
, "%u\n", (data
->alarms
>> nr
) & 1);
457 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, show_alarm
, NULL
, 0);
458 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, show_alarm
, NULL
, 1);
459 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, show_alarm
, NULL
, 2);
460 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, show_alarm
, NULL
, 3);
461 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, show_alarm
, NULL
, 8);
462 static SENSOR_DEVICE_ATTR(in5_alarm
, S_IRUGO
, show_alarm
, NULL
, 9);
463 static SENSOR_DEVICE_ATTR(in6_alarm
, S_IRUGO
, show_alarm
, NULL
, 10);
464 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, show_alarm
, NULL
, 6);
465 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, show_alarm
, NULL
, 7);
466 static SENSOR_DEVICE_ATTR(fan3_alarm
, S_IRUGO
, show_alarm
, NULL
, 11);
467 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, show_alarm
, NULL
, 4);
469 static struct attribute
*lm78_attributes
[] = {
470 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
471 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
472 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
473 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
474 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
475 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
476 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
477 &sensor_dev_attr_in1_alarm
.dev_attr
.attr
,
478 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
479 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
480 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
481 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
482 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
483 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
484 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
485 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
486 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
487 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
488 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
489 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
490 &sensor_dev_attr_in5_input
.dev_attr
.attr
,
491 &sensor_dev_attr_in5_min
.dev_attr
.attr
,
492 &sensor_dev_attr_in5_max
.dev_attr
.attr
,
493 &sensor_dev_attr_in5_alarm
.dev_attr
.attr
,
494 &sensor_dev_attr_in6_input
.dev_attr
.attr
,
495 &sensor_dev_attr_in6_min
.dev_attr
.attr
,
496 &sensor_dev_attr_in6_max
.dev_attr
.attr
,
497 &sensor_dev_attr_in6_alarm
.dev_attr
.attr
,
498 &dev_attr_temp1_input
.attr
,
499 &dev_attr_temp1_max
.attr
,
500 &dev_attr_temp1_max_hyst
.attr
,
501 &sensor_dev_attr_temp1_alarm
.dev_attr
.attr
,
502 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
503 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
504 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
505 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
506 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
507 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
508 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
509 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
510 &sensor_dev_attr_fan3_input
.dev_attr
.attr
,
511 &sensor_dev_attr_fan3_min
.dev_attr
.attr
,
512 &sensor_dev_attr_fan3_div
.dev_attr
.attr
,
513 &sensor_dev_attr_fan3_alarm
.dev_attr
.attr
,
514 &dev_attr_alarms
.attr
,
515 &dev_attr_cpu0_vid
.attr
,
520 static const struct attribute_group lm78_group
= {
521 .attrs
= lm78_attributes
,
529 /* ISA device, if found */
530 static struct platform_device
*pdev
;
532 static unsigned short isa_address
= 0x290;
535 * I2C devices get this name attribute automatically, but for ISA devices
536 * we must create it by ourselves.
538 static ssize_t
show_name(struct device
*dev
, struct device_attribute
541 struct lm78_data
*data
= dev_get_drvdata(dev
);
543 return sprintf(buf
, "%s\n", data
->name
);
545 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
547 static struct lm78_data
*lm78_data_if_isa(void)
549 return pdev
? platform_get_drvdata(pdev
) : NULL
;
552 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
553 static int lm78_alias_detect(struct i2c_client
*client
, u8 chipid
)
555 struct lm78_data
*isa
;
558 if (!pdev
) /* No ISA chip */
560 isa
= platform_get_drvdata(pdev
);
562 if (lm78_read_value(isa
, LM78_REG_I2C_ADDR
) != client
->addr
)
563 return 0; /* Address doesn't match */
564 if ((lm78_read_value(isa
, LM78_REG_CHIPID
) & 0xfe) != (chipid
& 0xfe))
565 return 0; /* Chip type doesn't match */
568 * We compare all the limit registers, the config register and the
569 * interrupt mask registers
571 for (i
= 0x2b; i
<= 0x3d; i
++) {
572 if (lm78_read_value(isa
, i
) !=
573 i2c_smbus_read_byte_data(client
, i
))
576 if (lm78_read_value(isa
, LM78_REG_CONFIG
) !=
577 i2c_smbus_read_byte_data(client
, LM78_REG_CONFIG
))
579 for (i
= 0x43; i
<= 0x46; i
++) {
580 if (lm78_read_value(isa
, i
) !=
581 i2c_smbus_read_byte_data(client
, i
))
587 #else /* !CONFIG_ISA */
589 static int lm78_alias_detect(struct i2c_client
*client
, u8 chipid
)
594 static struct lm78_data
*lm78_data_if_isa(void)
598 #endif /* CONFIG_ISA */
600 static int lm78_i2c_detect(struct i2c_client
*client
,
601 struct i2c_board_info
*info
)
604 struct lm78_data
*isa
= lm78_data_if_isa();
605 const char *client_name
;
606 struct i2c_adapter
*adapter
= client
->adapter
;
607 int address
= client
->addr
;
609 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
613 * We block updates of the ISA device to minimize the risk of
614 * concurrent access to the same LM78 chip through different
618 mutex_lock(&isa
->update_lock
);
620 if ((i2c_smbus_read_byte_data(client
, LM78_REG_CONFIG
) & 0x80)
621 || i2c_smbus_read_byte_data(client
, LM78_REG_I2C_ADDR
) != address
)
624 /* Explicitly prevent the misdetection of Winbond chips */
625 i
= i2c_smbus_read_byte_data(client
, 0x4f);
626 if (i
== 0xa3 || i
== 0x5c)
629 /* Determine the chip type. */
630 i
= i2c_smbus_read_byte_data(client
, LM78_REG_CHIPID
);
631 if (i
== 0x00 || i
== 0x20 /* LM78 */
632 || i
== 0x40) /* LM78-J */
633 client_name
= "lm78";
634 else if ((i
& 0xfe) == 0xc0)
635 client_name
= "lm79";
639 if (lm78_alias_detect(client
, i
)) {
640 dev_dbg(&adapter
->dev
,
641 "Device at 0x%02x appears to be the same as ISA device\n",
647 mutex_unlock(&isa
->update_lock
);
649 strlcpy(info
->type
, client_name
, I2C_NAME_SIZE
);
655 mutex_unlock(&isa
->update_lock
);
659 static int lm78_i2c_probe(struct i2c_client
*client
,
660 const struct i2c_device_id
*id
)
662 struct lm78_data
*data
;
665 data
= devm_kzalloc(&client
->dev
, sizeof(struct lm78_data
), GFP_KERNEL
);
669 i2c_set_clientdata(client
, data
);
670 data
->client
= client
;
671 data
->type
= id
->driver_data
;
673 /* Initialize the LM78 chip */
674 lm78_init_device(data
);
676 /* Register sysfs hooks */
677 err
= sysfs_create_group(&client
->dev
.kobj
, &lm78_group
);
681 data
->hwmon_dev
= hwmon_device_register(&client
->dev
);
682 if (IS_ERR(data
->hwmon_dev
)) {
683 err
= PTR_ERR(data
->hwmon_dev
);
690 sysfs_remove_group(&client
->dev
.kobj
, &lm78_group
);
694 static int lm78_i2c_remove(struct i2c_client
*client
)
696 struct lm78_data
*data
= i2c_get_clientdata(client
);
698 hwmon_device_unregister(data
->hwmon_dev
);
699 sysfs_remove_group(&client
->dev
.kobj
, &lm78_group
);
704 static const struct i2c_device_id lm78_i2c_id
[] = {
709 MODULE_DEVICE_TABLE(i2c
, lm78_i2c_id
);
711 static struct i2c_driver lm78_driver
= {
712 .class = I2C_CLASS_HWMON
,
716 .probe
= lm78_i2c_probe
,
717 .remove
= lm78_i2c_remove
,
718 .id_table
= lm78_i2c_id
,
719 .detect
= lm78_i2c_detect
,
720 .address_list
= normal_i2c
,
724 * The SMBus locks itself, but ISA access must be locked explicitly!
725 * We don't want to lock the whole ISA bus, so we lock each client
727 * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
728 * would slow down the LM78 access and should not be necessary.
730 static int lm78_read_value(struct lm78_data
*data
, u8 reg
)
732 struct i2c_client
*client
= data
->client
;
735 if (!client
) { /* ISA device */
737 mutex_lock(&data
->lock
);
738 outb_p(reg
, data
->isa_addr
+ LM78_ADDR_REG_OFFSET
);
739 res
= inb_p(data
->isa_addr
+ LM78_DATA_REG_OFFSET
);
740 mutex_unlock(&data
->lock
);
744 return i2c_smbus_read_byte_data(client
, reg
);
747 static int lm78_write_value(struct lm78_data
*data
, u8 reg
, u8 value
)
749 struct i2c_client
*client
= data
->client
;
752 if (!client
) { /* ISA device */
753 mutex_lock(&data
->lock
);
754 outb_p(reg
, data
->isa_addr
+ LM78_ADDR_REG_OFFSET
);
755 outb_p(value
, data
->isa_addr
+ LM78_DATA_REG_OFFSET
);
756 mutex_unlock(&data
->lock
);
760 return i2c_smbus_write_byte_data(client
, reg
, value
);
763 static void lm78_init_device(struct lm78_data
*data
)
768 /* Start monitoring */
769 config
= lm78_read_value(data
, LM78_REG_CONFIG
);
770 if ((config
& 0x09) != 0x01)
771 lm78_write_value(data
, LM78_REG_CONFIG
,
772 (config
& 0xf7) | 0x01);
774 /* A few vars need to be filled upon startup */
775 for (i
= 0; i
< 3; i
++) {
776 data
->fan_min
[i
] = lm78_read_value(data
,
777 LM78_REG_FAN_MIN(i
));
780 mutex_init(&data
->update_lock
);
783 static struct lm78_data
*lm78_update_device(struct device
*dev
)
785 struct lm78_data
*data
= dev_get_drvdata(dev
);
788 mutex_lock(&data
->update_lock
);
790 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
793 dev_dbg(dev
, "Starting lm78 update\n");
795 for (i
= 0; i
<= 6; i
++) {
797 lm78_read_value(data
, LM78_REG_IN(i
));
799 lm78_read_value(data
, LM78_REG_IN_MIN(i
));
801 lm78_read_value(data
, LM78_REG_IN_MAX(i
));
803 for (i
= 0; i
< 3; i
++) {
805 lm78_read_value(data
, LM78_REG_FAN(i
));
807 lm78_read_value(data
, LM78_REG_FAN_MIN(i
));
809 data
->temp
= lm78_read_value(data
, LM78_REG_TEMP
);
811 lm78_read_value(data
, LM78_REG_TEMP_OVER
);
813 lm78_read_value(data
, LM78_REG_TEMP_HYST
);
814 i
= lm78_read_value(data
, LM78_REG_VID_FANDIV
);
815 data
->vid
= i
& 0x0f;
816 if (data
->type
== lm79
)
818 (lm78_read_value(data
, LM78_REG_CHIPID
) &
822 data
->fan_div
[0] = (i
>> 4) & 0x03;
823 data
->fan_div
[1] = i
>> 6;
824 data
->alarms
= lm78_read_value(data
, LM78_REG_ALARM1
) +
825 (lm78_read_value(data
, LM78_REG_ALARM2
) << 8);
826 data
->last_updated
= jiffies
;
829 data
->fan_div
[2] = 1;
832 mutex_unlock(&data
->update_lock
);
838 static int lm78_isa_probe(struct platform_device
*pdev
)
841 struct lm78_data
*data
;
842 struct resource
*res
;
844 /* Reserve the ISA region */
845 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
846 if (!devm_request_region(&pdev
->dev
, res
->start
+ LM78_ADDR_REG_OFFSET
,
850 data
= devm_kzalloc(&pdev
->dev
, sizeof(struct lm78_data
), GFP_KERNEL
);
854 mutex_init(&data
->lock
);
855 data
->isa_addr
= res
->start
;
856 platform_set_drvdata(pdev
, data
);
858 if (lm78_read_value(data
, LM78_REG_CHIPID
) & 0x80) {
866 /* Initialize the LM78 chip */
867 lm78_init_device(data
);
869 /* Register sysfs hooks */
870 err
= sysfs_create_group(&pdev
->dev
.kobj
, &lm78_group
);
872 goto exit_remove_files
;
873 err
= device_create_file(&pdev
->dev
, &dev_attr_name
);
875 goto exit_remove_files
;
877 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
878 if (IS_ERR(data
->hwmon_dev
)) {
879 err
= PTR_ERR(data
->hwmon_dev
);
880 goto exit_remove_files
;
886 sysfs_remove_group(&pdev
->dev
.kobj
, &lm78_group
);
887 device_remove_file(&pdev
->dev
, &dev_attr_name
);
891 static int lm78_isa_remove(struct platform_device
*pdev
)
893 struct lm78_data
*data
= platform_get_drvdata(pdev
);
895 hwmon_device_unregister(data
->hwmon_dev
);
896 sysfs_remove_group(&pdev
->dev
.kobj
, &lm78_group
);
897 device_remove_file(&pdev
->dev
, &dev_attr_name
);
902 static struct platform_driver lm78_isa_driver
= {
904 .owner
= THIS_MODULE
,
907 .probe
= lm78_isa_probe
,
908 .remove
= lm78_isa_remove
,
911 /* return 1 if a supported chip is found, 0 otherwise */
912 static int __init
lm78_isa_found(unsigned short address
)
914 int val
, save
, found
= 0;
918 * Some boards declare base+0 to base+7 as a PNP device, some base+4
919 * to base+7 and some base+5 to base+6. So we better request each port
920 * individually for the probing phase.
922 for (port
= address
; port
< address
+ LM78_EXTENT
; port
++) {
923 if (!request_region(port
, 1, "lm78")) {
924 pr_debug("Failed to request port 0x%x\n", port
);
929 #define REALLY_SLOW_IO
931 * We need the timeouts for at least some LM78-like
932 * chips. But only if we read 'undefined' registers.
934 val
= inb_p(address
+ 1);
935 if (inb_p(address
+ 2) != val
936 || inb_p(address
+ 3) != val
937 || inb_p(address
+ 7) != val
)
939 #undef REALLY_SLOW_IO
942 * We should be able to change the 7 LSB of the address port. The
943 * MSB (busy flag) should be clear initially, set after the write.
945 save
= inb_p(address
+ LM78_ADDR_REG_OFFSET
);
949 outb_p(val
, address
+ LM78_ADDR_REG_OFFSET
);
950 if (inb_p(address
+ LM78_ADDR_REG_OFFSET
) != (val
| 0x80)) {
951 outb_p(save
, address
+ LM78_ADDR_REG_OFFSET
);
955 /* We found a device, now see if it could be an LM78 */
956 outb_p(LM78_REG_CONFIG
, address
+ LM78_ADDR_REG_OFFSET
);
957 val
= inb_p(address
+ LM78_DATA_REG_OFFSET
);
960 outb_p(LM78_REG_I2C_ADDR
, address
+ LM78_ADDR_REG_OFFSET
);
961 val
= inb_p(address
+ LM78_DATA_REG_OFFSET
);
962 if (val
< 0x03 || val
> 0x77) /* Not a valid I2C address */
965 /* The busy flag should be clear again */
966 if (inb_p(address
+ LM78_ADDR_REG_OFFSET
) & 0x80)
969 /* Explicitly prevent the misdetection of Winbond chips */
970 outb_p(0x4f, address
+ LM78_ADDR_REG_OFFSET
);
971 val
= inb_p(address
+ LM78_DATA_REG_OFFSET
);
972 if (val
== 0xa3 || val
== 0x5c)
975 /* Explicitly prevent the misdetection of ITE chips */
976 outb_p(0x58, address
+ LM78_ADDR_REG_OFFSET
);
977 val
= inb_p(address
+ LM78_DATA_REG_OFFSET
);
981 /* Determine the chip type */
982 outb_p(LM78_REG_CHIPID
, address
+ LM78_ADDR_REG_OFFSET
);
983 val
= inb_p(address
+ LM78_DATA_REG_OFFSET
);
984 if (val
== 0x00 || val
== 0x20 /* LM78 */
985 || val
== 0x40 /* LM78-J */
986 || (val
& 0xfe) == 0xc0) /* LM79 */
990 pr_info("Found an %s chip at %#x\n",
991 val
& 0x80 ? "LM79" : "LM78", (int)address
);
994 for (port
--; port
>= address
; port
--)
995 release_region(port
, 1);
999 static int __init
lm78_isa_device_add(unsigned short address
)
1001 struct resource res
= {
1003 .end
= address
+ LM78_EXTENT
- 1,
1005 .flags
= IORESOURCE_IO
,
1009 pdev
= platform_device_alloc("lm78", address
);
1012 pr_err("Device allocation failed\n");
1016 err
= platform_device_add_resources(pdev
, &res
, 1);
1018 pr_err("Device resource addition failed (%d)\n", err
);
1019 goto exit_device_put
;
1022 err
= platform_device_add(pdev
);
1024 pr_err("Device addition failed (%d)\n", err
);
1025 goto exit_device_put
;
1031 platform_device_put(pdev
);
1037 static int __init
lm78_isa_register(void)
1041 if (lm78_isa_found(isa_address
)) {
1042 res
= platform_driver_register(&lm78_isa_driver
);
1046 /* Sets global pdev as a side effect */
1047 res
= lm78_isa_device_add(isa_address
);
1049 goto exit_unreg_isa_driver
;
1054 exit_unreg_isa_driver
:
1055 platform_driver_unregister(&lm78_isa_driver
);
1060 static void lm78_isa_unregister(void)
1063 platform_device_unregister(pdev
);
1064 platform_driver_unregister(&lm78_isa_driver
);
1067 #else /* !CONFIG_ISA */
1069 static int __init
lm78_isa_register(void)
1074 static void lm78_isa_unregister(void)
1077 #endif /* CONFIG_ISA */
1079 static int __init
sm_lm78_init(void)
1084 * We register the ISA device first, so that we can skip the
1085 * registration of an I2C interface to the same device.
1087 res
= lm78_isa_register();
1091 res
= i2c_add_driver(&lm78_driver
);
1093 goto exit_unreg_isa_device
;
1097 exit_unreg_isa_device
:
1098 lm78_isa_unregister();
1103 static void __exit
sm_lm78_exit(void)
1105 lm78_isa_unregister();
1106 i2c_del_driver(&lm78_driver
);
1109 MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <khali@linux-fr.org>");
1110 MODULE_DESCRIPTION("LM78/LM79 driver");
1111 MODULE_LICENSE("GPL");
1113 module_init(sm_lm78_init
);
1114 module_exit(sm_lm78_exit
);