lm90.c 34.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
 *          monitoring
4
 * Copyright (C) 2003-2010  Jean Delvare <khali@linux-fr.org>
L
Linus Torvalds 已提交
5 6 7 8
 *
 * Based on the lm83 driver. The LM90 is a sensor chip made by National
 * Semiconductor. It reports up to two temperatures (its own plus up to
 * one external one) with a 0.125 deg resolution (1 deg for local
9
 * temperature) and a 3-4 deg accuracy.
L
Linus Torvalds 已提交
10 11 12 13 14
 *
 * This driver also supports the LM89 and LM99, two other sensor chips
 * made by National Semiconductor. Both have an increased remote
 * temperature measurement accuracy (1 degree), and the LM99
 * additionally shifts remote temperatures (measured and limits) by 16
15
 * degrees, which allows for higher temperatures measurement.
16
 * Note that there is no way to differentiate between both chips.
17
 * When device is auto-detected, the driver will assume an LM99.
L
Linus Torvalds 已提交
18 19 20 21 22 23 24
 *
 * This driver also supports the LM86, another sensor chip made by
 * National Semiconductor. It is exactly similar to the LM90 except it
 * has a higher accuracy.
 *
 * This driver also supports the ADM1032, a sensor chip made by Analog
 * Devices. That chip is similar to the LM90, with a few differences
25 26
 * that are not handled by this driver. Among others, it has a higher
 * accuracy than the LM90, much like the LM86 does.
L
Linus Torvalds 已提交
27 28
 *
 * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
29
 * chips made by Maxim. These chips are similar to the LM86.
30
 * Note that there is no easy way to differentiate between the three
31 32 33 34 35
 * variants. We use the device address to detect MAX6659, which will result
 * in a detection as max6657 if it is on address 0x4c. The extra address
 * and features of the MAX6659 are only supported if the chip is configured
 * explicitly as max6659, or if its address is not 0x4c.
 * These chips lack the remote temperature offset feature.
L
Linus Torvalds 已提交
36
 *
37 38 39 40
 * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and
 * MAX6692 chips made by Maxim.  These are again similar to the LM86,
 * but they use unsigned temperature values and can report temperatures
 * from 0 to 145 degrees.
41
 *
42 43
 * This driver also supports the MAX6680 and MAX6681, two other sensor
 * chips made by Maxim. These are quite similar to the other Maxim
44 45
 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
 * be treated identically.
46
 *
47 48 49 50
 * This driver also supports the ADT7461 chip from Analog Devices.
 * It's supported in both compatibility and extended mode. It is mostly
 * compatible with LM90 except for a data format difference for the
 * temperature value registers.
L
Linus Torvalds 已提交
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
 *
 * Since the LM90 was the first chipset supported by this driver, most
 * comments will refer to this chipset, but are actually general and
 * concern all supported chipsets, unless mentioned otherwise.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
76
#include <linux/hwmon-sysfs.h>
77 78
#include <linux/hwmon.h>
#include <linux/err.h>
79
#include <linux/mutex.h>
80
#include <linux/sysfs.h>
L
Linus Torvalds 已提交
81 82 83 84

/*
 * Addresses to scan
 * Address is fully defined internally and cannot be changed except for
85
 * MAX6659, MAX6680 and MAX6681.
86 87 88 89
 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6649, MAX6657
 * and MAX6658 have address 0x4c.
 * ADM1032-2, ADT7461-2, LM89-1, LM99-1 and MAX6646 have address 0x4d.
 * MAX6647 has address 0x4e.
90
 * MAX6659 can have address 0x4c, 0x4d or 0x4e.
91 92
 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
 * 0x4c, 0x4d or 0x4e.
L
Linus Torvalds 已提交
93 94
 */

95 96
static const unsigned short normal_i2c[] = {
	0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
L
Linus Torvalds 已提交
97

98 99
enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,
	max6646, w83l771 };
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139

/*
 * The LM90 registers
 */

#define LM90_REG_R_MAN_ID		0xFE
#define LM90_REG_R_CHIP_ID		0xFF
#define LM90_REG_R_CONFIG1		0x03
#define LM90_REG_W_CONFIG1		0x09
#define LM90_REG_R_CONFIG2		0xBF
#define LM90_REG_W_CONFIG2		0xBF
#define LM90_REG_R_CONVRATE		0x04
#define LM90_REG_W_CONVRATE		0x0A
#define LM90_REG_R_STATUS		0x02
#define LM90_REG_R_LOCAL_TEMP		0x00
#define LM90_REG_R_LOCAL_HIGH		0x05
#define LM90_REG_W_LOCAL_HIGH		0x0B
#define LM90_REG_R_LOCAL_LOW		0x06
#define LM90_REG_W_LOCAL_LOW		0x0C
#define LM90_REG_R_LOCAL_CRIT		0x20
#define LM90_REG_W_LOCAL_CRIT		0x20
#define LM90_REG_R_REMOTE_TEMPH		0x01
#define LM90_REG_R_REMOTE_TEMPL		0x10
#define LM90_REG_R_REMOTE_OFFSH		0x11
#define LM90_REG_W_REMOTE_OFFSH		0x11
#define LM90_REG_R_REMOTE_OFFSL		0x12
#define LM90_REG_W_REMOTE_OFFSL		0x12
#define LM90_REG_R_REMOTE_HIGHH		0x07
#define LM90_REG_W_REMOTE_HIGHH		0x0D
#define LM90_REG_R_REMOTE_HIGHL		0x13
#define LM90_REG_W_REMOTE_HIGHL		0x13
#define LM90_REG_R_REMOTE_LOWH		0x08
#define LM90_REG_W_REMOTE_LOWH		0x0E
#define LM90_REG_R_REMOTE_LOWL		0x14
#define LM90_REG_W_REMOTE_LOWL		0x14
#define LM90_REG_R_REMOTE_CRIT		0x19
#define LM90_REG_W_REMOTE_CRIT		0x19
#define LM90_REG_R_TCRIT_HYST		0x21
#define LM90_REG_W_TCRIT_HYST		0x21

