1/*
   2 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
   3 *          monitoring
   4 * Copyright (C) 2003-2010  Jean Delvare <khali@linux-fr.org>
   5 *
   6 * Based on the lm83 driver. The LM90 is a sensor chip made by National
   7 * Semiconductor. It reports up to two temperatures (its own plus up to
   8 * one external one) with a 0.125 deg resolution (1 deg for local
   9 * temperature) and a 3-4 deg accuracy.
  10 *
  11 * This driver also supports the LM89 and LM99, two other sensor chips
  12 * made by National Semiconductor. Both have an increased remote
  13 * temperature measurement accuracy (1 degree), and the LM99
  14 * additionally shifts remote temperatures (measured and limits) by 16
  15 * degrees, which allows for higher temperatures measurement.
  16 * Note that there is no way to differentiate between both chips.
  17 * When device is auto-detected, the driver will assume an LM99.
  18 *
  19 * This driver also supports the LM86, another sensor chip made by
  20 * National Semiconductor. It is exactly similar to the LM90 except it
  21 * has a higher accuracy.
  22 *
  23 * This driver also supports the ADM1032, a sensor chip made by Analog
  24 * Devices. That chip is similar to the LM90, with a few differences
  25 * that are not handled by this driver. Among others, it has a higher
  26 * accuracy than the LM90, much like the LM86 does.
  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 * variants. We use the device address to detect MAX6659, which will result
  32 * in a detection as max6657 if it is on address 0x4c. The extra address
  33 * and features of the MAX6659 are only supported if the chip is configured
  34 * explicitly as max6659, or if its address is not 0x4c.
  35 * These chips lack the remote temperature offset feature.
  36 *
  37 * This driver also supports the MAX6646, MAX6647, MAX6648, MAX6649 and
  38 * MAX6692 chips made by Maxim.  These are again similar to the LM86,
  39 * but they use unsigned temperature values and can report temperatures
  40 * from 0 to 145 degrees.
  41 *
  42 * This driver also supports the MAX6680 and MAX6681, two other sensor
  43 * chips made by Maxim. These are quite similar to the other Maxim
  44 * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
  45 * be treated identically.
  46 *
  47 * This driver also supports the MAX6695 and MAX6696, two other sensor
  48 * chips made by Maxim. These are also quite similar to other Maxim
  49 * chips, but support three temperature sensors instead of two. MAX6695
  50 * and MAX6696 only differ in the pinout so they can be treated identically.
  51 *
  52 * This driver also supports ADT7461 and ADT7461A from Analog Devices as well as
  53 * NCT1008 from ON Semiconductor. The chips are supported in both compatibility
  54 * and extended mode. They are mostly compatible with LM90 except for a data
  55 * format difference for the temperature value registers.
  56 *
  57 * This driver also supports the SA56004 from Philips. This device is
  58 * pin-compatible with the LM86, the ED/EDP parts are also address-compatible.
  59 *
 
 
 
 
 
 
 
 
  60 * Since the LM90 was the first chipset supported by this driver, most
  61 * comments will refer to this chipset, but are actually general and
  62 * concern all supported chipsets, unless mentioned otherwise.
  63 *
  64 * This program is free software; you can redistribute it and/or modify
  65 * it under the terms of the GNU General Public License as published by
  66 * the Free Software Foundation; either version 2 of the License, or
  67 * (at your option) any later version.
  68 *
  69 * This program is distributed in the hope that it will be useful,
  70 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  71 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  72 * GNU General Public License for more details.
  73 *
  74 * You should have received a copy of the GNU General Public License
  75 * along with this program; if not, write to the Free Software
  76 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  77 */
  78
  79#include <linux/module.h>
  80#include <linux/init.h>
  81#include <linux/slab.h>
  82#include <linux/jiffies.h>
  83#include <linux/i2c.h>
  84#include <linux/hwmon-sysfs.h>
  85#include <linux/hwmon.h>
  86#include <linux/err.h>
  87#include <linux/mutex.h>
  88#include <linux/sysfs.h>
 
 
  89
  90/*
  91 * Addresses to scan
  92 * Address is fully defined internally and cannot be changed except for
  93 * MAX6659, MAX6680 and MAX6681.
  94 * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, ADT7461A, MAX6649,
  95 * MAX6657, MAX6658, NCT1008 and W83L771 have address 0x4c.
  96 * ADM1032-2, ADT7461-2, ADT7461A-2, LM89-1, LM99-1, MAX6646, and NCT1008D
  97 * have address 0x4d.
  98 * MAX6647 has address 0x4e.
  99 * MAX6659 can have address 0x4c, 0x4d or 0x4e.
 100 * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
 101 * 0x4c, 0x4d or 0x4e.
 102 * SA56004 can have address 0x48 through 0x4F.
 103 */
 104
 105static const unsigned short normal_i2c[] = {
 106	0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
 107	0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
 108
 109enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,
 110	max6646, w83l771, max6696, sa56004 };
 111
 112/*
 113 * The LM90 registers
 114 */
 115
 116#define LM90_REG_R_MAN_ID		0xFE
 117#define LM90_REG_R_CHIP_ID		0xFF
 118#define LM90_REG_R_CONFIG1		0x03
 119#define LM90_REG_W_CONFIG1		0x09
 120#define LM90_REG_R_CONFIG2		0xBF
 121#define LM90_REG_W_CONFIG2		0xBF
 122#define LM90_REG_R_CONVRATE		0x04
 123#define LM90_REG_W_CONVRATE		0x0A
 124#define LM90_REG_R_STATUS		0x02
 125#define LM90_REG_R_LOCAL_TEMP		0x00
 126#define LM90_REG_R_LOCAL_HIGH		0x05
 127#define LM90_REG_W_LOCAL_HIGH		0x0B
 128#define LM90_REG_R_LOCAL_LOW		0x06
 129#define LM90_REG_W_LOCAL_LOW		0x0C
 130#define LM90_REG_R_LOCAL_CRIT		0x20
 131#define LM90_REG_W_LOCAL_CRIT		0x20
 132#define LM90_REG_R_REMOTE_TEMPH		0x01
 133#define LM90_REG_R_REMOTE_TEMPL		0x10
 134#define LM90_REG_R_REMOTE_OFFSH		0x11
 135#define LM90_REG_W_REMOTE_OFFSH		0x11
 136#define LM90_REG_R_REMOTE_OFFSL		0x12
 137#define LM90_REG_W_REMOTE_OFFSL		0x12
 138#define LM90_REG_R_REMOTE_HIGHH		0x07
 139#define LM90_REG_W_REMOTE_HIGHH		0x0D
 140#define LM90_REG_R_REMOTE_HIGHL		0x13
 141#define LM90_REG_W_REMOTE_HIGHL		0x13
 142#define LM90_REG_R_REMOTE_LOWH		0x08
 143#define LM90_REG_W_REMOTE_LOWH		0x0E
 144#define LM90_REG_R_REMOTE_LOWL		0x14
 145#define LM90_REG_W_REMOTE_LOWL		0x14
 146#define LM90_REG_R_REMOTE_CRIT		0x19
 147#define LM90_REG_W_REMOTE_CRIT		0x19
 148#define LM90_REG_R_TCRIT_HYST		0x21
 149#define LM90_REG_W_TCRIT_HYST		0x21
 150
 151/* MAX6646/6647/6649/6657/6658/6659/6695/6696 registers */
 152
 153#define MAX6657_REG_R_LOCAL_TEMPL	0x11
 154#define MAX6696_REG_R_STATUS2		0x12
 155#define MAX6659_REG_R_REMOTE_EMERG	0x16
 156#define MAX6659_REG_W_REMOTE_EMERG	0x16
 157#define MAX6659_REG_R_LOCAL_EMERG	0x17
 158#define MAX6659_REG_W_LOCAL_EMERG	0x17
 159
 160/*  SA56004 registers */
 161
 162#define SA56004_REG_R_LOCAL_TEMPL 0x22
 163
 164#define LM90_DEF_CONVRATE_RVAL	6	/* Def conversion rate register value */
 165#define LM90_MAX_CONVRATE_MS	16000	/* Maximum conversion rate in ms */
 166
 
 
 
 167/*
 168 * Device flags
 169 */
 170#define LM90_FLAG_ADT7461_EXT	(1 << 0) /* ADT7461 extended mode	*/
 171/* Device features */
 172#define LM90_HAVE_OFFSET	(1 << 1) /* temperature offset register	*/
 173#define LM90_HAVE_REM_LIMIT_EXT	(1 << 3) /* extended remote limit	*/
 174#define LM90_HAVE_EMERGENCY	(1 << 4) /* 3rd upper (emergency) limit	*/
 175#define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm		*/
 176#define LM90_HAVE_TEMP3		(1 << 6) /* 3rd temperature sensor	*/
 177#define LM90_HAVE_BROKEN_ALERT	(1 << 7) /* Broken alert		*/
 178
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 179/*
 180 * Driver data (common to all clients)
 181 */
 182
 183static const struct i2c_device_id lm90_id[] = {
 184	{ "adm1032", adm1032 },
 185	{ "adt7461", adt7461 },
 186	{ "adt7461a", adt7461 },
 
 187	{ "lm90", lm90 },
 188	{ "lm86", lm86 },
 189	{ "lm89", lm86 },
 190	{ "lm99", lm99 },
 191	{ "max6646", max6646 },
 192	{ "max6647", max6646 },
 193	{ "max6649", max6646 },
 194	{ "max6657", max6657 },
 195	{ "max6658", max6657 },
 196	{ "max6659", max6659 },
 197	{ "max6680", max6680 },
 198	{ "max6681", max6680 },
 199	{ "max6695", max6696 },
 200	{ "max6696", max6696 },
 201	{ "nct1008", adt7461 },
 202	{ "w83l771", w83l771 },
 203	{ "sa56004", sa56004 },
 
 204	{ }
 205};
 206MODULE_DEVICE_TABLE(i2c, lm90_id);
 207
 208/*
 209 * chip type specific parameters
 210 */
 211struct lm90_params {
 212	u32 flags;		/* Capabilities */
 213	u16 alert_alarms;	/* Which alarm bits trigger ALERT# */
 214				/* Upper 8 bits for max6695/96 */
 215	u8 max_convrate;	/* Maximum conversion rate register value */
 216	u8 reg_local_ext;	/* Extended local temp register (optional) */
 217};
 218
 219static const struct lm90_params lm90_params[] = {
 220	[adm1032] = {
 221		.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 222		  | LM90_HAVE_BROKEN_ALERT,
 223		.alert_alarms = 0x7c,
 224		.max_convrate = 10,
 225	},
 226	[adt7461] = {
 227		.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT
 228		  | LM90_HAVE_BROKEN_ALERT,
 229		.alert_alarms = 0x7c,
 230		.max_convrate = 10,
 231	},
 
 
 
 
 
 
 232	[lm86] = {
 233		.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 234		.alert_alarms = 0x7b,
 235		.max_convrate = 9,
 236	},
 237	[lm90] = {
 238		.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 239		.alert_alarms = 0x7b,
 240		.max_convrate = 9,
 241	},
 242	[lm99] = {
 243		.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 244		.alert_alarms = 0x7b,
 245		.max_convrate = 9,
 246	},
 247	[max6646] = {
 248		.alert_alarms = 0x7c,
 249		.max_convrate = 6,
 250		.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 251	},
 252	[max6657] = {
 253		.alert_alarms = 0x7c,
 254		.max_convrate = 8,
 255		.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 256	},
 257	[max6659] = {
 258		.flags = LM90_HAVE_EMERGENCY,
 259		.alert_alarms = 0x7c,
 260		.max_convrate = 8,
 261		.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 262	},
 263	[max6680] = {
 264		.flags = LM90_HAVE_OFFSET,
 265		.alert_alarms = 0x7c,
 266		.max_convrate = 7,
 267	},
 268	[max6696] = {
 269		.flags = LM90_HAVE_EMERGENCY
 270		  | LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3,
 271		.alert_alarms = 0x187c,
 272		.max_convrate = 6,
 273		.reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
 274	},
 275	[w83l771] = {
 276		.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 277		.alert_alarms = 0x7c,
 278		.max_convrate = 8,
 279	},
 280	[sa56004] = {
 281		.flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
 282		.alert_alarms = 0x7b,
 283		.max_convrate = 9,
 284		.reg_local_ext = SA56004_REG_R_LOCAL_TEMPL,
 285	},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 286};
 287
 288/*
 289 * Client data (each client gets its own)
 290 */
 291
 292struct lm90_data {
 
 293	struct device *hwmon_dev;
 
 294	struct mutex update_lock;
 
 295	char valid; /* zero until following fields are valid */
 296	unsigned long last_updated; /* in jiffies */
 297	int kind;
 298	u32 flags;
 299
 300	int update_interval;	/* in milliseconds */
 301
 302	u8 config_orig;		/* Original configuration register value */
 303	u8 convrate_orig;	/* Original conversion rate register value */
 304	u16 alert_alarms;	/* Which alarm bits trigger ALERT# */
 305				/* Upper 8 bits for max6695/96 */
 306	u8 max_convrate;	/* Maximum conversion rate */
 307	u8 reg_local_ext;	/* local extension register offset */
 308
 309	/* registers values */
 310	s8 temp8[8];	/* 0: local low limit
 311			   1: local high limit
 312			   2: local critical limit
 313			   3: remote critical limit
 314			   4: local emergency limit (max6659 and max6695/96)
 315			   5: remote emergency limit (max6659 and max6695/96)
 316			   6: remote 2 critical limit (max6695/96 only)
 317			   7: remote 2 emergency limit (max6695/96 only) */
 318	s16 temp11[8];	/* 0: remote input
 319			   1: remote low limit
 320			   2: remote high limit
 321			   3: remote offset (except max6646, max6657/58/59,
 322					     and max6695/96)
 323			   4: local input
 324			   5: remote 2 input (max6695/96 only)
 325			   6: remote 2 low limit (max6695/96 only)
 326			   7: remote 2 high limit (ma6695/96 only) */
 327	u8 temp_hyst;
 328	u16 alarms; /* bitvector (upper 8 bits for max6695/96) */
 329};
 330
 331/*
 332 * Support functions
 333 */
 334
 335/*
 336 * The ADM1032 supports PEC but not on write byte transactions, so we need
 337 * to explicitly ask for a transaction without PEC.
 338 */
 339static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
 340{
 341	return i2c_smbus_xfer(client->adapter, client->addr,
 342			      client->flags & ~I2C_CLIENT_PEC,
 343			      I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 344}
 345
 346/*
 347 * It is assumed that client->update_lock is held (unless we are in
 348 * detection or initialization steps). This matters when PEC is enabled,
 349 * because we don't want the address pointer to change between the write
 350 * byte and the read byte transactions.
 351 */
 352static int lm90_read_reg(struct i2c_client *client, u8 reg, u8 *value)
 353{
 354	int err;
 355
 356	if (client->flags & I2C_CLIENT_PEC) {
 357		err = adm1032_write_byte(client, reg);
 358		if (err >= 0)
 359			err = i2c_smbus_read_byte(client);
 360	} else
 361		err = i2c_smbus_read_byte_data(client, reg);
 362
 363	if (err < 0) {
 364		dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
 365			 reg, err);
 366		return err;
 367	}
 368	*value = err;
 369
 370	return 0;
 371}
 372
 373static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
 374{
 375	int err;
 376	u8 oldh, newh, l;
 377
 378	/*
 379	 * There is a trick here. We have to read two registers to have the
 380	 * sensor temperature, but we have to beware a conversion could occur
 381	 * between the readings. The datasheet says we should either use
 382	 * the one-shot conversion register, which we don't want to do
 383	 * (disables hardware monitoring) or monitor the busy bit, which is
 384	 * impossible (we can't read the values and monitor that bit at the
 385	 * exact same time). So the solution used here is to read the high
 386	 * byte once, then the low byte, then the high byte again. If the new
 387	 * high byte matches the old one, then we have a valid reading. Else
 388	 * we have to read the low byte again, and now we believe we have a
 389	 * correct reading.
 390	 */
 391	if ((err = lm90_read_reg(client, regh, &oldh))
 392	 || (err = lm90_read_reg(client, regl, &l))
 393	 || (err = lm90_read_reg(client, regh, &newh)))
 394		return err;
 395	if (oldh != newh) {
 396		err = lm90_read_reg(client, regl, &l);
 397		if (err)
 398			return err;
 399	}
 400	*value = (newh << 8) | l;
 401
 402	return 0;
 403}
 404
 405/*
 406 * client->update_lock must be held when calling this function (unless we are
 407 * in detection or initialization steps), and while a remote channel other
 408 * than channel 0 is selected. Also, calling code must make sure to re-select
 409 * external channel 0 before releasing the lock. This is necessary because
 410 * various registers have different meanings as a result of selecting a
 411 * non-default remote channel.
 412 */
 413static inline void lm90_select_remote_channel(struct i2c_client *client,
 414					      struct lm90_data *data,
 415					      int channel)
 416{
 417	u8 config;
 418
 419	if (data->kind == max6696) {
 420		lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
 421		config &= ~0x08;
 422		if (channel)
 423			config |= 0x08;
 424		i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
 425					  config);
 426	}
 427}
 428
 429/*
 430 * Set conversion rate.
 431 * client->update_lock must be held when calling this function (unless we are
 432 * in detection or initialization steps).
 433 */
 434static void lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,
 435			      unsigned int interval)
 436{
 437	int i;
 438	unsigned int update_interval;
 439
 440	/* Shift calculations to avoid rounding errors */
 441	interval <<= 6;
 442
 443	/* find the nearest update rate */
 444	for (i = 0, update_interval = LM90_MAX_CONVRATE_MS << 6;
 445	     i < data->max_convrate; i++, update_interval >>= 1)
 446		if (interval >= update_interval * 3 / 4)
 447			break;
 448
 449	i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE, i);
 450	data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64);
 451}
 452
 453static struct lm90_data *lm90_update_device(struct device *dev)
 454{
 455	struct i2c_client *client = to_i2c_client(dev);
 456	struct lm90_data *data = i2c_get_clientdata(client);
 457	unsigned long next_update;
 458
 459	mutex_lock(&data->update_lock);
 460
 461	next_update = data->last_updated
 462	  + msecs_to_jiffies(data->update_interval) + 1;
 463	if (time_after(jiffies, next_update) || !data->valid) {
 464		u8 h, l;
 465		u8 alarms;
 466
 467		dev_dbg(&client->dev, "Updating lm90 data.\n");
 468		lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
 469		lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
 470		lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
 471		lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
 
 
 
 
 472		lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 473
 474		if (data->reg_local_ext) {
 475			lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
 476				    data->reg_local_ext,
 477				    &data->temp11[4]);
 478		} else {
 479			if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
 480					  &h) == 0)
 481				data->temp11[4] = h << 8;
 482		}
 483		lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
 484			    LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
 
 485
 486		if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
 487			data->temp11[1] = h << 8;
 488			if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
 489			 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
 490					  &l) == 0)
 491				data->temp11[1] |= l;
 492		}
 493		if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
 494			data->temp11[2] = h << 8;
 495			if ((data->flags & LM90_HAVE_REM_LIMIT_EXT)
 496			 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
 497					  &l) == 0)
 498				data->temp11[2] |= l;
 499		}
 500
 501		if (data->flags & LM90_HAVE_OFFSET) {
 502			if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
 503					  &h) == 0
 504			 && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
 505					  &l) == 0)
 506				data->temp11[3] = (h << 8) | l;
 507		}
 508		if (data->flags & LM90_HAVE_EMERGENCY) {
 509			lm90_read_reg(client, MAX6659_REG_R_LOCAL_EMERG,
 510				      &data->temp8[4]);
 511			lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,
 512				      &data->temp8[5]);
 513		}
 514		lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);
 515		data->alarms = alarms;	/* save as 16 bit value */
 516
 517		if (data->kind == max6696) {
 518			lm90_select_remote_channel(client, data, 1);
 519			lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT,
 520				      &data->temp8[6]);
 521			lm90_read_reg(client, MAX6659_REG_R_REMOTE_EMERG,
 522				      &data->temp8[7]);
 523			lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
 524				    LM90_REG_R_REMOTE_TEMPL, &data->temp11[5]);
 
 525			if (!lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h))
 526				data->temp11[6] = h << 8;
 527			if (!lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h))
 528				data->temp11[7] = h << 8;
 529			lm90_select_remote_channel(client, data, 0);
 530
 531			if (!lm90_read_reg(client, MAX6696_REG_R_STATUS2,
 532					   &alarms))
 533				data->alarms |= alarms << 8;
 534		}
 535
 536		/* Re-enable ALERT# output if it was originally enabled and
 537		 * relevant alarms are all clear */
 
 
 538		if ((data->config_orig & 0x80) == 0
 539		 && (data->alarms & data->alert_alarms) == 0) {
 540			u8 config;
 541
 542			lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
 543			if (config & 0x80) {
 544				dev_dbg(&client->dev, "Re-enabling ALERT#\n");
 545				i2c_smbus_write_byte_data(client,
 546							  LM90_REG_W_CONFIG1,
 547							  config & ~0x80);
 548			}
 549		}
 550
 551		data->last_updated = jiffies;
 552		data->valid = 1;
 553	}
 554
 555	mutex_unlock(&data->update_lock);
 556
 557	return data;
 558}
 559
 560/*
 561 * Conversions
 562 * For local temperatures and limits, critical limits and the hysteresis
 563 * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
 564 * For remote temperatures and limits, it uses signed 11-bit values with
 565 * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
 566 * Maxim chips use unsigned values.
 567 */
 568
 569static inline int temp_from_s8(s8 val)
 570{
 571	return val * 1000;
 572}
 573
 574static inline int temp_from_u8(u8 val)
 575{
 576	return val * 1000;
 577}
 578
 579static inline int temp_from_s16(s16 val)
 580{
 581	return val / 32 * 125;
 582}
 583
 584static inline int temp_from_u16(u16 val)
 585{
 586	return val / 32 * 125;
 587}
 588
 589static s8 temp_to_s8(long val)
 590{
 591	if (val <= -128000)
 592		return -128;
 593	if (val >= 127000)
 594		return 127;
 595	if (val < 0)
 596		return (val - 500) / 1000;
 597	return (val + 500) / 1000;
 598}
 599
 600static u8 temp_to_u8(long val)
 601{
 602	if (val <= 0)
 603		return 0;
 604	if (val >= 255000)
 605		return 255;
 606	return (val + 500) / 1000;
 607}
 608
 609static s16 temp_to_s16(long val)
 610{
 611	if (val <= -128000)
 612		return 0x8000;
 613	if (val >= 127875)
 614		return 0x7FE0;
 615	if (val < 0)
 616		return (val - 62) / 125 * 32;
 617	return (val + 62) / 125 * 32;
 618}
 619
 620static u8 hyst_to_reg(long val)
 621{
 622	if (val <= 0)
 623		return 0;
 624	if (val >= 30500)
 625		return 31;
 626	return (val + 500) / 1000;
 627}
 628
 629/*
 630 * ADT7461 in compatibility mode is almost identical to LM90 except that
 631 * attempts to write values that are outside the range 0 < temp < 127 are
 632 * treated as the boundary value.
 633 *
 634 * ADT7461 in "extended mode" operation uses unsigned integers offset by
 635 * 64 (e.g., 0 -> -64 degC).  The range is restricted to -64..191 degC.
 636 */
 637static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
 638{
 639	if (data->flags & LM90_FLAG_ADT7461_EXT)
 640		return (val - 64) * 1000;
 641	else
 642		return temp_from_s8(val);
 643}
 644
 645static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
 646{
 647	if (data->flags & LM90_FLAG_ADT7461_EXT)
 648		return (val - 0x4000) / 64 * 250;
 649	else
 650		return temp_from_s16(val);
 651}
 652
 653static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
 654{
 655	if (data->flags & LM90_FLAG_ADT7461_EXT) {
 656		if (val <= -64000)
 657			return 0;
 658		if (val >= 191000)
 659			return 0xFF;
 660		return (val + 500 + 64000) / 1000;
 661	} else {
 662		if (val <= 0)
 663			return 0;
 664		if (val >= 127000)
 665			return 127;
 666		return (val + 500) / 1000;
 667	}
 668}
 669
 670static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
 671{
 672	if (data->flags & LM90_FLAG_ADT7461_EXT) {
 673		if (val <= -64000)
 674			return 0;
 675		if (val >= 191750)
 676			return 0xFFC0;
 677		return (val + 64000 + 125) / 250 * 64;
 678	} else {
 679		if (val <= 0)
 680			return 0;
 681		if (val >= 127750)
 682			return 0x7FC0;
 683		return (val + 125) / 250 * 64;
 684	}
 685}
 686
 687/*
 688 * Sysfs stuff
 689 */
 690
 691static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
 692			  char *buf)
 693{
 694	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 695	struct lm90_data *data = lm90_update_device(dev);
 696	int temp;
 697
 698	if (data->kind == adt7461)
 699		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
 700	else if (data->kind == max6646)
 701		temp = temp_from_u8(data->temp8[attr->index]);
 702	else
 703		temp = temp_from_s8(data->temp8[attr->index]);
 704
 705	/* +16 degrees offset for temp2 for the LM99 */
 706	if (data->kind == lm99 && attr->index == 3)
 707		temp += 16000;
 708
 709	return sprintf(buf, "%d\n", temp);
 710}
 711
 712static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
 713			 const char *buf, size_t count)
 714{
 715	static const u8 reg[8] = {
 716		LM90_REG_W_LOCAL_LOW,
 717		LM90_REG_W_LOCAL_HIGH,
 718		LM90_REG_W_LOCAL_CRIT,
 719		LM90_REG_W_REMOTE_CRIT,
 720		MAX6659_REG_W_LOCAL_EMERG,
 721		MAX6659_REG_W_REMOTE_EMERG,
 722		LM90_REG_W_REMOTE_CRIT,
 723		MAX6659_REG_W_REMOTE_EMERG,
 724	};
 725
 726	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 727	struct i2c_client *client = to_i2c_client(dev);
 728	struct lm90_data *data = i2c_get_clientdata(client);
 729	int nr = attr->index;
 730	long val;
 731	int err;
 732
 733	err = strict_strtol(buf, 10, &val);
 734	if (err < 0)
 735		return err;
 736
 737	/* +16 degrees offset for temp2 for the LM99 */
 738	if (data->kind == lm99 && attr->index == 3)
 739		val -= 16000;
 740
 741	mutex_lock(&data->update_lock);
 742	if (data->kind == adt7461)
 743		data->temp8[nr] = temp_to_u8_adt7461(data, val);
 744	else if (data->kind == max6646)
 745		data->temp8[nr] = temp_to_u8(val);
 746	else
 747		data->temp8[nr] = temp_to_s8(val);
 748
 749	lm90_select_remote_channel(client, data, nr >= 6);
 750	i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
 751	lm90_select_remote_channel(client, data, 0);
 752
 753	mutex_unlock(&data->update_lock);
 754	return count;
 755}
 756
 757static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
 758			   char *buf)
 759{
 760	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 761	struct lm90_data *data = lm90_update_device(dev);
 762	int temp;
 763
 764	if (data->kind == adt7461)
 765		temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
 766	else if (data->kind == max6646)
 767		temp = temp_from_u16(data->temp11[attr->index]);
 768	else
 769		temp = temp_from_s16(data->temp11[attr->index]);
 770
 771	/* +16 degrees offset for temp2 for the LM99 */
 772	if (data->kind == lm99 &&  attr->index <= 2)
 773		temp += 16000;
 774
 775	return sprintf(buf, "%d\n", temp);
 776}
 777
 778static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
 779			  const char *buf, size_t count)
 780{
 781	struct {
 782		u8 high;
 783		u8 low;
 784		int channel;
 785	} reg[5] = {
 786		{ LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 0 },
 787		{ LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 0 },
 788		{ LM90_REG_W_REMOTE_OFFSH, LM90_REG_W_REMOTE_OFFSL, 0 },
 789		{ LM90_REG_W_REMOTE_LOWH, LM90_REG_W_REMOTE_LOWL, 1 },
 790		{ LM90_REG_W_REMOTE_HIGHH, LM90_REG_W_REMOTE_HIGHL, 1 }
 791	};
 792
 793	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 794	struct i2c_client *client = to_i2c_client(dev);
 795	struct lm90_data *data = i2c_get_clientdata(client);
 796	int nr = attr->nr;
 797	int index = attr->index;
 798	long val;
 799	int err;
 800
 801	err = strict_strtol(buf, 10, &val);
 802	if (err < 0)
 803		return err;
 804
 805	/* +16 degrees offset for temp2 for the LM99 */
 806	if (data->kind == lm99 && index <= 2)
 807		val -= 16000;
 808
 809	mutex_lock(&data->update_lock);
 810	if (data->kind == adt7461)
 811		data->temp11[index] = temp_to_u16_adt7461(data, val);
 812	else if (data->kind == max6646)
 813		data->temp11[index] = temp_to_u8(val) << 8;
 814	else if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
 815		data->temp11[index] = temp_to_s16(val);
 816	else
 817		data->temp11[index] = temp_to_s8(val) << 8;
 818
 819	lm90_select_remote_channel(client, data, reg[nr].channel);
 820	i2c_smbus_write_byte_data(client, reg[nr].high,
 821				  data->temp11[index] >> 8);
 822	if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
 823		i2c_smbus_write_byte_data(client, reg[nr].low,
 824					  data->temp11[index] & 0xff);
 825	lm90_select_remote_channel(client, data, 0);
 826
 827	mutex_unlock(&data->update_lock);
 828	return count;
 829}
 830
 831static ssize_t show_temphyst(struct device *dev,
 832			     struct device_attribute *devattr,
 833			     char *buf)
 834{
 835	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 836	struct lm90_data *data = lm90_update_device(dev);
 837	int temp;
 838
 839	if (data->kind == adt7461)
 840		temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
 841	else if (data->kind == max6646)
 842		temp = temp_from_u8(data->temp8[attr->index]);
 843	else
 844		temp = temp_from_s8(data->temp8[attr->index]);
 845
 846	/* +16 degrees offset for temp2 for the LM99 */
 847	if (data->kind == lm99 && attr->index == 3)
 848		temp += 16000;
 849
 850	return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
 851}
 852
 853static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
 854			    const char *buf, size_t count)
 855{
 856	struct i2c_client *client = to_i2c_client(dev);
 857	struct lm90_data *data = i2c_get_clientdata(client);
 858	long val;
 859	int err;
 860	int temp;
 861
 862	err = strict_strtol(buf, 10, &val);
 863	if (err < 0)
 864		return err;
 865
 866	mutex_lock(&data->update_lock);
 867	if (data->kind == adt7461)
 868		temp = temp_from_u8_adt7461(data, data->temp8[2]);
 869	else if (data->kind == max6646)
 870		temp = temp_from_u8(data->temp8[2]);
 871	else
 872		temp = temp_from_s8(data->temp8[2]);
 873
 874	data->temp_hyst = hyst_to_reg(temp - val);
 875	i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
 876				  data->temp_hyst);
 877	mutex_unlock(&data->update_lock);
 878	return count;
 879}
 880
 881static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
 882			   char *buf)
 883{
 884	struct lm90_data *data = lm90_update_device(dev);
 885	return sprintf(buf, "%d\n", data->alarms);
 886}
 887
 888static ssize_t show_alarm(struct device *dev, struct device_attribute
 889			  *devattr, char *buf)
 890{
 891	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 892	struct lm90_data *data = lm90_update_device(dev);
 893	int bitnr = attr->index;
 894
 895	return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 896}
 897
 898static ssize_t show_update_interval(struct device *dev,
 899				    struct device_attribute *attr, char *buf)
 900{
 901	struct lm90_data *data = dev_get_drvdata(dev);
 902
 903	return sprintf(buf, "%u\n", data->update_interval);
 904}
 905
 906static ssize_t set_update_interval(struct device *dev,
 907				   struct device_attribute *attr,
 908				   const char *buf, size_t count)
 909{
 910	struct i2c_client *client = to_i2c_client(dev);
 911	struct lm90_data *data = i2c_get_clientdata(client);
 912	unsigned long val;
 913	int err;
 914
 915	err = strict_strtoul(buf, 10, &val);
 916	if (err)
 917		return err;
 918
 919	mutex_lock(&data->update_lock);
 920	lm90_set_convrate(client, data, val);
 921	mutex_unlock(&data->update_lock);
 922
 923	return count;
 924}
 925
 926static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp11, NULL, 0, 4);
 927static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp11, NULL, 0, 0);
 
 
 928static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
 929	set_temp8, 0);
 930static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
 931	set_temp11, 0, 1);
 932static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
 933	set_temp8, 1);
 934static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
 935	set_temp11, 1, 2);
 936static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
 937	set_temp8, 2);
 938static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
 939	set_temp8, 3);
 940static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
 941	set_temphyst, 2);
 942static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
 
 943static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
 944	set_temp11, 2, 3);
 945
 946/* Individual alarm files */
 947static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 0);
 948static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
 949static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
 950static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
 951static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
 952static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
 953static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
 954/* Raw alarm file for compatibility */
 955static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 956
 957static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
 958		   set_update_interval);
 959
 960static struct attribute *lm90_attributes[] = {
 961	&sensor_dev_attr_temp1_input.dev_attr.attr,
 962	&sensor_dev_attr_temp2_input.dev_attr.attr,
 963	&sensor_dev_attr_temp1_min.dev_attr.attr,
 964	&sensor_dev_attr_temp2_min.dev_attr.attr,
 965	&sensor_dev_attr_temp1_max.dev_attr.attr,
 966	&sensor_dev_attr_temp2_max.dev_attr.attr,
 967	&sensor_dev_attr_temp1_crit.dev_attr.attr,
 968	&sensor_dev_attr_temp2_crit.dev_attr.attr,
 969	&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 970	&sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 971
 972	&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 973	&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 974	&sensor_dev_attr_temp2_fault.dev_attr.attr,
 975	&sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 976	&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 977	&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 978	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 979	&dev_attr_alarms.attr,
 980	&dev_attr_update_interval.attr,
 981	NULL
 982};
 983
 984static const struct attribute_group lm90_group = {
 985	.attrs = lm90_attributes,
 986};
 987
 
 
 
 
 
 
 
 
 
 988/*
 989 * Additional attributes for devices with emergency sensors
 990 */
 991static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO, show_temp8,
 992	set_temp8, 4);
 993static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO, show_temp8,
 994	set_temp8, 5);
 995static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO, show_temphyst,
 996			  NULL, 4);
 997static SENSOR_DEVICE_ATTR(temp2_emergency_hyst, S_IRUGO, show_temphyst,
 998			  NULL, 5);
 999
