blob: 3edeebc0b8355361532becdcb246d6493924be44 [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 Delvare6388a382008-10-17 17:51:09 +02004 * Copyright (C) 2003-2008 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
Jean Delvarea874a102008-10-17 17:51:10 +02009 * temperature) and a 3-4 deg accuracy.
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * This driver also supports the LM89 and LM99, two other sensor chips
12 * made by National Semiconductor. Both have an increased remote
13 * temperature measurement accuracy (1 degree), and the LM99
14 * additionally shifts remote temperatures (measured and limits) by 16
15 * degrees, which allows for higher temperatures measurement. The
16 * driver doesn't handle it since it can be done easily in user-space.
Steven Cole44bbe872005-05-03 18:21:25 -060017 * Note that there is no way to differentiate between both chips.
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 *
19 * This driver also supports the LM86, another sensor chip made by
20 * National Semiconductor. It is exactly similar to the LM90 except it
21 * has a higher accuracy.
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 *
23 * This driver also supports the ADM1032, a sensor chip made by Analog
24 * Devices. That chip is similar to the LM90, with a few differences
Jean Delvarea874a102008-10-17 17:51:10 +020025 * that are not handled by this driver. Among others, it has a higher
26 * accuracy than the LM90, much like the LM86 does.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 *
28 * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
Jean Delvarea874a102008-10-17 17:51:10 +020029 * chips made by Maxim. These chips are similar to the LM86.
Steven Cole44bbe872005-05-03 18:21:25 -060030 * Note that there is no easy way to differentiate between the three
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 * variants. The extra address and features of the MAX6659 are not
Jean Delvare69f2f962007-09-05 14:15:37 +020032 * supported by this driver. These chips lack the remote temperature
33 * offset feature.
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 *
Ben Hutchings271dabf2008-10-17 17:51:11 +020035 * This driver also supports the MAX6646, MAX6647 and MAX6649 chips
36 * made by Maxim. These are again similar to the LM86, but they use
37 * unsigned temperature values and can report temperatures from 0 to
38 * 145 degrees.
39 *
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -040040 * This driver also supports the MAX6680 and MAX6681, two other sensor
41 * chips made by Maxim. These are quite similar to the other Maxim
Jean Delvarea874a102008-10-17 17:51:10 +020042 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
43 * be treated identically.
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -040044 *
Nate Case23b2d472008-10-17 17:51:10 +020045 * This driver also supports the ADT7461 chip from Analog Devices.
46 * It's supported in both compatibility and extended mode. It is mostly
47 * compatible with LM90 except for a data format difference for the
48 * temperature value registers.
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 *
50 * Since the LM90 was the first chipset supported by this driver, most
51 * comments will refer to this chipset, but are actually general and
52 * concern all supported chipsets, unless mentioned otherwise.
53 *
54 * This program is free software; you can redistribute it and/or modify
55 * it under the terms of the GNU General Public License as published by
56 * the Free Software Foundation; either version 2 of the License, or
57 * (at your option) any later version.
58 *
59 * This program is distributed in the hope that it will be useful,
60 * but WITHOUT ANY WARRANTY; without even the implied warranty of
61 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
62 * GNU General Public License for more details.
63 *
64 * You should have received a copy of the GNU General Public License
65 * along with this program; if not, write to the Free Software
66 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
67 */
68
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <linux/module.h>
70#include <linux/init.h>
71#include <linux/slab.h>
72#include <linux/jiffies.h>
73#include <linux/i2c.h>
Jean Delvare10c08f82005-06-06 19:34:45 +020074#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040075#include <linux/hwmon.h>
76#include <linux/err.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010077#include <linux/mutex.h>
Jean Delvare0e39e012006-09-24 21:16:40 +020078#include <linux/sysfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80/*
81 * Addresses to scan
82 * Address is fully defined internally and cannot be changed except for
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -040083 * MAX6659, MAX6680 and MAX6681.
Ben Hutchings271dabf2008-10-17 17:51:11 +020084 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6649, MAX6657
85 * and MAX6658 have address 0x4c.
86 * ADM1032-2, ADT7461-2, LM89-1, LM99-1 and MAX6646 have address 0x4d.
87 * MAX6647 has address 0x4e.
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -040089 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
90 * 0x4c, 0x4d or 0x4e.
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 */
92
Mark M. Hoffman25e9c862008-02-17 22:28:03 -050093static const unsigned short normal_i2c[] = {
94 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
96/*
97 * Insmod parameters
98 */
99
Ben Hutchings271dabf2008-10-17 17:51:11 +0200100I2C_CLIENT_INSMOD_8(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680,
101 max6646);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103/*
104 * The LM90 registers
105 */
106
107#define LM90_REG_R_MAN_ID 0xFE
108#define LM90_REG_R_CHIP_ID 0xFF
109#define LM90_REG_R_CONFIG1 0x03
110#define LM90_REG_W_CONFIG1 0x09
111#define LM90_REG_R_CONFIG2 0xBF
112#define LM90_REG_W_CONFIG2 0xBF
113#define LM90_REG_R_CONVRATE 0x04
114#define LM90_REG_W_CONVRATE 0x0A
115#define LM90_REG_R_STATUS 0x02
116#define LM90_REG_R_LOCAL_TEMP 0x00
117#define LM90_REG_R_LOCAL_HIGH 0x05
118#define LM90_REG_W_LOCAL_HIGH 0x0B
119#define LM90_REG_R_LOCAL_LOW 0x06
120#define LM90_REG_W_LOCAL_LOW 0x0C
121#define LM90_REG_R_LOCAL_CRIT 0x20
122#define LM90_REG_W_LOCAL_CRIT 0x20
123#define LM90_REG_R_REMOTE_TEMPH 0x01
124#define LM90_REG_R_REMOTE_TEMPL 0x10
125#define LM90_REG_R_REMOTE_OFFSH 0x11
126#define LM90_REG_W_REMOTE_OFFSH 0x11
127#define LM90_REG_R_REMOTE_OFFSL 0x12
128#define LM90_REG_W_REMOTE_OFFSL 0x12
129#define LM90_REG_R_REMOTE_HIGHH 0x07
130#define LM90_REG_W_REMOTE_HIGHH 0x0D
131#define LM90_REG_R_REMOTE_HIGHL 0x13
132#define LM90_REG_W_REMOTE_HIGHL 0x13
133#define LM90_REG_R_REMOTE_LOWH 0x08
134#define LM90_REG_W_REMOTE_LOWH 0x0E
135#define LM90_REG_R_REMOTE_LOWL 0x14
136#define LM90_REG_W_REMOTE_LOWL 0x14
137#define LM90_REG_R_REMOTE_CRIT 0x19
138#define LM90_REG_W_REMOTE_CRIT 0x19
139#define LM90_REG_R_TCRIT_HYST 0x21
140#define LM90_REG_W_TCRIT_HYST 0x21
141
Ben Hutchings271dabf2008-10-17 17:51:11 +0200142/* MAX6646/6647/6649/6657/6658/6659 registers */
Jean Delvaref65e1702008-10-17 17:51:09 +0200143
144#define MAX6657_REG_R_LOCAL_TEMPL 0x11
145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146/*
Nate Case23b2d472008-10-17 17:51:10 +0200147 * Device flags
148 */
149#define LM90_FLAG_ADT7461_EXT 0x01 /* ADT7461 extended mode */
150
151/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 * Functions declaration
153 */
154
Jean Delvare9b0e8522008-07-16 19:30:15 +0200155static int lm90_detect(struct i2c_client *client, int kind,
156 struct i2c_board_info *info);
157static int lm90_probe(struct i2c_client *client,
158 const struct i2c_device_id *id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159static void lm90_init_client(struct i2c_client *client);
Jean Delvare9b0e8522008-07-16 19:30:15 +0200160static int lm90_remove(struct i2c_client *client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161static struct lm90_data *lm90_update_device(struct device *dev);
162
163/*
164 * Driver data (common to all clients)
165 */
166
Jean Delvare9b0e8522008-07-16 19:30:15 +0200167static const struct i2c_device_id lm90_id[] = {
168 { "adm1032", adm1032 },
169 { "adt7461", adt7461 },
170 { "lm90", lm90 },
171 { "lm86", lm86 },
172 { "lm89", lm99 },
173 { "lm99", lm99 }, /* Missing temperature offset */
Ben Hutchings271dabf2008-10-17 17:51:11 +0200174 { "max6646", max6646 },
175 { "max6647", max6646 },
176 { "max6649", max6646 },
Jean Delvare9b0e8522008-07-16 19:30:15 +0200177 { "max6657", max6657 },
178 { "max6658", max6657 },
179 { "max6659", max6657 },
180 { "max6680", max6680 },
181 { "max6681", max6680 },
182 { }
183};
184MODULE_DEVICE_TABLE(i2c, lm90_id);
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186static struct i2c_driver lm90_driver = {
Jean Delvare9b0e8522008-07-16 19:30:15 +0200187 .class = I2C_CLASS_HWMON,
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100188 .driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100189 .name = "lm90",
190 },
Jean Delvare9b0e8522008-07-16 19:30:15 +0200191 .probe = lm90_probe,
192 .remove = lm90_remove,
193 .id_table = lm90_id,
194 .detect = lm90_detect,
195 .address_data = &addr_data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196};
197
198/*
199 * Client data (each client gets its own)
200 */
201
202struct lm90_data {
Tony Jones1beeffe2007-08-20 13:46:20 -0700203 struct device *hwmon_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100204 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 char valid; /* zero until following fields are valid */
206 unsigned long last_updated; /* in jiffies */
207 int kind;
Nate Case23b2d472008-10-17 17:51:10 +0200208 int flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
210 /* registers values */
Jean Delvaref65e1702008-10-17 17:51:09 +0200211 s8 temp8[4]; /* 0: local low limit
212 1: local high limit
213 2: local critical limit
214 3: remote critical limit */
215 s16 temp11[5]; /* 0: remote input
Jean Delvare30d73942005-06-05 21:27:28 +0200216 1: remote low limit
Jean Delvare69f2f962007-09-05 14:15:37 +0200217 2: remote high limit
Ben Hutchings271dabf2008-10-17 17:51:11 +0200218 3: remote offset (except max6646 and max6657)
Jean Delvaref65e1702008-10-17 17:51:09 +0200219 4: local input */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 u8 temp_hyst;
221 u8 alarms; /* bitvector */
222};
223
224/*
Nate Casecea50fe2008-10-17 17:51:10 +0200225 * Conversions
226 * For local temperatures and limits, critical limits and the hysteresis
227 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
228 * For remote temperatures and limits, it uses signed 11-bit values with
Ben Hutchings271dabf2008-10-17 17:51:11 +0200229 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers. Some
230 * Maxim chips use unsigned values.
Nate Casecea50fe2008-10-17 17:51:10 +0200231 */
232
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200233static inline int temp_from_s8(s8 val)
Nate Casecea50fe2008-10-17 17:51:10 +0200234{
235 return val * 1000;
236}
237
Ben Hutchings271dabf2008-10-17 17:51:11 +0200238static inline int temp_from_u8(u8 val)
239{
240 return val * 1000;
241}
242
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200243static inline int temp_from_s16(s16 val)
Nate Casecea50fe2008-10-17 17:51:10 +0200244{
245 return val / 32 * 125;
246}
247
Ben Hutchings271dabf2008-10-17 17:51:11 +0200248static inline int temp_from_u16(u16 val)
249{
250 return val / 32 * 125;
251}
252
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200253static s8 temp_to_s8(long val)
Nate Casecea50fe2008-10-17 17:51:10 +0200254{
255 if (val <= -128000)
256 return -128;
257 if (val >= 127000)
258 return 127;
259 if (val < 0)
260 return (val - 500) / 1000;
261 return (val + 500) / 1000;
262}
263
Ben Hutchings271dabf2008-10-17 17:51:11 +0200264static u8 temp_to_u8(long val)
265{
266 if (val <= 0)
267 return 0;
268 if (val >= 255000)
269 return 255;
270 return (val + 500) / 1000;
271}
272
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200273static s16 temp_to_s16(long val)
Nate Casecea50fe2008-10-17 17:51:10 +0200274{
275 if (val <= -128000)
276 return 0x8000;
277 if (val >= 127875)
278 return 0x7FE0;
279 if (val < 0)
280 return (val - 62) / 125 * 32;
281 return (val + 62) / 125 * 32;
282}
283
284static u8 hyst_to_reg(long val)
285{
286 if (val <= 0)
287 return 0;
288 if (val >= 30500)
289 return 31;
290 return (val + 500) / 1000;
291}
292
293/*
Nate Case23b2d472008-10-17 17:51:10 +0200294 * ADT7461 in compatibility mode is almost identical to LM90 except that
295 * attempts to write values that are outside the range 0 < temp < 127 are
296 * treated as the boundary value.
297 *
298 * ADT7461 in "extended mode" operation uses unsigned integers offset by
299 * 64 (e.g., 0 -> -64 degC). The range is restricted to -64..191 degC.
Nate Casecea50fe2008-10-17 17:51:10 +0200300 */
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200301static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
Nate Casecea50fe2008-10-17 17:51:10 +0200302{
Nate Case23b2d472008-10-17 17:51:10 +0200303 if (data->flags & LM90_FLAG_ADT7461_EXT)
304 return (val - 64) * 1000;
305 else
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200306 return temp_from_s8(val);
Nate Casecea50fe2008-10-17 17:51:10 +0200307}
308
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200309static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
Nate Casecea50fe2008-10-17 17:51:10 +0200310{
Nate Case23b2d472008-10-17 17:51:10 +0200311 if (data->flags & LM90_FLAG_ADT7461_EXT)
312 return (val - 0x4000) / 64 * 250;
313 else
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200314 return temp_from_s16(val);
Nate Case23b2d472008-10-17 17:51:10 +0200315}
316
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200317static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
Nate Case23b2d472008-10-17 17:51:10 +0200318{
319 if (data->flags & LM90_FLAG_ADT7461_EXT) {
320 if (val <= -64000)
321 return 0;
322 if (val >= 191000)
323 return 0xFF;
324 return (val + 500 + 64000) / 1000;
325 } else {
326 if (val <= 0)
327 return 0;
328 if (val >= 127000)
329 return 127;
330 return (val + 500) / 1000;
331 }
332}
333
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200334static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
Nate Case23b2d472008-10-17 17:51:10 +0200335{
336 if (data->flags & LM90_FLAG_ADT7461_EXT) {
337 if (val <= -64000)
338 return 0;
339 if (val >= 191750)
340 return 0xFFC0;
341 return (val + 64000 + 125) / 250 * 64;
342 } else {
343 if (val <= 0)
344 return 0;
345 if (val >= 127750)
346 return 0x7FC0;
347 return (val + 125) / 250 * 64;
348 }
Nate Casecea50fe2008-10-17 17:51:10 +0200349}
350
351/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 * Sysfs stuff
353 */
354
Jean Delvare30d73942005-06-05 21:27:28 +0200355static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
356 char *buf)
357{
358 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
359 struct lm90_data *data = lm90_update_device(dev);
Nate Case23b2d472008-10-17 17:51:10 +0200360 int temp;
361
362 if (data->kind == adt7461)
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200363 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
Ben Hutchings271dabf2008-10-17 17:51:11 +0200364 else if (data->kind == max6646)
365 temp = temp_from_u8(data->temp8[attr->index]);
Nate Case23b2d472008-10-17 17:51:10 +0200366 else
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200367 temp = temp_from_s8(data->temp8[attr->index]);
Nate Case23b2d472008-10-17 17:51:10 +0200368
369 return sprintf(buf, "%d\n", temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
Jean Delvare30d73942005-06-05 21:27:28 +0200372static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
373 const char *buf, size_t count)
374{
375 static const u8 reg[4] = {
376 LM90_REG_W_LOCAL_LOW,
377 LM90_REG_W_LOCAL_HIGH,
378 LM90_REG_W_LOCAL_CRIT,
379 LM90_REG_W_REMOTE_CRIT,
380 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Jean Delvare30d73942005-06-05 21:27:28 +0200382 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
383 struct i2c_client *client = to_i2c_client(dev);
384 struct lm90_data *data = i2c_get_clientdata(client);
385 long val = simple_strtol(buf, NULL, 10);
386 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100388 mutex_lock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200389 if (data->kind == adt7461)
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200390 data->temp8[nr] = temp_to_u8_adt7461(data, val);
Ben Hutchings271dabf2008-10-17 17:51:11 +0200391 else if (data->kind == max6646)
392 data->temp8[nr] = temp_to_u8(val);
Jean Delvare30d73942005-06-05 21:27:28 +0200393 else
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200394 data->temp8[nr] = temp_to_s8(val);
Jean Delvaref65e1702008-10-17 17:51:09 +0200395 i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100396 mutex_unlock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200397 return count;
398}
399
400static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
401 char *buf)
402{
403 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
404 struct lm90_data *data = lm90_update_device(dev);
Nate Case23b2d472008-10-17 17:51:10 +0200405 int temp;
406
407 if (data->kind == adt7461)
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200408 temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
Ben Hutchings271dabf2008-10-17 17:51:11 +0200409 else if (data->kind == max6646)
410 temp = temp_from_u16(data->temp11[attr->index]);
Nate Case23b2d472008-10-17 17:51:10 +0200411 else
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200412 temp = temp_from_s16(data->temp11[attr->index]);
Nate Case23b2d472008-10-17 17:51:10 +0200413
414 return sprintf(buf, "%d\n", temp);
Jean Delvare30d73942005-06-05 21:27:28 +0200415}
416
417static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
418 const char *buf, size_t count)
419{
Jean Delvare69f2f962007-09-05 14:15:37 +0200420 static const u8 reg[6] = {
Jean Delvare30d73942005-06-05 21:27:28 +0200421 LM90_REG_W_REMOTE_LOWH,
422 LM90_REG_W_REMOTE_LOWL,
423 LM90_REG_W_REMOTE_HIGHH,
424 LM90_REG_W_REMOTE_HIGHL,
Jean Delvare69f2f962007-09-05 14:15:37 +0200425 LM90_REG_W_REMOTE_OFFSH,
426 LM90_REG_W_REMOTE_OFFSL,
Jean Delvare30d73942005-06-05 21:27:28 +0200427 };
428
429 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
430 struct i2c_client *client = to_i2c_client(dev);
431 struct lm90_data *data = i2c_get_clientdata(client);
432 long val = simple_strtol(buf, NULL, 10);
433 int nr = attr->index;
434
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100435 mutex_lock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200436 if (data->kind == adt7461)
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200437 data->temp11[nr] = temp_to_u16_adt7461(data, val);
Jean Delvare5f502a82008-10-17 17:51:09 +0200438 else if (data->kind == max6657 || data->kind == max6680)
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200439 data->temp11[nr] = temp_to_s8(val) << 8;
Ben Hutchings271dabf2008-10-17 17:51:11 +0200440 else if (data->kind == max6646)
441 data->temp11[nr] = temp_to_u8(val) << 8;
Jean Delvare30d73942005-06-05 21:27:28 +0200442 else
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200443 data->temp11[nr] = temp_to_s16(val);
Jean Delvare5f502a82008-10-17 17:51:09 +0200444
Jean Delvare30d73942005-06-05 21:27:28 +0200445 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
446 data->temp11[nr] >> 8);
Ben Hutchings271dabf2008-10-17 17:51:11 +0200447 if (data->kind != max6657 && data->kind != max6680
448 && data->kind != max6646)
Jean Delvare5f502a82008-10-17 17:51:09 +0200449 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
450 data->temp11[nr] & 0xff);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100451 mutex_unlock(&data->update_lock);
Jean Delvare30d73942005-06-05 21:27:28 +0200452 return count;
453}
454
455static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
456 char *buf)
457{
458 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
459 struct lm90_data *data = lm90_update_device(dev);
Nate Case23b2d472008-10-17 17:51:10 +0200460 int temp;
461
462 if (data->kind == adt7461)
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200463 temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
Nate Case23b2d472008-10-17 17:51:10 +0200464 else
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200465 temp = temp_from_s8(data->temp8[attr->index]);
Nate Case23b2d472008-10-17 17:51:10 +0200466
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200467 return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
Jean Delvare30d73942005-06-05 21:27:28 +0200468}
469
470static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
471 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472{
473 struct i2c_client *client = to_i2c_client(dev);
474 struct lm90_data *data = i2c_get_clientdata(client);
475 long val = simple_strtol(buf, NULL, 10);
476 long hyst;
477
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100478 mutex_lock(&data->update_lock);
Ben Hutchings9d4d3832008-10-17 17:51:10 +0200479 hyst = temp_from_s8(data->temp8[2]) - val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
Nate Casecea50fe2008-10-17 17:51:10 +0200481 hyst_to_reg(hyst));
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100482 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 return count;
484}
485
Jean Delvare30d73942005-06-05 21:27:28 +0200486static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
487 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
489 struct lm90_data *data = lm90_update_device(dev);
490 return sprintf(buf, "%d\n", data->alarms);
491}
492
Jean Delvare2d457712006-09-24 20:52:15 +0200493static ssize_t show_alarm(struct device *dev, struct device_attribute
494 *devattr, char *buf)
495{
496 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
497 struct lm90_data *data = lm90_update_device(dev);
498 int bitnr = attr->index;
499
500 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
501}
502
Jean Delvaref65e1702008-10-17 17:51:09 +0200503static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
Jean Delvare30d73942005-06-05 21:27:28 +0200504static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
505static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
Jean Delvaref65e1702008-10-17 17:51:09 +0200506 set_temp8, 0);
Jean Delvare30d73942005-06-05 21:27:28 +0200507static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
508 set_temp11, 1);
509static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
Jean Delvaref65e1702008-10-17 17:51:09 +0200510 set_temp8, 1);
Jean Delvare30d73942005-06-05 21:27:28 +0200511static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
512 set_temp11, 2);
513static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
Jean Delvaref65e1702008-10-17 17:51:09 +0200514 set_temp8, 2);
Jean Delvare30d73942005-06-05 21:27:28 +0200515static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
Jean Delvaref65e1702008-10-17 17:51:09 +0200516 set_temp8, 3);
Jean Delvare30d73942005-06-05 21:27:28 +0200517static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
Jean Delvaref65e1702008-10-17 17:51:09 +0200518 set_temphyst, 2);
519static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
Jean Delvare69f2f962007-09-05 14:15:37 +0200520static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
521 set_temp11, 3);
Jean Delvare2d457712006-09-24 20:52:15 +0200522
523/* Individual alarm files */
524static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
525static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
Jean Delvare7817a392007-06-09 10:11:16 -0400526static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
Jean Delvare2d457712006-09-24 20:52:15 +0200527static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
528static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
529static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
530static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
531/* Raw alarm file for compatibility */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
533
Jean Delvare0e39e012006-09-24 21:16:40 +0200534static struct attribute *lm90_attributes[] = {
535 &sensor_dev_attr_temp1_input.dev_attr.attr,
536 &sensor_dev_attr_temp2_input.dev_attr.attr,
537 &sensor_dev_attr_temp1_min.dev_attr.attr,
538 &sensor_dev_attr_temp2_min.dev_attr.attr,
539 &sensor_dev_attr_temp1_max.dev_attr.attr,
540 &sensor_dev_attr_temp2_max.dev_attr.attr,
541 &sensor_dev_attr_temp1_crit.dev_attr.attr,
542 &sensor_dev_attr_temp2_crit.dev_attr.attr,
543 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
544 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
545
546 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
547 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
Jean Delvare7817a392007-06-09 10:11:16 -0400548 &sensor_dev_attr_temp2_fault.dev_attr.attr,
Jean Delvare0e39e012006-09-24 21:16:40 +0200549 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
550 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
551 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
552 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
553 &dev_attr_alarms.attr,
554 NULL
555};
556
557static const struct attribute_group lm90_group = {
558 .attrs = lm90_attributes,
559};
560
Jean Delvarec3df5802005-10-26 21:39:40 +0200561/* pec used for ADM1032 only */
562static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
563 char *buf)
564{
565 struct i2c_client *client = to_i2c_client(dev);
566 return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
567}
568
569static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
570 const char *buf, size_t count)
571{
572 struct i2c_client *client = to_i2c_client(dev);
573 long val = simple_strtol(buf, NULL, 10);
574
575 switch (val) {
576 case 0:
577 client->flags &= ~I2C_CLIENT_PEC;
578 break;
579 case 1:
580 client->flags |= I2C_CLIENT_PEC;
581 break;
582 default:
583 return -EINVAL;
584 }
585
586 return count;
587}
588
589static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591/*
592 * Real code
593 */
594
Jean Delvarec3df5802005-10-26 21:39:40 +0200595/* The ADM1032 supports PEC but not on write byte transactions, so we need
Jean Delvare09664152007-06-09 10:11:15 -0400596 to explicitly ask for a transaction without PEC. */
Jean Delvarec3df5802005-10-26 21:39:40 +0200597static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
598{
599 return i2c_smbus_xfer(client->adapter, client->addr,
600 client->flags & ~I2C_CLIENT_PEC,
601 I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
602}
603
604/* It is assumed that client->update_lock is held (unless we are in
605 detection or initialization steps). This matters when PEC is enabled,
606 because we don't want the address pointer to change between the write
607 byte and the read byte transactions. */
Jean Delvare8256fe02005-10-26 21:37:52 +0200608static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
609{
610 int err;
611
Jean Delvarec3df5802005-10-26 21:39:40 +0200612 if (client->flags & I2C_CLIENT_PEC) {
613 err = adm1032_write_byte(client, reg);
614 if (err >= 0)
615 err = i2c_smbus_read_byte(client);
616 } else
617 err = i2c_smbus_read_byte_data(client, reg);
Jean Delvare8256fe02005-10-26 21:37:52 +0200618
619 if (err < 0) {
620 dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
621 reg, err);
622 return err;
623 }
624 *value = err;
625
626 return 0;
627}
628
Jean Delvare9b0e8522008-07-16 19:30:15 +0200629/* Return 0 if detection is successful, -ENODEV otherwise */
630static int lm90_detect(struct i2c_client *new_client, int kind,
631 struct i2c_board_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632{
Jean Delvare9b0e8522008-07-16 19:30:15 +0200633 struct i2c_adapter *adapter = new_client->adapter;
634 int address = new_client->addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 const char *name = "";
636
637 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
Jean Delvare9b0e8522008-07-16 19:30:15 +0200638 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
640 /*
641 * Now we do the remaining detection. A negative kind means that
642 * the driver was loaded with no force parameter (default), so we
643 * must both detect and identify the chip. A zero kind means that
644 * the driver was loaded with the force parameter, the detection
645 * step shall be skipped. A positive kind means that the driver
646 * was loaded with the force parameter and a given kind of chip is
647 * requested, so both the detection and the identification steps
648 * are skipped.
649 */
650
651 /* Default to an LM90 if forced */
652 if (kind == 0)
653 kind = lm90;
654
655 if (kind < 0) { /* detection and identification */
Jean Delvaree0ae87a2007-11-25 21:58:21 +0100656 int man_id, chip_id, reg_config1, reg_convrate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Jean Delvaree0ae87a2007-11-25 21:58:21 +0100658 if ((man_id = i2c_smbus_read_byte_data(new_client,
659 LM90_REG_R_MAN_ID)) < 0
660 || (chip_id = i2c_smbus_read_byte_data(new_client,
661 LM90_REG_R_CHIP_ID)) < 0
662 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
663 LM90_REG_R_CONFIG1)) < 0
664 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
665 LM90_REG_R_CONVRATE)) < 0)
Jean Delvare9b0e8522008-07-16 19:30:15 +0200666 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400668 if ((address == 0x4C || address == 0x4D)
669 && man_id == 0x01) { /* National Semiconductor */
Jean Delvaree0ae87a2007-11-25 21:58:21 +0100670 int reg_config2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Jean Delvaree0ae87a2007-11-25 21:58:21 +0100672 if ((reg_config2 = i2c_smbus_read_byte_data(new_client,
673 LM90_REG_R_CONFIG2)) < 0)
Jean Delvare9b0e8522008-07-16 19:30:15 +0200674 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
676 if ((reg_config1 & 0x2A) == 0x00
677 && (reg_config2 & 0xF8) == 0x00
678 && reg_convrate <= 0x09) {
679 if (address == 0x4C
680 && (chip_id & 0xF0) == 0x20) { /* LM90 */
681 kind = lm90;
682 } else
683 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
684 kind = lm99;
685 } else
686 if (address == 0x4C
687 && (chip_id & 0xF0) == 0x10) { /* LM86 */
688 kind = lm86;
689 }
690 }
691 } else
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400692 if ((address == 0x4C || address == 0x4D)
693 && man_id == 0x41) { /* Analog Devices */
Jean Delvare90209b42005-10-26 22:20:21 +0200694 if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 && (reg_config1 & 0x3F) == 0x00
696 && reg_convrate <= 0x0A) {
697 kind = adm1032;
698 } else
Jean Delvare90209b42005-10-26 22:20:21 +0200699 if (chip_id == 0x51 /* ADT7461 */
Nate Case23b2d472008-10-17 17:51:10 +0200700 && (reg_config1 & 0x1B) == 0x00
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 && reg_convrate <= 0x0A) {
702 kind = adt7461;
703 }
704 } else
705 if (man_id == 0x4D) { /* Maxim */
706 /*
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400707 * The MAX6657, MAX6658 and MAX6659 do NOT have a
708 * chip_id register. Reading from that address will
709 * return the last read value, which in our case is
710 * those of the man_id register. Likewise, the config1
711 * register seems to lack a low nibble, so the value
712 * will be those of the previous read, so in our case
713 * those of the man_id register.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 */
715 if (chip_id == man_id
Guillaume Chazarainf5744e32007-07-27 01:04:22 +0200716 && (address == 0x4C || address == 0x4D)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 && (reg_config1 & 0x1F) == (man_id & 0x0F)
718 && reg_convrate <= 0x09) {
719 kind = max6657;
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400720 } else
721 /* The chip_id register of the MAX6680 and MAX6681
722 * holds the revision of the chip.
723 * the lowest bit of the config1 register is unused
724 * and should return zero when read, so should the
725 * second to last bit of config1 (software reset)
726 */
727 if (chip_id == 0x01
728 && (reg_config1 & 0x03) == 0x00
729 && reg_convrate <= 0x07) {
730 kind = max6680;
Ben Hutchings271dabf2008-10-17 17:51:11 +0200731 } else
732 /* The chip_id register of the MAX6646/6647/6649
733 * holds the revision of the chip.
734 * The lowest 6 bits of the config1 register are
735 * unused and should return zero when read.
736 */
737 if (chip_id == 0x59
738 && (reg_config1 & 0x3f) == 0x00
739 && reg_convrate <= 0x07) {
740 kind = max6646;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
742 }
743
744 if (kind <= 0) { /* identification failed */
Jean Delvare4b4e7a72008-10-17 17:51:11 +0200745 dev_dbg(&adapter->dev,
746 "Unsupported chip at 0x%02x (man_id=0x%02X, "
747 "chip_id=0x%02X)\n", address, man_id, chip_id);
Jean Delvare9b0e8522008-07-16 19:30:15 +0200748 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 }
750 }
751
Jean Delvare9b0e8522008-07-16 19:30:15 +0200752 /* Fill the i2c board info */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 if (kind == lm90) {
754 name = "lm90";
755 } else if (kind == adm1032) {
756 name = "adm1032";
Jean Delvarec3df5802005-10-26 21:39:40 +0200757 /* The ADM1032 supports PEC, but only if combined
758 transactions are not used. */
759 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
Jean Delvare9b0e8522008-07-16 19:30:15 +0200760 info->flags |= I2C_CLIENT_PEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 } else if (kind == lm99) {
762 name = "lm99";
763 } else if (kind == lm86) {
764 name = "lm86";
765 } else if (kind == max6657) {
766 name = "max6657";
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400767 } else if (kind == max6680) {
768 name = "max6680";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 } else if (kind == adt7461) {
770 name = "adt7461";
Ben Hutchings271dabf2008-10-17 17:51:11 +0200771 } else if (kind == max6646) {
772 name = "max6646";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 }
Jean Delvare9b0e8522008-07-16 19:30:15 +0200774 strlcpy(info->type, name, I2C_NAME_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
Jean Delvare9b0e8522008-07-16 19:30:15 +0200776 return 0;
777}
778
779static int lm90_probe(struct i2c_client *new_client,
780 const struct i2c_device_id *id)
781{
782 struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
783 struct lm90_data *data;
784 int err;
785
786 data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
787 if (!data) {
788 err = -ENOMEM;
789 goto exit;
790 }
791 i2c_set_clientdata(new_client, data);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100792 mutex_init(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Jean Delvare9b0e8522008-07-16 19:30:15 +0200794 /* Set the device type */
795 data->kind = id->driver_data;
796 if (data->kind == adm1032) {
797 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
798 new_client->flags &= ~I2C_CLIENT_PEC;
799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
801 /* Initialize the LM90 chip */
802 lm90_init_client(new_client);
803
804 /* Register sysfs hooks */
Jean Delvare0e39e012006-09-24 21:16:40 +0200805 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
Jean Delvare9b0e8522008-07-16 19:30:15 +0200806 goto exit_free;
Jean Delvare0e39e012006-09-24 21:16:40 +0200807 if (new_client->flags & I2C_CLIENT_PEC) {
808 if ((err = device_create_file(&new_client->dev,
809 &dev_attr_pec)))
810 goto exit_remove_files;
811 }
Ben Hutchings271dabf2008-10-17 17:51:11 +0200812 if (data->kind != max6657 && data->kind != max6646) {
Jean Delvare69f2f962007-09-05 14:15:37 +0200813 if ((err = device_create_file(&new_client->dev,
814 &sensor_dev_attr_temp2_offset.dev_attr)))
815 goto exit_remove_files;
816 }
Jean Delvare0e39e012006-09-24 21:16:40 +0200817
Tony Jones1beeffe2007-08-20 13:46:20 -0700818 data->hwmon_dev = hwmon_device_register(&new_client->dev);
819 if (IS_ERR(data->hwmon_dev)) {
820 err = PTR_ERR(data->hwmon_dev);
Jean Delvare0e39e012006-09-24 21:16:40 +0200821 goto exit_remove_files;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400822 }
823
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 return 0;
825
Jean Delvare0e39e012006-09-24 21:16:40 +0200826exit_remove_files:
827 sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
828 device_remove_file(&new_client->dev, &dev_attr_pec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829exit_free:
830 kfree(data);
831exit:
832 return err;
833}
834
835static void lm90_init_client(struct i2c_client *client)
836{
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400837 u8 config, config_orig;
838 struct lm90_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
840 /*
841 * Start the conversions.
842 */
843 i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
844 5); /* 2 Hz */
Jean Delvare8256fe02005-10-26 21:37:52 +0200845 if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
846 dev_warn(&client->dev, "Initialization failed!\n");
847 return;
848 }
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400849 config_orig = config;
850
Nate Case23b2d472008-10-17 17:51:10 +0200851 /* Check Temperature Range Select */
852 if (data->kind == adt7461) {
853 if (config & 0x04)
854 data->flags |= LM90_FLAG_ADT7461_EXT;
855 }
856
Rainer Birkenmaier32c82a92007-06-09 10:11:16 -0400857 /*
858 * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
859 * 0.125 degree resolution) and range (0x08, extend range
860 * to -64 degree) mode for the remote temperature sensor.
861 */
862 if (data->kind == max6680) {
863 config |= 0x18;
864 }
865
866 config &= 0xBF; /* run */
867 if (config != config_orig) /* Only write if changed */
868 i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
870
Jean Delvare9b0e8522008-07-16 19:30:15 +0200871static int lm90_remove(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872{
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400873 struct lm90_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Tony Jones1beeffe2007-08-20 13:46:20 -0700875 hwmon_device_unregister(data->hwmon_dev);
Jean Delvare0e39e012006-09-24 21:16:40 +0200876 sysfs_remove_group(&client->dev.kobj, &lm90_group);
877 device_remove_file(&client->dev, &dev_attr_pec);
Ben Hutchings271dabf2008-10-17 17:51:11 +0200878 if (data->kind != max6657 && data->kind != max6646)
Jean Delvare69f2f962007-09-05 14:15:37 +0200879 device_remove_file(&client->dev,
880 &sensor_dev_attr_temp2_offset.dev_attr);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400881
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400882 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 return 0;
884}
885
Jean Delvare6388a382008-10-17 17:51:09 +0200886static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
887{
888 int err;
889 u8 oldh, newh, l;
890
891 /*
892 * There is a trick here. We have to read two registers to have the
893 * sensor temperature, but we have to beware a conversion could occur
894 * inbetween the readings. The datasheet says we should either use
895 * the one-shot conversion register, which we don't want to do
896 * (disables hardware monitoring) or monitor the busy bit, which is
897 * impossible (we can't read the values and monitor that bit at the
898 * exact same time). So the solution used here is to read the high
899 * byte once, then the low byte, then the high byte again. If the new
900 * high byte matches the old one, then we have a valid reading. Else
901 * we have to read the low byte again, and now we believe we have a
902 * correct reading.
903 */
904 if ((err = lm90_read_reg(client, regh, &oldh))
905 || (err = lm90_read_reg(client, regl, &l))
906 || (err = lm90_read_reg(client, regh, &newh)))
907 return err;
908 if (oldh != newh) {
909 err = lm90_read_reg(client, regl, &l);
910 if (err)
911 return err;
912 }
913 *value = (newh << 8) | l;
914
915 return 0;
916}
917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918static struct lm90_data *lm90_update_device(struct device *dev)
919{
920 struct i2c_client *client = to_i2c_client(dev);
921 struct lm90_data *data = i2c_get_clientdata(client);
922
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100923 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
925 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
Jean Delvare6388a382008-10-17 17:51:09 +0200926 u8 h, l;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
928 dev_dbg(&client->dev, "Updating lm90 data.\n");
Jean Delvaref65e1702008-10-17 17:51:09 +0200929 lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
930 lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
931 lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
932 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
Jean Delvare8256fe02005-10-26 21:37:52 +0200933 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
Ben Hutchings271dabf2008-10-17 17:51:11 +0200935 if (data->kind == max6657 || data->kind == max6646) {
Jean Delvaref65e1702008-10-17 17:51:09 +0200936 lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
937 MAX6657_REG_R_LOCAL_TEMPL,
938 &data->temp11[4]);
939 } else {
940 if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
941 &h) == 0)
942 data->temp11[4] = h << 8;
943 }
Jean Delvare6388a382008-10-17 17:51:09 +0200944 lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
945 LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Jean Delvare5f502a82008-10-17 17:51:09 +0200947 if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
948 data->temp11[1] = h << 8;
949 if (data->kind != max6657 && data->kind != max6680
Ben Hutchings271dabf2008-10-17 17:51:11 +0200950 && data->kind != max6646
Jean Delvare5f502a82008-10-17 17:51:09 +0200951 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
952 &l) == 0)
953 data->temp11[1] |= l;
954 }
955 if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
956 data->temp11[2] = h << 8;
957 if (data->kind != max6657 && data->kind != max6680
Ben Hutchings271dabf2008-10-17 17:51:11 +0200958 && data->kind != max6646
Jean Delvare5f502a82008-10-17 17:51:09 +0200959 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
960 &l) == 0)
961 data->temp11[2] |= l;
962 }
963
Ben Hutchings271dabf2008-10-17 17:51:11 +0200964 if (data->kind != max6657 && data->kind != max6646) {
Jean Delvare69f2f962007-09-05 14:15:37 +0200965 if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
Jean Delvare6388a382008-10-17 17:51:09 +0200966 &h) == 0
Jean Delvare69f2f962007-09-05 14:15:37 +0200967 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
968 &l) == 0)
Jean Delvare6388a382008-10-17 17:51:09 +0200969 data->temp11[3] = (h << 8) | l;
Jean Delvare69f2f962007-09-05 14:15:37 +0200970 }
Jean Delvare8256fe02005-10-26 21:37:52 +0200971 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973 data->last_updated = jiffies;
974 data->valid = 1;
975 }
976
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100977 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
979 return data;
980}
981
982static int __init sensors_lm90_init(void)
983{
984 return i2c_add_driver(&lm90_driver);
985}
986
987static void __exit sensors_lm90_exit(void)
988{
989 i2c_del_driver(&lm90_driver);
990}
991
992MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
993MODULE_DESCRIPTION("LM90/ADM1032 driver");
994MODULE_LICENSE("GPL");
995
996module_init(sensors_lm90_init);
997module_exit(sensors_lm90_exit);