lm90.c 31.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
L
Linus Torvalds 已提交
31
 * variants. The extra address and features of the MAX6659 are not
32 33
 * supported by this driver. These chips lack the remote temperature
 * offset feature.
L
Linus Torvalds 已提交
34
 *
35 36 37 38
 * 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.
39
 *
40 41
 * This driver also supports the MAX6680 and MAX6681, two other sensor
 * chips made by Maxim. These are quite similar to the other Maxim
42 43
 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
 * be treated identically.
44
 *
45 46 47 48
 * 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 已提交
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
 *
 * 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>
74
#include <linux/hwmon-sysfs.h>
75 76
#include <linux/hwmon.h>
#include <linux/err.h>
77
#include <linux/mutex.h>
78
#include <linux/sysfs.h>
L
Linus Torvalds 已提交
79 80 81 82

/*
 * Addresses to scan
 * Address is fully defined internally and cannot be changed except for
83
 * MAX6659, MAX6680 and MAX6681.
84 85 86 87
 * 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.
L
Linus Torvalds 已提交
88
 * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
89 90
 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
 * 0x4c, 0x4d or 0x4e.
L
Linus Torvalds 已提交
91 92
 */

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

96 97
enum chips { lm90, adm1032, lm99, lm86, max6657, adt7461, max6680, max6646,
	w83l771 };
L
Linus Torvalds 已提交
98 99 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

/*
 * 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

138
/* MAX6646/6647/6649/6657/6658/6659 registers */
139 140 141

#define MAX6657_REG_R_LOCAL_TEMPL	0x11

142 143 144 145 146
/*
 * Device flags
 */
#define LM90_FLAG_ADT7461_EXT		0x01	/* ADT7461 extended mode */

L
Linus Torvalds 已提交
147 148 149 150
/*
 * Functions declaration
 */

151
static int lm90_detect(struct i2c_client *client, struct i2c_board_info *info);
152 153
static int lm90_probe(struct i2c_client *client,
		      const struct i2c_device_id *id);
L
Linus Torvalds 已提交
154
static void lm90_init_client(struct i2c_client *client);
155
static void lm90_alert(struct i2c_client *client, unsigned int flag);
156
static int lm90_remove(struct i2c_client *client);
L
Linus Torvalds 已提交
157 158 159 160 161 162
static struct lm90_data *lm90_update_device(struct device *dev);

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

163 164 165 166 167
static const struct i2c_device_id lm90_id[] = {
	{ "adm1032", adm1032 },
	{ "adt7461", adt7461 },
	{ "lm90", lm90 },
	{ "lm86", lm86 },
168 169
	{ "lm89", lm86 },
	{ "lm99", lm99 },
170 171 172
	{ "max6646", max6646 },
	{ "max6647", max6646 },
	{ "max6649", max6646 },
173 174 175 176 177
	{ "max6657", max6657 },
	{ "max6658", max6657 },
	{ "max6659", max6657 },
	{ "max6680", max6680 },
	{ "max6681", max6680 },
178
	{ "w83l771", w83l771 },
179 180 181 182
	{ }
};
MODULE_DEVICE_TABLE(i2c, lm90_id);

L
Linus Torvalds 已提交
183
static struct i2c_driver lm90_driver = {
184
	.class		= I2C_CLASS_HWMON,
185 186 187
	.driver = {
		.name	= "lm90",
	},
188 189
	.probe		= lm90_probe,
	.remove		= lm90_remove,
190
	.alert		= lm90_alert,
191 192
	.id_table	= lm90_id,
	.detect		= lm90_detect,
193
	.address_list	= normal_i2c,
L
Linus Torvalds 已提交
194 195 196 197 198 199 200
};

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