140
/* MAX6646/6647/6649/6657/6658/6659 registers */
141 142

#define MAX6657_REG_R_LOCAL_TEMPL	0x11
143 144 145 146
#define MAX6659_REG_R_REMOTE_EMERG	0x16
#define MAX6659_REG_W_REMOTE_EMERG	0x16
#define MAX6659_REG_R_LOCAL_EMERG	0x17
#define MAX6659_REG_W_LOCAL_EMERG	0x17
147

148 149 150
/*
 * Device flags
 */
151 152 153 154 155
#define LM90_FLAG_ADT7461_EXT	(1 << 0) /* ADT7461 extended mode	*/
/* Device features */
#define LM90_HAVE_OFFSET	(1 << 1) /* temperature offset register	*/
#define LM90_HAVE_LOCAL_EXT	(1 << 2) /* extended local temperature	*/
#define LM90_HAVE_REM_LIMIT_EXT	(1 << 3) /* extended remote limit	*/
156
#define LM90_HAVE_EMERGENCY	(1 << 4) /* 3rd upper (emergency) limit	*/
157

L
Linus Torvalds 已提交
158 159 160 161
/*
 * Functions declaration
 */

162
static int lm90_detect(struct i2c_client *client, struct i2c_board_info *info);
163 164
static int lm90_probe(struct i2c_client *client,
		      const struct i2c_device_id *id);
L
Linus Torvalds 已提交
165
static void lm90_init_client(struct i2c_client *client);
166
static void lm90_alert(struct i2c_client *client, unsigned int flag);
167
static int lm90_remove(struct i2c_client *client);
L
Linus Torvalds 已提交
168 169 170 171 172 173
static struct lm90_data *lm90_update_device(struct device *dev);

/*
 * Driver data (common to all clients)
 */

174 175 176 177 178
static const struct i2c_device_id lm90_id[] = {
	{ "adm1032", adm1032 },
	{ "adt7461", adt7461 },
	{ "lm90", lm90 },
	{ "lm86", lm86 },
179 180
	{ "lm89", lm86 },
	{ "lm99", lm99 },
181 182 183
	{ "max6646", max6646 },
	{ "max6647", max6646 },
	{ "max6649", max6646 },
184 185
	{ "max6657", max6657 },
	{ "max6658", max6657 },
186
	{ "max6659", max6659 },
187 188
	{ "max6680", max6680 },
	{ "max6681", max6680 },
189
	{ "w83l771", w83l771 },
190 191 192 193
	{ }
};
MODULE_DEVICE_TABLE(i2c, lm90_id);

L
Linus Torvalds 已提交
194
static struct i2c_driver lm90_driver = {
195
	.class		= I2C_CLASS_HWMON,
196 197 198
	.driver = {
		.name	= "lm90",
	},
199 200
	.probe		= lm90_probe,
	.remove		= lm90_remove,
201
	.alert		= lm90_alert,
202 203
	.id_table	= lm90_id,
	.detect		= lm90_detect,
204
	.address_list	= normal_i2c,
L
Linus Torvalds 已提交
205 206 207 208 209 210 211
};

/*
 * Client data (each client gets its own)
 */

struct lm90_data {
212
	struct device *hwmon_dev;
213
	struct mutex update_lock;
L
Linus Torvalds 已提交
214 215 216
	char valid; /* zero until following fields are valid */
	unsigned long last_updated; /* in jiffies */
	int kind;
217
	int flags;
L
Linus Torvalds 已提交
218

219
	u8 config_orig;		/* Original configuration register value */
220
	u8 alert_alarms;	/* Which alarm bits trigger ALERT# */
221

L
Linus Torvalds 已提交
222
	/* registers values */
223
	s8 temp8[6];	/* 0: local low limit
224 225
			   1: local high limit
			   2: local critical limit
226 227 228
			   3: remote critical limit
			   4: local emergency limit (max6659 only)
			   5: remote emergency limit (max6659 only) */
229
	s16 temp11[5];	/* 0: remote input
230
			   1: remote low limit
231
			   2: remote high limit
232
			   3: remote offset (except max6646 and max6657/58/59)
233
			   4: local input */
L
Linus Torvalds 已提交
234 235 236 237
	u8 temp_hyst;
	u8 alarms; /* bitvector */
};

