lm90.c 28.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
 *          monitoring
4
 * Copyright (C) 2003-2009  Jean Delvare <khali@linux-fr.org>
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
91 92
 */

93 94
static const unsigned short normal_i2c[] = {
	0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
Linus Torvalds's avatar
Linus Torvalds committed
95

96
enum chips { lm90, adm1032, lm99, lm86, max6657, adt7461, max6680, max6646 };
Linus Torvalds's avatar
Linus Torvalds committed
97 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

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

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

#define MAX6657_REG_R_LOCAL_TEMPL	0x11

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

Linus Torvalds's avatar
Linus Torvalds committed
146 147 148 149
/*
 * Functions declaration
 */

150
static int lm90_detect(struct i2c_client *client, struct i2c_board_info *info);
151 152
static int lm90_probe(struct i2c_client *client,
		      const struct i2c_device_id *id);
Linus Torvalds's avatar
Linus Torvalds committed
153
static void lm90_init_client(struct i2c_client *client);
154
static int lm90_remove(struct i2c_client *client);
Linus Torvalds's avatar
Linus Torvalds committed
155 156 157 158 159 160
static struct lm90_data *lm90_update_device(struct device *dev);

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

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

Linus Torvalds's avatar
Linus Torvalds committed
180
static struct i2c_driver lm90_driver = {
181
	.class		= I2C_CLASS_HWMON,
182 183 184
	.driver = {
		.name	= "lm90",
	},
185 186 187 188
	.probe		= lm90_probe,
	.remove		= lm90_remove,
	.id_table	= lm90_id,
	.detect		= lm90_detect,
189
	.address_list	= normal_i2c,
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192 193 194 195 196
};

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

struct lm90_data {
197
	struct device *hwmon_dev;
198
	struct mutex update_lock;
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201
	char valid; /* zero until following fields are valid */
	unsigned long last_updated; /* in jiffies */
	int kind;
202
	int flags;
Linus Torvalds's avatar
Linus Torvalds committed
203 204

	/* registers values */
205 206 207 208 209
	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
210
			   1: remote low limit
211
			   2: remote high limit
212
			   3: remote offset (except max6646 and max6657)
213
			   4: local input */
Linus Torvalds's avatar
Linus Torvalds committed
214 215 216 217
	u8 temp_hyst;
	u8 alarms; /* bitvector */
};

218 219 220 221 222
/*
 * 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
223 224
 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
 * Maxim chips use unsigned values.
225 226
 */

227
static inline int temp_from_s8(s8 val)
228 229 230 231
{
	return val * 1000;
}

232 233 234 235 236
static inline int temp_from_u8(u8 val)
{
	return val * 1000;
}

237
static inline int temp_from_s16(s16 val)
238 239 240 241
{
	return val / 32 * 125;
}

242 243 244 245 246
static inline int temp_from_u16(u16 val)
{
	return val / 32 * 125;
}

247
static s8 temp_to_s8(long val)
248 249 250 251 252 253 254 255 256 257
{
	if (val <= -128000)
		return -128;
	if (val >= 127000)
		return 127;
	if (val < 0)
		return (val - 500) / 1000;
	return (val + 500) / 1000;
}

258 259 260 261 262 263 264 265 266
static u8 temp_to_u8(long val)
{
	if (val <= 0)
		return 0;
	if (val >= 255000)
		return 255;
	return (val + 500) / 1000;
}

267
static s16 temp_to_s16(long val)
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
{
	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;
}

/*
288 289 290 291 292 293
 * 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.
294
 */
295
static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
296
{
297 298 299
	if (data->flags & LM90_FLAG_ADT7461_EXT)
		return (val - 64) * 1000;
	else
300
		return temp_from_s8(val);
301 302
}

303
static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
304
{
305 306 307
	if (data->flags & LM90_FLAG_ADT7461_EXT)
		return (val - 0x4000) / 64 * 250;
	else
308
		return temp_from_s16(val);
309 310
}

311
static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
{
	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;
	}
}

328
static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
329 330 331 332 333 334 335 336 337 338 339 340 341 342
{
	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;
	}
343 344
}

Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348
/*
 * Sysfs stuff
 */