struct lm90_data {
201
	struct device *hwmon_dev;
202
	struct mutex update_lock;
L
Linus Torvalds 已提交
203 204 205
	char valid; /* zero until following fields are valid */
	unsigned long last_updated; /* in jiffies */
	int kind;
206
	int flags;
L
Linus Torvalds 已提交
207

208
	u8 config_orig;		/* Original configuration register value */
209
	u8 alert_alarms;	/* Which alarm bits trigger ALERT# */
210

L
Linus Torvalds 已提交
211
	/* registers values */
212 213 214 215 216
	s8 temp8[4];	/* 0: local low limit
			   1: local high limit
			   2: local critical limit
			   3: remote critical limit */
	s16 temp11[5];	/* 0: remote input
217
			   1: remote low limit
218
			   2: remote high limit
219
			   3: remote offset (except max6646 and max6657)
220
			   4: local input */
L
Linus Torvalds 已提交
221 222 223 224
	u8 temp_hyst;
	u8 alarms; /* bitvector */
};

225 226 227 228 229
/*
 * 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
230 231
 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
 * Maxim chips use unsigned values.
232 233
 */

234
static inline int temp_from_s8(s8 val)
235 236 237 238
{
	return val * 1000;
}

239 240 241 242 243
static inline int temp_from_u8(u8 val)
{
	return val * 1000;
}

244
static inline int temp_from_s16(s16 val)
245 246 247 248
{
	return val / 32 * 125;
}

249 250 251 252 253
static inline int temp_from_u16(u16 val)
{
	return val / 32 * 125;
}

254
static s8 temp_to_s8(long val)
255 256 257 258 259 260 261 262 263 264
{
	if (val <= -128000)
		return -128;
	if (val >= 127000)
		return 127;
	if (val < 0)
		return (val - 500) / 1000;
	return (val + 500) / 1000;
}

265 266 267 268 269 270 271 272 273
static u8 temp_to_u8(long val)
{
	if (val <= 0)
		return 0;
	if (val >= 255000)
		return 255;
	return (val + 500) / 1000;
}

274
static s16 temp_to_s16(long val)
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
{
	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;
}

/*
295 296 297 298 299 300
 * 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.
301
 */
302
static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
303
{
304 305 306
	if (data->flags & LM90_FLAG_ADT7461_EXT)
		return (val - 64) * 1000;
	else
307
		return temp_from_s8(val);
308 309
}

310
static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
311
{
312 313 314
	if (data->flags & LM90_FLAG_ADT7461_EXT)
		return (val - 0x4000) / 64 * 250;
	else
315
		return temp_from_s16(val);
316 317
}

318
static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
{
	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;
	}
}

335
static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
336 337 338 339 340 341 342 343 344 345 346 347 348 349
{
	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;
	}
350 351
}

L
Linus Torvalds 已提交
352 353 354 355
/*
 * Sysfs stuff
 */

356 357 358 359 360
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);
361 362 363
	int temp;

	if (data->kind == adt7461)
364
		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
365 366
	else if (data->kind == max6646)
		temp = temp_from_u8(data->temp8[attr->index]);
367
	else
368
		temp = temp_from_s8(data->temp8[attr->index]);
369

370 371 372 373
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		temp += 16000;

374
	return sprintf(buf, "%d\n", temp);
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
}

static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
			 const char *buf, size_t count)
{
	static const u8 reg[4] = {
		LM90_REG_W_LOCAL_LOW,
		LM90_REG_W_LOCAL_HIGH,
		LM90_REG_W_LOCAL_CRIT,
		LM90_REG_W_REMOTE_CRIT,
	};

	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);
	long val = simple_strtol(buf, NULL, 10);
	int nr = attr->index;

393 394 395 396
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		val -= 16000;

397
	mutex_lock(&data->update_lock);
398
	if (data->kind == adt7461)
399
		data->temp8[nr] = temp_to_u8_adt7461(data, val);
400 401
	else if (data->kind == max6646)
		data->temp8[nr] = temp_to_u8(val);
402
	else
403
		data->temp8[nr] = temp_to_s8(val);
404
	i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
405
	mutex_unlock(&data->update_lock);
406
	return count;