238 239 240 241 242
/*
 * Conversions
 * For local temperatures and limits, critical limits and the hysteresis
 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
 * For remote temperatures and limits, it uses signed 11-bit values with
243 244
 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
 * Maxim chips use unsigned values.
245 246
 */

247
static inline int temp_from_s8(s8 val)
248 249 250 251
{
	return val * 1000;
}

252 253 254 255 256
static inline int temp_from_u8(u8 val)
{
	return val * 1000;
}

257
static inline int temp_from_s16(s16 val)
258 259 260 261
{
	return val / 32 * 125;
}

262 263 264 265 266
static inline int temp_from_u16(u16 val)
{
	return val / 32 * 125;
}

267
static s8 temp_to_s8(long val)
268 269 270 271 272 273 274 275 276 277
{
	if (val <= -128000)
		return -128;
	if (val >= 127000)
		return 127;
	if (val < 0)
		return (val - 500) / 1000;
	return (val + 500) / 1000;
}

278 279 280 281 282 283 284 285 286
static u8 temp_to_u8(long val)
{
	if (val <= 0)
		return 0;
	if (val >= 255000)
		return 255;
	return (val + 500) / 1000;
}

287
static s16 temp_to_s16(long val)
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
{
	if (val <= -128000)
		return 0x8000;
	if (val >= 127875)
		return 0x7FE0;
	if (val < 0)
		return (val - 62) / 125 * 32;
	return (val + 62) / 125 * 32;
}

static u8 hyst_to_reg(long val)
{
	if (val <= 0)
		return 0;
	if (val >= 30500)
		return 31;
	return (val + 500) / 1000;
}

/*
308 309 310 311 312 313
 * ADT7461 in compatibility mode is almost identical to LM90 except that
 * attempts to write values that are outside the range 0 < temp < 127 are
 * treated as the boundary value.
 *
 * ADT7461 in "extended mode" operation uses unsigned integers offset by
 * 64 (e.g., 0 -> -64 degC).  The range is restricted to -64..191 degC.
314
 */
315
static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
316
{
317 318 319
	if (data->flags & LM90_FLAG_ADT7461_EXT)
		return (val - 64) * 1000;
	else
320
		return temp_from_s8(val);
321 322
}

323
static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
324
{
325 326 327
	if (data->flags & LM90_FLAG_ADT7461_EXT)
		return (val - 0x4000) / 64 * 250;
	else
328
		return temp_from_s16(val);
329 330
}

331
static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
{
	if (data->flags & LM90_FLAG_ADT7461_EXT) {
		if (val <= -64000)
			return 0;
		if (val >= 191000)
			return 0xFF;
		return (val + 500 + 64000) / 1000;
	} else {
		if (val <= 0)
			return 0;
		if (val >= 127000)
			return 127;
		return (val + 500) / 1000;
	}
}

348
static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
349 350 351 352 353 354 355 356 357 358 359 360 361 362
{
	if (data->flags & LM90_FLAG_ADT7461_EXT) {
		if (val <= -64000)
			return 0;
		if (val >= 191750)
			return 0xFFC0;
		return (val + 64000 + 125) / 250 * 64;
	} else {
		if (val <= 0)
			return 0;
		if (val >= 127750)
			return 0x7FC0;
		return (val + 125) / 250 * 64;
	}
363 364
}

L
Linus Torvalds 已提交
365 366 367 368
/*
 * Sysfs stuff
 */

369 370 371 372 373
static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
			  char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct lm90_data *data = lm90_update_device(dev);
374 375 376
	int temp;

	if (data->kind == adt7461)
377
		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
378 379
	else if (data->kind == max6646)
		temp = temp_from_u8(data->temp8[attr->index]);
380
	else
381
		temp = temp_from_s8(data->temp8[attr->index]);
382

383 384 385 386
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		temp += 16000;

387
	return sprintf(buf, "%d\n", temp);
388 389 390 391 392
}

static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
			 const char *buf, size_t count)
{
393
	static const u8 reg[6] = {
394 395 396 397
		LM90_REG_W_LOCAL_LOW,
		LM90_REG_W_LOCAL_HIGH,
		LM90_REG_W_LOCAL_CRIT,
		LM90_REG_W_REMOTE_CRIT,
398 399
		MAX6659_REG_W_LOCAL_EMERG,
		MAX6659_REG_W_REMOTE_EMERG,
400 401 402 403 404 405
	};

	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct i2c_client *client = to_i2c_client(dev);
	struct lm90_data *data = i2c_get_clientdata(client);
	int nr = attr->index;
406 407 408 409 410 411
	long val;
	int err;

	err = strict_strtol(buf, 10, &val);
	if (err < 0)
		return err;
412

413 414 415 416
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		val -= 16000;

417
	mutex_lock(&data->update_lock);
418
	if (data->kind == adt7461)
419
		data->temp8[nr] = temp_to_u8_adt7461(data, val);
420 421
	else if (data->kind == max6646)
		data->temp8[nr] = temp_to_u8(val);
422
	else
423
		data->temp8[nr] = temp_to_s8(val);
424
	i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
425
	mutex_unlock(&data->update_lock);
426
	return count;
L
Linus Torvalds 已提交
427
}
428 429 430 431

