blob: 5679464447cc0140bbeddf6ac07897301cc1f22d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
3 * monitoring
Jean Delvare30d73942005-06-05 21:27:28 +02004 * Copyright (C) 2003-2005 Jean Delvare <khali@linux-fr.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * Based on the lm83 driver. The LM90 is a sensor chip made by National
7 * Semiconductor. It reports up to two temperatures (its own plus up to
8 * one external one) with a 0.125 deg resolution (1 deg for local
9 * temperature) and a 3-4 deg accuracy. Complete datasheet can be
10 * obtained from National's website at:
11 * http://www.national.com/pf/LM/LM90.html
12 *
13 * This driver also supports the LM89 and LM99, two other sensor chips
14 * made by National Semiconductor. Both have an increased remote
15 * temperature measurement accuracy (1 degree), and the LM99
16 * additionally shifts remote temperatures (measured and limits) by 16
17 * degrees, which allows for higher temperatures measurement. The
18 * driver doesn't handle it since it can be done easily in user-space.
19 * Complete datasheets can be obtained from National's website at:
20 * http://www.national.com/pf/LM/LM89.html
21 * http://www.national.com/pf/LM/LM99.html
Steven Cole44bbe872005-05-03 18:21:25 -060022 * Note that there is no way to differentiate between both chips.
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 *
24 * This driver also supports the LM86, another sensor chip made by
25 * National Semiconductor. It is exactly similar to the LM90 except it
26 * has a higher accuracy.
27 * Complete datasheet can be obtained from National's website at:
28 * http://www.national.com/pf/LM/LM86.html
29 *
30 * This driver also supports the ADM1032, a sensor chip made by Analog
31 * Devices. That chip is similar to the LM90, with a few differences
32 * that are not handled by this driver. Complete datasheet can be
33 * obtained from Analog's website at:
Jean Delvare90209b42005-10-26 22:20:21 +020034 * http://www.analog.com/en/prod/0,2877,ADM1032,00.html
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 * Among others, it has a higher accuracy than the LM90, much like the
36 * LM86 does.
37 *
38 * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
39 * chips made by Maxim. These chips are similar to the LM86. Complete
40 * datasheet can be obtained at Maxim's website at:
41 * http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2578
Steven Cole44bbe872005-05-03 18:21:25 -060042 * Note that there is no easy way to differentiate between the three
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * variants. The extra address and features of the MAX6659 are not
44 * supported by this driver.
45 *
46 * This driver also supports the ADT7461 chip from Analog Devices but
47 * only in its "compatability mode". If an ADT7461 chip is found but
48 * is configured in non-compatible mode (where its temperature
49 * register values are decoded differently) it is ignored by this
50 * driver. Complete datasheet can be obtained from Analog's website
51 * at:
Jean Delvare90209b42005-10-26 22:20:21 +020052 * http://www.analog.com/en/prod/0,2877,ADT7461,00.html
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 *
54 * Since the LM90 was the first chipset supported by this driver, most
55 * comments will refer to this chipset, but are actually general and
56 * concern all supported chipsets, unless mentioned otherwise.
57 *
58 * This program is free software; you can redistribute it and/or modify
59 * it under the terms of the GNU General Public License as published by
60 * the Free Software Foundation; either version 2 of the License, or
61 * (at your option) any later version.
62 *
63 * This program is distributed in the hope that it will be useful,
64 * but WITHOUT ANY WARRANTY; without even the implied warranty of
65 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
66 * GNU General Public License for more details.
67 *
68 * You should have received a copy of the GNU General Public License
69 * along with this program; if not, write to the Free Software
70 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
71 */
72
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <linux/module.h>
74#include <linux/init.h>
75#include <linux/slab.h>
76#include <linux/jiffies.h>
77#include <linux/i2c.h>
Jean Delvare10c08f82005-06-06 19:34:45 +020078#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040079#include <linux/hwmon.h>
80#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82/*
83 * Addresses to scan
84 * Address is fully defined internally and cannot be changed except for
85 * MAX6659.
Jean Delvare90209b42005-10-26 22:20:21 +020086 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
87 * have address 0x4c.
88 * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 */
91
92static unsigned short normal_i2c[] = { 0x4c, 0x4d, I2C_CLIENT_END };
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94/*
95 * Insmod parameters
96 */
97
Jean Delvaref4b50262005-07-31 21:49:03 +020098I2C_CLIENT_INSMOD_6(lm90, adm1032, lm99, lm86, max6657, adt7461);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100/*
101 * The LM90 registers
102 */
103
104#define LM90_REG_R_MAN_ID 0xFE
105#define LM90_REG_R_CHIP_ID 0xFF
106#define LM90_REG_R_CONFIG1 0x03
107#define LM90_REG_W_CONFIG1 0x09
108#define LM90_REG_R_CONFIG2 0xBF
109#define LM90_REG_W_CONFIG2 0xBF
110#define LM90_REG_R_CONVRATE 0x04
111#define LM90_REG_W_CONVRATE 0x0A
112#define LM90_REG_R_STATUS 0x02
113#define LM90_REG_R_LOCAL_TEMP 0x00
114#define LM90_REG_R_LOCAL_HIGH 0x05
115#define LM90_REG_W_LOCAL_HIGH 0x0B
116#define LM90_REG_R_LOCAL_LOW 0x06
117#define LM90_REG_W_LOCAL_LOW 0x0C
118#define LM90_REG_R_LOCAL_CRIT 0x20
119#define LM90_REG_W_LOCAL_CRIT 0x20
120#define LM90_REG_R_REMOTE_TEMPH 0x01
121#define LM90_REG_R_REMOTE_TEMPL 0x10
122#define LM90_REG_R_REMOTE_OFFSH 0x11
123#define LM90_REG_W_REMOTE_OFFSH 0x11
124#define LM90_REG_R_REMOTE_OFFSL 0x12
125#define LM90_REG_W_REMOTE_OFFSL 0x12
126#define LM90_REG_R_REMOTE_HIGHH 0x07
127#define LM90_REG_W_REMOTE_HIGHH 0x0D
128#define LM90_REG_R_REMOTE_HIGHL 0x13
129#define LM90_REG_W_REMOTE_HIGHL 0x13
130#define LM90_REG_R_REMOTE_LOWH 0x08
131#define LM90_REG_W_REMOTE_LOWH 0x0E
132#define LM90_REG_R_REMOTE_LOWL 0x14
133#define LM90_REG_W_REMOTE_LOWL 0x14
134#define LM90_REG_R_REMOTE_CRIT 0x19
135#define LM90_REG_W_REMOTE_CRIT 0x19
136#define LM90_REG_R_TCRIT_HYST 0x21
137#define LM90_REG_W_TCRIT_HYST 0x21
138
139/*
140 * Conversions and various macros
141 * For local temperatures and limits, critical limits and the hysteresis
Steven Cole44bbe872005-05-03 18:21:25 -0600142 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 * For remote temperatures and limits, it uses signed 11-bit values with
Steven Cole44bbe872005-05-03 18:21:25 -0600144 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 */
146
147#define TEMP1_FROM_REG(val) ((val) * 1000)
148#define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \
149 (val) >= 127000 ? 127 : \
150 (val) < 0 ? ((val) - 500) / 1000 : \
151 ((val) + 500) / 1000)
152#define TEMP2_FROM_REG(val) ((val) / 32 * 125)
153#define TEMP2_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
154 (val) >= 127875 ? 0x7FE0 : \
155 (val) < 0 ? ((val) - 62) / 125 * 32 : \
156 ((val) + 62) / 125 * 32)
157#define HYST_TO_REG(val) ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
158 ((val) + 500) / 1000)
159
160/*
161 * ADT7461 is almost identical to LM90 except that attempts to write
162 * values that are outside the range 0 < temp < 127 are treated as
163 * the boundary value.
164 */
165
166#define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
167 (val) >= 127000 ? 127 : \
168 ((val) + 500) / 1000)
169#define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
170 (val) >= 127750 ? 0x7FC0 : \
171 ((val) + 125) / 250 * 64)
172
173/*
174 * Functions declaration
175 */
176
177static int lm90_attach_adapter(struct i2c_adapter *adapter);
178static int lm90_detect(struct i2c_adapter *adapter, int address,
179 int kind);
180static void lm90_init_client(struct i2c_client *client);
181static int lm90_detach_client(struct i2c_client *client);
182static struct lm90_data *lm90_update_device(struct device *dev);
183
184/*
185 * Driver data (common to all clients)
186 */
187
188static struct i2c_driver lm90_driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100189 .driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100190 .name = "lm90",
191 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 .id = I2C_DRIVERID_LM90,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 .attach_adapter = lm90_attach_adapter,
194 .detach_client = lm90_detach_client,
195};
196
197/*
198 * Client data (each client gets its own)
199 */
200
201struct lm90_data {
202 struct i2c_client client;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400203 struct class_device *class_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 struct semaphore update_lock;
205 char valid; /* zero until following fields are valid */
206 unsigned long last_updated; /* in jiffies */
207 int kind;
208
209 /* registers values */
Jean Delvare30d73942005-06-05 21:27:28 +0200210 s8 temp8[5]; /* 0: local input
211 1: local low limit
212 2: local high limit
213 3: local critical limit
214 4: remote critical limit */
215 s16 temp11[3]; /* 0: remote input
216 1: remote low limit
217 2: remote high limit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 u8 temp_hyst;
219 u8 alarms; /* bitvector */
220};
221
222/*
223 * Sysfs stuff
224 */
225
Jean Delvare30d73942005-06-05 21:27:28 +0200226static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
227 char *buf)
228{
229 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
230 struct lm90_data *data = lm90_update_device(dev);
231 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Jean Delvare30d73942005-06-05 21:27:28 +0200234static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
235 const char *buf, size_t count)
236{
237 static const u8 reg[4] = {
238 LM90_REG_W_LOCAL_LOW,
239 LM90_REG_W_LOCAL_HIGH,
240 LM90_REG_W_LOCAL_CRIT,
241 LM90_REG_W_REMOTE_CRIT,
242 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Jean Delvare30d73942005-06-05 21:27:28 +0200244 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
245 struct i2c_client *client = to_i2c_client(dev);
246 struct lm90_data *data = i2c_get_clientdata(client);
247 long val = simple_strtol(buf, NULL, 10);
248 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Jean Delvare30d73942005-06-05 21:27:28 +0200250 down(&data->update_lock);
251 if (data->kind == adt7461)
252 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
253 else
254 data->temp8[nr] = TEMP1_TO_REG(val);
255 i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
256 up(&data->update_lock);
257 return count;
258}
259
260static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
261 char *buf)
262{
263 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
264 struct lm90_data *data = lm90_update_device(dev);
265 return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
266}
267
268static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
269 const char *buf, size_t count)
270{
271 static const u8 reg[4] = {
272 LM90_REG_W_REMOTE_LOWH,
273 LM90_REG_W_REMOTE_LOWL,
274 LM90_REG_W_REMOTE_HIGHH,
275 LM90_REG_W_REMOTE_HIGHL,
276 };
277
278 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
279 struct i2c_client *client = to_i2c_client(dev);
280 struct lm90_data *data = i2c_get_clientdata(client);
281 long val = simple_strtol(buf, NULL, 10);
282 int nr = attr->index;
283
284 down(&data->update_lock);
285 if (data->kind == adt7461)
286 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
287 else
288 data->temp11[nr] = TEMP2_TO_REG(val);
289 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
290 data->temp11[nr] >> 8);
291 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
292 data->temp11[nr] & 0xff);
293 up(&data->update_lock);
294 return count;
295}
296
297static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
298 char *buf)
299{
300 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
301 struct lm90_data *data = lm90_update_device(dev);
302 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
303 - TEMP1_FROM_REG(data->temp_hyst));
304}
305
306static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
307 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
309 struct i2c_client *client = to_i2c_client(dev);
310 struct lm90_data *data = i2c_get_clientdata(client);
311 long val = simple_strtol(buf, NULL, 10);
312 long hyst;
313
314 down(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200315 hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
317 HYST_TO_REG(hyst));
318 up(&data->update_lock);
319 return count;
320}
321
Jean Delvare30d73942005-06-05 21:27:28 +0200322static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
323 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
325 struct lm90_data *data = lm90_update_device(dev);
326 return sprintf(buf, "%d\n", data->alarms);
327}
328
Jean Delvare30d73942005-06-05 21:27:28 +0200329static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
330static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
331static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
332 set_temp8, 1);
333static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
334 set_temp11, 1);
335static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
336 set_temp8, 2);
337static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
338 set_temp11, 2);
339static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
340 set_temp8, 3);
341static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
342 set_temp8, 4);
343static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
344 set_temphyst, 3);
345static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
347
Jean Delvarec3df5802005-10-26 21:39:40 +0200348/* pec used for ADM1032 only */
349static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
350 char *buf)
351{
352 struct i2c_client *client = to_i2c_client(dev);
353 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
354}
355
356static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
357 const char *buf, size_t count)
358{
359 struct i2c_client *client = to_i2c_client(dev);
360 long val = simple_strtol(buf, NULL, 10);
361
362 switch (val) {
363 case 0:
364 client->flags &= ~I2C_CLIENT_PEC;
365 break;
366 case 1:
367 client->flags |= I2C_CLIENT_PEC;
368 break;
369 default:
370 return -EINVAL;
371 }
372
373 return count;
374}
375
376static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378/*
379 * Real code
380 */
381
Jean Delvarec3df5802005-10-26 21:39:40 +0200382/* The ADM1032 supports PEC but not on write byte transactions, so we need
383 to explicitely ask for a transaction without PEC. */
384static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
385{
386 return i2c_smbus_xfer(client->adapter, client->addr,
387 client->flags & ~I2C_CLIENT_PEC,
388 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
389}
390
391/* It is assumed that client->update_lock is held (unless we are in
392 detection or initialization steps). This matters when PEC is enabled,
393 because we don't want the address pointer to change between the write
394 byte and the read byte transactions. */
Jean Delvare8256fe02005-10-26 21:37:52 +0200395static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
396{
397 int err;
398
Jean Delvarec3df5802005-10-26 21:39:40 +0200399 if (client->flags & I2C_CLIENT_PEC) {
400 err = adm1032_write_byte(client, reg);
401 if (err >= 0)
402 err = i2c_smbus_read_byte(client);
403 } else
404 err = i2c_smbus_read_byte_data(client, reg);
Jean Delvare8256fe02005-10-26 21:37:52 +0200405
406 if (err < 0) {
407 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
408 reg, err);
409 return err;
410 }
411 *value = err;
412
413 return 0;
414}
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416static int lm90_attach_adapter(struct i2c_adapter *adapter)
417{
418 if (!(adapter->class & I2C_CLASS_HWMON))
419 return 0;
Jean Delvare2ed2dc32005-07-31 21:42:02 +0200420 return i2c_probe(adapter, &addr_data, lm90_detect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421}
422
423/*
424 * The following function does more than just detection. If detection
425 * succeeds, it also registers the new chip.
426 */
427static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
428{
429 struct i2c_client *new_client;
430 struct lm90_data *data;
431 int err = 0;
432 const char *name = "";
433
434 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
435 goto exit;
436
Deepak Saxenaba9c2e82005-10-17 23:08:32 +0200437 if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 err = -ENOMEM;
439 goto exit;
440 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 /* The common I2C client data is placed right before the
443 LM90-specific data. */
444 new_client = &data->client;
445 i2c_set_clientdata(new_client, data);
446 new_client->addr = address;
447 new_client->adapter = adapter;
448 new_client->driver = &lm90_driver;
449 new_client->flags = 0;
450
451 /*
452 * Now we do the remaining detection. A negative kind means that
453 * the driver was loaded with no force parameter (default), so we
454 * must both detect and identify the chip. A zero kind means that
455 * the driver was loaded with the force parameter, the detection
456 * step shall be skipped. A positive kind means that the driver
457 * was loaded with the force parameter and a given kind of chip is
458 * requested, so both the detection and the identification steps
459 * are skipped.
460 */
461
462 /* Default to an LM90 if forced */
463 if (kind == 0)
464 kind = lm90;
465
466 if (kind < 0) { /* detection and identification */
467 u8 man_id, chip_id, reg_config1, reg_convrate;
468
Jean Delvare8256fe02005-10-26 21:37:52 +0200469 if (lm90_read_reg(new_client, LM90_REG_R_MAN_ID,
470 &man_id) < 0
471 || lm90_read_reg(new_client, LM90_REG_R_CHIP_ID,
472 &chip_id) < 0
473 || lm90_read_reg(new_client, LM90_REG_R_CONFIG1,
474 &reg_config1) < 0
475 || lm90_read_reg(new_client, LM90_REG_R_CONVRATE,
476 &reg_convrate) < 0)
477 goto exit_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
479 if (man_id == 0x01) { /* National Semiconductor */
480 u8 reg_config2;
481
Jean Delvare8256fe02005-10-26 21:37:52 +0200482 if (lm90_read_reg(new_client, LM90_REG_R_CONFIG2,
483 &reg_config2) < 0)
484 goto exit_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 if ((reg_config1 & 0x2A) == 0x00
487 && (reg_config2 & 0xF8) == 0x00
488 && reg_convrate <= 0x09) {
489 if (address == 0x4C
490 && (chip_id & 0xF0) == 0x20) { /* LM90 */
491 kind = lm90;
492 } else
493 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
494 kind = lm99;
495 } else
496 if (address == 0x4C
497 && (chip_id & 0xF0) == 0x10) { /* LM86 */
498 kind = lm86;
499 }
500 }
501 } else
502 if (man_id == 0x41) { /* Analog Devices */
Jean Delvare90209b42005-10-26 22:20:21 +0200503 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 && (reg_config1 & 0x3F) == 0x00
505 && reg_convrate <= 0x0A) {
506 kind = adm1032;
507 } else
Jean Delvare90209b42005-10-26 22:20:21 +0200508 if (chip_id == 0x51 /* ADT7461 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
510 && reg_convrate <= 0x0A) {
511 kind = adt7461;
512 }
513 } else
514 if (man_id == 0x4D) { /* Maxim */
515 /*
516 * The Maxim variants do NOT have a chip_id register.
517 * Reading from that address will return the last read
518 * value, which in our case is those of the man_id
519 * register. Likewise, the config1 register seems to
520 * lack a low nibble, so the value will be those of the
521 * previous read, so in our case those of the man_id
522 * register.
523 */
524 if (chip_id == man_id
525 && (reg_config1 & 0x1F) == (man_id & 0x0F)
526 && reg_convrate <= 0x09) {
527 kind = max6657;
528 }
529 }
530
531 if (kind <= 0) { /* identification failed */
532 dev_info(&adapter->dev,
533 "Unsupported chip (man_id=0x%02X, "
534 "chip_id=0x%02X).\n", man_id, chip_id);
535 goto exit_free;
536 }
537 }
538
539 if (kind == lm90) {
540 name = "lm90";
541 } else if (kind == adm1032) {
542 name = "adm1032";
Jean Delvarec3df5802005-10-26 21:39:40 +0200543 /* The ADM1032 supports PEC, but only if combined
544 transactions are not used. */
545 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
546 new_client->flags |= I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 } else if (kind == lm99) {
548 name = "lm99";
549 } else if (kind == lm86) {
550 name = "lm86";
551 } else if (kind == max6657) {
552 name = "max6657";
553 } else if (kind == adt7461) {
554 name = "adt7461";
555 }
556
557 /* We can fill in the remaining client fields */
558 strlcpy(new_client->name, name, I2C_NAME_SIZE);
559 data->valid = 0;
560 data->kind = kind;
561 init_MUTEX(&data->update_lock);
562
563 /* Tell the I2C layer a new client has arrived */
564 if ((err = i2c_attach_client(new_client)))
565 goto exit_free;
566
567 /* Initialize the LM90 chip */
568 lm90_init_client(new_client);
569
570 /* Register sysfs hooks */
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400571 data->class_dev = hwmon_device_register(&new_client->dev);
572 if (IS_ERR(data->class_dev)) {
573 err = PTR_ERR(data->class_dev);
574 goto exit_detach;
575 }
576
Jean Delvare30d73942005-06-05 21:27:28 +0200577 device_create_file(&new_client->dev,
578 &sensor_dev_attr_temp1_input.dev_attr);
579 device_create_file(&new_client->dev,
580 &sensor_dev_attr_temp2_input.dev_attr);
581 device_create_file(&new_client->dev,
582 &sensor_dev_attr_temp1_min.dev_attr);
583 device_create_file(&new_client->dev,
584 &sensor_dev_attr_temp2_min.dev_attr);
585 device_create_file(&new_client->dev,
586 &sensor_dev_attr_temp1_max.dev_attr);
587 device_create_file(&new_client->dev,
588 &sensor_dev_attr_temp2_max.dev_attr);
589 device_create_file(&new_client->dev,
590 &sensor_dev_attr_temp1_crit.dev_attr);
591 device_create_file(&new_client->dev,
592 &sensor_dev_attr_temp2_crit.dev_attr);
593 device_create_file(&new_client->dev,
594 &sensor_dev_attr_temp1_crit_hyst.dev_attr);
595 device_create_file(&new_client->dev,
596 &sensor_dev_attr_temp2_crit_hyst.dev_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 device_create_file(&new_client->dev, &dev_attr_alarms);
598
Jean Delvarec3df5802005-10-26 21:39:40 +0200599 if (new_client->flags & I2C_CLIENT_PEC)
600 device_create_file(&new_client->dev, &dev_attr_pec);
601
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 return 0;
603
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400604exit_detach:
605 i2c_detach_client(new_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606exit_free:
607 kfree(data);
608exit:
609 return err;
610}
611
612static void lm90_init_client(struct i2c_client *client)
613{
614 u8 config;
615
616 /*
617 * Start the conversions.
618 */
619 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
620 5); /* 2 Hz */
Jean Delvare8256fe02005-10-26 21:37:52 +0200621 if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
622 dev_warn(&client->dev, "Initialization failed!\n");
623 return;
624 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 if (config & 0x40)
626 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
627 config & 0xBF); /* run */
628}
629
630static int lm90_detach_client(struct i2c_client *client)
631{
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400632 struct lm90_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 int err;
634
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400635 hwmon_device_unregister(data->class_dev);
636
Jean Delvare7bef5592005-07-27 22:14:49 +0200637 if ((err = i2c_detach_client(client)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400640 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 return 0;
642}
643
644static struct lm90_data *lm90_update_device(struct device *dev)
645{
646 struct i2c_client *client = to_i2c_client(dev);
647 struct lm90_data *data = i2c_get_clientdata(client);
648
649 down(&data->update_lock);
650
651 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
Jean Delvare8256fe02005-10-26 21:37:52 +0200652 u8 oldh, newh, l;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 dev_dbg(&client->dev, "Updating lm90 data.\n");
Jean Delvare8256fe02005-10-26 21:37:52 +0200655 lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
656 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
657 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
658 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
659 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
660 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662 /*
663 * There is a trick here. We have to read two registers to
664 * have the remote sensor temperature, but we have to beware
665 * a conversion could occur inbetween the readings. The
666 * datasheet says we should either use the one-shot
667 * conversion register, which we don't want to do (disables
668 * hardware monitoring) or monitor the busy bit, which is
669 * impossible (we can't read the values and monitor that bit
670 * at the exact same time). So the solution used here is to
671 * read the high byte once, then the low byte, then the high
672 * byte again. If the new high byte matches the old one,
673 * then we have a valid reading. Else we have to read the low
674 * byte again, and now we believe we have a correct reading.
675 */
Jean Delvare8256fe02005-10-26 21:37:52 +0200676 if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
677 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
678 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
679 && (newh == oldh
680 || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
681 data->temp11[0] = (newh << 8) | l;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
Jean Delvare8256fe02005-10-26 21:37:52 +0200683 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
684 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
685 data->temp11[1] = (newh << 8) | l;
686 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
687 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
688 data->temp11[2] = (newh << 8) | l;
689 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
691 data->last_updated = jiffies;
692 data->valid = 1;
693 }
694
695 up(&data->update_lock);
696
697 return data;
698}
699
700static int __init sensors_lm90_init(void)
701{
702 return i2c_add_driver(&lm90_driver);
703}
704
705static void __exit sensors_lm90_exit(void)
706{
707 i2c_del_driver(&lm90_driver);
708}
709
710MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
711MODULE_DESCRIPTION("LM90/ADM1032 driver");
712MODULE_LICENSE("GPL");
713
714module_init(sensors_lm90_init);
715module_exit(sensors_lm90_exit);