L
Linus Torvalds 已提交
407
}
408 409 410 411 412 413

static ssize_t show_temp11(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);
414 415 416
	int temp;

	if (data->kind == adt7461)
417
		temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
418 419
	else if (data->kind == max6646)
		temp = temp_from_u16(data->temp11[attr->index]);
420
	else
421
		temp = temp_from_s16(data->temp11[attr->index]);
422

423 424 425 426
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 &&  attr->index <= 2)
		temp += 16000;

427
	return sprintf(buf, "%d\n", temp);
L
Linus Torvalds 已提交
428
}
429 430 431 432

static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
			  const char *buf, size_t count)
{
433
	static const u8 reg[6] = {
434 435 436 437
		LM90_REG_W_REMOTE_LOWH,
		LM90_REG_W_REMOTE_LOWL,
		LM90_REG_W_REMOTE_HIGHH,
		LM90_REG_W_REMOTE_HIGHL,
438 439
		LM90_REG_W_REMOTE_OFFSH,
		LM90_REG_W_REMOTE_OFFSL,
440 441 442 443 444 445 446 447
	};

	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);
	long val = simple_strtol(buf, NULL, 10);
	int nr = attr->index;

448 449 450 451
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index <= 2)
		val -= 16000;

452
	mutex_lock(&data->update_lock);
453
	if (data->kind == adt7461)
454
		data->temp11[nr] = temp_to_u16_adt7461(data, val);
455
	else if (data->kind == max6657 || data->kind == max6680)
456
		data->temp11[nr] = temp_to_s8(val) << 8;
457 458
	else if (data->kind == max6646)
		data->temp11[nr] = temp_to_u8(val) << 8;
459
	else
460
		data->temp11[nr] = temp_to_s16(val);
461

462 463
	i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
				  data->temp11[nr] >> 8);
464 465
	if (data->kind != max6657 && data->kind != max6680
	    && data->kind != max6646)
466 467
		i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
					  data->temp11[nr] & 0xff);
468
	mutex_unlock(&data->update_lock);
469
	return count;
L
Linus Torvalds 已提交
470
}
471 472 473 474 475 476

static ssize_t show_temphyst(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);
477 478 479
	int temp;

	if (data->kind == adt7461)
480
		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
481 482
	else if (data->kind == max6646)
		temp = temp_from_u8(data->temp8[attr->index]);
483
	else
484
		temp = temp_from_s8(data->temp8[attr->index]);
485

486 487 488 489
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		temp += 16000;

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

493 494
static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
			    const char *buf, size_t count)
L
Linus Torvalds 已提交
495 496 497 498
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm90_data *data = i2c_get_clientdata(client);
	long val = simple_strtol(buf, NULL, 10);
499
	int temp;
L
Linus Torvalds 已提交
500

501
	mutex_lock(&data->update_lock);
502 503 504 505 506 507 508 509
	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 已提交
510
	i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
511
				  data->temp_hyst);
512
	mutex_unlock(&data->update_lock);
L
Linus Torvalds 已提交
513 514 515
	return count;
}

516 517
static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
			   char *buf)
L
Linus Torvalds 已提交
518 519 520 521 522
{
	struct lm90_data *data = lm90_update_device(dev);
	return sprintf(buf, "%d\n", data->alarms);
}

523 524 525 526 527 528 529 530 531 532
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);
}

533
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
534 535
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
536
	set_temp8, 0);
537 538 539
static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
	set_temp11, 1);
static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
540
	set_temp8, 1);
541 542 543
static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
	set_temp11, 2);
static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
544
	set_temp8, 2);
545
static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
546
	set_temp8, 3);
547
static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
548 549
	set_temphyst, 2);
static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
550 551
static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
	set_temp11, 3);
552 553 554 555

