2 * lm92 - Hardware monitoring driver
3 * Copyright (C) 2005 Jean Delvare <khali@linux-fr.org>
5 * Based on the lm90 driver, with some ideas taken from the lm_sensors
8 * The LM92 is a sensor chip made by National Semiconductor. It reports
9 * its own temperature with a 0.0625 deg resolution and a 0.33 deg
10 * accuracy. Complete datasheet can be obtained from National's website
12 * http://www.national.com/pf/LM/LM92.html
14 * This driver also supports the MAX6635 sensor chip made by Maxim.
15 * This chip is compatible with the LM92, but has a lesser accuracy
16 * (1.0 deg). Complete datasheet can be obtained from Maxim's website
18 * http://www.maxim-ic.com/quick_view2.cfm/qv_pk/3074
20 * Since the LM92 was the first chipset supported by this driver, most
21 * comments will refer to this chipset, but are actually general and
22 * concern all supported chipsets, unless mentioned otherwise.
24 * Support could easily be added for the National Semiconductor LM76
25 * and Maxim MAX6633 and MAX6634 chips, which are mostly compatible
28 * This program is free software; you can redistribute it and/or modify
29 * it under the terms of the GNU General Public License as published by
30 * the Free Software Foundation; either version 2 of the License, or
31 * (at your option) any later version.
33 * This program is distributed in the hope that it will be useful,
34 * but WITHOUT ANY WARRANTY; without even the implied warranty of
35 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36 * GNU General Public License for more details.
38 * You should have received a copy of the GNU General Public License
39 * along with this program; if not, write to the Free Software
40 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
43 #include <linux/module.h>
44 #include <linux/init.h>
45 #include <linux/slab.h>
46 #include <linux/i2c.h>
47 #include <linux/hwmon.h>
48 #include <linux/err.h>
50 /* The LM92 and MAX6635 have 2 two-state pins for address selection,
51 resulting in 4 possible addresses. */
52 static unsigned short normal_i2c
[] = { 0x48, 0x49, 0x4a, 0x4b,
55 /* Insmod parameters */
56 I2C_CLIENT_INSMOD_1(lm92
);
58 /* The LM92 registers */
59 #define LM92_REG_CONFIG 0x01 /* 8-bit, RW */
60 #define LM92_REG_TEMP 0x00 /* 16-bit, RO */
61 #define LM92_REG_TEMP_HYST 0x02 /* 16-bit, RW */
62 #define LM92_REG_TEMP_CRIT 0x03 /* 16-bit, RW */
63 #define LM92_REG_TEMP_LOW 0x04 /* 16-bit, RW */
64 #define LM92_REG_TEMP_HIGH 0x05 /* 16-bit, RW */
65 #define LM92_REG_MAN_ID 0x07 /* 16-bit, RO, LM92 only */
67 /* The LM92 uses signed 13-bit values with LSB = 0.0625 degree Celsius,
68 left-justified in 16-bit registers. No rounding is done, with such
69 a resolution it's just not worth it. Note that the MAX6635 doesn't
70 make use of the 4 lower bits for limits (i.e. effective resolution
71 for limits is 1 degree Celsius). */
72 static inline int TEMP_FROM_REG(s16 reg
)
74 return reg
/ 8 * 625 / 10;
77 static inline s16
TEMP_TO_REG(int val
)
80 return -60000 * 10 / 625 * 8;
82 return 160000 * 10 / 625 * 8;
83 return val
* 10 / 625 * 8;
86 /* Alarm flags are stored in the 3 LSB of the temperature register */
87 static inline u8
ALARMS_FROM_REG(s16 reg
)
92 /* Driver data (common to all clients) */
93 static struct i2c_driver lm92_driver
;
95 /* Client data (each client gets its own) */
97 struct i2c_client client
;
98 struct class_device
*class_dev
;
99 struct semaphore update_lock
;
100 char valid
; /* zero until following fields are valid */
101 unsigned long last_updated
; /* in jiffies */
103 /* registers values */
104 s16 temp1_input
, temp1_crit
, temp1_min
, temp1_max
, temp1_hyst
;
109 * Sysfs attributes and callback functions
112 static struct lm92_data
*lm92_update_device(struct device
*dev
)
114 struct i2c_client
*client
= to_i2c_client(dev
);
115 struct lm92_data
*data
= i2c_get_clientdata(client
);
117 down(&data
->update_lock
);
119 if (time_after(jiffies
, data
->last_updated
+ HZ
)
121 dev_dbg(&client
->dev
, "Updating lm92 data\n");
122 data
->temp1_input
= swab16(i2c_smbus_read_word_data(client
,
124 data
->temp1_hyst
= swab16(i2c_smbus_read_word_data(client
,
125 LM92_REG_TEMP_HYST
));
126 data
->temp1_crit
= swab16(i2c_smbus_read_word_data(client
,
127 LM92_REG_TEMP_CRIT
));
128 data
->temp1_min
= swab16(i2c_smbus_read_word_data(client
,
130 data
->temp1_max
= swab16(i2c_smbus_read_word_data(client
,
131 LM92_REG_TEMP_HIGH
));
133 data
->last_updated
= jiffies
;
137 up(&data
->update_lock
);
142 #define show_temp(value) \
143 static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \
145 struct lm92_data *data = lm92_update_device(dev); \
146 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->value)); \
148 show_temp(temp1_input
);
149 show_temp(temp1_crit
);
150 show_temp(temp1_min
);
151 show_temp(temp1_max
);
153 #define set_temp(value, reg) \
154 static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, \
157 struct i2c_client *client = to_i2c_client(dev); \
158 struct lm92_data *data = i2c_get_clientdata(client); \
159 long val = simple_strtol(buf, NULL, 10); \
161 down(&data->update_lock); \
162 data->value = TEMP_TO_REG(val); \
163 i2c_smbus_write_word_data(client, reg, swab16(data->value)); \
164 up(&data->update_lock); \
167 set_temp(temp1_crit
, LM92_REG_TEMP_CRIT
);
168 set_temp(temp1_min
, LM92_REG_TEMP_LOW
);
169 set_temp(temp1_max
, LM92_REG_TEMP_HIGH
);
171 static ssize_t
show_temp1_crit_hyst(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
173 struct lm92_data
*data
= lm92_update_device(dev
);
174 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp1_crit
)
175 - TEMP_FROM_REG(data
->temp1_hyst
));
177 static ssize_t
show_temp1_max_hyst(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
179 struct lm92_data
*data
= lm92_update_device(dev
);
180 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp1_max
)
181 - TEMP_FROM_REG(data
->temp1_hyst
));
183 static ssize_t
show_temp1_min_hyst(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
185 struct lm92_data
*data
= lm92_update_device(dev
);
186 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp1_min
)
187 + TEMP_FROM_REG(data
->temp1_hyst
));
190 static ssize_t
set_temp1_crit_hyst(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
193 struct i2c_client
*client
= to_i2c_client(dev
);
194 struct lm92_data
*data
= i2c_get_clientdata(client
);
195 long val
= simple_strtol(buf
, NULL
, 10);
197 down(&data
->update_lock
);
198 data
->temp1_hyst
= TEMP_FROM_REG(data
->temp1_crit
) - val
;
199 i2c_smbus_write_word_data(client
, LM92_REG_TEMP_HYST
,
200 swab16(TEMP_TO_REG(data
->temp1_hyst
)));
201 up(&data
->update_lock
);
205 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
207 struct lm92_data
*data
= lm92_update_device(dev
);
208 return sprintf(buf
, "%d\n", ALARMS_FROM_REG(data
->temp1_input
));
211 static DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp1_input
, NULL
);
212 static DEVICE_ATTR(temp1_crit
, S_IWUSR
| S_IRUGO
, show_temp1_crit
,
214 static DEVICE_ATTR(temp1_crit_hyst
, S_IWUSR
| S_IRUGO
, show_temp1_crit_hyst
,
215 set_temp1_crit_hyst
);
216 static DEVICE_ATTR(temp1_min
, S_IWUSR
| S_IRUGO
, show_temp1_min
,
218 static DEVICE_ATTR(temp1_min_hyst
, S_IRUGO
, show_temp1_min_hyst
, NULL
);
219 static DEVICE_ATTR(temp1_max
, S_IWUSR
| S_IRUGO
, show_temp1_max
,
221 static DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
, show_temp1_max_hyst
, NULL
);
222 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
226 * Detection and registration
229 static void lm92_init_client(struct i2c_client
*client
)
233 /* Start the conversions if needed */
234 config
= i2c_smbus_read_byte_data(client
, LM92_REG_CONFIG
);
236 i2c_smbus_write_byte_data(client
, LM92_REG_CONFIG
,
240 /* The MAX6635 has no identification register, so we have to use tricks
241 to identify it reliably. This is somewhat slow.
242 Note that we do NOT rely on the 2 MSB of the configuration register
243 always reading 0, as suggested by the datasheet, because it was once
244 reported not to be true. */
245 static int max6635_check(struct i2c_client
*client
)
247 u16 temp_low
, temp_high
, temp_hyst
, temp_crit
;
251 /* No manufacturer ID register, so a read from this address will
252 always return the last read value. */
253 temp_low
= i2c_smbus_read_word_data(client
, LM92_REG_TEMP_LOW
);
254 if (i2c_smbus_read_word_data(client
, LM92_REG_MAN_ID
) != temp_low
)
256 temp_high
= i2c_smbus_read_word_data(client
, LM92_REG_TEMP_HIGH
);
257 if (i2c_smbus_read_word_data(client
, LM92_REG_MAN_ID
) != temp_high
)
260 /* Limits are stored as integer values (signed, 9-bit). */
261 if ((temp_low
& 0x7f00) || (temp_high
& 0x7f00))
263 temp_hyst
= i2c_smbus_read_word_data(client
, LM92_REG_TEMP_HYST
);
264 temp_crit
= i2c_smbus_read_word_data(client
, LM92_REG_TEMP_CRIT
);
265 if ((temp_hyst
& 0x7f00) || (temp_crit
& 0x7f00))
268 /* Registers addresses were found to cycle over 16-byte boundaries.
269 We don't test all registers with all offsets so as to save some
270 reads and time, but this should still be sufficient to dismiss
271 non-MAX6635 chips. */
272 conf
= i2c_smbus_read_byte_data(client
, LM92_REG_CONFIG
);
273 for (i
=16; i
<96; i
*=2) {
274 if (temp_hyst
!= i2c_smbus_read_word_data(client
,
275 LM92_REG_TEMP_HYST
+ i
- 16)
276 || temp_crit
!= i2c_smbus_read_word_data(client
,
277 LM92_REG_TEMP_CRIT
+ i
)
278 || temp_low
!= i2c_smbus_read_word_data(client
,
279 LM92_REG_TEMP_LOW
+ i
+ 16)
280 || temp_high
!= i2c_smbus_read_word_data(client
,
281 LM92_REG_TEMP_HIGH
+ i
+ 32)
282 || conf
!= i2c_smbus_read_byte_data(client
,
283 LM92_REG_CONFIG
+ i
))
290 /* The following function does more than just detection. If detection
291 succeeds, it also registers the new chip. */
292 static int lm92_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
294 struct i2c_client
*new_client
;
295 struct lm92_data
*data
;
299 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
300 | I2C_FUNC_SMBUS_WORD_DATA
))
303 if (!(data
= kmalloc(sizeof(struct lm92_data
), GFP_KERNEL
))) {
307 memset(data
, 0, sizeof(struct lm92_data
));
309 /* Fill in enough client fields so that we can read from the chip,
310 which is required for identication */
311 new_client
= &data
->client
;
312 i2c_set_clientdata(new_client
, data
);
313 new_client
->addr
= address
;
314 new_client
->adapter
= adapter
;
315 new_client
->driver
= &lm92_driver
;
316 new_client
->flags
= 0;
318 /* A negative kind means that the driver was loaded with no force
319 parameter (default), so we must identify the chip. */
321 u8 config
= i2c_smbus_read_byte_data(new_client
,
323 u16 man_id
= i2c_smbus_read_word_data(new_client
,
326 if ((config
& 0xe0) == 0x00
327 && man_id
== 0x0180) {
328 pr_info("lm92: Found National Semiconductor LM92 chip\n");
331 if (max6635_check(new_client
)) {
332 pr_info("lm92: Found Maxim MAX6635 chip\n");
333 kind
= lm92
; /* No separate prefix */
338 if (kind
== 0) /* Default to an LM92 if forced */
341 /* Give it the proper name */
344 } else { /* Supposedly cannot happen */
345 dev_dbg(&new_client
->dev
, "Kind out of range?\n");
349 /* Fill in the remaining client fields */
350 strlcpy(new_client
->name
, name
, I2C_NAME_SIZE
);
352 init_MUTEX(&data
->update_lock
);
354 /* Tell the i2c subsystem a new client has arrived */
355 if ((err
= i2c_attach_client(new_client
)))
358 /* Initialize the chipset */
359 lm92_init_client(new_client
);
361 /* Register sysfs hooks */
362 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
363 if (IS_ERR(data
->class_dev
)) {
364 err
= PTR_ERR(data
->class_dev
);
368 device_create_file(&new_client
->dev
, &dev_attr_temp1_input
);
369 device_create_file(&new_client
->dev
, &dev_attr_temp1_crit
);
370 device_create_file(&new_client
->dev
, &dev_attr_temp1_crit_hyst
);
371 device_create_file(&new_client
->dev
, &dev_attr_temp1_min
);
372 device_create_file(&new_client
->dev
, &dev_attr_temp1_min_hyst
);
373 device_create_file(&new_client
->dev
, &dev_attr_temp1_max
);
374 device_create_file(&new_client
->dev
, &dev_attr_temp1_max_hyst
);
375 device_create_file(&new_client
->dev
, &dev_attr_alarms
);
380 i2c_detach_client(new_client
);
387 static int lm92_attach_adapter(struct i2c_adapter
*adapter
)
389 if (!(adapter
->class & I2C_CLASS_HWMON
))
391 return i2c_probe(adapter
, &addr_data
, lm92_detect
);
394 static int lm92_detach_client(struct i2c_client
*client
)
396 struct lm92_data
*data
= i2c_get_clientdata(client
);
399 hwmon_device_unregister(data
->class_dev
);
401 if ((err
= i2c_detach_client(client
)))
410 * Module and driver stuff
413 static struct i2c_driver lm92_driver
= {
414 .owner
= THIS_MODULE
,
416 .id
= I2C_DRIVERID_LM92
,
417 .flags
= I2C_DF_NOTIFY
,
418 .attach_adapter
= lm92_attach_adapter
,
419 .detach_client
= lm92_detach_client
,
422 static int __init
sensors_lm92_init(void)
424 return i2c_add_driver(&lm92_driver
);
427 static void __exit
sensors_lm92_exit(void)
429 i2c_del_driver(&lm92_driver
);
432 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
433 MODULE_DESCRIPTION("LM92/MAX6635 driver");
434 MODULE_LICENSE("GPL");
436 module_init(sensors_lm92_init
);
437 module_exit(sensors_lm92_exit
);