349 350 351 352 353
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);
354 355 356
	int temp;

	if (data->kind == adt7461)
357
		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
358 359
	else if (data->kind == max6646)
		temp = temp_from_u8(data->temp8[attr->index]);
360
	else
361
		temp = temp_from_s8(data->temp8[attr->index]);
362

363 364 365 366
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		temp += 16000;

367
	return sprintf(buf, "%d\n", temp);
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
}

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;

386 387 388 389
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		val -= 16000;

390
	mutex_lock(&data->update_lock);
391
	if (data->kind == adt7461)
392
		data->temp8[nr] = temp_to_u8_adt7461(data, val);
393 394
	else if (data->kind == max6646)
		data->temp8[nr] = temp_to_u8(val);
395
	else
396
		data->temp8[nr] = temp_to_s8(val);
397
	i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
398
	mutex_unlock(&data->update_lock);
399
	return count;
Linus Torvalds's avatar
Linus Torvalds committed
400
}
401 402 403 404 405 406

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);
407 408 409
	int temp;

	if (data->kind == adt7461)
410
		temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
411 412
	else if (data->kind == max6646)
		temp = temp_from_u16(data->temp11[attr->index]);
413
	else
414
		temp = temp_from_s16(data->temp11[attr->index]);
415

416 417 418 419
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 &&  attr->index <= 2)
		temp += 16000;

420
	return sprintf(buf, "%d\n", temp);
Linus Torvalds's avatar
Linus Torvalds committed
421
}
422 423 424 425

static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
			  const char *buf, size_t count)
{
426
	static const u8 reg[6] = {
427 428 429 430
		LM90_REG_W_REMOTE_LOWH,
		LM90_REG_W_REMOTE_LOWL,
		LM90_REG_W_REMOTE_HIGHH,
		LM90_REG_W_REMOTE_HIGHL,
431 432
		LM90_REG_W_REMOTE_OFFSH,
		LM90_REG_W_REMOTE_OFFSL,
433 434 435 436 437 438 439 440
	};

	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;

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

445
	mutex_lock(&data->update_lock);
446
	if (data->kind == adt7461)
447
		data->temp11[nr] = temp_to_u16_adt7461(data, val);
448
	else if (data->kind == max6657 || data->kind == max6680)
449
		data->temp11[nr] = temp_to_s8(val) << 8;
450 451
	else if (data->kind == max6646)
		data->temp11[nr] = temp_to_u8(val) << 8;
452
	else
453
		data->temp11[nr] = temp_to_s16(val);
454

455 456
	i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
				  data->temp11[nr] >> 8);
457 458
	if (data->kind != max6657 && data->kind != max6680
	    && data->kind != max6646)
459 460
		i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
					  data->temp11[nr] & 0xff);
461
	mutex_unlock(&data->update_lock);
462
	return count;
Linus Torvalds's avatar
Linus Torvalds committed
463
}
464 465 466 467 468 469

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);
470 471 472
	int temp;

	if (data->kind == adt7461)
473
		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
474 475
	else if (data->kind == max6646)
		temp = temp_from_u8(data->temp8[attr->index]);
476
	else
477
		temp = temp_from_s8(data->temp8[attr->index]);
478

479 480 481 482
	/* +16 degrees offset for temp2 for the LM99 */
	if (data->kind == lm99 && attr->index == 3)
		temp += 16000;

483
	return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
Linus Torvalds's avatar
Linus Torvalds committed
484 485
}

486 487
static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
			    const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
488 489 490 491
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm90_data *data = i2c_get_clientdata(client);
	long val = simple_strtol(buf, NULL, 10);
492
	int temp;
Linus Torvalds's avatar
Linus Torvalds committed
493

494
	mutex_lock(&data->update_lock);
495 496 497 498 499 500 501 502
	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);
Linus Torvalds's avatar
Linus Torvalds committed
503
	i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
504
				  data->temp_hyst);
505
	mutex_unlock(&data->update_lock);
Linus Torvalds's avatar
Linus Torvalds committed
506 507 508
	return count;
}

509 510
static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
			   char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
511 512 513 514 515
{
	struct lm90_data *data = lm90_update_device(dev);
	return sprintf(buf, "%d\n", data->alarms);
}

