1/*
   2 * A hwmon driver for the Analog Devices ADT7462
   3 * Copyright (C) 2008 IBM
   4 *
   5 * Author: Darrick J. Wong <djwong@us.ibm.com>
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 2 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20 */
  21
  22#include <linux/module.h>
  23#include <linux/jiffies.h>
  24#include <linux/i2c.h>
  25#include <linux/hwmon.h>
  26#include <linux/hwmon-sysfs.h>
  27#include <linux/err.h>
  28#include <linux/mutex.h>
  29#include <linux/delay.h>
  30#include <linux/log2.h>
  31#include <linux/slab.h>
  32
  33/* Addresses to scan */
  34static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
  35
  36/* ADT7462 registers */
  37#define ADT7462_REG_DEVICE			0x3D
  38#define ADT7462_REG_VENDOR			0x3E
  39#define ADT7462_REG_REVISION			0x3F
  40
  41#define ADT7462_REG_MIN_TEMP_BASE_ADDR		0x44
  42#define ADT7462_REG_MIN_TEMP_MAX_ADDR		0x47
  43#define ADT7462_REG_MAX_TEMP_BASE_ADDR		0x48
  44#define ADT7462_REG_MAX_TEMP_MAX_ADDR		0x4B
  45#define ADT7462_REG_TEMP_BASE_ADDR		0x88
  46#define ADT7462_REG_TEMP_MAX_ADDR		0x8F
  47
  48#define ADT7462_REG_FAN_BASE_ADDR		0x98
  49#define ADT7462_REG_FAN_MAX_ADDR		0x9F
  50#define ADT7462_REG_FAN2_BASE_ADDR		0xA2
  51#define ADT7462_REG_FAN2_MAX_ADDR		0xA9
  52#define ADT7462_REG_FAN_ENABLE			0x07
  53#define ADT7462_REG_FAN_MIN_BASE_ADDR		0x78
  54#define ADT7462_REG_FAN_MIN_MAX_ADDR		0x7F
  55
  56#define ADT7462_REG_CFG2			0x02
  57#define		ADT7462_FSPD_MASK		0x20
  58
  59#define ADT7462_REG_PWM_BASE_ADDR		0xAA
  60#define ADT7462_REG_PWM_MAX_ADDR		0xAD
  61#define	ADT7462_REG_PWM_MIN_BASE_ADDR		0x28
  62#define ADT7462_REG_PWM_MIN_MAX_ADDR		0x2B
  63#define ADT7462_REG_PWM_MAX			0x2C
  64#define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR	0x5C
  65#define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR	0x5F
  66#define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR	0x60
  67#define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR	0x63
  68#define 	ADT7462_PWM_HYST_MASK		0x0F
  69#define 	ADT7462_PWM_RANGE_MASK		0xF0
  70#define		ADT7462_PWM_RANGE_SHIFT		4
  71#define ADT7462_REG_PWM_CFG_BASE_ADDR		0x21
  72#define ADT7462_REG_PWM_CFG_MAX_ADDR		0x24
  73#define		ADT7462_PWM_CHANNEL_MASK	0xE0
  74#define		ADT7462_PWM_CHANNEL_SHIFT	5
  75
  76#define ADT7462_REG_PIN_CFG_BASE_ADDR		0x10
  77#define ADT7462_REG_PIN_CFG_MAX_ADDR		0x13
  78#define		ADT7462_PIN7_INPUT		0x01	/* cfg0 */
  79#define		ADT7462_DIODE3_INPUT		0x20
  80#define		ADT7462_DIODE1_INPUT		0x40
  81#define		ADT7462_VID_INPUT		0x80
  82#define		ADT7462_PIN22_INPUT		0x04	/* cfg1 */
  83#define		ADT7462_PIN21_INPUT		0x08
  84#define		ADT7462_PIN19_INPUT		0x10
  85#define		ADT7462_PIN15_INPUT		0x20
  86#define		ADT7462_PIN13_INPUT		0x40
  87#define		ADT7462_PIN8_INPUT		0x80
  88#define 	ADT7462_PIN23_MASK		0x03
  89#define		ADT7462_PIN23_SHIFT		0
  90#define		ADT7462_PIN26_MASK		0x0C	/* cfg2 */
  91#define		ADT7462_PIN26_SHIFT		2
  92#define		ADT7462_PIN25_MASK		0x30
  93#define		ADT7462_PIN25_SHIFT		4
  94#define		ADT7462_PIN24_MASK		0xC0
  95#define		ADT7462_PIN24_SHIFT		6
  96#define		ADT7462_PIN26_VOLT_INPUT	0x08
  97#define		ADT7462_PIN25_VOLT_INPUT	0x20
  98#define		ADT7462_PIN28_SHIFT		4	/* cfg3 */
  99#define		ADT7462_PIN28_VOLT		0x5
 100
 101#define ADT7462_REG_ALARM1			0xB8
 102#define 	ADT7462_LT_ALARM		0x02
 103#define		ADT7462_R1T_ALARM		0x04
 104#define		ADT7462_R2T_ALARM		0x08
 105#define		ADT7462_R3T_ALARM		0x10
 106#define ADT7462_REG_ALARM2			0xBB
 107#define		ADT7462_V0_ALARM		0x01
 108#define		ADT7462_V1_ALARM		0x02
 109#define		ADT7462_V2_ALARM		0x04
 110#define		ADT7462_V3_ALARM		0x08
 111#define		ADT7462_V4_ALARM		0x10
 112#define		ADT7462_V5_ALARM		0x20
 113#define		ADT7462_V6_ALARM		0x40
 114#define		ADT7462_V7_ALARM		0x80
 115#define ADT7462_REG_ALARM3			0xBC
 116#define		ADT7462_V8_ALARM		0x08
 117#define		ADT7462_V9_ALARM		0x10
 118#define		ADT7462_V10_ALARM		0x20
 119#define		ADT7462_V11_ALARM		0x40
 120#define		ADT7462_V12_ALARM		0x80
 121#define ADT7462_REG_ALARM4			0xBD
 122#define		ADT7462_F0_ALARM		0x01
 123#define		ADT7462_F1_ALARM		0x02
 124#define		ADT7462_F2_ALARM		0x04
 125#define		ADT7462_F3_ALARM		0x08
 126#define		ADT7462_F4_ALARM		0x10
 127#define		ADT7462_F5_ALARM		0x20
 128#define		ADT7462_F6_ALARM		0x40
 129#define		ADT7462_F7_ALARM		0x80
 130#define ADT7462_ALARM1				0x0000
 131#define ADT7462_ALARM2				0x0100
 132#define ADT7462_ALARM3				0x0200
 133#define ADT7462_ALARM4				0x0300
 134#define ADT7462_ALARM_REG_SHIFT			8
 135#define ADT7462_ALARM_FLAG_MASK			0x0F
 136
 137#define ADT7462_TEMP_COUNT		4
 138#define ADT7462_TEMP_REG(x)		(ADT7462_REG_TEMP_BASE_ADDR + (x * 2))
 139#define ADT7462_TEMP_MIN_REG(x) 	(ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
 140#define ADT7462_TEMP_MAX_REG(x) 	(ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
 141#define TEMP_FRAC_OFFSET		6
 142
 143#define ADT7462_FAN_COUNT		8
 144#define ADT7462_REG_FAN_MIN(x)		(ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
 145
 146#define ADT7462_PWM_COUNT		4
 147#define ADT7462_REG_PWM(x)		(ADT7462_REG_PWM_BASE_ADDR + (x))
 148#define ADT7462_REG_PWM_MIN(x)		(ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
 149#define ADT7462_REG_PWM_TMIN(x)		\
 150	(ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
 151#define ADT7462_REG_PWM_TRANGE(x)	\
 152	(ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
 153
 154#define ADT7462_PIN_CFG_REG_COUNT	4
 155#define ADT7462_REG_PIN_CFG(x)		(ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
 156#define ADT7462_REG_PWM_CFG(x)		(ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
 157
 158#define ADT7462_ALARM_REG_COUNT		4
 159
 160/*
 161 * The chip can measure 13 different voltage sources:
 162 *
 163 * 1. +12V1 (pin 7)
 164 * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
 165 * 3. +12V3 (pin 22)
 166 * 4. +5V (pin 21)
 167 * 5. +1.25V/+0.9V (pin 19)
 168 * 6. +2.5V/+1.8V (pin 15)
 169 * 7. +3.3v (pin 13)
 170 * 8. +12V2 (pin 8)
 171 * 9. Vbatt/FSB_Vtt (pin 26)
 172 * A. +3.3V/+1.2V1 (pin 25)
 173 * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
 174 * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
 175 * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
 176 *
 177 * Each of these 13 has a factor to convert raw to voltage.  Even better,
 178 * the pins can be connected to other sensors (tach/gpio/hot/etc), which
 179 * makes the bookkeeping tricky.
 180 *
 181 * Some, but not all, of these voltages have low/high limits.
 182 */
 183#define ADT7462_VOLT_COUNT	13
 184
 185#define ADT7462_VENDOR		0x41
 186#define ADT7462_DEVICE		0x62
 187/* datasheet only mentions a revision 4 */
 188#define ADT7462_REVISION	0x04
 189
 190/* How often do we reread sensors values? (In jiffies) */
 191#define SENSOR_REFRESH_INTERVAL	(2 * HZ)
 192
 193/* How often do we reread sensor limit values? (In jiffies) */
 194#define LIMIT_REFRESH_INTERVAL	(60 * HZ)
 195
 196/* datasheet says to divide this number by the fan reading to get fan rpm */
 197#define FAN_PERIOD_TO_RPM(x)	((90000 * 60) / (x))
 198#define FAN_RPM_TO_PERIOD	FAN_PERIOD_TO_RPM
 199#define FAN_PERIOD_INVALID	65535
 200#define FAN_DATA_VALID(x)	((x) && (x) != FAN_PERIOD_INVALID)
 201
 202#define MASK_AND_SHIFT(value, prefix)	\
 203	(((value) & prefix##_MASK) >> prefix##_SHIFT)
 204
 205struct adt7462_data {
 206	struct device		*hwmon_dev;
 207	struct attribute_group	attrs;
 208	struct mutex		lock;
 209	char			sensors_valid;
 210	char			limits_valid;
 211	unsigned long		sensors_last_updated;	/* In jiffies */
 212	unsigned long		limits_last_updated;	/* In jiffies */
 213
 214	u8			temp[ADT7462_TEMP_COUNT];
 215				/* bits 6-7 are quarter pieces of temp */
 216	u8			temp_frac[ADT7462_TEMP_COUNT];
 217	u8			temp_min[ADT7462_TEMP_COUNT];
 218	u8			temp_max[ADT7462_TEMP_COUNT];
 219	u16			fan[ADT7462_FAN_COUNT];
 220	u8			fan_enabled;
 221	u8			fan_min[ADT7462_FAN_COUNT];
 222	u8			cfg2;
 223	u8			pwm[ADT7462_PWM_COUNT];
 224	u8			pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
 225	u8			voltages[ADT7462_VOLT_COUNT];
 226	u8			volt_max[ADT7462_VOLT_COUNT];
 227	u8			volt_min[ADT7462_VOLT_COUNT];
 228	u8			pwm_min[ADT7462_PWM_COUNT];
 229	u8			pwm_tmin[ADT7462_PWM_COUNT];
 230	u8			pwm_trange[ADT7462_PWM_COUNT];
 231	u8			pwm_max;	/* only one per chip */
 232	u8			pwm_cfg[ADT7462_PWM_COUNT];
 233	u8			alarms[ADT7462_ALARM_REG_COUNT];
 234};
 235
 236static int adt7462_probe(struct i2c_client *client,
 237			 const struct i2c_device_id *id);
 238static int adt7462_detect(struct i2c_client *client,
 239			  struct i2c_board_info *info);
 240static int adt7462_remove(struct i2c_client *client);
 241
 242static const struct i2c_device_id adt7462_id[] = {
 243	{ "adt7462", 0 },
 244	{ }
 245};
 246MODULE_DEVICE_TABLE(i2c, adt7462_id);
 247
 248static struct i2c_driver adt7462_driver = {
 249	.class		= I2C_CLASS_HWMON,
 250	.driver = {
 251		.name	= "adt7462",
 252	},
 253	.probe		= adt7462_probe,
 254	.remove		= adt7462_remove,
 255	.id_table	= adt7462_id,
 256	.detect		= adt7462_detect,
 257	.address_list	= normal_i2c,
 258};
 259
 260/*
 261 * 16-bit registers on the ADT7462 are low-byte first.  The data sheet says
 262 * that the low byte must be read before the high byte.
 263 */
 264static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
 265{
 266	u16 foo;
 267	foo = i2c_smbus_read_byte_data(client, reg);
 268	foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
 269	return foo;
 270}
 271
 272/* For some reason these registers are not contiguous. */
 273static int ADT7462_REG_FAN(int fan)
 274{
 275	if (fan < 4)
 276		return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
 277	return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
 278}
 279
 280/* Voltage registers are scattered everywhere */
 281static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
 282{
 283	switch (which) {
 284	case 0:
 285		if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 286			return 0x7C;
 287		break;
 288	case 1:
 289		return 0x69;
 290	case 2:
 291		if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 292			return 0x7F;
 293		break;
 294	case 3:
 295		if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 296			return 0x7E;
 297		break;
 298	case 4:
 299		if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 300			return 0x4B;
 301		break;
 302	case 5:
 303		if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 304			return 0x49;
 305		break;
 306	case 6:
 307		if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 308			return 0x68;
 309		break;
 310	case 7:
 311		if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 312			return 0x7D;
 313		break;
 314	case 8:
 315		if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 316			return 0x6C;
 317		break;
 318	case 9:
 319		if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 320			return 0x6B;
 321		break;
 322	case 10:
 323		return 0x6A;
 324	case 11:
 325		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 326					ADT7462_PIN28_VOLT &&
 327		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 328			return 0x50;
 329		break;
 330	case 12:
 331		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 332					ADT7462_PIN28_VOLT &&
 333		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 334			return 0x4C;
 335		break;
 336	}
 337	return -ENODEV;
 338}
 339
 340static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
 341{
 342	switch (which) {
 343	case 0:
 344		if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 345			return 0x6D;
 346		break;
 347	case 1:
 348		return 0x72;
 349	case 2:
 350		if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 351			return 0x6F;
 352		break;
 353	case 3:
 354		if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 355			return 0x71;
 356		break;
 357	case 4:
 358		if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 359			return 0x47;
 360		break;
 361	case 5:
 362		if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 363			return 0x45;
 364		break;
 365	case 6:
 366		if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 367			return 0x70;
 368		break;
 369	case 7:
 370		if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 371			return 0x6E;
 372		break;
 373	case 8:
 374		if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 375			return 0x75;
 376		break;
 377	case 9:
 378		if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 379			return 0x74;
 380		break;
 381	case 10:
 382		return 0x73;
 383	case 11:
 384		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 385					ADT7462_PIN28_VOLT &&
 386		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 387			return 0x76;
 388		break;
 389	case 12:
 390		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 391					ADT7462_PIN28_VOLT &&
 392		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 393			return 0x77;
 394		break;
 395	}
 396	return -ENODEV;
 397}
 398
 399static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
 400{
 401	switch (which) {
 402	case 0:
 403		if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 404			return 0xA3;
 405		break;
 406	case 1:
 407		return 0x90;
 408	case 2:
 409		if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 410			return 0xA9;
 411		break;
 412	case 3:
 413		if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 414			return 0xA7;
 415		break;
 416	case 4:
 417		if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
 418			return 0x8F;
 419		break;
 420	case 5:
 421		if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
 422			return 0x8B;
 423		break;
 424	case 6:
 425		if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 426			return 0x96;
 427		break;
 428	case 7:
 429		if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 430			return 0xA5;
 431		break;
 432	case 8:
 433		if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
 434			return 0x93;
 435		break;
 436	case 9:
 437		if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
 438			return 0x92;
 439		break;
 440	case 10:
 441		return 0x91;
 442	case 11:
 443		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 444					ADT7462_PIN28_VOLT &&
 445		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 446			return 0x94;
 447		break;
 448	case 12:
 449		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 450					ADT7462_PIN28_VOLT &&
 451		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 452			return 0x95;
 453		break;
 454	}
 455	return -ENODEV;
 456}
 457
 458/* Provide labels for sysfs */
 459static const char *voltage_label(struct adt7462_data *data, int which)
 460{
 461	switch (which) {
 462	case 0:
 463		if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 464			return "+12V1";
 465		break;
 466	case 1:
 467		switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
 468		case 0:
 469			return "Vccp1";
 470		case 1:
 471			return "+2.5V";
 472		case 2:
 473			return "+1.8V";
 474		case 3:
 475			return "+1.5V";
 476		}
 
 477	case 2:
 478		if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 479			return "+12V3";
 480		break;
 481	case 3:
 482		if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 483			return "+5V";
 484		break;
 485	case 4:
 486		if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
 487			if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 488				return "+0.9V";
 489			return "+1.25V";
 490		}
 491		break;
 492	case 5:
 493		if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
 494			if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 495				return "+1.8V";
 496			return "+2.5V";
 497		}
 498		break;
 499	case 6:
 500		if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 501			return "+3.3V";
 502		break;
 503	case 7:
 504		if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 505			return "+12V2";
 506		break;
 507	case 8:
 508		switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
 509		case 0:
 510			return "Vbatt";
 511		case 1:
 512			return "FSB_Vtt";
 513		}
 514		break;
 515	case 9:
 516		switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
 517		case 0:
 518			return "+3.3V";
 519		case 1:
 520			return "+1.2V1";
 521		}
 522		break;
 523	case 10:
 524		switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
 525		case 0:
 526			return "Vccp2";
 527		case 1:
 528			return "+2.5V";
 529		case 2:
 530			return "+1.8V";
 531		case 3:
 532			return "+1.5";
 533		}
 
 534	case 11:
 535		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 536					ADT7462_PIN28_VOLT &&
 537		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 538			return "+1.5V ICH";
 539		break;
 540	case 12:
 541		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 542					ADT7462_PIN28_VOLT &&
 543		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 544			return "+1.5V 3GPIO";
 545		break;
 546	}
 547	return "N/A";
 548}
 549
 550/* Multipliers are actually in uV, not mV. */
 551static int voltage_multiplier(struct adt7462_data *data, int which)
 552{
 553	switch (which) {
 554	case 0:
 555		if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
 556			return 62500;
 557		break;
 558	case 1:
 559		switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
 560		case 0:
 561			if (data->pin_cfg[0] & ADT7462_VID_INPUT)
 562				return 12500;
 563			return 6250;
 564		case 1:
 565			return 13000;
 566		case 2:
 567			return 9400;
 568		case 3:
 569			return 7800;
 570		}
 
 571	case 2:
 572		if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
 573			return 62500;
 574		break;
 575	case 3:
 576		if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
 577			return 26000;
 578		break;
 579	case 4:
 580		if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
 581			if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
 582				return 4690;
 583			return 6500;
 584		}
 585		break;
 586	case 5:
 587		if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
 588			if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
 589				return 9400;
 590			return 13000;
 591		}
 592		break;
 593	case 6:
 594		if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
 595			return 17200;
 596		break;
 597	case 7:
 598		if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
 599			return 62500;
 600		break;
 601	case 8:
 602		switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
 603		case 0:
 604			return 15600;
 605		case 1:
 606			return 6250;
 607		}
 608		break;
 609	case 9:
 610		switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
 611		case 0:
 612			return 17200;
 613		case 1:
 614			return 6250;
 615		}
 616		break;
 617	case 10:
 618		switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
 619		case 0:
 620			return 6250;
 621		case 1:
 622			return 13000;
 623		case 2:
 624			return 9400;
 625		case 3:
 626			return 7800;
 627		}
 
 628	case 11:
 629	case 12:
 630		if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
 631					ADT7462_PIN28_VOLT &&
 632		    !(data->pin_cfg[0] & ADT7462_VID_INPUT))
 633			return 7800;
 634	}
 635	return 0;
 636}
 637
 638static int temp_enabled(struct adt7462_data *data, int which)
 639{
 640	switch (which) {
 641	case 0:
 642	case 2:
 643		return 1;
 644	case 1:
 645		if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
 646			return 1;
 647		break;
 648	case 3:
 649		if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
 650			return 1;
 651		break;
 652	}
 653	return 0;
 654}
 655
 656static const char *temp_label(struct adt7462_data *data, int which)
 657{
 658	switch (which) {
 659	case 0:
 660		return "local";
 661	case 1:
 662		if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
 663			return "remote1";
 664		break;
 665	case 2:
 666		return "remote2";
 667	case 3:
 668		if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
 669			return "remote3";
 670		break;
 671	}
 672	return "N/A";
 673}
 674
 675/* Map Trange register values to mC */
 676#define NUM_TRANGE_VALUES	16
 677static const int trange_values[NUM_TRANGE_VALUES] = {
 678	2000,
 679	2500,
 680	3300,
 681	4000,
 682	5000,
 683	6700,
 684	8000,
 685	10000,
 686	13300,
 687	16000,
 688	20000,
 689	26700,
 690	32000,
 691	40000,
 692	53300,
 693	80000
 694};
 695
 696static int find_trange_value(int trange)
 697{
 698	int i;
 699
 700	for (i = 0; i < NUM_TRANGE_VALUES; i++)
 701		if (trange_values[i] == trange)
 702			return i;
 703
 704	return -ENODEV;
 705}
 706
 707static struct adt7462_data *adt7462_update_device(struct device *dev)
 708{
 709	struct i2c_client *client = to_i2c_client(dev);
 710	struct adt7462_data *data = i2c_get_clientdata(client);
 711	unsigned long local_jiffies = jiffies;
 712	int i;
 713
 714	mutex_lock(&data->lock);
 715	if (time_before(local_jiffies, data->sensors_last_updated +
 716		SENSOR_REFRESH_INTERVAL)
 717		&& data->sensors_valid)
 718		goto no_sensor_update;
 719
 720	for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
 721		/*
 722		 * Reading the fractional register locks the integral
 723		 * register until both have been read.
 724		 */
 725		data->temp_frac[i] = i2c_smbus_read_byte_data(client,
 726						ADT7462_TEMP_REG(i));
 727		data->temp[i] = i2c_smbus_read_byte_data(client,
 728						ADT7462_TEMP_REG(i) + 1);
 729	}
 730
 731	for (i = 0; i < ADT7462_FAN_COUNT; i++)
 732		data->fan[i] = adt7462_read_word_data(client,
 733						ADT7462_REG_FAN(i));
 734
 735	data->fan_enabled = i2c_smbus_read_byte_data(client,
 736					ADT7462_REG_FAN_ENABLE);
 737
 738	for (i = 0; i < ADT7462_PWM_COUNT; i++)
 739		data->pwm[i] = i2c_smbus_read_byte_data(client,
 740						ADT7462_REG_PWM(i));
 741
 742	for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
 743		data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
 744				ADT7462_REG_PIN_CFG(i));
 745
 746	for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
 747		int reg = ADT7462_REG_VOLT(data, i);
 748		if (!reg)
 749			data->voltages[i] = 0;
 750		else
 751			data->voltages[i] = i2c_smbus_read_byte_data(client,
 752								     reg);
 753	}
 754
 755	data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
 756	data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
 757	data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
 758	data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
 759
 760	data->sensors_last_updated = local_jiffies;
 761	data->sensors_valid = 1;
 762
 763no_sensor_update:
 764	if (time_before(local_jiffies, data->limits_last_updated +
 765		LIMIT_REFRESH_INTERVAL)
 766		&& data->limits_valid)
 767		goto out;
 768
 769	for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
 770		data->temp_min[i] = i2c_smbus_read_byte_data(client,
 771						ADT7462_TEMP_MIN_REG(i));
 772		data->temp_max[i] = i2c_smbus_read_byte_data(client,
 773						ADT7462_TEMP_MAX_REG(i));
 774	}
 775
 776	for (i = 0; i < ADT7462_FAN_COUNT; i++)
 777		data->fan_min[i] = i2c_smbus_read_byte_data(client,
 778						ADT7462_REG_FAN_MIN(i));
 779
 780	for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
 781		int reg = ADT7462_REG_VOLT_MAX(data, i);
 782		data->volt_max[i] =
 783			(reg ? i2c_smbus_read_byte_data(client, reg) : 0);
 784
 785		reg = ADT7462_REG_VOLT_MIN(data, i);
 786		data->volt_min[i] =
 787			(reg ? i2c_smbus_read_byte_data(client, reg) : 0);
 788	}
 789
 790	for (i = 0; i < ADT7462_PWM_COUNT; i++) {
 791		data->pwm_min[i] = i2c_smbus_read_byte_data(client,
 792						ADT7462_REG_PWM_MIN(i));
 793		data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
 794						ADT7462_REG_PWM_TMIN(i));
 795		data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
 796						ADT7462_REG_PWM_TRANGE(i));
 797		data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
 798						ADT7462_REG_PWM_CFG(i));
 799	}
 800
 801	data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
 802
 803	data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
 804
 805	data->limits_last_updated = local_jiffies;
 806	data->limits_valid = 1;
 807
 808out:
 809	mutex_unlock(&data->lock);
 810	return data;
 811}
 812
 813static ssize_t show_temp_min(struct device *dev,
 814			     struct device_attribute *devattr,
 815			     char *buf)
 816{
 817	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 818	struct adt7462_data *data = adt7462_update_device(dev);
 819
 820	if (!temp_enabled(data, attr->index))
 821		return sprintf(buf, "0\n");
 822
 823	return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
 824}
 825
 826static ssize_t set_temp_min(struct device *dev,
 827			    struct device_attribute *devattr,
 828			    const char *buf,
 829			    size_t count)
 830{
 831	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 832	struct i2c_client *client = to_i2c_client(dev);
 833	struct adt7462_data *data = i2c_get_clientdata(client);
 834	long temp;
 835
 836	if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
 837		return -EINVAL;
 838
 
 839	temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
 840	temp = SENSORS_LIMIT(temp, 0, 255);
 841
 842	mutex_lock(&data->lock);
 843	data->temp_min[attr->index] = temp;
 844	i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
 845				  temp);
 846	mutex_unlock(&data->lock);
 847
 848	return count;
 849}
 850
 851static ssize_t show_temp_max(struct device *dev,
 852			     struct device_attribute *devattr,
 853			     char *buf)
 854{
 855	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 856	struct adt7462_data *data = adt7462_update_device(dev);
 857
 858	if (!temp_enabled(data, attr->index))
 859		return sprintf(buf, "0\n");
 860
 861	return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
 862}
 863
 864static ssize_t set_temp_max(struct device *dev,
 865			    struct device_attribute *devattr,
 866			    const char *buf,
 867			    size_t count)
 868{
 869	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 870	struct i2c_client *client = to_i2c_client(dev);
 871	struct adt7462_data *data = i2c_get_clientdata(client);
 872	long temp;
 873
 874	if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
 875		return -EINVAL;
 876
 
 877	temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
 878	temp = SENSORS_LIMIT(temp, 0, 255);
 879
 880	mutex_lock(&data->lock);
 881	data->temp_max[attr->index] = temp;
 882	i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
 883				  temp);
 884	mutex_unlock(&data->lock);
 885
 886	return count;
 887}
 888
 889static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
 890			 char *buf)
 891{
 892	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 893	struct adt7462_data *data = adt7462_update_device(dev);
 894	u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
 895
 896	if (!temp_enabled(data, attr->index))
 897		return sprintf(buf, "0\n");
 898
 899	return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
 900				     250 * frac);
 901}
 902
 903static ssize_t show_temp_label(struct device *dev,
 904			       struct device_attribute *devattr,
 905			       char *buf)
 906{
 907	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 908	struct adt7462_data *data = adt7462_update_device(dev);
 909
 910	return sprintf(buf, "%s\n", temp_label(data, attr->index));
 911}
 912
 913static ssize_t show_volt_max(struct device *dev,
 914			     struct device_attribute *devattr,
 915			     char *buf)
 916{
 917	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 918	struct adt7462_data *data = adt7462_update_device(dev);
 919	int x = voltage_multiplier(data, attr->index);
 920
 921	x *= data->volt_max[attr->index];
 922	x /= 1000; /* convert from uV to mV */
 923
 924	return sprintf(buf, "%d\n", x);
 925}
 926
 927static ssize_t set_volt_max(struct device *dev,
 928			    struct device_attribute *devattr,
 929			    const char *buf,
 930			    size_t count)
 931{
 932	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 933	struct i2c_client *client = to_i2c_client(dev);
 934	struct adt7462_data *data = i2c_get_clientdata(client);
 935	int x = voltage_multiplier(data, attr->index);
 936	long temp;
 937
 938	if (strict_strtol(buf, 10, &temp) || !x)
 939		return -EINVAL;
 940
 
 941	temp *= 1000; /* convert mV to uV */
 942	temp = DIV_ROUND_CLOSEST(temp, x);
 943	temp = SENSORS_LIMIT(temp, 0, 255);
 944
 945	mutex_lock(&data->lock);
 946	data->volt_max[attr->index] = temp;
 947	i2c_smbus_write_byte_data(client,
 948				  ADT7462_REG_VOLT_MAX(data, attr->index),
 949				  temp);
 950	mutex_unlock(&data->lock);
 951
 952	return count;
 953}
 954
 955static ssize_t show_volt_min(struct device *dev,
 956			     struct device_attribute *devattr,
 957			     char *buf)
 958{
 959	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 960	struct adt7462_data *data = adt7462_update_device(dev);
 961	int x = voltage_multiplier(data, attr->index);
 962
 963	x *= data->volt_min[attr->index];
 964	x /= 1000; /* convert from uV to mV */
 965
 966	return sprintf(buf, "%d\n", x);
 967}
 968
 969static ssize_t set_volt_min(struct device *dev,
 970			    struct device_attribute *devattr,
 971			    const char *buf,
 972			    size_t count)
 973{
 974	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 975	struct i2c_client *client = to_i2c_client(dev);
 976	struct adt7462_data *data = i2c_get_clientdata(client);
 977	int x = voltage_multiplier(data, attr->index);
 978	long temp;
 979
 980	if (strict_strtol(buf, 10, &temp) || !x)
 981		return -EINVAL;
 982
 
 983	temp *= 1000; /* convert mV to uV */
 984	temp = DIV_ROUND_CLOSEST(temp, x);
 985	temp = SENSORS_LIMIT(temp, 0, 255);
 986
 987	mutex_lock(&data->lock);
 988	data->volt_min[attr->index] = temp;
 989	i2c_smbus_write_byte_data(client,
 990				  ADT7462_REG_VOLT_MIN(data, attr->index),
 991				  temp);
 992	mutex_unlock(&data->lock);
 993
 994	return count;
 995}
 996
 997static ssize_t show_voltage(struct device *dev,
 998			    struct device_attribute *devattr,
 999			    char *buf)