static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
			   char *buf)
{
432
	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
433
	struct lm90_data *data = lm90_update_device(dev);
434 435 436
	int temp;

	if (data->kind == adt7461)
437
		temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
438 439
	else if (data->kind == max6646)
		temp = temp_from_u16(data->temp11[attr->index]);
440
	else
441
		temp = temp_from_s16(data->temp11[attr->index]);
442

443 444 445 446
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 &&  attr->index <= 2)
		temp += 16000;

447
	return sprintf(buf, "%d\n", temp);
L
Linus Torvalds 已提交
448
}
449 450 451 452

static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
			  const char *buf, size_t count)
{
453 454 455 456 457 458 459
	struct {
		u8 high;
		u8 low;
	} reg[3] = {
		{ LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL },
		{ LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL },
		{ LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL }
460 461
	};

462
	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
463 464
	struct i2c_client *client = to_i2c_client(dev);
	struct lm90_data *data = i2c_get_clientdata(client);
465 466
	int nr = attr->nr;
	int index = attr->index;
467 468 469 470 471 472
	long val;
	int err;

	err = strict_strtol(buf, 10, &val);
	if (err < 0)
		return err;
473

474
	/* +16 degrees offset for temp2 for the LM99 */
475
	if (data->kind == lm99 && index <= 2)
476 477
		val -= 16000;

478
	mutex_lock(&data->update_lock);
479
	if (data->kind == adt7461)
480
		data->temp11[index] = temp_to_u16_adt7461(data, val);
481
	else if (data->kind == max6646)
482
		data->temp11[index] = temp_to_u8(val) << 8;
483
	else if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
484
		data->temp11[index] = temp_to_s16(val);
485
	else
486
		data->temp11[index] = temp_to_s8(val) << 8;
487

488 489
	i2c_smbus_write_byte_data(client, reg[nr].high,
				  data->temp11[index] >> 8);
490
	if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
491 492
		i2c_smbus_write_byte_data(client, reg[nr].low,
					  data->temp11[index] & 0xff);
493
	mutex_unlock(&data->update_lock);
494
	return count;
L
Linus Torvalds 已提交
495
}
496

497 498
static ssize_t show_temphyst(struct device *dev,
			     struct device_attribute *devattr,
499 500 501 502
			     char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct lm90_data *data = lm90_update_device(dev);
503 504 505
	int temp;

	if (data->kind == adt7461)
506
		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
507 508
	else if (data->kind == max6646)
		temp = temp_from_u8(data->temp8[attr->index]);
509
	else
510
		temp = temp_from_s8(data->temp8[attr->index]);
511

512 513 514 515
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		temp += 16000;

516
	return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
L
Linus Torvalds 已提交
517 518
}

519 520
static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
			    const char *buf, size_t count)
L
Linus Torvalds 已提交
521 522 523
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm90_data *data = i2c_get_clientdata(client);
524 525
	long val;
	int err;
526
	int temp;
L
Linus Torvalds 已提交
527

528 529 530 531
	err = strict_strtol(buf, 10, &val);
	if (err < 0)
		return err;

532
	mutex_lock(&data->update_lock);
533 534 535 536 537 538 539 540
	if (data->kind == adt7461)
		temp = temp_from_u8_adt7461(data, data->temp8[2]);
	else if (data->kind == max6646)
		temp = temp_from_u8(data->temp8[2]);
	else
		temp = temp_from_s8(data->temp8[2]);

	data->temp_hyst = hyst_to_reg(temp - val);
L
Linus Torvalds 已提交
541
	i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
542
				  data->temp_hyst);
543
	mutex_unlock(&data->update_lock);
L
Linus Torvalds 已提交
544 545 546
	return count;
}

547 548
static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
			   char *buf)
L
Linus Torvalds 已提交
549 550 551 552 553
{
	struct lm90_data *data = lm90_update_device(dev);
	return sprintf(buf, "%d\n", data->alarms);
}

554 555 556 557 558 559 560 561 562 563
static ssize_t show_alarm(struct device *dev, struct device_attribute
			  *devattr, char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct lm90_data *data = lm90_update_device(dev);
	int bitnr = attr->index;

	return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
}

564 565
static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp11, NULL, 0, 4);
static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp11, NULL, 0, 0);
566
static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
567
	set_temp8, 0);
568 569
static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
	set_temp11, 0, 1);
570
static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
571
	set_temp8, 1);
572 573
static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
	set_temp11, 1, 2);
574
static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
575
	set_temp8, 2);
576
static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
577
	set_temp8, 3);
578
static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
579 580
	set_temphyst, 2);