516 517 518 519 520 521 522 523 524 525
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);
}

526
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
527 528
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
529
	set_temp8, 0);
530 531 532
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,
533
	set_temp8, 1);
534 535 536
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,
537
	set_temp8, 2);
538
static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
539
	set_temp8, 3);
540
static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
541 542
	set_temphyst, 2);
static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
543 544
static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
	set_temp11, 3);
545 546 547 548

/* 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);
549
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
550 551 552 553 554
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 */
Linus Torvalds's avatar
Linus Torvalds committed
555 556
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);

557 558 559 560 561 562 563 564 565 566 567 568 569 570
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,
571
	&sensor_dev_attr_temp2_fault.dev_attr.attr,
572 573 574 575 576 577 578 579 580 581 582 583
	&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,
};

584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
/* 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);

Linus Torvalds's avatar
Linus Torvalds committed
614 615 616 617
/*
 * Real code
 */

618
/* The ADM1032 supports PEC but not on write byte transactions, so we need
619
   to explicitly ask for a transaction without PEC. */
620 621 622 623 624 625 626 627 628 629 630
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. */
631 632 633 634
static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
{
	int err;

635 636 637 638 639 640
 	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);
641 642 643 644 645 646 647 648 649 650 651

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

	return 0;
}

652
/* Return 0 if detection is successful, -ENODEV otherwise */
653
static int lm90_detect(struct i2c_client *new_client,
654
		       struct i2c_board_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
655
{
656 657
	struct i2c_adapter *adapter = new_client->adapter;
	int address = new_client->addr;
658 659
	const char *name = NULL;
	int man_id, chip_id, reg_config1, reg_convrate;
Linus Torvalds's avatar
Linus Torvalds committed
660 661

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
662
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
663

664 665
	/* detection and identification */
	if ((man_id = i2c_smbus_read_byte_data(new_client,
666
						LM90_REG_R_MAN_ID)) < 0
667
	 || (chip_id = i2c_smbus_read_byte_data(new_client,
668
						LM90_REG_R_CHIP_ID)) < 0
669
	 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
670
						LM90_REG_R_CONFIG1)) < 0
671
	 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
672
						LM90_REG_R_CONVRATE)) < 0)
673 674 675 676 677 678 679 680 681
		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)
682
			return -ENODEV;
683 684 685 686 687 688 689

		if ((reg_config1 & 0x2A) == 0x00
		 && (reg_config2 & 0xF8) == 0x00
		 && reg_convrate <= 0x09) {
			if (address == 0x4C
			 && (chip_id & 0xF0) == 0x20) { /* LM90 */
				name = "lm90";
690
			} else
691 692 693 694 695 696 697 698 699
			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");
700
			} else
701 702 703
			if (address == 0x4C
			 && (chip_id & 0xF0) == 0x10) { /* LM86 */
				name = "lm86";
Linus Torvalds's avatar
Linus Torvalds committed
704 705
			}
		}
706 707 708 709 710 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
	} 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";
Linus Torvalds's avatar
Linus Torvalds committed
760 761 762
		}
	}

763 764 765 766 767
	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;
Linus Torvalds's avatar
Linus Torvalds committed
768
	}
769

770 771 772 773 774 775 776 777 778 779 780
	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;
Linus Torvalds's avatar
Linus Torvalds committed
781

782 783 784 785 786 787
	data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
	if (!data) {
		err = -ENOMEM;
		goto exit;
	}
	i2c_set_clientdata(new_client, data);
788
	mutex_init(&data->update_lock);
Linus Torvalds's avatar
Linus Torvalds committed
789

790 791 792 793 794 795
	/* 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;
	}
Linus Torvalds's avatar
Linus Torvalds committed
796 797 798 799 800

	/* Initialize the LM90 chip */
	lm90_init_client(new_client);

	/* Register sysfs hooks */
801
	if ((err = sysfs_create_group(&new_client->dev.kobj, &lm90_group)))
802
		goto exit_free;
803 804 805 806 807
	if (new_client->flags & I2C_CLIENT_PEC) {
		if ((err = device_create_file(&new_client->dev,
					      &dev_attr_pec)))
			goto exit_remove_files;
	}