/* 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);
556
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
557 558 559 560 561
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 已提交
562 563
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);

564 565 566 567 568 569 570 571 572 573 574 575 576 577
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,
578
	&sensor_dev_attr_temp2_fault.dev_attr.attr,
579 580 581 582 583 584 585 586 587 588 589 590
	&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,
};

591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
/* 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);
	long val = simple_strtol(buf, NULL, 10);

	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 已提交
621 622 623 624
/*
 * Real code
 */

625
/* The ADM1032 supports PEC but not on write byte transactions, so we need
626
   to explicitly ask for a transaction without PEC. */
627 628 629 630 631 632 633 634 635 636 637
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);
}

/* 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. */
638 639 640 641
static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
{
	int err;

642 643 644 645 646 647
 	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);
648 649 650 651 652 653 654 655 656 657 658

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

	return 0;
}

659
/* Return 0 if detection is successful, -ENODEV otherwise */
660
static int lm90_detect(struct i2c_client *new_client,
661
		       struct i2c_board_info *info)
L
Linus Torvalds 已提交
662
{
663 664
	struct i2c_adapter *adapter = new_client->adapter;
	int address = new_client->addr;
665 666
	const char *name = NULL;
	int man_id, chip_id, reg_config1, reg_convrate;
L
Linus Torvalds 已提交
667 668

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

671 672
	/* detection and identification */
	if ((man_id = i2c_smbus_read_byte_data(new_client,
673
						LM90_REG_R_MAN_ID)) < 0
674
	 || (chip_id = i2c_smbus_read_byte_data(new_client,
675
						LM90_REG_R_CHIP_ID)) < 0
676
	 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
677
						LM90_REG_R_CONFIG1)) < 0
678
	 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
679
						LM90_REG_R_CONVRATE)) < 0)
680 681 682 683 684 685 686 687 688
		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)
689
			return -ENODEV;
690 691 692 693 694 695 696

		if ((reg_config1 & 0x2A) == 0x00
		 && (reg_config2 & 0xF8) == 0x00
		 && reg_convrate <= 0x09) {
			if (address == 0x4C
			 && (chip_id & 0xF0) == 0x20) { /* LM90 */
				name = "lm90";
697
			} else
698 699 700 701 702 703 704 705 706
			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");
707
			} else
708 709 710
			if (address == 0x4C
			 && (chip_id & 0xF0) == 0x10) { /* LM86 */
				name = "lm86";
L
Linus Torvalds 已提交
711 712
			}
		}
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
	} 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.
		 */
		if (chip_id == man_id
		 && (address == 0x4C || address == 0x4D)
		 && (reg_config1 & 0x1F) == (man_id & 0x0F)
		 && reg_convrate <= 0x09) {
			name = "max6657";
		} 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 已提交
767
		}
768 769 770 771 772 773 774 775
	} 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 已提交
776 777
	}

778 779 780 781 782
	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 已提交
783
	}
784

785 786 787 788 789 790 791 792 793 794 795
	strlcpy(info->type, name, I2C_NAME_SIZE);

	return 0;
}

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 已提交
796

797 798 799 800 801 802
	data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
	if (!data) {
		err = -ENOMEM;
		goto exit;
	}
	i2c_set_clientdata(new_client, data);
803
	mutex_init(&data->update_lock);
L
Linus Torvalds 已提交
804

805 806 807 808 809 810
	/* 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 已提交
811

812 813 814 815 816 817 818 819 820 821 822 823 824
	/* 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;
	}

L
Linus Torvalds 已提交
825 826 827 828
	/* Initialize the LM90 chip */
	lm90_init_client(new_client);

	/* Register sysfs hooks */
829
	if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
830
		goto exit_free;
831 832 833 834 835
	if (new_client->flags & I2C_CLIENT_PEC) {
		if ((err = device_create_file(&new_client->dev,
					      &dev_attr_pec)))
			goto exit_remove_files;
	}
836
	if (data->kind != max6657 && data->kind != max6646) {
837 838 839 840
		if ((err = device_create_file(&new_client->dev,
				&sensor_dev_attr_temp2_offset.dev_attr)))
			goto exit_remove_files;
	}
841