1000static struct attribute *lm90_emergency_attributes[] = {
1001	&sensor_dev_attr_temp1_emergency.dev_attr.attr,
1002	&sensor_dev_attr_temp2_emergency.dev_attr.attr,
1003	&sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr,
1004	&sensor_dev_attr_temp2_emergency_hyst.dev_attr.attr,
1005	NULL
1006};
1007
1008static const struct attribute_group lm90_emergency_group = {
1009	.attrs = lm90_emergency_attributes,
1010};
1011
1012static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 15);
1013static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 13);
1014
1015static struct attribute *lm90_emergency_alarm_attributes[] = {
1016	&sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
1017	&sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
1018	NULL
1019};
1020
1021static const struct attribute_group lm90_emergency_alarm_group = {
1022	.attrs = lm90_emergency_alarm_attributes,
1023};
1024
1025/*
1026 * Additional attributes for devices with 3 temperature sensors
1027 */
1028static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp11, NULL, 0, 5);
 
1029static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp11,
1030	set_temp11, 3, 6);
1031static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp11,
1032	set_temp11, 4, 7);
1033static SENSOR_DEVICE_ATTR(temp3_crit, S_IWUSR | S_IRUGO, show_temp8,
1034	set_temp8, 6);
1035static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temphyst, NULL, 6);
 