static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
581 582
static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
	set_temp11, 2, 3);
583 584 585 586

/* Individual alarm files */
static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
587
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
588 589 590 591 592
static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
/* Raw alarm file for compatibility */
L
Linus Torvalds 已提交
593 594
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);

595 596 597 598 599 600 601 602 603 604 605 606 607 608
static struct attribute *lm90_attributes[] = {
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_temp2_input.dev_attr.attr,
	&sensor_dev_attr_temp1_min.dev_attr.attr,
	&sensor_dev_attr_temp2_min.dev_attr.attr,
	&sensor_dev_attr_temp1_max.dev_attr.attr,
	&sensor_dev_attr_temp2_max.dev_attr.attr,
	&sensor_dev_attr_temp1_crit.dev_attr.attr,
	&sensor_dev_attr_temp2_crit.dev_attr.attr,
	&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
	&sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,

	&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
	&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
609
	&sensor_dev_attr_temp2_fault.dev_attr.attr,
610 611 612 613 614 615 616 617 618 619 620 621
	&sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
	&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
	&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
	&dev_attr_alarms.attr,
	NULL
};

static const struct attribute_group lm90_group = {
	.attrs = lm90_attributes,
};

622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
/*
 * Additional attributes for devices with emergency sensors
 */
static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO, show_temp8,
	set_temp8, 4);
static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO, show_temp8,
	set_temp8, 5);
static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO, show_temphyst,
			  NULL, 4);
static SENSOR_DEVICE_ATTR(temp2_emergency_hyst, S_IRUGO, show_temphyst,
			  NULL, 5);

static struct attribute *lm90_emergency_attributes[] = {
	&sensor_dev_attr_temp1_emergency.dev_attr.attr,
	&sensor_dev_attr_temp2_emergency.dev_attr.attr,
	&sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr,
	&sensor_dev_attr_temp2_emergency_hyst.dev_attr.attr,
	NULL
};

static const struct attribute_group lm90_emergency_group = {
	.attrs = lm90_emergency_attributes,
};

646 647 648 649 650 651 652 653 654 655 656 657
/* pec used for ADM1032 only */
static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
			char *buf)
{
	struct i2c_client *client = to_i2c_client(dev);
	return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
}

static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
		       const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
658 659 660 661 662 663
	long val;
	int err;

	err = strict_strtol(buf, 10, &val);
	if (err < 0)
		return err;
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680

	switch (val) {
	case 0:
		client->flags &= ~I2C_CLIENT_PEC;
		break;
	case 1:
		client->flags |= I2C_CLIENT_PEC;
		break;
	default:
		return -EINVAL;
	}

	return count;
}

static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);

L
Linus Torvalds 已提交
681 682 683 684
/*
 * Real code
 */

685 686 687 688
/*
 * The ADM1032 supports PEC but not on write byte transactions, so we need
 * to explicitly ask for a transaction without PEC.
 */
689 690 691 692 693 694 695
static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
{
	return i2c_smbus_xfer(client->adapter, client->addr,
			      client->flags & ~I2C_CLIENT_PEC,
			      I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
}

696 697 698 699 700 701 702
/*
 * It is assumed that client->update_lock is held (unless we are in
 * detection or initialization steps). This matters when PEC is enabled,
 * because we don't want the address pointer to change between the write
 * byte and the read byte transactions.
 */
static int lm90_read_reg(struct i2c_client *client, u8 reg, u8 *value)
703 704 705
{
	int err;

706 707 708 709 710 711
	if (client->flags & I2C_CLIENT_PEC) {
		err = adm1032_write_byte(client, reg);
		if (err >= 0)
			err = i2c_smbus_read_byte(client);
	} else
		err = i2c_smbus_read_byte_data(client, reg);
712 713 714 715 716 717 718 719 720 721 722

	if (err < 0) {
		dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
			 reg, err);
		return err;
	}
	*value = err;

	return 0;
}

723
/* Return 0 if detection is successful, -ENODEV otherwise */
724
static int lm90_detect(struct i2c_client *new_client,
725
		       struct i2c_board_info *info)
L
Linus Torvalds 已提交
726
{
727 728
	struct i2c_adapter *adapter = new_client->adapter;
	int address = new_client->addr;
729 730
	const char *name = NULL;
	int man_id, chip_id, reg_config1, reg_convrate;
L
Linus Torvalds 已提交
731 732

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
733
		return -ENODEV;
L
Linus Torvalds 已提交
734

735 736
	/* detection and identification */
	if ((man_id = i2c_smbus_read_byte_data(new_client,
737
						LM90_REG_R_MAN_ID)) < 0
738
	 || (chip_id = i2c_smbus_read_byte_data(new_client,
739
						LM90_REG_R_CHIP_ID)) < 0
740
	 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
741
						LM90_REG_R_CONFIG1)) < 0
742
	 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
743
						LM90_REG_R_CONVRATE)) < 0)