808
	if (data->kind != max6657 && data->kind != max6646) {
809 810 811 812
		if ((err = device_create_file(&new_client->dev,
				&sensor_dev_attr_temp2_offset.dev_attr)))
			goto exit_remove_files;
	}
813

814 815 816
	data->hwmon_dev = hwmon_device_register(&new_client->dev);
	if (IS_ERR(data->hwmon_dev)) {
		err = PTR_ERR(data->hwmon_dev);
817
		goto exit_remove_files;
818 819
	}

Linus Torvalds's avatar
Linus Torvalds committed
820 821
	return 0;

822 823 824
exit_remove_files:
	sysfs_remove_group(&new_client->dev.kobj, &lm90_group);
	device_remove_file(&new_client->dev, &dev_attr_pec);
Linus Torvalds's avatar
Linus Torvalds committed
825 826 827 828 829 830 831 832
exit_free:
	kfree(data);
exit:
	return err;
}

static void lm90_init_client(struct i2c_client *client)
{
833 834
	u8 config, config_orig;
	struct lm90_data *data = i2c_get_clientdata(client);
Linus Torvalds's avatar
Linus Torvalds committed
835 836 837 838 839 840

	/*
	 * Start the conversions.
	 */
	i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
				  5); /* 2 Hz */
841 842 843 844
	if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
		dev_warn(&client->dev, "Initialization failed!\n");
		return;
	}
845 846
	config_orig = config;

847 848 849 850 851 852
	/* Check Temperature Range Select */
	if (data->kind == adt7461) {
		if (config & 0x04)
			data->flags |= LM90_FLAG_ADT7461_EXT;
	}

853 854 855 856 857 858 859 860 861 862 863 864
	/*
	 * 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 */
	if (config != config_orig) /* Only write if changed */
		i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
Linus Torvalds's avatar
Linus Torvalds committed
865 866
}

867
static int lm90_remove(struct i2c_client *client)
Linus Torvalds's avatar
Linus Torvalds committed
868
{
869
	struct lm90_data *data = i2c_get_clientdata(client);
Linus Torvalds's avatar
Linus Torvalds committed
870

871
	hwmon_device_unregister(data->hwmon_dev);
872 873
	sysfs_remove_group(&client->dev.kobj, &lm90_group);
	device_remove_file(&client->dev, &dev_attr_pec);
874
	if (data->kind != max6657 && data->kind != max6646)
875 876
		device_remove_file(&client->dev,
				   &sensor_dev_attr_temp2_offset.dev_attr);
877 878

	kfree(data);
Linus Torvalds's avatar
Linus Torvalds committed
879 880 881
	return 0;
}

882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
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;
}

Linus Torvalds's avatar
Linus Torvalds committed
914 915 916 917 918
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);

919
	mutex_lock(&data->update_lock);
Linus Torvalds's avatar
Linus Torvalds committed
920 921

	if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
922
		u8 h, l;
Linus Torvalds's avatar
Linus Torvalds committed
923 924

		dev_dbg(&client->dev, "Updating lm90 data.\n");
925 926 927 928
		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]);
929
		lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
Linus Torvalds's avatar
Linus Torvalds committed
930

931
		if (data->kind == max6657 || data->kind == max6646) {
932 933 934 935 936 937 938 939
			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;
		}
940 941 942
		lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
			    LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);

943 944 945
		if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
			data->temp11[1] = h << 8;
			if (data->kind != max6657 && data->kind != max6680
946
			 && data->kind != max6646
947 948 949 950 951 952 953
			 && 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
954
			 && data->kind != max6646
955 956 957 958 959
			 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
					  &l) == 0)
				data->temp11[2] |= l;
		}

960
		if (data->kind != max6657 && data->kind != max6646) {
961
			if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
962
					  &h) == 0
963 964
			 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
					  &l) == 0)
965
				data->temp11[3] = (h << 8) | l;
966
		}
967
		lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
Linus Torvalds's avatar
Linus Torvalds committed
968 969 970 971 972

		data->last_updated = jiffies;
		data->valid = 1;
	}

973
	mutex_unlock(&data->update_lock);
Linus Torvalds's avatar
Linus Torvalds committed
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993

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