842 843 844
	data->hwmon_dev = hwmon_device_register(&new_client->dev);
	if (IS_ERR(data->hwmon_dev)) {
		err = PTR_ERR(data->hwmon_dev);
845
		goto exit_remove_files;
846 847
	}

L
Linus Torvalds 已提交
848 849
	return 0;

850 851 852
exit_remove_files:
	sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
	device_remove_file(&new_client->dev, &dev_attr_pec);
L
Linus Torvalds 已提交
853 854 855 856 857 858 859 860
exit_free:
	kfree(data);
exit:
	return err;
}

static void lm90_init_client(struct i2c_client *client)
{
861
	u8 config;
862
	struct lm90_data *data = i2c_get_clientdata(client);
L
Linus Torvalds 已提交
863 864 865 866 867 868

	/*
	 * Start the conversions.
	 */
	i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
				  5); /* 2 Hz */
869 870 871 872
	if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
		dev_warn(&client->dev, "Initialization failed!\n");
		return;
	}
873
	data->config_orig = config;
874

875 876 877 878 879 880
	/* Check Temperature Range Select */
	if (data->kind == adt7461) {
		if (config & 0x04)
			data->flags |= LM90_FLAG_ADT7461_EXT;
	}

881 882 883 884 885 886 887 888 889 890
	/*
	 * 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.
	 */
	if (data->kind == max6680) {
		config |= 0x18;
	}

	config &= 0xBF;	/* run */
891
	if (config != data->config_orig) /* Only write if changed */
892
		i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
L
Linus Torvalds 已提交
893 894
}

895
static int lm90_remove(struct i2c_client *client)
L
Linus Torvalds 已提交
896
{
897
	struct lm90_data *data = i2c_get_clientdata(client);
L
Linus Torvalds 已提交
898

899
	hwmon_device_unregister(data->hwmon_dev);
900 901
	sysfs_remove_group(&client->dev.kobj, &lm90_group);
	device_remove_file(&client->dev, &dev_attr_pec);
902
	if (data->kind != max6657 && data->kind != max6646)
903 904
		device_remove_file(&client->dev,
				   &sensor_dev_attr_temp2_offset.dev_attr);
905

906 907 908 909
	/* Restore initial configuration */
	i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
				  data->config_orig);

910
	kfree(data);
L
Linus Torvalds 已提交
911 912 913
	return 0;
}

914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
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);
		}
	}
}

946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
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 已提交
978 979 980 981 982
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);

983
	mutex_lock(&data->update_lock);
L
Linus Torvalds 已提交
984 985

	if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
986
		u8 h, l;
L
Linus Torvalds 已提交
987 988

		dev_dbg(&client->dev, "Updating lm90 data.\n");
989 990 991 992
		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]);
993
		lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
L
Linus Torvalds 已提交
994

995
		if (data->kind == max6657 || data->kind == max6646) {
996 997 998 999 1000 1001 1002 1003
			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;
		}
1004 1005 1006
		lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
			    LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);

1007 1008 1009
		if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
			data->temp11[1] = h << 8;
			if (data->kind != max6657 && data->kind != max6680
1010
			 && data->kind != max6646
1011 1012 1013 1014 1015 1016 1017
			 && 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;
			if (data->kind != max6657 && data->kind != max6680
1018
			 && data->kind != max6646
1019 1020 1021 1022 1023
			 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
					  &l) == 0)
				data->temp11[2] |= l;
		}

1024
		if (data->kind != max6657 && data->kind != max6646) {
1025
			if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
1026
					  &h) == 0
1027 1028
			 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
					  &l) == 0)
1029
				data->temp11[3] = (h << 8) | l;
1030
		}
1031
		lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
L
Linus Torvalds 已提交
1032

1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
		/* 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 已提交
1048 1049 1050 1051
		data->last_updated = jiffies;
		data->valid = 1;
	}

1052
	mutex_unlock(&data->update_lock);
L
Linus Torvalds 已提交
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072

	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);