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