1000{
1001	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1002	struct adt7462_data *data = adt7462_update_device(dev);
1003	int x = voltage_multiplier(data, attr->index);
1004
1005	x *= data->voltages[attr->index];
1006	x /= 1000; /* convert from uV to mV */
1007
1008	return sprintf(buf, "%d\n", x);
1009}
1010
1011static ssize_t show_voltage_label(struct device *dev,
1012				  struct device_attribute *devattr,
1013				  char *buf)
1014{
1015	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1016	struct adt7462_data *data = adt7462_update_device(dev);
1017
1018	return sprintf(buf, "%s\n", voltage_label(data, attr->index));
1019}
1020
1021static ssize_t show_alarm(struct device *dev,
1022			  struct device_attribute *devattr,
1023			  char *buf)
1024{
1025	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1026	struct adt7462_data *data = adt7462_update_device(dev);
1027	int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
1028	int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
1029
1030	if (data->alarms[reg] & mask)
1031		return sprintf(buf, "1\n");
1032	else
1033		return sprintf(buf, "0\n");
1034}
1035
1036static int fan_enabled(struct adt7462_data *data, int fan)
1037{
1038	return data->fan_enabled & (1 << fan);
1039}
1040
1041static ssize_t show_fan_min(struct device *dev,
1042			    struct device_attribute *devattr,
1043			    char *buf)
1044{
1045	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1046	struct adt7462_data *data = adt7462_update_device(dev);
1047	u16 temp;
1048
1049	/* Only the MSB of the min fan period is stored... */
1050	temp = data->fan_min[attr->index];
1051	temp <<= 8;
1052
1053	if (!fan_enabled(data, attr->index) ||
1054	    !FAN_DATA_VALID(temp))
1055		return sprintf(buf, "0\n");
1056
1057	return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1058}
1059
1060static ssize_t set_fan_min(struct device *dev,
1061			   struct device_attribute *devattr,
1062			   const char *buf, size_t count)
1063{
1064	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1065	struct i2c_client *client = to_i2c_client(dev);
1066	struct adt7462_data *data = i2c_get_clientdata(client);
1067	long temp;
1068
1069	if (strict_strtol(buf, 10, &temp) || !temp ||
1070	    !fan_enabled(data, attr->index))
1071		return -EINVAL;
1072
1073	temp = FAN_RPM_TO_PERIOD(temp);
1074	temp >>= 8;
1075	temp = SENSORS_LIMIT(temp, 1, 255);
1076
1077	mutex_lock(&data->lock);
1078	data->fan_min[attr->index] = temp;
1079	i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1080				  temp);
1081	mutex_unlock(&data->lock);
1082
1083	return count;
1084}
1085
1086static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
1087			char *buf)
1088{
1089	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1090	struct adt7462_data *data = adt7462_update_device(dev);
1091
1092	if (!fan_enabled(data, attr->index) ||
1093	    !FAN_DATA_VALID(data->fan[attr->index]))
1094		return sprintf(buf, "0\n");
1095
1096	return sprintf(buf, "%d\n",
1097		       FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1098}
1099
1100static ssize_t show_force_pwm_max(struct device *dev,
1101				  struct device_attribute *devattr,
1102				  char *buf)
1103{
1104	struct adt7462_data *data = adt7462_update_device(dev);
1105	return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1106}
1107
1108static ssize_t set_force_pwm_max(struct device *dev,
1109				 struct device_attribute *devattr,
1110				 const char *buf,
1111				 size_t count)
1112{
1113	struct i2c_client *client = to_i2c_client(dev);
1114	struct adt7462_data *data = i2c_get_clientdata(client);
1115	long temp;
1116	u8 reg;
1117
1118	if (strict_strtol(buf, 10, &temp))
1119		return -EINVAL;
1120
1121	mutex_lock(&data->lock);
1122	reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1123	if (temp)
1124		reg |= ADT7462_FSPD_MASK;
1125	else
1126		reg &= ~ADT7462_FSPD_MASK;
1127	data->cfg2 = reg;
1128	i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1129	mutex_unlock(&data->lock);
1130
1131	return count;
1132}
1133
1134static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
1135			char *buf)
1136{
1137	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1138	struct adt7462_data *data = adt7462_update_device(dev);
1139	return sprintf(buf, "%d\n", data->pwm[attr->index]);
1140}
1141
1142static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
1143			const char *buf, size_t count)
1144{
1145	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1146	struct i2c_client *client = to_i2c_client(dev);
1147	struct adt7462_data *data = i2c_get_clientdata(client);
1148	long temp;
1149
1150	if (strict_strtol(buf, 10, &temp))
1151		return -EINVAL;
1152
1153	temp = SENSORS_LIMIT(temp, 0, 255);
1154
1155	mutex_lock(&data->lock);
1156	data->pwm[attr->index] = temp;
1157	i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1158	mutex_unlock(&data->lock);
1159
1160	return count;
1161}
1162
1163static ssize_t show_pwm_max(struct device *dev,
1164			    struct device_attribute *devattr,
1165			    char *buf)
1166{
1167	struct adt7462_data *data = adt7462_update_device(dev);
1168	return sprintf(buf, "%d\n", data->pwm_max);
1169}
1170
1171static ssize_t set_pwm_max(struct device *dev,
1172			   struct device_attribute *devattr,
1173			   const char *buf,
1174			   size_t count)
1175{
1176	struct i2c_client *client = to_i2c_client(dev);
1177	struct adt7462_data *data = i2c_get_clientdata(client);
1178	long temp;
1179
1180	if (strict_strtol(buf, 10, &temp))
1181		return -EINVAL;
1182
1183	temp = SENSORS_LIMIT(temp, 0, 255);
1184
1185	mutex_lock(&data->lock);
1186	data->pwm_max = temp;
1187	i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1188	mutex_unlock(&data->lock);
1189
1190	return count;
1191}
1192
1193static ssize_t show_pwm_min(struct device *dev,
1194			    struct device_attribute *devattr,
1195			    char *buf)
1196{
1197	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1198	struct adt7462_data *data = adt7462_update_device(dev);
1199	return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1200}
1201
1202static ssize_t set_pwm_min(struct device *dev,
1203			   struct device_attribute *devattr,
1204			   const char *buf,
1205			   size_t count)
1206{
1207	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1208	struct i2c_client *client = to_i2c_client(dev);
1209	struct adt7462_data *data = i2c_get_clientdata(client);
1210	long temp;
1211
1212	if (strict_strtol(buf, 10, &temp))
1213		return -EINVAL;
1214
1215	temp = SENSORS_LIMIT(temp, 0, 255);
1216
1217	mutex_lock(&data->lock);
1218	data->pwm_min[attr->index] = temp;
1219	i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1220				  temp);
1221	mutex_unlock(&data->lock);
1222
1223	return count;
1224}
1225
1226static ssize_t show_pwm_hyst(struct device *dev,
1227			     struct device_attribute *devattr,
1228			     char *buf)
1229{
1230	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1231	struct adt7462_data *data = adt7462_update_device(dev);
1232	return sprintf(buf, "%d\n", 1000 *
1233		      (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1234}
1235
1236static ssize_t set_pwm_hyst(struct device *dev,
1237			    struct device_attribute *devattr,
1238			    const char *buf,
1239			    size_t count)
1240{
1241	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1242	struct i2c_client *client = to_i2c_client(dev);
1243	struct adt7462_data *data = i2c_get_clientdata(client);
1244	long temp;
1245
1246	if (strict_strtol(buf, 10, &temp))
1247		return -EINVAL;
1248
 
1249	temp = DIV_ROUND_CLOSEST(temp, 1000);
1250	temp = SENSORS_LIMIT(temp, 0, 15);
1251
1252	/* package things up */
1253	temp &= ADT7462_PWM_HYST_MASK;
1254	temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1255
1256	mutex_lock(&data->lock);
1257	data->pwm_trange[attr->index] = temp;
1258	i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1259				  temp);
1260	mutex_unlock(&data->lock);
1261
1262	return count;
1263}
1264
1265static ssize_t show_pwm_tmax(struct device *dev,
1266			     struct device_attribute *devattr,
1267			     char *buf)
1268{
1269	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1270	struct adt7462_data *data = adt7462_update_device(dev);
1271
1272	/* tmax = tmin + trange */
1273	int trange = trange_values[data->pwm_trange[attr->index] >>
1274				   ADT7462_PWM_RANGE_SHIFT];
1275	int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1276
1277	return sprintf(buf, "%d\n", tmin + trange);
1278}
1279
1280static ssize_t set_pwm_tmax(struct device *dev,
1281			    struct device_attribute *devattr,
1282			    const char *buf,
1283			    size_t count)
1284{
1285	int temp;
1286	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1287	struct i2c_client *client = to_i2c_client(dev);
1288	struct adt7462_data *data = i2c_get_clientdata(client);
1289	int tmin, trange_value;
1290	long trange;
1291
1292	if (strict_strtol(buf, 10, &trange))
1293		return -EINVAL;
1294
1295	/* trange = tmax - tmin */
1296	tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1297	trange_value = find_trange_value(trange - tmin);
1298
1299	if (trange_value < 0)
1300		return -EINVAL;
1301
1302	temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1303	temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1304
1305	mutex_lock(&data->lock);
1306	data->pwm_trange[attr->index] = temp;
1307	i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1308				  temp);
1309	mutex_unlock(&data->lock);
1310
1311	return count;
1312}
1313
1314static ssize_t show_pwm_tmin(struct device *dev,
1315			     struct device_attribute *devattr,
1316			     char *buf)
1317{
1318	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1319	struct adt7462_data *data = adt7462_update_device(dev);
1320	return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1321}
1322
1323static ssize_t set_pwm_tmin(struct device *dev,
1324			    struct device_attribute *devattr,
1325			    const char *buf,
1326			    size_t count)
1327{
1328	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1329	struct i2c_client *client = to_i2c_client(dev);
1330	struct adt7462_data *data = i2c_get_clientdata(client);
1331	long temp;
1332
1333	if (strict_strtol(buf, 10, &temp))
1334		return -EINVAL;
1335
 
1336	temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1337	temp = SENSORS_LIMIT(temp, 0, 255);
1338
1339	mutex_lock(&data->lock);
1340	data->pwm_tmin[attr->index] = temp;
1341	i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1342				  temp);
1343	mutex_unlock(&data->lock);
1344
1345	return count;
1346}
1347
1348static ssize_t show_pwm_auto(struct device *dev,
1349			     struct device_attribute *devattr,
1350			     char *buf)
1351{
1352	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1353	struct adt7462_data *data = adt7462_update_device(dev);
1354	int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1355
1356	switch (cfg) {
1357	case 4: /* off */
1358		return sprintf(buf, "0\n");
1359	case 7: /* manual */
1360		return sprintf(buf, "1\n");
1361	default: /* automatic */
1362		return sprintf(buf, "2\n");
1363	}
1364}
1365
1366static void set_pwm_channel(struct i2c_client *client,
1367			    struct adt7462_data *data,
1368			    int which,
1369			    int value)
1370{
1371	int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1372	temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1373
1374	mutex_lock(&data->lock);
1375	data->pwm_cfg[which] = temp;
1376	i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1377	mutex_unlock(&data->lock);
1378}
1379
1380static ssize_t set_pwm_auto(struct device *dev,
1381			    struct device_attribute *devattr,
1382			    const char *buf,
1383			    size_t count)
1384{
1385	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1386	struct i2c_client *client = to_i2c_client(dev);
1387	struct adt7462_data *data = i2c_get_clientdata(client);
1388	long temp;
1389
1390	if (strict_strtol(buf, 10, &temp))
1391		return -EINVAL;
1392
1393	switch (temp) {
1394	case 0: /* off */
1395		set_pwm_channel(client, data, attr->index, 4);
1396		return count;
1397	case 1: /* manual */
1398		set_pwm_channel(client, data, attr->index, 7);
1399		return count;
1400	default:
1401		return -EINVAL;
1402	}
1403}
1404
1405static ssize_t show_pwm_auto_temp(struct device *dev,
1406				  struct device_attribute *devattr,
1407				  char *buf)
1408{
1409	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1410	struct adt7462_data *data = adt7462_update_device(dev);
1411	int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1412
1413	switch (channel) {
1414	case 0: /* temp[1234] only */
1415	case 1:
1416	case 2:
1417	case 3:
1418		return sprintf(buf, "%d\n", (1 << channel));
1419	case 5: /* temp1 & temp4  */
1420		return sprintf(buf, "9\n");
1421	case 6:
1422		return sprintf(buf, "15\n");
1423	default:
1424		return sprintf(buf, "0\n");
1425	}
1426}
1427
1428static int cvt_auto_temp(int input)
1429{
1430	if (input == 0xF)
1431		return 6;
1432	if (input == 0x9)
1433		return 5;
1434	if (input < 1 || !is_power_of_2(input))
1435		return -EINVAL;
1436	return ilog2(input);
1437}
1438
1439static ssize_t set_pwm_auto_temp(struct device *dev,
1440				 struct device_attribute *devattr,
1441				 const char *buf,
1442				 size_t count)
1443{
1444	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1445	struct i2c_client *client = to_i2c_client(dev);
1446	struct adt7462_data *data = i2c_get_clientdata(client);
1447	long temp;
1448
1449	if (strict_strtol(buf, 10, &temp))
1450		return -EINVAL;
1451
1452	temp = cvt_auto_temp(temp);
1453	if (temp < 0)
1454		return temp;
1455
1456	set_pwm_channel(client, data, attr->index, temp);
1457
1458	return count;
1459}
1460
1461static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
1462		    set_temp_max, 0);
1463static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
1464		    set_temp_max, 1);
1465static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
1466		    set_temp_max, 2);
1467static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
1468		    set_temp_max, 3);
1469
1470static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
1471		    set_temp_min, 0);
1472static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
1473		    set_temp_min, 1);
1474static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
1475		    set_temp_min, 2);
1476static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
1477		    set_temp_min, 3);
1478
1479static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1480static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1481static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1482static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
1483
1484static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0);
1485static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1);
1486static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2);
1487static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3);
1488
1489static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
1490			  ADT7462_ALARM1 | ADT7462_LT_ALARM);
1491static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
1492			  ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1493static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
1494			  ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1495static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
1496			  ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1497
1498static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
1499		    set_volt_max, 0);
1500static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
1501		    set_volt_max, 1);
1502static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, show_volt_max,
1503		    set_volt_max, 2);
1504static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, show_volt_max,
1505		    set_volt_max, 3);
1506static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, show_volt_max,
1507		    set_volt_max, 4);
1508static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, show_volt_max,
1509		    set_volt_max, 5);
1510static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, show_volt_max,
1511		    set_volt_max, 6);
1512static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, show_volt_max,
1513		    set_volt_max, 7);
1514static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, show_volt_max,
1515		    set_volt_max, 8);
1516static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, show_volt_max,
1517		    set_volt_max, 9);
1518static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, show_volt_max,
1519		    set_volt_max, 10);
1520static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, show_volt_max,
1521		    set_volt_max, 11);
1522static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, show_volt_max,
1523		    set_volt_max, 12);
1524
1525static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
1526		    set_volt_min, 0);
1527static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
1528		    set_volt_min, 1);
1529static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, show_volt_min,
1530		    set_volt_min, 2);
1531static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, show_volt_min,
1532		    set_volt_min, 3);
1533static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, show_volt_min,
1534		    set_volt_min, 4);
1535static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, show_volt_min,
1536		    set_volt_min, 5);
1537static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, show_volt_min,
1538		    set_volt_min, 6);
1539static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, show_volt_min,
1540		    set_volt_min, 7);
1541static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, show_volt_min,
1542		    set_volt_min, 8);
1543static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, show_volt_min,
1544		    set_volt_min, 9);
1545static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, show_volt_min,
1546		    set_volt_min, 10);
1547static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, show_volt_min,
1548		    set_volt_min, 11);
1549static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, show_volt_min,
1550		    set_volt_min, 12);
1551
1552static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_voltage, NULL, 0);
1553static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_voltage, NULL, 1);
1554static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_voltage, NULL, 2);
1555static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_voltage, NULL, 3);
1556static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_voltage, NULL, 4);
1557static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_voltage, NULL, 5);
1558static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_voltage, NULL, 6);
1559static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_voltage, NULL, 7);
1560static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_voltage, NULL, 8);
1561static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_voltage, NULL, 9);
1562static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_voltage, NULL, 10);
1563static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_voltage, NULL, 11);
1564static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_voltage, NULL, 12);
1565
1566static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, show_voltage_label, NULL, 0);
1567static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, show_voltage_label, NULL, 1);
1568static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_voltage_label, NULL, 2);
1569static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, show_voltage_label, NULL, 3);
1570static SENSOR_DEVICE_ATTR(in5_label, S_IRUGO, show_voltage_label, NULL, 4);
1571static SENSOR_DEVICE_ATTR(in6_label, S_IRUGO, show_voltage_label, NULL, 5);
1572static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_voltage_label, NULL, 6);
1573static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_voltage_label, NULL, 7);
1574static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_voltage_label, NULL, 8);
1575static SENSOR_DEVICE_ATTR(in10_label, S_IRUGO, show_voltage_label, NULL, 9);
1576static SENSOR_DEVICE_ATTR(in11_label, S_IRUGO, show_voltage_label, NULL, 10);
1577static SENSOR_DEVICE_ATTR(in12_label, S_IRUGO, show_voltage_label, NULL, 11);
1578static SENSOR_DEVICE_ATTR(in13_label, S_IRUGO, show_voltage_label, NULL, 12);
1579
1580static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
1581			  ADT7462_ALARM2 | ADT7462_V0_ALARM);
1582static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
1583			  ADT7462_ALARM2 | ADT7462_V7_ALARM);
1584static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL,
1585			  ADT7462_ALARM2 | ADT7462_V2_ALARM);
1586static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL,
1587			  ADT7462_ALARM2 | ADT7462_V6_ALARM);
1588static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL,
1589			  ADT7462_ALARM2 | ADT7462_V5_ALARM);
1590static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL,
1591			  ADT7462_ALARM2 | ADT7462_V4_ALARM);
1592static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL,
1593			  ADT7462_ALARM2 | ADT7462_V3_ALARM);
1594static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL,
1595			  ADT7462_ALARM2 | ADT7462_V1_ALARM);
1596static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL,
1597			  ADT7462_ALARM3 | ADT7462_V10_ALARM);
1598static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL,
1599			  ADT7462_ALARM3 | ADT7462_V9_ALARM);
1600static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL,
1601			  ADT7462_ALARM3 | ADT7462_V8_ALARM);
1602static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL,
1603			  ADT7462_ALARM3 | ADT7462_V11_ALARM);
1604static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL,
1605			  ADT7462_ALARM3 | ADT7462_V12_ALARM);
1606
1607static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1608		    set_fan_min, 0);
1609static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1610		    set_fan_min, 1);
1611static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1612		    set_fan_min, 2);
1613static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1614		    set_fan_min, 3);
1615static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1616		    set_fan_min, 4);
1617static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min,
1618		    set_fan_min, 5);
1619static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min,
1620		    set_fan_min, 6);
1621static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, show_fan_min,
1622		    set_fan_min, 7);
1623
1624static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
1625static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
1626static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
1627static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
1628static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4);
1629static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 5);
1630static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 6);
1631static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan, NULL, 7);
1632
1633static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
1634			  ADT7462_ALARM4 | ADT7462_F0_ALARM);
1635static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
1636			  ADT7462_ALARM4 | ADT7462_F1_ALARM);
1637static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
1638			  ADT7462_ALARM4 | ADT7462_F2_ALARM);
1639static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
1640			  ADT7462_ALARM4 | ADT7462_F3_ALARM);
1641static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL,
1642			  ADT7462_ALARM4 | ADT7462_F4_ALARM);
1643static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL,
1644			  ADT7462_ALARM4 | ADT7462_F5_ALARM);
1645static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL,
1646			  ADT7462_ALARM4 | ADT7462_F6_ALARM);
1647static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL,
1648			  ADT7462_ALARM4 | ADT7462_F7_ALARM);
1649
1650static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
1651		    show_force_pwm_max, set_force_pwm_max, 0);
1652
1653static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
1654static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
1655static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
1656static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
1657
1658static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
1659		    show_pwm_min, set_pwm_min, 0);
1660static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
1661		    show_pwm_min, set_pwm_min, 1);
1662static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
1663		    show_pwm_min, set_pwm_min, 2);
1664static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
1665		    show_pwm_min, set_pwm_min, 3);
1666
1667static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
1668		    show_pwm_max, set_pwm_max, 0);
1669static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
1670		    show_pwm_max, set_pwm_max, 1);
1671static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
1672		    show_pwm_max, set_pwm_max, 2);
1673static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
1674		    show_pwm_max, set_pwm_max, 3);
1675
1676static SENSOR_DEVICE_ATTR(temp1_auto_point1_hyst, S_IWUSR | S_IRUGO,
1677		    show_pwm_hyst, set_pwm_hyst, 0);
1678static SENSOR_DEVICE_ATTR(temp2_auto_point1_hyst, S_IWUSR | S_IRUGO,
1679		    show_pwm_hyst, set_pwm_hyst, 1);
1680static SENSOR_DEVICE_ATTR(temp3_auto_point1_hyst, S_IWUSR | S_IRUGO,
1681		    show_pwm_hyst, set_pwm_hyst, 2);
1682static SENSOR_DEVICE_ATTR(temp4_auto_point1_hyst, S_IWUSR | S_IRUGO,
1683		    show_pwm_hyst, set_pwm_hyst, 3);
1684
1685static SENSOR_DEVICE_ATTR(temp1_auto_point2_hyst, S_IWUSR | S_IRUGO,
1686		    show_pwm_hyst, set_pwm_hyst, 0);
1687static SENSOR_DEVICE_ATTR(temp2_auto_point2_hyst, S_IWUSR | S_IRUGO,
1688		    show_pwm_hyst, set_pwm_hyst, 1);
1689static SENSOR_DEVICE_ATTR(temp3_auto_point2_hyst, S_IWUSR | S_IRUGO,
1690		    show_pwm_hyst, set_pwm_hyst, 2);
1691static SENSOR_DEVICE_ATTR(temp4_auto_point2_hyst, S_IWUSR | S_IRUGO,
1692		    show_pwm_hyst, set_pwm_hyst, 3);
1693
1694static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
1695		    show_pwm_tmin, set_pwm_tmin, 0);
1696static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
1697		    show_pwm_tmin, set_pwm_tmin, 1);
1698static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
1699		    show_pwm_tmin, set_pwm_tmin, 2);
1700static SENSOR_DEVICE_ATTR(temp4_auto_point1_temp, S_IWUSR | S_IRUGO,
1701		    show_pwm_tmin, set_pwm_tmin, 3);
1702
1703static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
1704		    show_pwm_tmax, set_pwm_tmax, 0);
1705static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
1706		    show_pwm_tmax, set_pwm_tmax, 1);
1707static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
1708		    show_pwm_tmax, set_pwm_tmax, 2);
1709static SENSOR_DEVICE_ATTR(temp4_auto_point2_temp, S_IWUSR | S_IRUGO,
1710		    show_pwm_tmax, set_pwm_tmax, 3);
1711
1712static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1713		    set_pwm_auto, 0);
1714static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1715		    set_pwm_auto, 1);
1716static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1717		    set_pwm_auto, 2);
1718static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1719		    set_pwm_auto, 3);
1720
1721static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
1722		    show_pwm_auto_temp, set_pwm_auto_temp, 0);
1723static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
1724		    show_pwm_auto_temp, set_pwm_auto_temp, 1);
1725static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
1726		    show_pwm_auto_temp, set_pwm_auto_temp, 2);
1727static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
1728		    show_pwm_auto_temp, set_pwm_auto_temp, 3);
1729
1730static struct attribute *adt7462_attr[] =
1731{
1732	&sensor_dev_attr_temp1_max.dev_attr.attr,
1733	&sensor_dev_attr_temp2_max.dev_attr.attr,
1734	&sensor_dev_attr_temp3_max.dev_attr.attr,
1735	&sensor_dev_attr_temp4_max.dev_attr.attr,
1736
1737	&sensor_dev_attr_temp1_min.dev_attr.attr,
1738	&sensor_dev_attr_temp2_min.dev_attr.attr,
1739	&sensor_dev_attr_temp3_min.dev_attr.attr,
1740	&sensor_dev_attr_temp4_min.dev_attr.attr,
1741
1742	&sensor_dev_attr_temp1_input.dev_attr.attr,
1743	&sensor_dev_attr_temp2_input.dev_attr.attr,
1744	&sensor_dev_attr_temp3_input.dev_attr.attr,
1745	&sensor_dev_attr_temp4_input.dev_attr.attr,
1746
1747	&sensor_dev_attr_temp1_label.dev_attr.attr,
1748	&sensor_dev_attr_temp2_label.dev_attr.attr,
1749	&sensor_dev_attr_temp3_label.dev_attr.attr,
1750	&sensor_dev_attr_temp4_label.dev_attr.attr,
1751
1752	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
1753	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
1754	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
1755	&sensor_dev_attr_temp4_alarm.dev_attr.attr,
1756
1757	&sensor_dev_attr_in1_max.dev_attr.attr,
1758	&sensor_dev_attr_in2_max.dev_attr.attr,
1759	&sensor_dev_attr_in3_max.dev_attr.attr,
1760	&sensor_dev_attr_in4_max.dev_attr.attr,
1761	&sensor_dev_attr_in5_max.dev_attr.attr,
1762	&sensor_dev_attr_in6_max.dev_attr.attr,
1763	&sensor_dev_attr_in7_max.dev_attr.attr,
1764	&sensor_dev_attr_in8_max.dev_attr.attr,
1765	&sensor_dev_attr_in9_max.dev_attr.attr,
1766	&sensor_dev_attr_in10_max.dev_attr.attr,
1767	&sensor_dev_attr_in11_max.dev_attr.attr,
1768	&sensor_dev_attr_in12_max.dev_attr.attr,
1769	&sensor_dev_attr_in13_max.dev_attr.attr,
1770
1771	&sensor_dev_attr_in1_min.dev_attr.attr,
1772	&sensor_dev_attr_in2_min.dev_attr.attr,
1773	&sensor_dev_attr_in3_min.dev_attr.attr,
1774	&sensor_dev_attr_in4_min.dev_attr.attr,
1775	&sensor_dev_attr_in5_min.dev_attr.attr,
1776	&sensor_dev_attr_in6_min.dev_attr.attr,
1777	&sensor_dev_attr_in7_min.dev_attr.attr,
1778	&sensor_dev_attr_in8_min.dev_attr.attr,
1779	&sensor_dev_attr_in9_min.dev_attr.attr,
1780	&sensor_dev_attr_in10_min.dev_attr.attr,
1781	&sensor_dev_attr_in11_min.dev_attr.attr,
1782	&sensor_dev_attr_in12_min.dev_attr.attr,
1783	&sensor_dev_attr_in13_min.dev_attr.attr,
1784
1785	&sensor_dev_attr_in1_input.dev_attr.attr,
1786	&sensor_dev_attr_in2_input.dev_attr.attr,
1787	&sensor_dev_attr_in3_input.dev_attr.attr,
1788	&sensor_dev_attr_in4_input.dev_attr.attr,
1789	&sensor_dev_attr_in5_input.dev_attr.attr,
1790	&sensor_dev_attr_in6_input.dev_attr.attr,
1791	&sensor_dev_attr_in7_input.dev_attr.attr,
1792	&sensor_dev_attr_in8_input.dev_attr.attr,
1793	&sensor_dev_attr_in9_input.dev_attr.attr,
1794	&sensor_dev_attr_in10_input.dev_attr.attr,
1795	&sensor_dev_attr_in11_input.dev_attr.attr,
1796	&sensor_dev_attr_in12_input.dev_attr.attr,
1797	&sensor_dev_attr_in13_input.dev_attr.attr,
1798
1799	&sensor_dev_attr_in1_label.dev_attr.attr,
1800	&sensor_dev_attr_in2_label.dev_attr.attr,
1801	&sensor_dev_attr_in3_label.dev_attr.attr,
1802	&sensor_dev_attr_in4_label.dev_attr.attr,
1803	&sensor_dev_attr_in5_label.dev_attr.attr,
1804	&sensor_dev_attr_in6_label.dev_attr.attr,
1805	&sensor_dev_attr_in7_label.dev_attr.attr,
1806	&sensor_dev_attr_in8_label.dev_attr.attr,
1807	&sensor_dev_attr_in9_label.dev_attr.attr,
1808	&sensor_dev_attr_in10_label.dev_attr.attr,
1809	&sensor_dev_attr_in11_label.dev_attr.attr,
1810	&sensor_dev_attr_in12_label.dev_attr.attr,
1811	&sensor_dev_attr_in13_label.dev_attr.attr,
1812
1813	&sensor_dev_attr_in1_alarm.dev_attr.attr,
1814	&sensor_dev_attr_in2_alarm.dev_attr.attr,
1815	&sensor_dev_attr_in3_alarm.dev_attr.attr,
1816	&sensor_dev_attr_in4_alarm.dev_attr.attr,
1817	&sensor_dev_attr_in5_alarm.dev_attr.attr,
1818	&sensor_dev_attr_in6_alarm.dev_attr.attr,
1819	&sensor_dev_attr_in7_alarm.dev_attr.attr,
1820	&sensor_dev_attr_in8_alarm.dev_attr.attr,
1821	&sensor_dev_attr_in9_alarm.dev_attr.attr,
1822	&sensor_dev_attr_in10_alarm.dev_attr.attr,
1823	&sensor_dev_attr_in11_alarm.dev_attr.attr,
1824	&sensor_dev_attr_in12_alarm.dev_attr.attr,
1825	&sensor_dev_attr_in13_alarm.dev_attr.attr,
1826
1827	&sensor_dev_attr_fan1_min.dev_attr.attr,
1828	&sensor_dev_attr_fan2_min.dev_attr.attr,
1829	&sensor_dev_attr_fan3_min.dev_attr.attr,
1830	&sensor_dev_attr_fan4_min.dev_attr.attr,
1831	&sensor_dev_attr_fan5_min.dev_attr.attr,
1832	&sensor_dev_attr_fan6_min.dev_attr.attr,
1833	&sensor_dev_attr_fan7_min.dev_attr.attr,
1834	&sensor_dev_attr_fan8_min.dev_attr.attr,
1835
1836	&sensor_dev_attr_fan1_input.dev_attr.attr,
1837	&sensor_dev_attr_fan2_input.dev_attr.attr,
1838	&sensor_dev_attr_fan3_input.dev_attr.attr,
1839	&sensor_dev_attr_fan4_input.dev_attr.attr,
1840	&sensor_dev_attr_fan5_input.dev_attr.attr,
1841	&sensor_dev_attr_fan6_input.dev_attr.attr,
1842	&sensor_dev_attr_fan7_input.dev_attr.attr,
1843	&sensor_dev_attr_fan8_input.dev_attr.attr,
1844
1845	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
1846	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
1847	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
1848	&sensor_dev_attr_fan4_alarm.dev_attr.attr,
1849	&sensor_dev_attr_fan5_alarm.dev_attr.attr,
1850	&sensor_dev_attr_fan6_alarm.dev_attr.attr,
1851	&sensor_dev_attr_fan7_alarm.dev_attr.attr,
1852	&sensor_dev_attr_fan8_alarm.dev_attr.attr,
1853
1854	&sensor_dev_attr_force_pwm_max.dev_attr.attr,
1855	&sensor_dev_attr_pwm1.dev_attr.attr,
1856	&sensor_dev_attr_pwm2.dev_attr.attr,
1857	&sensor_dev_attr_pwm3.dev_attr.attr,
1858	&sensor_dev_attr_pwm4.dev_attr.attr,
1859
1860	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1861	&sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1862	&sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1863	&sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1864
1865	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1866	&sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1867	&sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1868	&sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1869
1870	&sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1871	&sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1872	&sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1873	&sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1874
1875	&sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1876	&sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1877	&sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1878	&sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1879
1880	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1881	&sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1882	&sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1883	&sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1884
1885	&sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1886	&sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1887	&sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1888	&sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1889
1890	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
1891	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
1892	&sensor_dev_attr_pwm3_enable.dev_attr.attr,
1893	&sensor_dev_attr_pwm4_enable.dev_attr.attr,
1894
1895	&sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1896	&sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1897	&sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1898	&sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1899	NULL
1900};
1901
 
 
1902/* Return 0 if detection is successful, -ENODEV otherwise */
1903static int adt7462_detect(struct i2c_client *client,
1904			  struct i2c_board_info *info)
1905{
1906	struct i2c_adapter *adapter = client->adapter;
1907	int vendor, device, revision;
1908
1909	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1910		return -ENODEV;
1911
1912	vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1913	if (vendor != ADT7462_VENDOR)
1914		return -ENODEV;
1915
1916	device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1917	if (device != ADT7462_DEVICE)
1918		return -ENODEV;
1919
1920	revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
1921	if (revision != ADT7462_REVISION)
1922		return -ENODEV;
1923
1924	strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1925
1926	return 0;
1927}
1928
1929static int adt7462_probe(struct i2c_client *client,
1930			 const struct i2c_device_id *id)
1931{
 
1932	struct adt7462_data *data;
1933	int err;
1934
1935	data = kzalloc(sizeof(struct adt7462_data), GFP_KERNEL);
1936	if (!data) {
1937		err = -ENOMEM;
1938		goto exit;
1939	}
1940
1941	i2c_set_clientdata(client, data);
1942	mutex_init(&data->lock);
1943
1944	dev_info(&client->dev, "%s chip found\n", client->name);
1945
1946	/* Register sysfs hooks */
1947	data->attrs.attrs = adt7462_attr;
1948	err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1949	if (err)
1950		goto exit_free;
1951
1952	data->hwmon_dev = hwmon_device_register(&client->dev);
1953	if (IS_ERR(data->hwmon_dev)) {
1954		err = PTR_ERR(data->hwmon_dev);
1955		goto exit_remove;
1956	}
1957
1958	return 0;
1959
1960exit_remove:
1961	sysfs_remove_group(&client->dev.kobj, &data->attrs);
1962exit_free:
1963	kfree(data);
1964exit:
1965	return err;
1966}
1967
1968static int adt7462_remove(struct i2c_client *client)
1969{
1970	struct adt7462_data *data = i2c_get_clientdata(client);
1971
1972	hwmon_device_unregister(data->hwmon_dev);
1973	sysfs_remove_group(&client->dev.kobj, &data->attrs);
1974	kfree(data);
1975	return 0;
1976}
1977
1978static int __init adt7462_init(void)
1979{
1980	return i2c_add_driver(&adt7462_driver);
1981}
 
 
 
 
 
 
1982
1983static void __exit adt7462_exit(void)
1984{
1985	i2c_del_driver(&adt7462_driver);
1986}
1987
1988MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1989MODULE_DESCRIPTION("ADT7462 driver");
1990MODULE_LICENSE("GPL");
1991
1992module_init(adt7462_init);
1993module_exit(adt7462_exit);