744 745 746 747 748 749 750 751 752
		return -ENODEV;

	if ((address == 0x4C || address == 0x4D)
	 && man_id == 0x01) { /* National Semiconductor */
		int reg_config2;

		reg_config2 = i2c_smbus_read_byte_data(new_client,
						LM90_REG_R_CONFIG2);
		if (reg_config2 < 0)
753
			return -ENODEV;
754 755 756 757 758 759 760

		if ((reg_config1 & 0x2A) == 0x00
		 && (reg_config2 & 0xF8) == 0x00
		 && reg_convrate <= 0x09) {
			if (address == 0x4C
			 && (chip_id & 0xF0) == 0x20) { /* LM90 */
				name = "lm90";
761
			} else
762 763 764 765 766 767 768 769 770
			if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
				name = "lm99";
				dev_info(&adapter->dev,
					 "Assuming LM99 chip at 0x%02x\n",
					 address);
				dev_info(&adapter->dev,
					 "If it is an LM89, instantiate it "
					 "with the new_device sysfs "
					 "interface\n");
771
			} else
772 773 774
			if (address == 0x4C
			 && (chip_id & 0xF0) == 0x10) { /* LM86 */
				name = "lm86";
L
Linus Torvalds 已提交
775 776
			}
		}
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
	} else
	if ((address == 0x4C || address == 0x4D)
	 && man_id == 0x41) { /* Analog Devices */
		if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
		 && (reg_config1 & 0x3F) == 0x00
		 && reg_convrate <= 0x0A) {
			name = "adm1032";
			/* The ADM1032 supports PEC, but only if combined
			   transactions are not used. */
			if (i2c_check_functionality(adapter,
						    I2C_FUNC_SMBUS_BYTE))
				info->flags |= I2C_CLIENT_PEC;
		} else
		if (chip_id == 0x51 /* ADT7461 */
		 && (reg_config1 & 0x1B) == 0x00
		 && reg_convrate <= 0x0A) {
			name = "adt7461";
		}
	} else
	if (man_id == 0x4D) { /* Maxim */
		/*
		 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
		 * register. Reading from that address will return the last
		 * read value, which in our case is those of the man_id
		 * register. Likewise, the config1 register seems to lack a
		 * low nibble, so the value will be those of the previous
		 * read, so in our case those of the man_id register.
804 805 806 807 808
		 * MAX6659 has a third set of upper temperature limit registers.
		 * Those registers also return values on MAX6657 and MAX6658,
		 * thus the only way to detect MAX6659 is by its address.
		 * For this reason it will be mis-detected as MAX6657 if its
		 * address is 0x4C.
809 810
		 */
		if (chip_id == man_id
811
		 && (address == 0x4C || address == 0x4D || address == 0x4E)
812 813
		 && (reg_config1 & 0x1F) == (man_id & 0x0F)
		 && reg_convrate <= 0x09) {
814 815 816 817
			if (address == 0x4C)
				name = "max6657";
			else
				name = "max6659";
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838
		} else
		/*
		 * The chip_id register of the MAX6680 and MAX6681 holds the
		 * revision of the chip. The lowest bit of the config1 register
		 * is unused and should return zero when read, so should the
		 * second to last bit of config1 (software reset).
		 */
		if (chip_id == 0x01
		 && (reg_config1 & 0x03) == 0x00
		 && reg_convrate <= 0x07) {
			name = "max6680";
		} else
		/*
		 * The chip_id register of the MAX6646/6647/6649 holds the
		 * revision of the chip. The lowest 6 bits of the config1
		 * register are unused and should return zero when read.
		 */
		if (chip_id == 0x59
		 && (reg_config1 & 0x3f) == 0x00
		 && reg_convrate <= 0x07) {
			name = "max6646";
L
Linus Torvalds 已提交
839
		}
840 841 842 843 844 845 846 847
	} else
	if (address == 0x4C
	 && man_id == 0x5C) { /* Winbond/Nuvoton */
		if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */
		 && (reg_config1 & 0x2A) == 0x00
		 && reg_convrate <= 0x08) {
			name = "w83l771";
		}
L
Linus Torvalds 已提交
848 849
	}

850 851 852 853 854
	if (!name) { /* identification failed */
		dev_dbg(&adapter->dev,
			"Unsupported chip at 0x%02x (man_id=0x%02X, "
			"chip_id=0x%02X)\n", address, man_id, chip_id);
		return -ENODEV;
L
Linus Torvalds 已提交
855
	}
856

857 858 859 860 861
	strlcpy(info->type, name, I2C_NAME_SIZE);

	return 0;
}

862 863
static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data)
{
864 865 866
	if (data->flags & LM90_HAVE_EMERGENCY)
		sysfs_remove_group(&client->dev.kobj,
				   &lm90_emergency_group);
867 868 869 870 871 872 873
	if (data->flags & LM90_HAVE_OFFSET)
		device_remove_file(&client->dev,
				   &sensor_dev_attr_temp2_offset.dev_attr);
	device_remove_file(&client->dev, &dev_attr_pec);
	sysfs_remove_group(&client->dev.kobj, &lm90_group);
}