1036static SENSOR_DEVICE_ATTR(temp3_emergency, S_IWUSR | S_IRUGO, show_temp8,
1037	set_temp8, 7);
1038static SENSOR_DEVICE_ATTR(temp3_emergency_hyst, S_IRUGO, show_temphyst,
1039			  NULL, 7);
1040
1041static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 9);
1042static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 10);
1043static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
1044static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 12);
1045static SENSOR_DEVICE_ATTR(temp3_emergency_alarm, S_IRUGO, show_alarm, NULL, 14);
1046
1047static struct attribute *lm90_temp3_attributes[] = {
1048	&sensor_dev_attr_temp3_input.dev_attr.attr,
1049	&sensor_dev_attr_temp3_min.dev_attr.attr,
1050	&sensor_dev_attr_temp3_max.dev_attr.attr,
1051	&sensor_dev_attr_temp3_crit.dev_attr.attr,
1052	&sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
1053	&sensor_dev_attr_temp3_emergency.dev_attr.attr,
1054	&sensor_dev_attr_temp3_emergency_hyst.dev_attr.attr,
1055
1056	&sensor_dev_attr_temp3_fault.dev_attr.attr,
1057	&sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
1058	&sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
1059	&sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
1060	&sensor_dev_attr_temp3_emergency_alarm.dev_attr.attr,
1061	NULL
1062};
1063
1064static const struct attribute_group lm90_temp3_group = {
1065	.attrs = lm90_temp3_attributes,
1066};
1067
1068/* pec used for ADM1032 only */
1069static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
1070			char *buf)
1071{
1072	struct i2c_client *client = to_i2c_client(dev);
1073	return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
1074}
1075
1076static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
1077		       const char *buf, size_t count)
1078{
1079	struct i2c_client *client = to_i2c_client(dev);
1080	long val;
1081	int err;
1082
1083	err = strict_strtol(buf, 10, &val);
1084	if (err < 0)
1085		return err;
1086
1087	switch (val) {
1088	case 0:
1089		client->flags &= ~I2C_CLIENT_PEC;
1090		break;
1091	case 1:
1092		client->flags |= I2C_CLIENT_PEC;
1093		break;
1094	default:
1095		return -EINVAL;
1096	}
1097
1098	return count;
1099}
1100
1101static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
1102
1103/*
1104 * Real code
1105 */
1106
1107/* Return 0 if detection is successful, -ENODEV otherwise */
1108static int lm90_detect(struct i2c_client *new_client,
1109		       struct i2c_board_info *info)
1110{
1111	struct i2c_adapter *adapter = new_client->adapter;
1112	int address = new_client->addr;
1113	const char *name = NULL;
1114	int man_id, chip_id, reg_config1, reg_config2, reg_convrate;
1115
1116	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1117		return -ENODEV;
1118
1119	/* detection and identification */
1120	if ((man_id = i2c_smbus_read_byte_data(new_client,
1121						LM90_REG_R_MAN_ID)) < 0
1122	 || (chip_id = i2c_smbus_read_byte_data(new_client,
1123						LM90_REG_R_CHIP_ID)) < 0
1124	 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
1125						LM90_REG_R_CONFIG1)) < 0
1126	 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
1127						LM90_REG_R_CONVRATE)) < 0)
1128		return -ENODEV;
1129
1130	if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) {
1131		reg_config2 = i2c_smbus_read_byte_data(new_client,
1132						LM90_REG_R_CONFIG2);
1133		if (reg_config2 < 0)
1134			return -ENODEV;
1135	} else
1136		reg_config2 = 0;	/* Make compiler happy */
1137
1138	if ((address == 0x4C || address == 0x4D)
1139	 && man_id == 0x01) { /* National Semiconductor */
1140		if ((reg_config1 & 0x2A) == 0x00
1141		 && (reg_config2 & 0xF8) == 0x00
1142		 && reg_convrate <= 0x09) {
1143			if (address == 0x4C
1144			 && (chip_id & 0xF0) == 0x20) { /* LM90 */
1145				name = "lm90";
1146			} else
1147			if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
1148				name = "lm99";
1149				dev_info(&adapter->dev,
1150					 "Assuming LM99 chip at 0x%02x\n",
1151					 address);
1152				dev_info(&adapter->dev,
1153					 "If it is an LM89, instantiate it "
1154					 "with the new_device sysfs "
1155					 "interface\n");
1156			} else
1157			if (address == 0x4C
1158			 && (chip_id & 0xF0) == 0x10) { /* LM86 */
1159				name = "lm86";
1160			}
1161		}
1162	} else
1163	if ((address == 0x4C || address == 0x4D)
1164	 && man_id == 0x41) { /* Analog Devices */
1165		if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
1166		 && (reg_config1 & 0x3F) == 0x00
1167		 && reg_convrate <= 0x0A) {
1168			name = "adm1032";
1169			/* The ADM1032 supports PEC, but only if combined
1170			   transactions are not used. */
 
 
1171			if (i2c_check_functionality(adapter,
1172						    I2C_FUNC_SMBUS_BYTE))
1173				info->flags |= I2C_CLIENT_PEC;
1174		} else
1175		if (chip_id == 0x51 /* ADT7461 */
1176		 && (reg_config1 & 0x1B) == 0x00
1177		 && reg_convrate <= 0x0A) {
1178			name = "adt7461";
1179		} else
1180		if (chip_id == 0x57 /* ADT7461A, NCT1008 */
1181		 && (reg_config1 & 0x1B) == 0x00
1182		 && reg_convrate <= 0x0A) {
1183			name = "adt7461a";
1184		}
1185	} else
1186	if (man_id == 0x4D) { /* Maxim */
1187		int reg_emerg, reg_emerg2, reg_status2;
1188
1189		/*
1190		 * We read MAX6659_REG_R_REMOTE_EMERG twice, and re-read
1191		 * LM90_REG_R_MAN_ID in between. If MAX6659_REG_R_REMOTE_EMERG
1192		 * exists, both readings will reflect the same value. Otherwise,
1193		 * the readings will be different.
1194		 */
1195		if ((reg_emerg = i2c_smbus_read_byte_data(new_client,
1196						MAX6659_REG_R_REMOTE_EMERG)) < 0
1197		 || i2c_smbus_read_byte_data(new_client, LM90_REG_R_MAN_ID) < 0
1198		 || (reg_emerg2 = i2c_smbus_read_byte_data(new_client,
1199						MAX6659_REG_R_REMOTE_EMERG)) < 0
1200		 || (reg_status2 = i2c_smbus_read_byte_data(new_client,
1201						MAX6696_REG_R_STATUS2)) < 0)
 
 
1202			return -ENODEV;
1203
1204		/*
1205		 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
1206		 * register. Reading from that address will return the last
1207		 * read value, which in our case is those of the man_id
1208		 * register. Likewise, the config1 register seems to lack a
1209		 * low nibble, so the value will be those of the previous
1210		 * read, so in our case those of the man_id register.
1211		 * MAX6659 has a third set of upper temperature limit registers.
1212		 * Those registers also return values on MAX6657 and MAX6658,
1213		 * thus the only way to detect MAX6659 is by its address.
1214		 * For this reason it will be mis-detected as MAX6657 if its
1215		 * address is 0x4C.
1216		 */
1217		if (chip_id == man_id
1218		 && (address == 0x4C || address == 0x4D || address == 0x4E)
1219		 && (reg_config1 & 0x1F) == (man_id & 0x0F)
1220		 && reg_convrate <= 0x09) {
1221			if (address == 0x4C)
1222				name = "max6657";
1223			else
1224				name = "max6659";
1225		} else
1226		/*
1227		 * Even though MAX6695 and MAX6696 do not have a chip ID
1228		 * register, reading it returns 0x01. Bit 4 of the config1
1229		 * register is unused and should return zero when read. Bit 0 of
1230		 * the status2 register is unused and should return zero when
1231		 * read.
1232		 *
1233		 * MAX6695 and MAX6696 have an additional set of temperature
1234		 * limit registers. We can detect those chips by checking if
1235		 * one of those registers exists.
1236		 */
1237		if (chip_id == 0x01
1238		 && (reg_config1 & 0x10) == 0x00
1239		 && (reg_status2 & 0x01) == 0x00
1240		 && reg_emerg == reg_emerg2
1241		 && reg_convrate <= 0x07) {
1242			name = "max6696";
1243		} else
1244		/*
1245		 * The chip_id register of the MAX6680 and MAX6681 holds the
1246		 * revision of the chip. The lowest bit of the config1 register
1247		 * is unused and should return zero when read, so should the
1248		 * second to last bit of config1 (software reset).
1249		 */
1250		if (chip_id == 0x01
1251		 && (reg_config1 & 0x03) == 0x00
1252		 && reg_convrate <= 0x07) {
1253			name = "max6680";
1254		} else
1255		/*
1256		 * The chip_id register of the MAX6646/6647/6649 holds the
1257		 * revision of the chip. The lowest 6 bits of the config1
1258		 * register are unused and should return zero when read.
1259		 */
1260		if (chip_id == 0x59
1261		 && (reg_config1 & 0x3f) == 0x00
1262		 && reg_convrate <= 0x07) {
1263			name = "max6646";
1264		}
1265	} else
1266	if (address == 0x4C
1267	 && man_id == 0x5C) { /* Winbond/Nuvoton */
1268		if ((reg_config1 & 0x2A) == 0x00
1269		 && (reg_config2 & 0xF8) == 0x00) {
1270			if (chip_id == 0x01 /* W83L771W/G */
1271			 && reg_convrate <= 0x09) {
1272				name = "w83l771";
1273			} else
1274			if ((chip_id & 0xFE) == 0x10 /* W83L771AWG/ASG */
1275			 && reg_convrate <= 0x08) {
1276				name = "w83l771";
1277			}
1278		}
1279	} else
1280	if (address >= 0x48 && address <= 0x4F
1281	 && man_id == 0xA1) { /*  NXP Semiconductor/Philips */
1282		if (chip_id == 0x00
1283		 && (reg_config1 & 0x2A) == 0x00
1284		 && (reg_config2 & 0xFE) == 0x00
1285		 && reg_convrate <= 0x09) {
1286			name = "sa56004";
1287		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1288	}
1289
1290	if (!name) { /* identification failed */
1291		dev_dbg(&adapter->dev,
1292			"Unsupported chip at 0x%02x (man_id=0x%02X, "
1293			"chip_id=0x%02X)\n", address, man_id, chip_id);
1294		return -ENODEV;
1295	}
1296
1297	strlcpy(info->type, name, I2C_NAME_SIZE);
1298
1299	return 0;
1300}
1301
1302static void lm90_remove_files(struct i2c_client *client, struct lm90_data *data)
1303{
1304	if (data->flags & LM90_HAVE_TEMP3)
1305		sysfs_remove_group(&client->dev.kobj, &lm90_temp3_group);
1306	if (data->flags & LM90_HAVE_EMERGENCY_ALARM)
1307		sysfs_remove_group(&client->dev.kobj,
1308				   &lm90_emergency_alarm_group);
1309	if (data->flags & LM90_HAVE_EMERGENCY)
1310		sysfs_remove_group(&client->dev.kobj,
1311				   &lm90_emergency_group);
1312	if (data->flags & LM90_HAVE_OFFSET)
1313		device_remove_file(&client->dev,
1314				   &sensor_dev_attr_temp2_offset.dev_attr);
1315	device_remove_file(&client->dev, &dev_attr_pec);
1316	sysfs_remove_group(&client->dev.kobj, &lm90_group);
1317}
1318
1319static void lm90_init_client(struct i2c_client *client)
1320{
1321	u8 config, convrate;
1322	struct lm90_data *data = i2c_get_clientdata(client);
1323
1324	if (lm90_read_reg(client, LM90_REG_R_CONVRATE, &convrate) < 0) {
1325		dev_warn(&client->dev, "Failed to read convrate register!\n");
1326		convrate = LM90_DEF_CONVRATE_RVAL;
1327	}
1328	data->convrate_orig = convrate;
1329
1330	/*
1331	 * Start the conversions.
1332	 */
1333	lm90_set_convrate(client, data, 500);	/* 500ms; 2Hz conversion rate */
1334	if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
1335		dev_warn(&client->dev, "Initialization failed!\n");
1336		return;
1337	}
1338	data->config_orig = config;
1339
1340	/* Check Temperature Range Select */
1341	if (data->kind == adt7461) {
1342		if (config & 0x04)
1343			data->flags |= LM90_FLAG_ADT7461_EXT;
1344	}
1345
1346	/*
1347	 * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
1348	 * 0.125 degree resolution) and range (0x08, extend range
1349	 * to -64 degree) mode for the remote temperature sensor.
1350	 */
1351	if (data->kind == max6680)
1352		config |= 0x18;
1353
1354	/*
1355	 * Select external channel 0 for max6695/96
1356	 */
1357	if (data->kind == max6696)
1358		config &= ~0x08;
1359
1360	config &= 0xBF;	/* run */
1361	if (config != data->config_orig) /* Only write if changed */
1362		i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1, config);
1363}
1364
1365static int lm90_probe(struct i2c_client *new_client,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1366		      const struct i2c_device_id *id)
1367{
1368	struct i2c_adapter *adapter = to_i2c_adapter(new_client->dev.parent);
 
1369	struct lm90_data *data;
 
 
1370	int err;
1371
1372	data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL);
1373	if (!data) {
1374		err = -ENOMEM;
1375		goto exit;
 
 
 
 
1376	}
1377	i2c_set_clientdata(new_client, data);
 
 
 
 
 
 
1378	mutex_init(&data->update_lock);
1379
 
 
1380	/* Set the device type */
1381	data->kind = id->driver_data;
1382	if (data->kind == adm1032) {
1383		if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
1384			new_client->flags &= ~I2C_CLIENT_PEC;
1385	}
1386
1387	/* Different devices have different alarm bits triggering the
1388	 * ALERT# output */
 
 
1389	data->alert_alarms = lm90_params[data->kind].alert_alarms;
1390
1391	/* Set chip capabilities */
1392	data->flags = lm90_params[data->kind].flags;
1393	data->reg_local_ext = lm90_params[data->kind].reg_local_ext;
1394
1395	/* Set maximum conversion rate */
1396	data->max_convrate = lm90_params[data->kind].max_convrate;
1397
1398	/* Initialize the LM90 chip */
1399	lm90_init_client(new_client);
1400
1401	/* Register sysfs hooks */
1402	err = sysfs_create_group(&new_client->dev.kobj, &lm90_group);
1403	if (err)
1404		goto exit_free;
1405	if (new_client->flags & I2C_CLIENT_PEC) {
1406		err = device_create_file(&new_client->dev, &dev_attr_pec);
1407		if (err)
1408			goto exit_remove_files;
1409	}
1410	if (data->flags & LM90_HAVE_OFFSET) {
1411		err = device_create_file(&new_client->dev,
1412					&sensor_dev_attr_temp2_offset.dev_attr);
1413		if (err)
1414			goto exit_remove_files;
1415	}
1416	if (data->flags & LM90_HAVE_EMERGENCY) {
1417		err = sysfs_create_group(&new_client->dev.kobj,
1418					 &lm90_emergency_group);
1419		if (err)
1420			goto exit_remove_files;
1421	}
1422	if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {
1423		err = sysfs_create_group(&new_client->dev.kobj,
1424					 &lm90_emergency_alarm_group);
1425		if (err)
1426			goto exit_remove_files;
1427	}
1428	if (data->flags & LM90_HAVE_TEMP3) {
1429		err = sysfs_create_group(&new_client->dev.kobj,
1430					 &lm90_temp3_group);
1431		if (err)
1432			goto exit_remove_files;
1433	}
1434
1435	data->hwmon_dev = hwmon_device_register(&new_client->dev);
 
