blob: d9eeaf7585bd3be3d171ba2d8f33a3b9393564e3 [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>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010081#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83/*
84 * Addresses to scan
85 * Address is fully defined internally and cannot be changed except for
86 * MAX6659.
Jean Delvare90209b42005-10-26 22:20:21 +020087 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
88 * have address 0x4c.
89 * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 */
92
93static unsigned short normal_i2c[] = { 0x4c, 0x4d, I2C_CLIENT_END };
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95/*
96 * Insmod parameters
97 */
98
Jean Delvaref4b50262005-07-31 21:49:03 +020099I2C_CLIENT_INSMOD_6(lm90, adm1032, lm99, lm86, max6657, adt7461);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
101/*
102 * The LM90 registers
103 */
104
105#define LM90_REG_R_MAN_ID 0xFE
106#define LM90_REG_R_CHIP_ID 0xFF
107#define LM90_REG_R_CONFIG1 0x03
108#define LM90_REG_W_CONFIG1 0x09
109#define LM90_REG_R_CONFIG2 0xBF
110#define LM90_REG_W_CONFIG2 0xBF
111#define LM90_REG_R_CONVRATE 0x04
112#define LM90_REG_W_CONVRATE 0x0A
113#define LM90_REG_R_STATUS 0x02
114#define LM90_REG_R_LOCAL_TEMP 0x00
115#define LM90_REG_R_LOCAL_HIGH 0x05
116#define LM90_REG_W_LOCAL_HIGH 0x0B
117#define LM90_REG_R_LOCAL_LOW 0x06
118#define LM90_REG_W_LOCAL_LOW 0x0C
119#define LM90_REG_R_LOCAL_CRIT 0x20
120#define LM90_REG_W_LOCAL_CRIT 0x20
121#define LM90_REG_R_REMOTE_TEMPH 0x01
122#define LM90_REG_R_REMOTE_TEMPL 0x10
123#define LM90_REG_R_REMOTE_OFFSH 0x11
124#define LM90_REG_W_REMOTE_OFFSH 0x11
125#define LM90_REG_R_REMOTE_OFFSL 0x12
126#define LM90_REG_W_REMOTE_OFFSL 0x12
127#define LM90_REG_R_REMOTE_HIGHH 0x07
128#define LM90_REG_W_REMOTE_HIGHH 0x0D
129#define LM90_REG_R_REMOTE_HIGHL 0x13
130#define LM90_REG_W_REMOTE_HIGHL 0x13
131#define LM90_REG_R_REMOTE_LOWH 0x08
132#define LM90_REG_W_REMOTE_LOWH 0x0E
133#define LM90_REG_R_REMOTE_LOWL 0x14
134#define LM90_REG_W_REMOTE_LOWL 0x14
135#define LM90_REG_R_REMOTE_CRIT 0x19
136#define LM90_REG_W_REMOTE_CRIT 0x19
137#define LM90_REG_R_TCRIT_HYST 0x21
138#define LM90_REG_W_TCRIT_HYST 0x21
139
140/*
141 * Conversions and various macros
142 * For local temperatures and limits, critical limits and the hysteresis
Steven Cole44bbe872005-05-03 18:21:25 -0600143 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 * For remote temperatures and limits, it uses signed 11-bit values with
Steven Cole44bbe872005-05-03 18:21:25 -0600145 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 */
147
148#define TEMP1_FROM_REG(val) ((val) * 1000)
149#define TEMP1_TO_REG(val) ((val) <= -128000 ? -128 : \
150 (val) >= 127000 ? 127 : \
151 (val) < 0 ? ((val) - 500) / 1000 : \
152 ((val) + 500) / 1000)
153#define TEMP2_FROM_REG(val) ((val) / 32 * 125)
154#define TEMP2_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
155 (val) >= 127875 ? 0x7FE0 : \
156 (val) < 0 ? ((val) - 62) / 125 * 32 : \
157 ((val) + 62) / 125 * 32)
158#define HYST_TO_REG(val) ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
159 ((val) + 500) / 1000)
160
161/*
162 * ADT7461 is almost identical to LM90 except that attempts to write
163 * values that are outside the range 0 < temp < 127 are treated as
164 * the boundary value.
165 */
166
167#define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
168 (val) >= 127000 ? 127 : \
169 ((val) + 500) / 1000)
170#define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
171 (val) >= 127750 ? 0x7FC0 : \
172 ((val) + 125) / 250 * 64)
173
174/*
175 * Functions declaration
176 */
177
178static int lm90_attach_adapter(struct i2c_adapter *adapter);
179static int lm90_detect(struct i2c_adapter *adapter, int address,
180 int kind);
181static void lm90_init_client(struct i2c_client *client);
182static int lm90_detach_client(struct i2c_client *client);
183static struct lm90_data *lm90_update_device(struct device *dev);
184
185/*
186 * Driver data (common to all clients)
187 */
188
189static struct i2c_driver lm90_driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100190 .driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100191 .name = "lm90",
192 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 .id = I2C_DRIVERID_LM90,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 .attach_adapter = lm90_attach_adapter,
195 .detach_client = lm90_detach_client,
196};
197
198/*
199 * Client data (each client gets its own)
200 */
201
202struct lm90_data {
203 struct i2c_client client;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400204 struct class_device *class_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100205 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 char valid; /* zero until following fields are valid */
207 unsigned long last_updated; /* in jiffies */
208 int kind;
209
210 /* registers values */
Jean Delvare30d73942005-06-05 21:27:28 +0200211 s8 temp8[5]; /* 0: local input
212 1: local low limit
213 2: local high limit
214 3: local critical limit
215 4: remote critical limit */
216 s16 temp11[3]; /* 0: remote input
217 1: remote low limit
218 2: remote high limit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 u8 temp_hyst;
220 u8 alarms; /* bitvector */
221};
222
223/*
224 * Sysfs stuff
225 */
226
Jean Delvare30d73942005-06-05 21:27:28 +0200227static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
228 char *buf)
229{
230 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
231 struct lm90_data *data = lm90_update_device(dev);
232 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Jean Delvare30d73942005-06-05 21:27:28 +0200235static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
236 const char *buf, size_t count)
237{
238 static const u8 reg[4] = {
239 LM90_REG_W_LOCAL_LOW,
240 LM90_REG_W_LOCAL_HIGH,
241 LM90_REG_W_LOCAL_CRIT,
242 LM90_REG_W_REMOTE_CRIT,
243 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Jean Delvare30d73942005-06-05 21:27:28 +0200245 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
246 struct i2c_client *client = to_i2c_client(dev);
247 struct lm90_data *data = i2c_get_clientdata(client);
248 long val = simple_strtol(buf, NULL, 10);
249 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100251 mutex_lock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200252 if (data->kind == adt7461)
253 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
254 else
255 data->temp8[nr] = TEMP1_TO_REG(val);
256 i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100257 mutex_unlock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200258 return count;
259}
260
261static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
262 char *buf)
263{
264 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
265 struct lm90_data *data = lm90_update_device(dev);
266 return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
267}
268
269static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
270 const char *buf, size_t count)
271{
272 static const u8 reg[4] = {
273 LM90_REG_W_REMOTE_LOWH,
274 LM90_REG_W_REMOTE_LOWL,
275 LM90_REG_W_REMOTE_HIGHH,
276 LM90_REG_W_REMOTE_HIGHL,
277 };
278
279 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
280 struct i2c_client *client = to_i2c_client(dev);
281 struct lm90_data *data = i2c_get_clientdata(client);
282 long val = simple_strtol(buf, NULL, 10);
283 int nr = attr->index;
284
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100285 mutex_lock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200286 if (data->kind == adt7461)
287 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
288 else
289 data->temp11[nr] = TEMP2_TO_REG(val);
290 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
291 data->temp11[nr] >> 8);
292 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
293 data->temp11[nr] & 0xff);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100294 mutex_unlock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200295 return count;
296}
297
298static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
299 char *buf)
300{
301 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
302 struct lm90_data *data = lm90_update_device(dev);
303 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
304 - TEMP1_FROM_REG(data->temp_hyst));
305}
306
307static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
308 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
310 struct i2c_client *client = to_i2c_client(dev);
311 struct lm90_data *data = i2c_get_clientdata(client);
312 long val = simple_strtol(buf, NULL, 10);
313 long hyst;
314
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100315 mutex_lock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200316 hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
318 HYST_TO_REG(hyst));
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100319 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 return count;
321}
322
Jean Delvare30d73942005-06-05 21:27:28 +0200323static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
324 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325{
326 struct lm90_data *data = lm90_update_device(dev);
327 return sprintf(buf, "%d\n", data->alarms);
328}
329
Jean Delvare30d73942005-06-05 21:27:28 +0200330static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
331static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
332static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
333 set_temp8, 1);
334static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
335 set_temp11, 1);
336static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
337 set_temp8, 2);
338static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
339 set_temp11, 2);
340static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
341 set_temp8, 3);
342static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
343 set_temp8, 4);
344static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
345 set_temphyst, 3);
346static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
348
Jean Delvarec3df5802005-10-26 21:39:40 +0200349/* pec used for ADM1032 only */
350static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
351 char *buf)
352{
353 struct i2c_client *client = to_i2c_client(dev);
354 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
355}
356
357static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
358 const char *buf, size_t count)
359{
360 struct i2c_client *client = to_i2c_client(dev);
361 long val = simple_strtol(buf, NULL, 10);
362
363 switch (val) {
364 case 0:
365 client->flags &= ~I2C_CLIENT_PEC;
366 break;
367 case 1:
368 client->flags |= I2C_CLIENT_PEC;
369 break;
370 default:
371 return -EINVAL;
372 }
373
374 return count;
375}
376
377static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379/*
380 * Real code
381 */
382
Jean Delvarec3df5802005-10-26 21:39:40 +0200383/* The ADM1032 supports PEC but not on write byte transactions, so we need
384 to explicitely ask for a transaction without PEC. */
385static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
386{
387 return i2c_smbus_xfer(client->adapter, client->addr,
388 client->flags & ~I2C_CLIENT_PEC,
389 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
390}
391
392/* It is assumed that client->update_lock is held (unless we are in
393 detection or initialization steps). This matters when PEC is enabled,
394 because we don't want the address pointer to change between the write
395 byte and the read byte transactions. */
Jean Delvare8256fe02005-10-26 21:37:52 +0200396static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
397{
398 int err;
399
Jean Delvarec3df5802005-10-26 21:39:40 +0200400 if (client->flags & I2C_CLIENT_PEC) {
401 err = adm1032_write_byte(client, reg);
402 if (err >= 0)
403 err = i2c_smbus_read_byte(client);
404 } else
405 err = i2c_smbus_read_byte_data(client, reg);
Jean Delvare8256fe02005-10-26 21:37:52 +0200406
407 if (err < 0) {
408 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
409 reg, err);
410 return err;
411 }
412 *value = err;
413
414 return 0;
415}
416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417static int lm90_attach_adapter(struct i2c_adapter *adapter)
418{
419 if (!(adapter->class & I2C_CLASS_HWMON))
420 return 0;
Jean Delvare2ed2dc32005-07-31 21:42:02 +0200421 return i2c_probe(adapter, &addr_data, lm90_detect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422}
423
424/*
425 * The following function does more than just detection. If detection
426 * succeeds, it also registers the new chip.
427 */
428static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
429{
430 struct i2c_client *new_client;
431 struct lm90_data *data;
432 int err = 0;
433 const char *name = "";
434
435 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
436 goto exit;
437
Deepak Saxenaba9c2e82005-10-17 23:08:32 +0200438 if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 err = -ENOMEM;
440 goto exit;
441 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443 /* The common I2C client data is placed right before the
444 LM90-specific data. */
445 new_client = &data->client;
446 i2c_set_clientdata(new_client, data);
447 new_client->addr = address;
448 new_client->adapter = adapter;
449 new_client->driver = &lm90_driver;
450 new_client->flags = 0;
451
452 /*
453 * Now we do the remaining detection. A negative kind means that
454 * the driver was loaded with no force parameter (default), so we
455 * must both detect and identify the chip. A zero kind means that
456 * the driver was loaded with the force parameter, the detection
457 * step shall be skipped. A positive kind means that the driver
458 * was loaded with the force parameter and a given kind of chip is
459 * requested, so both the detection and the identification steps
460 * are skipped.
461 */
462
463 /* Default to an LM90 if forced */
464 if (kind == 0)
465 kind = lm90;
466
467 if (kind < 0) { /* detection and identification */
468 u8 man_id, chip_id, reg_config1, reg_convrate;
469
Jean Delvare8256fe02005-10-26 21:37:52 +0200470 if (lm90_read_reg(new_client, LM90_REG_R_MAN_ID,
471 &man_id) < 0
472 || lm90_read_reg(new_client, LM90_REG_R_CHIP_ID,
473 &chip_id) < 0
474 || lm90_read_reg(new_client, LM90_REG_R_CONFIG1,
475 &reg_config1) < 0
476 || lm90_read_reg(new_client, LM90_REG_R_CONVRATE,
477 &reg_convrate) < 0)
478 goto exit_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
480 if (man_id == 0x01) { /* National Semiconductor */
481 u8 reg_config2;
482
Jean Delvare8256fe02005-10-26 21:37:52 +0200483 if (lm90_read_reg(new_client, LM90_REG_R_CONFIG2,
484 &reg_config2) < 0)
485 goto exit_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
487 if ((reg_config1 & 0x2A) == 0x00
488 && (reg_config2 & 0xF8) == 0x00
489 && reg_convrate <= 0x09) {
490 if (address == 0x4C
491 && (chip_id & 0xF0) == 0x20) { /* LM90 */
492 kind = lm90;
493 } else
494 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
495 kind = lm99;
496 } else
497 if (address == 0x4C
498 && (chip_id & 0xF0) == 0x10) { /* LM86 */
499 kind = lm86;
500 }
501 }
502 } else
503 if (man_id == 0x41) { /* Analog Devices */
Jean Delvare90209b42005-10-26 22:20:21 +0200504 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 && (reg_config1 & 0x3F) == 0x00
506 && reg_convrate <= 0x0A) {
507 kind = adm1032;
508 } else
Jean Delvare90209b42005-10-26 22:20:21 +0200509 if (chip_id == 0x51 /* ADT7461 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
511 && reg_convrate <= 0x0A) {
512 kind = adt7461;
513 }
514 } else
515 if (man_id == 0x4D) { /* Maxim */
516 /*
517 * The Maxim variants do NOT have a chip_id register.
518 * Reading from that address will return the last read
519 * value, which in our case is those of the man_id
520 * register. Likewise, the config1 register seems to
521 * lack a low nibble, so the value will be those of the
522 * previous read, so in our case those of the man_id
523 * register.
524 */
525 if (chip_id == man_id
526 && (reg_config1 & 0x1F) == (man_id & 0x0F)
527 && reg_convrate <= 0x09) {
528 kind = max6657;
529 }
530 }
531
532 if (kind <= 0) { /* identification failed */
533 dev_info(&adapter->dev,
534 "Unsupported chip (man_id=0x%02X, "
535 "chip_id=0x%02X).\n", man_id, chip_id);
536 goto exit_free;
537 }
538 }
539
540 if (kind == lm90) {
541 name = "lm90";
542 } else if (kind == adm1032) {
543 name = "adm1032";
Jean Delvarec3df5802005-10-26 21:39:40 +0200544 /* The ADM1032 supports PEC, but only if combined
545 transactions are not used. */
546 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
547 new_client->flags |= I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 } else if (kind == lm99) {
549 name = "lm99";
550 } else if (kind == lm86) {
551 name = "lm86";
552 } else if (kind == max6657) {
553 name = "max6657";
554 } else if (kind == adt7461) {
555 name = "adt7461";
556 }
557
558 /* We can fill in the remaining client fields */
559 strlcpy(new_client->name, name, I2C_NAME_SIZE);
560 data->valid = 0;
561 data->kind = kind;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100562 mutex_init(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
564 /* Tell the I2C layer a new client has arrived */
565 if ((err = i2c_attach_client(new_client)))
566 goto exit_free;
567
568 /* Initialize the LM90 chip */
569 lm90_init_client(new_client);
570
571 /* Register sysfs hooks */
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400572 data->class_dev = hwmon_device_register(&new_client->dev);
573 if (IS_ERR(data->class_dev)) {
574 err = PTR_ERR(data->class_dev);
575 goto exit_detach;
576 }
577
Jean Delvare30d73942005-06-05 21:27:28 +0200578 device_create_file(&new_client->dev,
579 &sensor_dev_attr_temp1_input.dev_attr);
580 device_create_file(&new_client->dev,
581 &sensor_dev_attr_temp2_input.dev_attr);
582 device_create_file(&new_client->dev,
583 &sensor_dev_attr_temp1_min.dev_attr);
584 device_create_file(&new_client->dev,
585 &sensor_dev_attr_temp2_min.dev_attr);
586 device_create_file(&new_client->dev,
587 &sensor_dev_attr_temp1_max.dev_attr);
588 device_create_file(&new_client->dev,
589 &sensor_dev_attr_temp2_max.dev_attr);
590 device_create_file(&new_client->dev,
591 &sensor_dev_attr_temp1_crit.dev_attr);
592 device_create_file(&new_client->dev,
593 &sensor_dev_attr_temp2_crit.dev_attr);
594 device_create_file(&new_client->dev,
595 &sensor_dev_attr_temp1_crit_hyst.dev_attr);
596 device_create_file(&new_client->dev,
597 &sensor_dev_attr_temp2_crit_hyst.dev_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 device_create_file(&new_client->dev, &dev_attr_alarms);
599
Jean Delvarec3df5802005-10-26 21:39:40 +0200600 if (new_client->flags & I2C_CLIENT_PEC)
601 device_create_file(&new_client->dev, &dev_attr_pec);
602
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 return 0;
604
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400605exit_detach:
606 i2c_detach_client(new_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607exit_free:
608 kfree(data);
609exit:
610 return err;
611}
612
613static void lm90_init_client(struct i2c_client *client)
614{
615 u8 config;
616
617 /*
618 * Start the conversions.
619 */
620 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
621 5); /* 2 Hz */
Jean Delvare8256fe02005-10-26 21:37:52 +0200622 if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
623 dev_warn(&client->dev, "Initialization failed!\n");
624 return;
625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 if (config & 0x40)
627 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
628 config & 0xBF); /* run */
629}
630
631static int lm90_detach_client(struct i2c_client *client)
632{
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400633 struct lm90_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 int err;
635
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400636 hwmon_device_unregister(data->class_dev);
637
Jean Delvare7bef5592005-07-27 22:14:49 +0200638 if ((err = i2c_detach_client(client)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400641 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return 0;
643}
644
645static struct lm90_data *lm90_update_device(struct device *dev)
646{
647 struct i2c_client *client = to_i2c_client(dev);
648 struct lm90_data *data = i2c_get_clientdata(client);
649
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100650 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
652 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
Jean Delvare8256fe02005-10-26 21:37:52 +0200653 u8 oldh, newh, l;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655 dev_dbg(&client->dev, "Updating lm90 data.\n");
Jean Delvare8256fe02005-10-26 21:37:52 +0200656 lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
657 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
658 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
659 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
660 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
661 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663 /*
664 * There is a trick here. We have to read two registers to
665 * have the remote sensor temperature, but we have to beware
666 * a conversion could occur inbetween the readings. The
667 * datasheet says we should either use the one-shot
668 * conversion register, which we don't want to do (disables
669 * hardware monitoring) or monitor the busy bit, which is
670 * impossible (we can't read the values and monitor that bit
671 * at the exact same time). So the solution used here is to
672 * read the high byte once, then the low byte, then the high
673 * byte again. If the new high byte matches the old one,
674 * then we have a valid reading. Else we have to read the low
675 * byte again, and now we believe we have a correct reading.
676 */
Jean Delvare8256fe02005-10-26 21:37:52 +0200677 if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
678 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
679 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
680 && (newh == oldh
681 || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
682 data->temp11[0] = (newh << 8) | l;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
Jean Delvare8256fe02005-10-26 21:37:52 +0200684 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
685 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
686 data->temp11[1] = (newh << 8) | l;
687 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
688 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
689 data->temp11[2] = (newh << 8) | l;
690 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
692 data->last_updated = jiffies;
693 data->valid = 1;
694 }
695
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100696 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 return data;
699}
700
701static int __init sensors_lm90_init(void)
702{
703 return i2c_add_driver(&lm90_driver);
704}
705
706static void __exit sensors_lm90_exit(void)
707{
708 i2c_del_driver(&lm90_driver);
709}
710
711MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
712MODULE_DESCRIPTION("LM90/ADM1032 driver");
713MODULE_LICENSE("GPL");
714
715module_init(sensors_lm90_init);
716module_exit(sensors_lm90_exit);