874 875 876 877 878 879
static int lm90_probe(struct i2c_client *new_client,
		      const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
	struct lm90_data *data;
	int err;
L
Linus Torvalds 已提交
880

881 882 883 884 885 886
	data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
	if (!data) {
		err = -ENOMEM;
		goto exit;
	}
	i2c_set_clientdata(new_client, data);
887
	mutex_init(&data->update_lock);
L
Linus Torvalds 已提交
888

889 890 891 892 893 894
	/* Set the device type */
	data->kind = id->driver_data;
	if (data->kind == adm1032) {
		if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
			new_client->flags &= ~I2C_CLIENT_PEC;
	}
L
Linus Torvalds 已提交
895

896 897 898 899 900 901 902 903 904 905 906 907 908
	/* Different devices have different alarm bits triggering the
	 * ALERT# output */
	switch (data->kind) {
	case lm90:
	case lm99:
	case lm86:
		data->alert_alarms = 0x7b;
		break;
	default:
		data->alert_alarms = 0x7c;
		break;
	}

909
	/* Set chip capabilities */
910 911
	if (data->kind != max6657 && data->kind != max6659
	    && data->kind != max6646)
912 913
		data->flags |= LM90_HAVE_OFFSET;

914 915
	if (data->kind == max6657 || data->kind == max6659
	    || data->kind == max6646)
916 917
		data->flags |= LM90_HAVE_LOCAL_EXT;

918 919
	if (data->kind != max6657 && data->kind != max6659
	    && data->kind != max6646 && data->kind != max6680)
920 921
		data->flags |= LM90_HAVE_REM_LIMIT_EXT;

922 923 924
	if (data->kind == max6659)
		data->flags |= LM90_HAVE_EMERGENCY;

L
Linus Torvalds 已提交
925 926 927 928
	/* Initialize the LM90 chip */
	lm90_init_client(new_client);

	/* Register sysfs hooks */
929 930
	err = sysfs_create_group(&new_client->dev.kobj, &lm90_group);
	if (err)
931
		goto exit_free;
932
	if (new_client->flags & I2C_CLIENT_PEC) {
933 934
		err = device_create_file(&new_client->dev, &dev_attr_pec);
		if (err)
935 936
			goto exit_remove_files;
	}
937
	if (data->flags & LM90_HAVE_OFFSET) {
938 939 940
		err = device_create_file(&new_client->dev,
					&sensor_dev_attr_temp2_offset.dev_attr);
		if (err)
941 942
			goto exit_remove_files;
	}
943 944 945 946 947 948
	if (data->flags & LM90_HAVE_EMERGENCY) {
		err = sysfs_create_group(&new_client->dev.kobj,
					 &lm90_emergency_group);
		if (err)
			goto exit_remove_files;
	}
949

950 951 952
	data->hwmon_dev = hwmon_device_register(&new_client->dev);
	if (IS_ERR(data->hwmon_dev)) {
		err = PTR_ERR(data->hwmon_dev);
953
		goto exit_remove_files;
954 955
	}

L
Linus Torvalds 已提交
956 957
	return 0;

958
exit_remove_files:
959
	lm90_remove_files(new_client, data);
L
Linus Torvalds 已提交
960 961 962 963 964 965 966 967
exit_free:
	kfree(data);
exit:
	return err;
}

static void lm90_init_client(struct i2c_client *client)
{
968
	u8 config;
969
	struct lm90_data *data = i2c_get_clientdata(client);
L
Linus Torvalds 已提交
970 971 972 973 974 975

	/*
	 * Start the conversions.
	 */
	i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
				  5); /* 2 Hz */
976 977 978 979
	if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
		dev_warn(&client->dev, "Initialization failed!\n");
		return;
	}
980
	data->config_orig = config;
981

982 983 984 985 986 987
	/* Check Temperature Range Select */
	if (data->kind == adt7461) {
		if (config & 0x04)
			data->flags |= LM90_FLAG_ADT7461_EXT;
	}

988 989 990 991 992
	/*
	 * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
	 * 0.125 degree resolution) and range (0x08, extend range
	 * to -64 degree) mode for the remote temperature sensor.
	 */
993
	if (data->kind == max6680)
994 995 996
		config |= 0x18;

	config &= 0xBF;	/* run */
997
	if (config != data->config_orig) /* Only write if changed */
998
		i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
L
Linus Torvalds 已提交
999 1000
}

1001
static int lm90_remove(struct i2c_client *client)
L
Linus Torvalds 已提交
1002
{
1003
	struct lm90_data *data = i2c_get_clientdata(client);
L
Linus Torvalds 已提交
1004

1005
	hwmon_device_unregister(data->hwmon_dev);
1006
	lm90_remove_files(client, data);
1007

1008 1009 1010 1011
	/* Restore initial configuration */
	i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
				  data->config_orig);

1012
	kfree(data);