1436	if (IS_ERR(data->hwmon_dev)) {
1437		err = PTR_ERR(data->hwmon_dev);
1438		goto exit_remove_files;
 
 
 
 
 
 
 
 
 
 
 
 
1439	}
1440
1441	return 0;
1442
1443exit_remove_files:
1444	lm90_remove_files(new_client, data);
1445exit_free:
1446	kfree(data);
1447exit:
 
 
 
1448	return err;
1449}
1450
1451static int lm90_remove(struct i2c_client *client)
1452{
1453	struct lm90_data *data = i2c_get_clientdata(client);
1454
1455	hwmon_device_unregister(data->hwmon_dev);
1456	lm90_remove_files(client, data);
1457
1458	/* Restore initial configuration */
1459	i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
1460				  data->convrate_orig);
1461	i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
1462				  data->config_orig);
1463
1464	kfree(data);
1465	return 0;
1466}
1467
1468static void lm90_alert(struct i2c_client *client, unsigned int flag)
1469{
1470	struct lm90_data *data = i2c_get_clientdata(client);
1471	u8 config, alarms, alarms2 = 0;
1472
1473	lm90_read_reg(client, LM90_REG_R_STATUS, &alarms);
1474
1475	if (data->kind == max6696)
1476		lm90_read_reg(client, MAX6696_REG_R_STATUS2, &alarms2);
 
 
 
 
 
1477
1478	if ((alarms & 0x7f) == 0 && (alarms2 & 0xfe) == 0) {
1479		dev_info(&client->dev, "Everything OK\n");
1480	} else {
1481		if (alarms & 0x61)
1482			dev_warn(&client->dev,
1483				 "temp%d out of range, please check!\n", 1);
1484		if (alarms & 0x1a)
1485			dev_warn(&client->dev,
1486				 "temp%d out of range, please check!\n", 2);
1487		if (alarms & 0x04)
1488			dev_warn(&client->dev,
1489				 "temp%d diode open, please check!\n", 2);
1490
1491		if (alarms2 & 0x18)
1492			dev_warn(&client->dev,
1493				 "temp%d out of range, please check!\n", 3);
1494
1495		/* Disable ALERT# output, because these chips don't implement
1496		  SMBus alert correctly; they should only hold the alert line
1497		  low briefly. */
1498		if ((data->flags & LM90_HAVE_BROKEN_ALERT)
1499		 && (alarms & data->alert_alarms)) {
 
1500			dev_dbg(&client->dev, "Disabling ALERT#\n");
1501			lm90_read_reg(client, LM90_REG_R_CONFIG1, &config);
1502			i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
1503						  config | 0x80);
1504		}
 
 
1505	}
1506}
1507
1508static struct i2c_driver lm90_driver = {
1509	.class		= I2C_CLASS_HWMON,
1510	.driver = {
1511		.name	= "lm90",
1512	},
1513	.probe		= lm90_probe,
1514	.remove		= lm90_remove,
1515	.alert		= lm90_alert,
1516	.id_table	= lm90_id,
1517	.detect		= lm90_detect,
1518	.address_list	= normal_i2c,
1519};
1520
1521static int __init sensors_lm90_init(void)
1522{
1523	return i2c_add_driver(&lm90_driver);
1524}
1525
1526static void __exit sensors_lm90_exit(void)
1527{
1528	i2c_del_driver(&lm90_driver);
1529}
1530
1531MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1532MODULE_DESCRIPTION("LM90/ADM1032 driver");
1533MODULE_LICENSE("GPL");
1534
1535module_init(sensors_lm90_init);
1536module_exit(sensors_lm90_exit);