L
Linus Torvalds 已提交
1013 1014 1015
	return 0;
}

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
static void lm90_alert(struct i2c_client *client, unsigned int flag)
{
	struct lm90_data *data = i2c_get_clientdata(client);
	u8 config, alarms;

	lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);
	if ((alarms & 0x7f) == 0) {
		dev_info(&client->dev, "Everything OK\n");
	} else {
		if (alarms & 0x61)
			dev_warn(&client->dev,
				 "temp%d out of range, please check!\n", 1);
		if (alarms & 0x1a)
			dev_warn(&client->dev,
				 "temp%d out of range, please check!\n", 2);
		if (alarms & 0x04)
			dev_warn(&client->dev,
				 "temp%d diode open, please check!\n", 2);

		/* Disable ALERT# output, because these chips don't implement
		  SMBus alert correctly; they should only hold the alert line
		  low briefly. */
		if ((data->kind == adm1032 || data->kind == adt7461)
		 && (alarms & data->alert_alarms)) {
			dev_dbg(&client->dev, "Disabling ALERT#\n");
			lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
			i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
						  config | 0x80);
		}
	}
}

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
{
	int err;
	u8 oldh, newh, l;

	/*
	 * There is a trick here. We have to read two registers to have the
	 * sensor temperature, but we have to beware a conversion could occur
	 * inbetween the readings. The datasheet says we should either use
	 * the one-shot conversion register, which we don't want to do
	 * (disables hardware monitoring) or monitor the busy bit, which is
	 * impossible (we can't read the values and monitor that bit at the
	 * exact same time). So the solution used here is to read the high
	 * byte once, then the low byte, then the high byte again. If the new
	 * high byte matches the old one, then we have a valid reading. Else
	 * we have to read the low byte again, and now we believe we have a
	 * correct reading.
	 */
	if ((err = lm90_read_reg(client, regh, &oldh))
	 || (err = lm90_read_reg(client, regl, &l))
	 || (err = lm90_read_reg(client, regh, &newh)))
		return err;
	if (oldh != newh) {
		err = lm90_read_reg(client, regl, &l);
		if (err)
			return err;
	}
	*value = (newh << 8) | l;

	return 0;
}

L
Linus Torvalds 已提交
1080 1081 1082 1083 1084
static struct lm90_data *lm90_update_device(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm90_data *data = i2c_get_clientdata(client);

1085
	mutex_lock(&data->update_lock);
L
Linus Torvalds 已提交
1086

1087 1088
	if (time_after(jiffies, data->last_updated + HZ / 2 + HZ / 10)
	 || !data->valid) {
1089
		u8 h, l;
L
Linus Torvalds 已提交
1090 1091

		dev_dbg(&client->dev, "Updating lm90 data.\n");
1092 1093 1094 1095
		lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
		lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
		lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
		lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
1096
		lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
L
Linus Torvalds 已提交
1097

1098
		if (data->flags & LM90_HAVE_LOCAL_EXT) {
1099 1100 1101 1102 1103 1104 1105 1106
			lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
				    MAX6657_REG_R_LOCAL_TEMPL,
				    &data->temp11[4]);
		} else {
			if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
					  &h) == 0)
				data->temp11[4] = h << 8;
		}
1107 1108 1109
		lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
			    LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);

1110 1111
		if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
			data->temp11[1] = h << 8;
1112
			if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
1113 1114 1115 1116 1117 1118
			 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
					  &l) == 0)
				data->temp11[1] |= l;
		}
		if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
			data->temp11[2] = h << 8;
1119
			if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
1120 1121 1122 1123 1124
			 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
					  &l) == 0)
				data->temp11[2] |= l;
		}

1125
		if (data->flags & LM90_HAVE_OFFSET) {
1126
			if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
1127
					  &h) == 0
1128 1129
			 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
					  &l) == 0)
1130
				data->temp11[3] = (h << 8) | l;
1131
		}
1132 1133 1134 1135 1136 1137
		if (data->flags & LM90_HAVE_EMERGENCY) {
			lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG,
				      &data->temp8[4]);
			lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,
				      &data->temp8[5]);
		}
1138
		lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
L
Linus Torvalds 已提交
1139

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
		/* Re-enable ALERT# output if it was originally enabled and
		 * relevant alarms are all clear */
		if ((data->config_orig & 0x80) == 0
		 && (data->alarms & data->alert_alarms) == 0) {
			u8 config;

			lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
			if (config & 0x80) {
				dev_dbg(&client->dev, "Re-enabling ALERT#\n");
				i2c_smbus_write_byte_data(client,
							  LM90_REG_W_CONFIG1,
							  config & ~0x80);
			}
		}

L
Linus Torvalds 已提交
1155 1156 1157 1158
		data->last_updated = jiffies;
		data->valid = 1;
	}

1159
	mutex_unlock(&data->update_lock);
L
Linus Torvalds 已提交
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

	return data;
}

static int __init sensors_lm90_init(void)
{
	return i2c_add_driver(&lm90_driver);
}

static void __exit sensors_lm90_exit(void)
{
	i2c_del_driver(&lm90_driver);
}

MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
MODULE_DESCRIPTION("LM90/ADM1032 driver");
MODULE_LICENSE("GPL");

module_init(sensors_lm90_init);
module_exit(sensors_lm90_exit);