1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * adt7475 - Thermal sensor driver for the ADT7475 chip and derivatives
   4 * Copyright (C) 2007-2008, Advanced Micro Devices, Inc.
   5 * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
   6 * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com>
   7 * Copyright (C) 2009 Jean Delvare <jdelvare@suse.de>
   8 *
   9 * Derived from the lm83 driver by Jean Delvare
 
 
 
 
  10 */
  11
  12#include <linux/module.h>
  13#include <linux/init.h>
  14#include <linux/slab.h>
  15#include <linux/i2c.h>
  16#include <linux/hwmon.h>
  17#include <linux/hwmon-sysfs.h>
  18#include <linux/hwmon-vid.h>
  19#include <linux/err.h>
  20#include <linux/jiffies.h>
  21#include <linux/of.h>
  22#include <linux/util_macros.h>
  23
  24/* Indexes for the sysfs hooks */
  25
  26#define INPUT		0
  27#define MIN		1
  28#define MAX		2
  29#define CONTROL		3
  30#define OFFSET		3
  31#define AUTOMIN		4
  32#define THERM		5
  33#define HYSTERSIS	6
  34
  35/*
  36 * These are unique identifiers for the sysfs functions - unlike the
  37 * numbers above, these are not also indexes into an array
  38 */
  39
  40#define ALARM		9
  41#define FAULT		10
  42
  43/* 7475 Common Registers */
  44
  45#define REG_DEVREV2		0x12	/* ADT7490 only */
  46#define REG_IMON		0x1D	/* ADT7490 only */
  47
  48#define REG_VTT			0x1E	/* ADT7490 only */
  49#define REG_EXTEND3		0x1F	/* ADT7490 only */
  50
  51#define REG_VOLTAGE_BASE	0x20
  52#define REG_TEMP_BASE		0x25
  53#define REG_TACH_BASE		0x28
  54#define REG_PWM_BASE		0x30
  55#define REG_PWM_MAX_BASE	0x38
  56
  57#define REG_DEVID		0x3D
  58#define REG_VENDID		0x3E
  59#define REG_DEVID2		0x3F
  60
  61#define REG_CONFIG1		0x40
  62
  63#define REG_STATUS1		0x41
  64#define REG_STATUS2		0x42
  65
  66#define REG_VID			0x43	/* ADT7476 only */
  67
  68#define REG_VOLTAGE_MIN_BASE	0x44
  69#define REG_VOLTAGE_MAX_BASE	0x45
  70
  71#define REG_TEMP_MIN_BASE	0x4E
  72#define REG_TEMP_MAX_BASE	0x4F
  73
  74#define REG_TACH_MIN_BASE	0x54
  75
  76#define REG_PWM_CONFIG_BASE	0x5C
  77
  78#define REG_TEMP_TRANGE_BASE	0x5F
  79
  80#define REG_ENHANCE_ACOUSTICS1	0x62
  81#define REG_ENHANCE_ACOUSTICS2	0x63
  82
  83#define REG_PWM_MIN_BASE	0x64
  84
  85#define REG_TEMP_TMIN_BASE	0x67
  86#define REG_TEMP_THERM_BASE	0x6A
  87
  88#define REG_REMOTE1_HYSTERSIS	0x6D
  89#define REG_REMOTE2_HYSTERSIS	0x6E
  90
  91#define REG_TEMP_OFFSET_BASE	0x70
  92
  93#define REG_CONFIG2		0x73
  94
  95#define REG_EXTEND1		0x76
  96#define REG_EXTEND2		0x77
  97
  98#define REG_CONFIG3		0x78
  99#define REG_CONFIG5		0x7C
 100#define REG_CONFIG4		0x7D
 101
 102#define REG_STATUS4		0x81	/* ADT7490 only */
 103
 104#define REG_VTT_MIN		0x84	/* ADT7490 only */
 105#define REG_VTT_MAX		0x86	/* ADT7490 only */
 106
 107#define REG_IMON_MIN		0x85	/* ADT7490 only */
 108#define REG_IMON_MAX		0x87	/* ADT7490 only */
 109
 110#define VID_VIDSEL		0x80	/* ADT7476 only */
 111
 112#define CONFIG2_ATTN		0x20
 113
 114#define CONFIG3_SMBALERT	0x01
 115#define CONFIG3_THERM		0x02
 116
 117#define CONFIG4_PINFUNC		0x03
 118#define CONFIG4_THERM		0x01
 119#define CONFIG4_SMBALERT	0x02
 120#define CONFIG4_MAXDUTY		0x08
 121#define CONFIG4_ATTN_IN10	0x30
 122#define CONFIG4_ATTN_IN43	0xC0
 123
 124#define CONFIG5_TWOSCOMP	0x01
 125#define CONFIG5_TEMPOFFSET	0x02
 126#define CONFIG5_VIDGPIO		0x10	/* ADT7476 only */
 127
 128/* ADT7475 Settings */
 129
 130#define ADT7475_VOLTAGE_COUNT	5	/* Not counting Vtt or Imon */
 131#define ADT7475_TEMP_COUNT	3
 132#define ADT7475_TACH_COUNT	4
 133#define ADT7475_PWM_COUNT	3
 134
 135/* Macro to read the registers */
 136
 137#define adt7475_read(reg) i2c_smbus_read_byte_data(client, (reg))
 138
 139/* Macros to easily index the registers */
 140
 141#define TACH_REG(idx) (REG_TACH_BASE + ((idx) * 2))
 142#define TACH_MIN_REG(idx) (REG_TACH_MIN_BASE + ((idx) * 2))
 143
 144#define PWM_REG(idx) (REG_PWM_BASE + (idx))
 145#define PWM_MAX_REG(idx) (REG_PWM_MAX_BASE + (idx))
 146#define PWM_MIN_REG(idx) (REG_PWM_MIN_BASE + (idx))
 147#define PWM_CONFIG_REG(idx) (REG_PWM_CONFIG_BASE + (idx))
 148
 149#define VOLTAGE_REG(idx) (REG_VOLTAGE_BASE + (idx))
 150#define VOLTAGE_MIN_REG(idx) (REG_VOLTAGE_MIN_BASE + ((idx) * 2))
 151#define VOLTAGE_MAX_REG(idx) (REG_VOLTAGE_MAX_BASE + ((idx) * 2))
 152
 153#define TEMP_REG(idx) (REG_TEMP_BASE + (idx))
 154#define TEMP_MIN_REG(idx) (REG_TEMP_MIN_BASE + ((idx) * 2))
 155#define TEMP_MAX_REG(idx) (REG_TEMP_MAX_BASE + ((idx) * 2))
 156#define TEMP_TMIN_REG(idx) (REG_TEMP_TMIN_BASE + (idx))
 157#define TEMP_THERM_REG(idx) (REG_TEMP_THERM_BASE + (idx))
 158#define TEMP_OFFSET_REG(idx) (REG_TEMP_OFFSET_BASE + (idx))
 159#define TEMP_TRANGE_REG(idx) (REG_TEMP_TRANGE_BASE + (idx))
 160
 161static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
 162
 163enum chips { adt7473, adt7475, adt7476, adt7490 };
 164
 165static const struct i2c_device_id adt7475_id[] = {
 166	{ "adt7473", adt7473 },
 167	{ "adt7475", adt7475 },
 168	{ "adt7476", adt7476 },
 169	{ "adt7490", adt7490 },
 170	{ }
 171};
 172MODULE_DEVICE_TABLE(i2c, adt7475_id);
 173
 174static const struct of_device_id __maybe_unused adt7475_of_match[] = {
 175	{
 176		.compatible = "adi,adt7473",
 177		.data = (void *)adt7473
 178	},
 179	{
 180		.compatible = "adi,adt7475",
 181		.data = (void *)adt7475
 182	},
 183	{
 184		.compatible = "adi,adt7476",
 185		.data = (void *)adt7476
 186	},
 187	{
 188		.compatible = "adi,adt7490",
 189		.data = (void *)adt7490
 190	},
 191	{ },
 192};
 193MODULE_DEVICE_TABLE(of, adt7475_of_match);
 194
 195struct adt7475_data {
 196	struct i2c_client *client;
 197	struct mutex lock;
 198
 199	unsigned long measure_updated;
 200	bool valid;
 
 201
 202	u8 config2;
 203	u8 config4;
 204	u8 config5;
 205	u8 has_voltage;
 206	u8 bypass_attn;		/* Bypass voltage attenuator */
 207	u8 has_pwm2:1;
 208	u8 has_fan4:1;
 209	u8 has_vid:1;
 210	u32 alarms;
 211	u16 voltage[3][7];
 212	u16 temp[7][3];
 213	u16 tach[2][4];
 214	u8 pwm[4][3];
 215	u8 range[3];
 216	u8 pwmctl[3];
 217	u8 pwmchan[3];
 218	u8 enh_acoustics[2];
 219
 220	u8 vid;
 221	u8 vrm;
 222	const struct attribute_group *groups[10];
 223};
 224
 225static struct i2c_driver adt7475_driver;
 226static struct adt7475_data *adt7475_update_device(struct device *dev);
 227static void adt7475_read_hystersis(struct i2c_client *client);
 228static void adt7475_read_pwm(struct i2c_client *client, int index);
 229
 230/* Given a temp value, convert it to register value */
 231
 232static inline u16 temp2reg(struct adt7475_data *data, long val)
 233{
 234	u16 ret;
 235
 236	if (!(data->config5 & CONFIG5_TWOSCOMP)) {
 237		val = clamp_val(val, -64000, 191000);
 238		ret = (val + 64500) / 1000;
 239	} else {
 240		val = clamp_val(val, -128000, 127000);
 241		if (val < -500)
 242			ret = (256500 + val) / 1000;
 243		else
 244			ret = (val + 500) / 1000;
 245	}
 246
 247	return ret << 2;
 248}
 249
 250/* Given a register value, convert it to a real temp value */
 251
 252static inline int reg2temp(struct adt7475_data *data, u16 reg)
 253{
 254	if (data->config5 & CONFIG5_TWOSCOMP) {
 255		if (reg >= 512)
 256			return (reg - 1024) * 250;
 257		else
 258			return reg * 250;
 259	} else
 260		return (reg - 256) * 250;
 261}
 262
 263static inline int tach2rpm(u16 tach)
 264{
 265	if (tach == 0 || tach == 0xFFFF)
 266		return 0;
 267
 268	return (90000 * 60) / tach;
 269}
 270
 271static inline u16 rpm2tach(unsigned long rpm)
 272{
 273	if (rpm == 0)
 274		return 0;
 275
 276	return clamp_val((90000 * 60) / rpm, 1, 0xFFFF);
 277}
 278
 279/* Scaling factors for voltage inputs, taken from the ADT7490 datasheet */
 280static const int adt7473_in_scaling[ADT7475_VOLTAGE_COUNT + 2][2] = {
 281	{ 45, 94 },	/* +2.5V */
 282	{ 175, 525 },	/* Vccp */
 283	{ 68, 71 },	/* Vcc */
 284	{ 93, 47 },	/* +5V */
 285	{ 120, 20 },	/* +12V */
 286	{ 45, 45 },	/* Vtt */
 287	{ 45, 45 },	/* Imon */
 288};
 289
 290static inline int reg2volt(int channel, u16 reg, u8 bypass_attn)
 291{
 292	const int *r = adt7473_in_scaling[channel];
 293
 294	if (bypass_attn & (1 << channel))
 295		return DIV_ROUND_CLOSEST(reg * 2250, 1024);
 296	return DIV_ROUND_CLOSEST(reg * (r[0] + r[1]) * 2250, r[1] * 1024);
 297}
 298
 299static inline u16 volt2reg(int channel, long volt, u8 bypass_attn)
 300{
 301	const int *r = adt7473_in_scaling[channel];
 302	long reg;
 303
 304	if (bypass_attn & (1 << channel))
 305		reg = DIV_ROUND_CLOSEST(volt * 1024, 2250);
 306	else
 307		reg = DIV_ROUND_CLOSEST(volt * r[1] * 1024,
 308					(r[0] + r[1]) * 2250);
 309	return clamp_val(reg, 0, 1023) & (0xff << 2);
 310}
 311
 312static int adt7475_read_word(struct i2c_client *client, int reg)
 313{
 314	int val1, val2;
 315
 316	val1 = i2c_smbus_read_byte_data(client, reg);
 317	if (val1 < 0)
 318		return val1;
 319	val2 = i2c_smbus_read_byte_data(client, reg + 1);
 320	if (val2 < 0)
 321		return val2;
 322
 323	return val1 | (val2 << 8);
 324}
 325
 326static void adt7475_write_word(struct i2c_client *client, int reg, u16 val)
 327{
 328	i2c_smbus_write_byte_data(client, reg + 1, val >> 8);
 329	i2c_smbus_write_byte_data(client, reg, val & 0xFF);
 330}
 331
 332static ssize_t voltage_show(struct device *dev, struct device_attribute *attr,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 333			    char *buf)
 334{
 335	struct adt7475_data *data = adt7475_update_device(dev);
 336	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 337	unsigned short val;
 338
 339	if (IS_ERR(data))
 340		return PTR_ERR(data);
 341
 342	switch (sattr->nr) {
 343	case ALARM:
 344		return sprintf(buf, "%d\n",
 345			       (data->alarms >> sattr->index) & 1);
 346	default:
 347		val = data->voltage[sattr->nr][sattr->index];
 348		return sprintf(buf, "%d\n",
 349			       reg2volt(sattr->index, val, data->bypass_attn));
 350	}
 351}
 352
 353static ssize_t voltage_store(struct device *dev,
 354			     struct device_attribute *attr, const char *buf,
 355			     size_t count)
 356{
 357
 358	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 359	struct adt7475_data *data = dev_get_drvdata(dev);
 360	struct i2c_client *client = data->client;
 361	unsigned char reg;
 362	long val;
 363
 364	if (kstrtol(buf, 10, &val))
 365		return -EINVAL;
 366
 367	mutex_lock(&data->lock);
 368
 369	data->voltage[sattr->nr][sattr->index] =
 370				volt2reg(sattr->index, val, data->bypass_attn);
 371
 372	if (sattr->index < ADT7475_VOLTAGE_COUNT) {
 373		if (sattr->nr == MIN)
 374			reg = VOLTAGE_MIN_REG(sattr->index);
 375		else
 376			reg = VOLTAGE_MAX_REG(sattr->index);
 377	} else if (sattr->index == 5) {
 378		if (sattr->nr == MIN)
 379			reg = REG_VTT_MIN;
 380		else
 381			reg = REG_VTT_MAX;
 382	} else {
 383		if (sattr->nr == MIN)
 384			reg = REG_IMON_MIN;
 385		else
 386			reg = REG_IMON_MAX;
 387	}
 388
 389	i2c_smbus_write_byte_data(client, reg,
 390				  data->voltage[sattr->nr][sattr->index] >> 2);
 391	mutex_unlock(&data->lock);
 392
 393	return count;
 394}
 395
 396static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
 397			 char *buf)
 398{
 399	struct adt7475_data *data = adt7475_update_device(dev);
 400	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 401	int out;
 402
 403	if (IS_ERR(data))
 404		return PTR_ERR(data);
 405
 406	switch (sattr->nr) {
 407	case HYSTERSIS:
 408		mutex_lock(&data->lock);
 409		out = data->temp[sattr->nr][sattr->index];
 410		if (sattr->index != 1)
 411			out = (out >> 4) & 0xF;
 412		else
 413			out = (out & 0xF);
 414		/*
 415		 * Show the value as an absolute number tied to
 416		 * THERM
 417		 */
 418		out = reg2temp(data, data->temp[THERM][sattr->index]) -
 419			out * 1000;
 420		mutex_unlock(&data->lock);
 421		break;
 422
 423	case OFFSET:
 424		/*
 425		 * Offset is always 2's complement, regardless of the
 426		 * setting in CONFIG5
 427		 */
 428		mutex_lock(&data->lock);
 429		out = (s8)data->temp[sattr->nr][sattr->index];
 430		if (data->config5 & CONFIG5_TEMPOFFSET)
 431			out *= 1000;
 432		else
 433			out *= 500;
 434		mutex_unlock(&data->lock);
 435		break;
 436
 437	case ALARM:
 438		out = (data->alarms >> (sattr->index + 4)) & 1;
 439		break;
 440
 441	case FAULT:
 442		/* Note - only for remote1 and remote2 */
 443		out = !!(data->alarms & (sattr->index ? 0x8000 : 0x4000));
 444		break;
 445
 446	default:
 447		/* All other temp values are in the configured format */
 448		out = reg2temp(data, data->temp[sattr->nr][sattr->index]);
 449	}
 450
 451	return sprintf(buf, "%d\n", out);
 452}
 453
 454static ssize_t temp_store(struct device *dev, struct device_attribute *attr,
 455			  const char *buf, size_t count)
 456{
 457	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 458	struct adt7475_data *data = dev_get_drvdata(dev);
 459	struct i2c_client *client = data->client;
 460	unsigned char reg = 0;
 461	u8 out;
 462	int temp;
 463	long val;
 464
 465	if (kstrtol(buf, 10, &val))
 466		return -EINVAL;
 467
 468	mutex_lock(&data->lock);
 469
 470	/* We need the config register in all cases for temp <-> reg conv. */
 471	data->config5 = adt7475_read(REG_CONFIG5);
 472
 473	switch (sattr->nr) {
 474	case OFFSET:
 475		if (data->config5 & CONFIG5_TEMPOFFSET) {
 476			val = clamp_val(val, -63000, 127000);
 477			out = data->temp[OFFSET][sattr->index] = val / 1000;
 478		} else {
 479			val = clamp_val(val, -63000, 64000);
 480			out = data->temp[OFFSET][sattr->index] = val / 500;
 481		}
 482		break;
 483
 484	case HYSTERSIS:
 485		/*
 486		 * The value will be given as an absolute value, turn it
 487		 * into an offset based on THERM
 488		 */
 489
 490		/* Read fresh THERM and HYSTERSIS values from the chip */
 491		data->temp[THERM][sattr->index] =
 492			adt7475_read(TEMP_THERM_REG(sattr->index)) << 2;
 493		adt7475_read_hystersis(client);
 494
 495		temp = reg2temp(data, data->temp[THERM][sattr->index]);
 496		val = clamp_val(val, temp - 15000, temp);
 497		val = (temp - val) / 1000;
 498
 499		if (sattr->index != 1) {
 500			data->temp[HYSTERSIS][sattr->index] &= 0x0F;
 501			data->temp[HYSTERSIS][sattr->index] |= (val & 0xF) << 4;
 502		} else {
 503			data->temp[HYSTERSIS][sattr->index] &= 0xF0;
 504			data->temp[HYSTERSIS][sattr->index] |= (val & 0xF);
 505		}
 506
 507		out = data->temp[HYSTERSIS][sattr->index];
 508		break;
 509
 510	default:
 511		data->temp[sattr->nr][sattr->index] = temp2reg(data, val);
 512
 513		/*
 514		 * We maintain an extra 2 digits of precision for simplicity
 515		 * - shift those back off before writing the value
 516		 */
 517		out = (u8) (data->temp[sattr->nr][sattr->index] >> 2);
 518	}
 519
 520	switch (sattr->nr) {
 521	case MIN:
 522		reg = TEMP_MIN_REG(sattr->index);
 523		break;
 524	case MAX:
 525		reg = TEMP_MAX_REG(sattr->index);
 526		break;
 527	case OFFSET:
 528		reg = TEMP_OFFSET_REG(sattr->index);
 529		break;
 530	case AUTOMIN:
 531		reg = TEMP_TMIN_REG(sattr->index);
 532		break;
 533	case THERM:
 534		reg = TEMP_THERM_REG(sattr->index);
 535		break;
 536	case HYSTERSIS:
 537		if (sattr->index != 2)
 538			reg = REG_REMOTE1_HYSTERSIS;
 539		else
 540			reg = REG_REMOTE2_HYSTERSIS;
 541
 542		break;
 543	}
 544
 545	i2c_smbus_write_byte_data(client, reg, out);
 546
 547	mutex_unlock(&data->lock);
 548	return count;
 549}
 550
 551/* Assuming CONFIG6[SLOW] is 0 */
 552static const int ad7475_st_map[] = {
 553	37500, 18800, 12500, 7500, 4700, 3100, 1600, 800,
 554};
 555
 556static ssize_t temp_st_show(struct device *dev, struct device_attribute *attr,
 557			    char *buf)
 558{
 559	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 560	struct adt7475_data *data = dev_get_drvdata(dev);
 561	long val;
 562
 563	switch (sattr->index) {
 564	case 0:
 565		val = data->enh_acoustics[0] & 0xf;
 566		break;
 567	case 1:
 568		val = data->enh_acoustics[1] & 0xf;
 569		break;
 570	case 2:
 571	default:
 572		val = (data->enh_acoustics[1] >> 4) & 0xf;
 573		break;
 574	}
 575
 576	if (val & 0x8)
 577		return sprintf(buf, "%d\n", ad7475_st_map[val & 0x7]);
 578	else
 579		return sprintf(buf, "0\n");
 580}
 581
 582static ssize_t temp_st_store(struct device *dev,
 583			     struct device_attribute *attr, const char *buf,
 584			     size_t count)
 585{
 586	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 587	struct adt7475_data *data = dev_get_drvdata(dev);
 588	struct i2c_client *client = data->client;
 589	unsigned char reg;
 590	int shift, idx;
 591	ulong val;
 592
 593	if (kstrtoul(buf, 10, &val))
 594		return -EINVAL;
 595
 596	switch (sattr->index) {
 597	case 0:
 598		reg = REG_ENHANCE_ACOUSTICS1;
 599		shift = 0;
 600		idx = 0;
 601		break;
 602	case 1:
 603		reg = REG_ENHANCE_ACOUSTICS2;
 604		shift = 0;
 605		idx = 1;
 606		break;
 607	case 2:
 608	default:
 609		reg = REG_ENHANCE_ACOUSTICS2;
 610		shift = 4;
 611		idx = 1;
 612		break;
 613	}
 614
 615	if (val > 0) {
 616		val = find_closest_descending(val, ad7475_st_map,
 617					      ARRAY_SIZE(ad7475_st_map));
 618		val |= 0x8;
 619	}
 620
 621	mutex_lock(&data->lock);
 622
 623	data->enh_acoustics[idx] &= ~(0xf << shift);
 624	data->enh_acoustics[idx] |= (val << shift);
 625
 626	i2c_smbus_write_byte_data(client, reg, data->enh_acoustics[idx]);
 627
 628	mutex_unlock(&data->lock);
 629
 630	return count;
 631}
 632
 633/*
 634 * Table of autorange values - the user will write the value in millidegrees,
 635 * and we'll convert it
 636 */
 637static const int autorange_table[] = {
 638	2000, 2500, 3330, 4000, 5000, 6670, 8000,
 639	10000, 13330, 16000, 20000, 26670, 32000, 40000,
 640	53330, 80000
 641};
 642
 643static ssize_t point2_show(struct device *dev, struct device_attribute *attr,
 644			   char *buf)
 645{
 646	struct adt7475_data *data = adt7475_update_device(dev);
 647	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 648	int out, val;
 649
 650	if (IS_ERR(data))
 651		return PTR_ERR(data);
 652
 653	mutex_lock(&data->lock);
 654	out = (data->range[sattr->index] >> 4) & 0x0F;
 655	val = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
 656	mutex_unlock(&data->lock);
 657
 658	return sprintf(buf, "%d\n", val + autorange_table[out]);
 659}
 660
 661static ssize_t point2_store(struct device *dev, struct device_attribute *attr,
 662			    const char *buf, size_t count)
 663{
 664	struct adt7475_data *data = dev_get_drvdata(dev);
 665	struct i2c_client *client = data->client;
 666	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 667	int temp;
 668	long val;
 669
 670	if (kstrtol(buf, 10, &val))
 671		return -EINVAL;
 672
 673	mutex_lock(&data->lock);
 674
 675	/* Get a fresh copy of the needed registers */
 676	data->config5 = adt7475_read(REG_CONFIG5);
 677	data->temp[AUTOMIN][sattr->index] =
 678		adt7475_read(TEMP_TMIN_REG(sattr->index)) << 2;
 679	data->range[sattr->index] =
 680		adt7475_read(TEMP_TRANGE_REG(sattr->index));
 681
 682	/*
 683	 * The user will write an absolute value, so subtract the start point
 684	 * to figure the range
 685	 */
 686	temp = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
 687	val = clamp_val(val, temp + autorange_table[0],
 688		temp + autorange_table[ARRAY_SIZE(autorange_table) - 1]);
 689	val -= temp;
 690
 691	/* Find the nearest table entry to what the user wrote */
 692	val = find_closest(val, autorange_table, ARRAY_SIZE(autorange_table));
 693
 694	data->range[sattr->index] &= ~0xF0;
 695	data->range[sattr->index] |= val << 4;
 696
 697	i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
 698				  data->range[sattr->index]);
 699
 700	mutex_unlock(&data->lock);
 701	return count;
 702}
 703
 704static ssize_t tach_show(struct device *dev, struct device_attribute *attr,
 705			 char *buf)
 706{
 707	struct adt7475_data *data = adt7475_update_device(dev);
 708	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 709	int out;
 710
 711	if (IS_ERR(data))
 712		return PTR_ERR(data);
 713
 714	if (sattr->nr == ALARM)
 715		out = (data->alarms >> (sattr->index + 10)) & 1;
 716	else
 717		out = tach2rpm(data->tach[sattr->nr][sattr->index]);
 718
 719	return sprintf(buf, "%d\n", out);
 720}
 721
 722static ssize_t tach_store(struct device *dev, struct device_attribute *attr,
 723			  const char *buf, size_t count)
 724{
 725
 726	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 727	struct adt7475_data *data = dev_get_drvdata(dev);
 728	struct i2c_client *client = data->client;
 729	unsigned long val;
 730
 731	if (kstrtoul(buf, 10, &val))
 732		return -EINVAL;
 733
 734	mutex_lock(&data->lock);
 735
 736	data->tach[MIN][sattr->index] = rpm2tach(val);
 737
 738	adt7475_write_word(client, TACH_MIN_REG(sattr->index),
 739			   data->tach[MIN][sattr->index]);
 740
 741	mutex_unlock(&data->lock);
 742	return count;
 743}
 744
 745static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
 746			char *buf)
 747{
 748	struct adt7475_data *data = adt7475_update_device(dev);
 749	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 750
 751	if (IS_ERR(data))
 752		return PTR_ERR(data);
 753
 754	return sprintf(buf, "%d\n", data->pwm[sattr->nr][sattr->index]);
 755}
 756
 757static ssize_t pwmchan_show(struct device *dev, struct device_attribute *attr,
 758			    char *buf)
 759{
 760	struct adt7475_data *data = adt7475_update_device(dev);
 761	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 762
 763	if (IS_ERR(data))
 764		return PTR_ERR(data);
 765
 766	return sprintf(buf, "%d\n", data->pwmchan[sattr->index]);
 767}
 768
 769static ssize_t pwmctrl_show(struct device *dev, struct device_attribute *attr,
 770			    char *buf)
 771{
 772	struct adt7475_data *data = adt7475_update_device(dev);
 773	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 774
 775	if (IS_ERR(data))
 776		return PTR_ERR(data);
 777
 778	return sprintf(buf, "%d\n", data->pwmctl[sattr->index]);
 779}
 780
 781static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
 782			 const char *buf, size_t count)
 783{
 784
 785	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 786	struct adt7475_data *data = dev_get_drvdata(dev);
 787	struct i2c_client *client = data->client;
 788	unsigned char reg = 0;
 789	long val;
 790
 791	if (kstrtol(buf, 10, &val))
 792		return -EINVAL;
 793
 794	mutex_lock(&data->lock);
 795
 796	switch (sattr->nr) {
 797	case INPUT:
 798		/* Get a fresh value for CONTROL */
 799		data->pwm[CONTROL][sattr->index] =
 800			adt7475_read(PWM_CONFIG_REG(sattr->index));
 801
 802		/*
 803		 * If we are not in manual mode, then we shouldn't allow
 804		 * the user to set the pwm speed
 805		 */
 806		if (((data->pwm[CONTROL][sattr->index] >> 5) & 7) != 7) {
 807			mutex_unlock(&data->lock);
 808			return count;
 809		}
 810
 811		reg = PWM_REG(sattr->index);
 812		break;
 813
 814	case MIN:
 815		reg = PWM_MIN_REG(sattr->index);
 816		break;
 817
 818	case MAX:
 819		reg = PWM_MAX_REG(sattr->index);
 820		break;
 821	}
 822
 823	data->pwm[sattr->nr][sattr->index] = clamp_val(val, 0, 0xFF);
 824	i2c_smbus_write_byte_data(client, reg,
 825				  data->pwm[sattr->nr][sattr->index]);
 826	mutex_unlock(&data->lock);
 827
 828	return count;
 829}
 830
 831static ssize_t stall_disable_show(struct device *dev,
 832				  struct device_attribute *attr, char *buf)
 833{
 834	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 835	struct adt7475_data *data = dev_get_drvdata(dev);
 836
 837	u8 mask = BIT(5 + sattr->index);
 838
 839	return sprintf(buf, "%d\n", !!(data->enh_acoustics[0] & mask));
 840}
 841
 842static ssize_t stall_disable_store(struct device *dev,
 843				   struct device_attribute *attr,
 844				   const char *buf, size_t count)
 845{
 846	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 847	struct adt7475_data *data = dev_get_drvdata(dev);
 848	struct i2c_client *client = data->client;
 849	long val;
 850	u8 mask = BIT(5 + sattr->index);
 851
 852	if (kstrtol(buf, 10, &val))
 853		return -EINVAL;
 854
 855	mutex_lock(&data->lock);
 856
 857	data->enh_acoustics[0] &= ~mask;
 858	if (val)
 859		data->enh_acoustics[0] |= mask;
 860
 861	i2c_smbus_write_byte_data(client, REG_ENHANCE_ACOUSTICS1,
 862				  data->enh_acoustics[0]);
 863
 864	mutex_unlock(&data->lock);
 865
 866	return count;
 867}
 868
 869/* Called by set_pwmctrl and set_pwmchan */
 870
 871static int hw_set_pwm(struct i2c_client *client, int index,
 872		      unsigned int pwmctl, unsigned int pwmchan)
 873{
 874	struct adt7475_data *data = i2c_get_clientdata(client);
 875	long val = 0;
 876
 877	switch (pwmctl) {
 878	case 0:
 879		val = 0x03;	/* Run at full speed */
 880		break;
 881	case 1:
 882		val = 0x07;	/* Manual mode */
 883		break;
 884	case 2:
 885		switch (pwmchan) {
 886		case 1:
 887			/* Remote1 controls PWM */
 888			val = 0x00;
 889			break;
 890		case 2:
 891			/* local controls PWM */
 892			val = 0x01;
 893			break;
 894		case 4:
 895			/* remote2 controls PWM */
 896			val = 0x02;
 897			break;
 898		case 6:
 899			/* local/remote2 control PWM */
 900			val = 0x05;
 901			break;
 902		case 7:
 903			/* All three control PWM */
 904			val = 0x06;
 905			break;
 906		default:
 907			return -EINVAL;
 908		}
 909		break;
 910	default:
 911		return -EINVAL;
 912	}
 913
 914	data->pwmctl[index] = pwmctl;
 915	data->pwmchan[index] = pwmchan;
 916
 917	data->pwm[CONTROL][index] &= ~0xE0;
 918	data->pwm[CONTROL][index] |= (val & 7) << 5;
 919
 920	i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
 921				  data->pwm[CONTROL][index]);
 922
 923	return 0;
 924}
 925
 926static ssize_t pwmchan_store(struct device *dev,
 927			     struct device_attribute *attr, const char *buf,
 928			     size_t count)
 929{
 930	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 931	struct adt7475_data *data = dev_get_drvdata(dev);
 932	struct i2c_client *client = data->client;
 933	int r;
 934	long val;
 935
 936	if (kstrtol(buf, 10, &val))
 937		return -EINVAL;
 938
 939	mutex_lock(&data->lock);
 940	/* Read Modify Write PWM values */
 941	adt7475_read_pwm(client, sattr->index);
 942	r = hw_set_pwm(client, sattr->index, data->pwmctl[sattr->index], val);
 943	if (r)
 944		count = r;
 945	mutex_unlock(&data->lock);
 946
 947	return count;
 948}
 949
 950static ssize_t pwmctrl_store(struct device *dev,
 951			     struct device_attribute *attr, const char *buf,
 952			     size_t count)
 953{
 954	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 955	struct adt7475_data *data = dev_get_drvdata(dev);
 956	struct i2c_client *client = data->client;
 957	int r;
 958	long val;
 959
 960	if (kstrtol(buf, 10, &val))
 961		return -EINVAL;
 962
 963	mutex_lock(&data->lock);
 964	/* Read Modify Write PWM values */
 965	adt7475_read_pwm(client, sattr->index);
 966	r = hw_set_pwm(client, sattr->index, val, data->pwmchan[sattr->index]);
 967	if (r)
 968		count = r;
 969	mutex_unlock(&data->lock);
 970
 971	return count;
 972}
 973
 974/* List of frequencies for the PWM */
 975static const int pwmfreq_table[] = {
 976	11, 14, 22, 29, 35, 44, 58, 88, 22500
 977};
 978
 979static ssize_t pwmfreq_show(struct device *dev, struct device_attribute *attr,
 980			    char *buf)
 981{
 982	struct adt7475_data *data = adt7475_update_device(dev);
 983	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 984	int idx;
 985
 986	if (IS_ERR(data))
 987		return PTR_ERR(data);
 988	idx = clamp_val(data->range[sattr->index] & 0xf, 0,
 989			ARRAY_SIZE(pwmfreq_table) - 1);
 990
 991	return sprintf(buf, "%d\n", pwmfreq_table[idx]);
 992}
 993
 994static ssize_t pwmfreq_store(struct device *dev,
 995			     struct device_attribute *attr, const char *buf,
 996			     size_t count)
 997{
 998	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 999	struct adt7475_data *data = dev_get_drvdata(dev);
1000	struct i2c_client *client = data->client;
1001	int out;
1002	long val;
1003
1004	if (kstrtol(buf, 10, &val))
1005		return -EINVAL;
1006
1007	out = find_closest(val, pwmfreq_table, ARRAY_SIZE(pwmfreq_table));
1008
1009	mutex_lock(&data->lock);
1010
1011	data->range[sattr->index] =
1012		adt7475_read(TEMP_TRANGE_REG(sattr->index));
1013	data->range[sattr->index] &= ~0xf;
1014	data->range[sattr->index] |= out;
1015
1016	i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
1017				  data->range[sattr->index]);
1018
1019	mutex_unlock(&data->lock);
1020	return count;
1021}
1022
1023static ssize_t pwm_use_point2_pwm_at_crit_show(struct device *dev,
1024					struct device_attribute *devattr,
1025					char *buf)
1026{
1027	struct adt7475_data *data = adt7475_update_device(dev);
1028
1029	if (IS_ERR(data))
1030		return PTR_ERR(data);
1031
1032	return sprintf(buf, "%d\n", !!(data->config4 & CONFIG4_MAXDUTY));
1033}
1034
1035static ssize_t pwm_use_point2_pwm_at_crit_store(struct device *dev,
1036					struct device_attribute *devattr,
1037					const char *buf, size_t count)
1038{
1039	struct adt7475_data *data = dev_get_drvdata(dev);
1040	struct i2c_client *client = data->client;
1041	long val;
1042
1043	if (kstrtol(buf, 10, &val))
1044		return -EINVAL;
1045	if (val != 0 && val != 1)
1046		return -EINVAL;
1047
1048	mutex_lock(&data->lock);
1049	data->config4 = i2c_smbus_read_byte_data(client, REG_CONFIG4);
1050	if (val)
1051		data->config4 |= CONFIG4_MAXDUTY;
1052	else
1053		data->config4 &= ~CONFIG4_MAXDUTY;
1054	i2c_smbus_write_byte_data(client, REG_CONFIG4, data->config4);
1055	mutex_unlock(&data->lock);
1056
1057	return count;
1058}
1059
1060static ssize_t vrm_show(struct device *dev, struct device_attribute *devattr,
1061			char *buf)
1062{
1063	struct adt7475_data *data = dev_get_drvdata(dev);
1064	return sprintf(buf, "%d\n", (int)data->vrm);
1065}
1066
1067static ssize_t vrm_store(struct device *dev, struct device_attribute *devattr,
1068			 const char *buf, size_t count)
1069{
1070	struct adt7475_data *data = dev_get_drvdata(dev);
1071	long val;
1072
1073	if (kstrtol(buf, 10, &val))
1074		return -EINVAL;
1075	if (val < 0 || val > 255)
1076		return -EINVAL;
1077	data->vrm = val;
1078
1079	return count;
1080}
1081
1082static ssize_t cpu0_vid_show(struct device *dev,
1083			     struct device_attribute *devattr, char *buf)
1084{
1085	struct adt7475_data *data = adt7475_update_device(dev);
1086
1087	if (IS_ERR(data))
1088		return PTR_ERR(data);
1089
1090	return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1091}
1092
1093static SENSOR_DEVICE_ATTR_2_RO(in0_input, voltage, INPUT, 0);
1094static SENSOR_DEVICE_ATTR_2_RW(in0_max, voltage, MAX, 0);
1095static SENSOR_DEVICE_ATTR_2_RW(in0_min, voltage, MIN, 0);
1096static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, voltage, ALARM, 0);
1097static SENSOR_DEVICE_ATTR_2_RO(in1_input, voltage, INPUT, 1);
1098static SENSOR_DEVICE_ATTR_2_RW(in1_max, voltage, MAX, 1);
1099static SENSOR_DEVICE_ATTR_2_RW(in1_min, voltage, MIN, 1);
1100static SENSOR_DEVICE_ATTR_2_RO(in1_alarm, voltage, ALARM, 1);
1101static SENSOR_DEVICE_ATTR_2_RO(in2_input, voltage, INPUT, 2);
1102static SENSOR_DEVICE_ATTR_2_RW(in2_max, voltage, MAX, 2);
1103static SENSOR_DEVICE_ATTR_2_RW(in2_min, voltage, MIN, 2);
1104static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, voltage, ALARM, 2);
1105static SENSOR_DEVICE_ATTR_2_RO(in3_input, voltage, INPUT, 3);
1106static SENSOR_DEVICE_ATTR_2_RW(in3_max, voltage, MAX, 3);
1107static SENSOR_DEVICE_ATTR_2_RW(in3_min, voltage, MIN, 3);
1108static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, voltage, ALARM, 3);
1109static SENSOR_DEVICE_ATTR_2_RO(in4_input, voltage, INPUT, 4);
1110static SENSOR_DEVICE_ATTR_2_RW(in4_max, voltage, MAX, 4);
1111static SENSOR_DEVICE_ATTR_2_RW(in4_min, voltage, MIN, 4);
1112static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, voltage, ALARM, 8);
1113static SENSOR_DEVICE_ATTR_2_RO(in5_input, voltage, INPUT, 5);
1114static SENSOR_DEVICE_ATTR_2_RW(in5_max, voltage, MAX, 5);
1115static SENSOR_DEVICE_ATTR_2_RW(in5_min, voltage, MIN, 5);
1116static SENSOR_DEVICE_ATTR_2_RO(in5_alarm, voltage, ALARM, 31);
1117static SENSOR_DEVICE_ATTR_2_RO(in6_input, voltage, INPUT, 6);
1118static SENSOR_DEVICE_ATTR_2_RW(in6_max, voltage, MAX, 6);
1119static SENSOR_DEVICE_ATTR_2_RW(in6_min, voltage, MIN, 6);
1120static SENSOR_DEVICE_ATTR_2_RO(in6_alarm, voltage, ALARM, 30);
1121static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, INPUT, 0);
1122static SENSOR_DEVICE_ATTR_2_RO(temp1_alarm, temp, ALARM, 0);
1123static SENSOR_DEVICE_ATTR_2_RO(temp1_fault, temp, FAULT, 0);
1124static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, MAX, 0);
1125static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, MIN, 0);
1126static SENSOR_DEVICE_ATTR_2_RW(temp1_offset, temp, OFFSET, 0);
1127static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point1_temp, temp, AUTOMIN, 0);
1128static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, point2, 0, 0);
1129static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, THERM, 0);
1130static SENSOR_DEVICE_ATTR_2_RW(temp1_crit_hyst, temp, HYSTERSIS, 0);
1131static SENSOR_DEVICE_ATTR_2_RW(temp1_smoothing, temp_st, 0, 0);
1132static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, INPUT, 1);
1133static SENSOR_DEVICE_ATTR_2_RO(temp2_alarm, temp, ALARM, 1);
1134static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, MAX, 1);
1135static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, MIN, 1);
1136static SENSOR_DEVICE_ATTR_2_RW(temp2_offset, temp, OFFSET, 1);
1137static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp, AUTOMIN, 1);
1138static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, point2, 0, 1);
1139static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, THERM, 1);
1140static SENSOR_DEVICE_ATTR_2_RW(temp2_crit_hyst, temp, HYSTERSIS, 1);
1141static SENSOR_DEVICE_ATTR_2_RW(temp2_smoothing, temp_st, 0, 1);
1142static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, INPUT, 2);
1143static SENSOR_DEVICE_ATTR_2_RO(temp3_alarm, temp, ALARM, 2);
1144static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, temp, FAULT, 2);
1145static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, MAX, 2);
1146static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, MIN, 2);
1147static SENSOR_DEVICE_ATTR_2_RW(temp3_offset, temp, OFFSET, 2);
1148static SENSOR_DEVICE_ATTR_2_RW(temp3_auto_point1_temp, temp, AUTOMIN, 2);
1149static SENSOR_DEVICE_ATTR_2_RW(temp3_auto_point2_temp, point2, 0, 2);
1150static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, THERM, 2);
1151static SENSOR_DEVICE_ATTR_2_RW(temp3_crit_hyst, temp, HYSTERSIS, 2);
1152static SENSOR_DEVICE_ATTR_2_RW(temp3_smoothing, temp_st, 0, 2);
1153static SENSOR_DEVICE_ATTR_2_RO(fan1_input, tach, INPUT, 0);
1154static SENSOR_DEVICE_ATTR_2_RW(fan1_min, tach, MIN, 0);
1155static SENSOR_DEVICE_ATTR_2_RO(fan1_alarm, tach, ALARM, 0);
1156static SENSOR_DEVICE_ATTR_2_RO(fan2_input, tach, INPUT, 1);
1157static SENSOR_DEVICE_ATTR_2_RW(fan2_min, tach, MIN, 1);
1158static SENSOR_DEVICE_ATTR_2_RO(fan2_alarm, tach, ALARM, 1);
1159static SENSOR_DEVICE_ATTR_2_RO(fan3_input, tach, INPUT, 2);
1160static SENSOR_DEVICE_ATTR_2_RW(fan3_min, tach, MIN, 2);
1161static SENSOR_DEVICE_ATTR_2_RO(fan3_alarm, tach, ALARM, 2);
1162static SENSOR_DEVICE_ATTR_2_RO(fan4_input, tach, INPUT, 3);
1163static SENSOR_DEVICE_ATTR_2_RW(fan4_min, tach, MIN, 3);
1164static SENSOR_DEVICE_ATTR_2_RO(fan4_alarm, tach, ALARM, 3);
1165static SENSOR_DEVICE_ATTR_2_RW(pwm1, pwm, INPUT, 0);
1166static SENSOR_DEVICE_ATTR_2_RW(pwm1_freq, pwmfreq, INPUT, 0);
1167static SENSOR_DEVICE_ATTR_2_RW(pwm1_enable, pwmctrl, INPUT, 0);
1168static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_channels_temp, pwmchan, INPUT, 0);
1169static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, pwm, MIN, 0);
1170static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, pwm, MAX, 0);
1171static SENSOR_DEVICE_ATTR_2_RW(pwm1_stall_disable, stall_disable, 0, 0);
1172static SENSOR_DEVICE_ATTR_2_RW(pwm2, pwm, INPUT, 1);
1173static SENSOR_DEVICE_ATTR_2_RW(pwm2_freq, pwmfreq, INPUT, 1);
1174static SENSOR_DEVICE_ATTR_2_RW(pwm2_enable, pwmctrl, INPUT, 1);
1175static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_channels_temp, pwmchan, INPUT, 1);
1176static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, pwm, MIN, 1);
1177static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, pwm, MAX, 1);
1178static SENSOR_DEVICE_ATTR_2_RW(pwm2_stall_disable, stall_disable, 0, 1);
1179static SENSOR_DEVICE_ATTR_2_RW(pwm3, pwm, INPUT, 2);
1180static SENSOR_DEVICE_ATTR_2_RW(pwm3_freq, pwmfreq, INPUT, 2);
1181static SENSOR_DEVICE_ATTR_2_RW(pwm3_enable, pwmctrl, INPUT, 2);
1182static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_channels_temp, pwmchan, INPUT, 2);
1183static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_pwm, pwm, MIN, 2);
1184static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_pwm, pwm, MAX, 2);
1185static SENSOR_DEVICE_ATTR_2_RW(pwm3_stall_disable, stall_disable, 0, 2);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1186
1187/* Non-standard name, might need revisiting */
1188static DEVICE_ATTR_RW(pwm_use_point2_pwm_at_crit);
 
1189
1190static DEVICE_ATTR_RW(vrm);
1191static DEVICE_ATTR_RO(cpu0_vid);
1192
1193static struct attribute *adt7475_attrs[] = {
1194	&sensor_dev_attr_in1_input.dev_attr.attr,
1195	&sensor_dev_attr_in1_max.dev_attr.attr,
1196	&sensor_dev_attr_in1_min.dev_attr.attr,
1197	&sensor_dev_attr_in1_alarm.dev_attr.attr,
1198	&sensor_dev_attr_in2_input.dev_attr.attr,
1199	&sensor_dev_attr_in2_max.dev_attr.attr,
1200	&sensor_dev_attr_in2_min.dev_attr.attr,
1201	&sensor_dev_attr_in2_alarm.dev_attr.attr,
1202	&sensor_dev_attr_temp1_input.dev_attr.attr,
1203	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
1204	&sensor_dev_attr_temp1_fault.dev_attr.attr,
1205	&sensor_dev_attr_temp1_max.dev_attr.attr,
1206	&sensor_dev_attr_temp1_min.dev_attr.attr,
1207	&sensor_dev_attr_temp1_offset.dev_attr.attr,
1208	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1209	&sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1210	&sensor_dev_attr_temp1_crit.dev_attr.attr,
1211	&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
1212	&sensor_dev_attr_temp1_smoothing.dev_attr.attr,
1213	&sensor_dev_attr_temp2_input.dev_attr.attr,
1214	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
1215	&sensor_dev_attr_temp2_max.dev_attr.attr,
1216	&sensor_dev_attr_temp2_min.dev_attr.attr,
1217	&sensor_dev_attr_temp2_offset.dev_attr.attr,
1218	&sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1219	&sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1220	&sensor_dev_attr_temp2_crit.dev_attr.attr,
1221	&sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
1222	&sensor_dev_attr_temp2_smoothing.dev_attr.attr,
1223	&sensor_dev_attr_temp3_input.dev_attr.attr,
1224	&sensor_dev_attr_temp3_fault.dev_attr.attr,
1225	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
1226	&sensor_dev_attr_temp3_max.dev_attr.attr,
1227	&sensor_dev_attr_temp3_min.dev_attr.attr,
1228	&sensor_dev_attr_temp3_offset.dev_attr.attr,
1229	&sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1230	&sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1231	&sensor_dev_attr_temp3_crit.dev_attr.attr,
1232	&sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
1233	&sensor_dev_attr_temp3_smoothing.dev_attr.attr,
1234	&sensor_dev_attr_fan1_input.dev_attr.attr,
1235	&sensor_dev_attr_fan1_min.dev_attr.attr,
1236	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
1237	&sensor_dev_attr_fan2_input.dev_attr.attr,
1238	&sensor_dev_attr_fan2_min.dev_attr.attr,
1239	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
1240	&sensor_dev_attr_fan3_input.dev_attr.attr,
1241	&sensor_dev_attr_fan3_min.dev_attr.attr,
1242	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
1243	&sensor_dev_attr_pwm1.dev_attr.attr,
1244	&sensor_dev_attr_pwm1_freq.dev_attr.attr,
1245	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
1246	&sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1247	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1248	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1249	&sensor_dev_attr_pwm1_stall_disable.dev_attr.attr,
1250	&sensor_dev_attr_pwm3.dev_attr.attr,
1251	&sensor_dev_attr_pwm3_freq.dev_attr.attr,
1252	&sensor_dev_attr_pwm3_enable.dev_attr.attr,
1253	&sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1254	&sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1255	&sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1256	&sensor_dev_attr_pwm3_stall_disable.dev_attr.attr,
1257	&dev_attr_pwm_use_point2_pwm_at_crit.attr,
1258	NULL,
1259};
1260
1261static struct attribute *fan4_attrs[] = {
1262	&sensor_dev_attr_fan4_input.dev_attr.attr,
1263	&sensor_dev_attr_fan4_min.dev_attr.attr,
1264	&sensor_dev_attr_fan4_alarm.dev_attr.attr,
1265	NULL
1266};
1267
1268static struct attribute *pwm2_attrs[] = {
1269	&sensor_dev_attr_pwm2.dev_attr.attr,
1270	&sensor_dev_attr_pwm2_freq.dev_attr.attr,
1271	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
1272	&sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1273	&sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1274	&sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1275	&sensor_dev_attr_pwm2_stall_disable.dev_attr.attr,
1276	NULL
1277};
1278
1279static struct attribute *in0_attrs[] = {
1280	&sensor_dev_attr_in0_input.dev_attr.attr,
1281	&sensor_dev_attr_in0_max.dev_attr.attr,
1282	&sensor_dev_attr_in0_min.dev_attr.attr,
1283	&sensor_dev_attr_in0_alarm.dev_attr.attr,
1284	NULL
1285};
1286
1287static struct attribute *in3_attrs[] = {
1288	&sensor_dev_attr_in3_input.dev_attr.attr,
1289	&sensor_dev_attr_in3_max.dev_attr.attr,
1290	&sensor_dev_attr_in3_min.dev_attr.attr,
1291	&sensor_dev_attr_in3_alarm.dev_attr.attr,
1292	NULL
1293};
1294
1295static struct attribute *in4_attrs[] = {
1296	&sensor_dev_attr_in4_input.dev_attr.attr,
1297	&sensor_dev_attr_in4_max.dev_attr.attr,
1298	&sensor_dev_attr_in4_min.dev_attr.attr,
1299	&sensor_dev_attr_in4_alarm.dev_attr.attr,
1300	NULL
1301};
1302
1303static struct attribute *in5_attrs[] = {
1304	&sensor_dev_attr_in5_input.dev_attr.attr,
1305	&sensor_dev_attr_in5_max.dev_attr.attr,
1306	&sensor_dev_attr_in5_min.dev_attr.attr,
1307	&sensor_dev_attr_in5_alarm.dev_attr.attr,
1308	NULL
1309};
1310
1311static struct attribute *in6_attrs[] = {
1312	&sensor_dev_attr_in6_input.dev_attr.attr,
1313	&sensor_dev_attr_in6_max.dev_attr.attr,
1314	&sensor_dev_attr_in6_min.dev_attr.attr,
1315	&sensor_dev_attr_in6_alarm.dev_attr.attr,
1316	NULL
1317};
1318
1319static struct attribute *vid_attrs[] = {
1320	&dev_attr_cpu0_vid.attr,
1321	&dev_attr_vrm.attr,
1322	NULL
1323};
1324
1325static const struct attribute_group adt7475_attr_group = { .attrs = adt7475_attrs };
1326static const struct attribute_group fan4_attr_group = { .attrs = fan4_attrs };
1327static const struct attribute_group pwm2_attr_group = { .attrs = pwm2_attrs };
1328static const struct attribute_group in0_attr_group = { .attrs = in0_attrs };
1329static const struct attribute_group in3_attr_group = { .attrs = in3_attrs };
1330static const struct attribute_group in4_attr_group = { .attrs = in4_attrs };
1331static const struct attribute_group in5_attr_group = { .attrs = in5_attrs };
1332static const struct attribute_group in6_attr_group = { .attrs = in6_attrs };
1333static const struct attribute_group vid_attr_group = { .attrs = vid_attrs };
1334
1335static int adt7475_detect(struct i2c_client *client,
1336			  struct i2c_board_info *info)
1337{
1338	struct i2c_adapter *adapter = client->adapter;
1339	int vendid, devid, devid2;
1340	const char *name;
1341
1342	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1343		return -ENODEV;
1344
1345	vendid = adt7475_read(REG_VENDID);
1346	devid2 = adt7475_read(REG_DEVID2);
1347	if (vendid != 0x41 ||		/* Analog Devices */
1348	    (devid2 & 0xf8) != 0x68)
1349		return -ENODEV;
1350
1351	devid = adt7475_read(REG_DEVID);
1352	if (devid == 0x73)
1353		name = "adt7473";
1354	else if (devid == 0x75 && client->addr == 0x2e)
1355		name = "adt7475";
1356	else if (devid == 0x76)
1357		name = "adt7476";
1358	else if ((devid2 & 0xfc) == 0x6c)
1359		name = "adt7490";
1360	else {
1361		dev_dbg(&adapter->dev,
1362			"Couldn't detect an ADT7473/75/76/90 part at "
1363			"0x%02x\n", (unsigned int)client->addr);
1364		return -ENODEV;
1365	}
1366
1367	strscpy(info->type, name, I2C_NAME_SIZE);
1368
1369	return 0;
1370}
1371
1372static int adt7475_update_limits(struct i2c_client *client)
1373{
1374	struct adt7475_data *data = i2c_get_clientdata(client);
1375	int i;
1376	int ret;
1377
1378	ret = adt7475_read(REG_CONFIG4);
1379	if (ret < 0)
1380		return ret;
1381	data->config4 = ret;
1382
1383	ret = adt7475_read(REG_CONFIG5);
1384	if (ret < 0)
1385		return ret;
1386	data->config5 = ret;
1387
1388	for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
1389		if (!(data->has_voltage & (1 << i)))
1390			continue;
1391		/* Adjust values so they match the input precision */
1392		ret = adt7475_read(VOLTAGE_MIN_REG(i));
1393		if (ret < 0)
1394			return ret;
1395		data->voltage[MIN][i] = ret << 2;
1396
1397		ret = adt7475_read(VOLTAGE_MAX_REG(i));
1398		if (ret < 0)
1399			return ret;
1400		data->voltage[MAX][i] = ret << 2;
1401	}
1402
1403	if (data->has_voltage & (1 << 5)) {
1404		ret = adt7475_read(REG_VTT_MIN);
1405		if (ret < 0)
1406			return ret;
1407		data->voltage[MIN][5] = ret << 2;
1408
1409		ret = adt7475_read(REG_VTT_MAX);
1410		if (ret < 0)
1411			return ret;
1412		data->voltage[MAX][5] = ret << 2;
1413	}
1414
1415	if (data->has_voltage & (1 << 6)) {
1416		ret = adt7475_read(REG_IMON_MIN);
1417		if (ret < 0)
1418			return ret;
1419		data->voltage[MIN][6] = ret << 2;
1420
1421		ret = adt7475_read(REG_IMON_MAX);
1422		if (ret < 0)
1423			return ret;
1424		data->voltage[MAX][6] = ret << 2;
1425	}
1426
1427	for (i = 0; i < ADT7475_TEMP_COUNT; i++) {
1428		/* Adjust values so they match the input precision */
1429		ret = adt7475_read(TEMP_MIN_REG(i));
1430		if (ret < 0)
1431			return ret;
1432		data->temp[MIN][i] = ret << 2;
1433
1434		ret = adt7475_read(TEMP_MAX_REG(i));
1435		if (ret < 0)
1436			return ret;
1437		data->temp[MAX][i] = ret << 2;
1438
1439		ret = adt7475_read(TEMP_TMIN_REG(i));
1440		if (ret < 0)
1441			return ret;
1442		data->temp[AUTOMIN][i] = ret << 2;
1443
1444		ret = adt7475_read(TEMP_THERM_REG(i));
1445		if (ret < 0)
1446			return ret;
1447		data->temp[THERM][i] = ret << 2;
1448
1449		ret = adt7475_read(TEMP_OFFSET_REG(i));
1450		if (ret < 0)
1451			return ret;
1452		data->temp[OFFSET][i] = ret;
1453	}
1454	adt7475_read_hystersis(client);
1455
1456	for (i = 0; i < ADT7475_TACH_COUNT; i++) {
1457		if (i == 3 && !data->has_fan4)
1458			continue;
1459		ret = adt7475_read_word(client, TACH_MIN_REG(i));
1460		if (ret < 0)
1461			return ret;
1462		data->tach[MIN][i] = ret;
1463	}
1464
1465	for (i = 0; i < ADT7475_PWM_COUNT; i++) {
1466		if (i == 1 && !data->has_pwm2)
1467			continue;
1468		ret = adt7475_read(PWM_MAX_REG(i));
1469		if (ret < 0)
1470			return ret;
1471		data->pwm[MAX][i] = ret;
1472
1473		ret = adt7475_read(PWM_MIN_REG(i));
1474		if (ret < 0)
1475			return ret;
1476		data->pwm[MIN][i] = ret;
1477		/* Set the channel and control information */
1478		adt7475_read_pwm(client, i);
1479	}
1480
1481	ret = adt7475_read(TEMP_TRANGE_REG(0));
1482	if (ret < 0)
1483		return ret;
1484	data->range[0] = ret;
1485
1486	ret = adt7475_read(TEMP_TRANGE_REG(1));
1487	if (ret < 0)
1488		return ret;
1489	data->range[1] = ret;
1490
1491	ret = adt7475_read(TEMP_TRANGE_REG(2));
1492	if (ret < 0)
1493		return ret;
1494	data->range[2] = ret;
1495
1496	return 0;
1497}
1498
1499static int load_config3(const struct i2c_client *client, const char *propname)
1500{
1501	const char *function;
1502	u8 config3;
1503	int ret;
1504
1505	ret = device_property_read_string(&client->dev, propname, &function);
1506	if (!ret) {
1507		ret = adt7475_read(REG_CONFIG3);
1508		if (ret < 0)
1509			return ret;
1510
1511		config3 = ret & ~CONFIG3_SMBALERT;
1512		if (!strcmp("pwm2", function))
1513			;
1514		else if (!strcmp("smbalert#", function))
1515			config3 |= CONFIG3_SMBALERT;
1516		else
1517			return -EINVAL;
1518
1519		return i2c_smbus_write_byte_data(client, REG_CONFIG3, config3);
1520	}
1521
1522	return 0;
1523}
1524
1525static int load_config4(const struct i2c_client *client, const char *propname)
 
1526{
1527	const char *function;
1528	u8 config4;
1529	int ret;
1530
1531	ret = device_property_read_string(&client->dev, propname, &function);
1532	if (!ret) {
1533		ret = adt7475_read(REG_CONFIG4);
1534		if (ret < 0)
1535			return ret;
1536
1537		config4 = ret & ~CONFIG4_PINFUNC;
1538
1539		if (!strcmp("tach4", function))
1540			;
1541		else if (!strcmp("therm#", function))
1542			config4 |= CONFIG4_THERM;
1543		else if (!strcmp("smbalert#", function))
1544			config4 |= CONFIG4_SMBALERT;
1545		else if (!strcmp("gpio", function))
1546			config4 |= CONFIG4_PINFUNC;
1547		else
1548			return -EINVAL;
1549
1550		return i2c_smbus_write_byte_data(client, REG_CONFIG4, config4);
1551	}
1552
1553	return 0;
1554}
1555
1556static int load_config(const struct i2c_client *client, enum chips chip)
 
1557{
1558	int err;
1559	const char *prop1, *prop2;
1560
1561	switch (chip) {
1562	case adt7473:
1563	case adt7475:
1564		prop1 = "adi,pin5-function";
1565		prop2 = "adi,pin9-function";
1566		break;
1567	case adt7476:
1568	case adt7490:
1569		prop1 = "adi,pin10-function";
1570		prop2 = "adi,pin14-function";
1571		break;
1572	}
1573
1574	err = load_config3(client, prop1);
1575	if (err) {
1576		dev_err(&client->dev, "failed to configure %s\n", prop1);
1577		return err;
1578	}
1579
1580	err = load_config4(client, prop2);
1581	if (err) {
1582		dev_err(&client->dev, "failed to configure %s\n", prop2);
1583		return err;
1584	}
1585
1586	return 0;
1587}
1588
1589static int set_property_bit(const struct i2c_client *client, char *property,
1590			    u8 *config, u8 bit_index)
1591{
1592	u32 prop_value = 0;
1593	int ret = device_property_read_u32(&client->dev, property,
1594					   &prop_value);
1595
1596	if (!ret) {
1597		if (prop_value)
1598			*config |= (1 << bit_index);
1599		else
1600			*config &= ~(1 << bit_index);
1601	}
1602
1603	return ret;
1604}
1605
1606static int load_attenuators(const struct i2c_client *client, enum chips chip,
1607			    struct adt7475_data *data)
1608{
1609	switch (chip) {
1610	case adt7476:
1611	case adt7490:
1612		set_property_bit(client, "adi,bypass-attenuator-in0",
1613				 &data->config4, 4);
1614		set_property_bit(client, "adi,bypass-attenuator-in1",
1615				 &data->config4, 5);
1616		set_property_bit(client, "adi,bypass-attenuator-in3",
1617				 &data->config4, 6);
1618		set_property_bit(client, "adi,bypass-attenuator-in4",
1619				 &data->config4, 7);
1620
1621		return i2c_smbus_write_byte_data(client, REG_CONFIG4,
1622						 data->config4);
1623	case adt7473:
1624	case adt7475:
1625		set_property_bit(client, "adi,bypass-attenuator-in1",
1626				 &data->config2, 5);
1627
1628		return i2c_smbus_write_byte_data(client, REG_CONFIG2,
1629						 data->config2);
1630	}
1631
1632	return 0;
1633}
1634
1635static int adt7475_set_pwm_polarity(struct i2c_client *client)
1636{
1637	u32 states[ADT7475_PWM_COUNT];
1638	int ret, i;
1639	u8 val;
1640
1641	ret = device_property_read_u32_array(&client->dev,
1642					     "adi,pwm-active-state", states,
1643					     ARRAY_SIZE(states));
1644	if (ret)
1645		return ret;
1646
1647	for (i = 0; i < ADT7475_PWM_COUNT; i++) {
1648		ret = adt7475_read(PWM_CONFIG_REG(i));
1649		if (ret < 0)
1650			return ret;
1651		val = ret;
1652		if (states[i])
1653			val &= ~BIT(4);
1654		else
1655			val |= BIT(4);
1656
1657		ret = i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(i), val);
1658		if (ret)
1659			return ret;
1660	}
1661
1662	return 0;
1663}
1664
1665static int adt7475_probe(struct i2c_client *client)
1666{
1667	enum chips chip;
1668	static const char * const names[] = {
1669		[adt7473] = "ADT7473",
1670		[adt7475] = "ADT7475",
1671		[adt7476] = "ADT7476",
1672		[adt7490] = "ADT7490",
1673	};
1674
1675	struct adt7475_data *data;
1676	struct device *hwmon_dev;
1677	int i, ret = 0, revision, group_num = 0;
1678	u8 config3;
1679	const struct i2c_device_id *id = i2c_match_id(adt7475_id, client);
1680
1681	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1682	if (data == NULL)
1683		return -ENOMEM;
1684
1685	mutex_init(&data->lock);
1686	data->client = client;
1687	i2c_set_clientdata(client, data);
1688
1689	if (client->dev.of_node)
1690		chip = (uintptr_t)of_device_get_match_data(&client->dev);
1691	else
1692		chip = id->driver_data;
1693
1694	/* Initialize device-specific values */
1695	switch (chip) {
1696	case adt7476:
1697		data->has_voltage = 0x0e;	/* in1 to in3 */
1698		revision = adt7475_read(REG_DEVID2) & 0x07;
1699		break;
1700	case adt7490:
1701		data->has_voltage = 0x7e;	/* in1 to in6 */
1702		revision = adt7475_read(REG_DEVID2) & 0x03;
1703		if (revision == 0x03)
1704			revision += adt7475_read(REG_DEVREV2);
1705		break;
1706	default:
1707		data->has_voltage = 0x06;	/* in1, in2 */
1708		revision = adt7475_read(REG_DEVID2) & 0x07;
1709	}
1710
1711	ret = load_config(client, chip);
1712	if (ret)
1713		return ret;
1714
1715	config3 = adt7475_read(REG_CONFIG3);
1716	/* Pin PWM2 may alternatively be used for ALERT output */
1717	if (!(config3 & CONFIG3_SMBALERT))
1718		data->has_pwm2 = 1;
1719	/* Meaning of this bit is inverted for the ADT7473-1 */
1720	if (id->driver_data == adt7473 && revision >= 1)
1721		data->has_pwm2 = !data->has_pwm2;
1722
1723	data->config4 = adt7475_read(REG_CONFIG4);
1724	/* Pin TACH4 may alternatively be used for THERM */
1725	if ((data->config4 & CONFIG4_PINFUNC) == 0x0)
1726		data->has_fan4 = 1;
1727
1728	/*
1729	 * THERM configuration is more complex on the ADT7476 and ADT7490,
1730	 * because 2 different pins (TACH4 and +2.5 Vin) can be used for
1731	 * this function
1732	 */
1733	if (id->driver_data == adt7490) {
1734		if ((data->config4 & CONFIG4_PINFUNC) == 0x1 &&
1735		    !(config3 & CONFIG3_THERM))
1736			data->has_fan4 = 1;
1737	}
1738	if (id->driver_data == adt7476 || id->driver_data == adt7490) {
1739		if (!(config3 & CONFIG3_THERM) ||
1740		    (data->config4 & CONFIG4_PINFUNC) == 0x1)
1741			data->has_voltage |= (1 << 0);		/* in0 */
1742	}
1743
1744	/*
1745	 * On the ADT7476, the +12V input pin may instead be used as VID5,
1746	 * and VID pins may alternatively be used as GPIO
1747	 */
1748	if (id->driver_data == adt7476) {
1749		u8 vid = adt7475_read(REG_VID);
1750		if (!(vid & VID_VIDSEL))
1751			data->has_voltage |= (1 << 4);		/* in4 */
1752
1753		data->has_vid = !(adt7475_read(REG_CONFIG5) & CONFIG5_VIDGPIO);
1754	}
1755
1756	/* Voltage attenuators can be bypassed, globally or individually */
1757	data->config2 = adt7475_read(REG_CONFIG2);
1758	ret = load_attenuators(client, chip, data);
1759	if (ret)
1760		dev_warn(&client->dev, "Error configuring attenuator bypass\n");
1761
1762	if (data->config2 & CONFIG2_ATTN) {
1763		data->bypass_attn = (0x3 << 3) | 0x3;
1764	} else {
1765		data->bypass_attn = ((data->config4 & CONFIG4_ATTN_IN10) >> 4) |
1766				    ((data->config4 & CONFIG4_ATTN_IN43) >> 3);
1767	}
1768	data->bypass_attn &= data->has_voltage;
1769
1770	/*
1771	 * Call adt7475_read_pwm for all pwm's as this will reprogram any
1772	 * pwm's which are disabled to manual mode with 0% duty cycle
1773	 */
1774	for (i = 0; i < ADT7475_PWM_COUNT; i++)
1775		adt7475_read_pwm(client, i);
1776
1777	ret = adt7475_set_pwm_polarity(client);
1778	if (ret && ret != -EINVAL)
1779		dev_warn(&client->dev, "Error configuring pwm polarity\n");
1780
1781	/* Start monitoring */
1782	switch (chip) {
1783	case adt7475:
1784	case adt7476:
1785		i2c_smbus_write_byte_data(client, REG_CONFIG1,
1786					  adt7475_read(REG_CONFIG1) | 0x01);
1787		break;
1788	default:
1789		break;
1790	}
1791
1792	data->groups[group_num++] = &adt7475_attr_group;
1793
1794	/* Features that can be disabled individually */
1795	if (data->has_fan4) {
1796		data->groups[group_num++] = &fan4_attr_group;
 
 
1797	}
1798	if (data->has_pwm2) {
1799		data->groups[group_num++] = &pwm2_attr_group;
 
 
1800	}
1801	if (data->has_voltage & (1 << 0)) {
1802		data->groups[group_num++] = &in0_attr_group;
 
 
1803	}
1804	if (data->has_voltage & (1 << 3)) {
1805		data->groups[group_num++] = &in3_attr_group;
 
 
1806	}
1807	if (data->has_voltage & (1 << 4)) {
1808		data->groups[group_num++] = &in4_attr_group;
 
 
1809	}
1810	if (data->has_voltage & (1 << 5)) {
1811		data->groups[group_num++] = &in5_attr_group;
1812	}
1813	if (data->has_voltage & (1 << 6)) {
1814		data->groups[group_num++] = &in6_attr_group;
1815	}
1816	if (data->has_vid) {
1817		data->vrm = vid_which_vrm();
1818		data->groups[group_num] = &vid_attr_group;
 
 
1819	}
1820
1821	/* register device with all the acquired attributes */
1822	hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
1823							   client->name, data,
1824							   data->groups);
1825
1826	if (IS_ERR(hwmon_dev)) {
1827		ret = PTR_ERR(hwmon_dev);
1828		return ret;
1829	}
1830
1831	dev_info(&client->dev, "%s device, revision %d\n",
1832		 names[id->driver_data], revision);
1833	if ((data->has_voltage & 0x11) || data->has_fan4 || data->has_pwm2)
1834		dev_info(&client->dev, "Optional features:%s%s%s%s%s\n",
1835			 (data->has_voltage & (1 << 0)) ? " in0" : "",
1836			 (data->has_voltage & (1 << 4)) ? " in4" : "",
1837			 data->has_fan4 ? " fan4" : "",
1838			 data->has_pwm2 ? " pwm2" : "",
1839			 data->has_vid ? " vid" : "");
1840	if (data->bypass_attn)
1841		dev_info(&client->dev, "Bypassing attenuators on:%s%s%s%s\n",
1842			 (data->bypass_attn & (1 << 0)) ? " in0" : "",
1843			 (data->bypass_attn & (1 << 1)) ? " in1" : "",
1844			 (data->bypass_attn & (1 << 3)) ? " in3" : "",
1845			 (data->bypass_attn & (1 << 4)) ? " in4" : "");
1846
1847	/* Limits and settings, should never change update more than once */
1848	ret = adt7475_update_limits(client);
1849	if (ret)
1850		return ret;
 
 
 
 
 
 
 
 
 
1851
1852	return 0;
1853}
1854
1855static struct i2c_driver adt7475_driver = {
1856	.class		= I2C_CLASS_HWMON,
1857	.driver = {
1858		.name	= "adt7475",
1859		.of_match_table = of_match_ptr(adt7475_of_match),
1860	},
1861	.probe		= adt7475_probe,
 
1862	.id_table	= adt7475_id,
1863	.detect		= adt7475_detect,
1864	.address_list	= normal_i2c,
1865};
1866
1867static void adt7475_read_hystersis(struct i2c_client *client)
1868{
1869	struct adt7475_data *data = i2c_get_clientdata(client);
1870
1871	data->temp[HYSTERSIS][0] = (u16) adt7475_read(REG_REMOTE1_HYSTERSIS);
1872	data->temp[HYSTERSIS][1] = data->temp[HYSTERSIS][0];
1873	data->temp[HYSTERSIS][2] = (u16) adt7475_read(REG_REMOTE2_HYSTERSIS);
1874}
1875
1876static void adt7475_read_pwm(struct i2c_client *client, int index)
1877{
1878	struct adt7475_data *data = i2c_get_clientdata(client);
1879	unsigned int v;
1880
1881	data->pwm[CONTROL][index] = adt7475_read(PWM_CONFIG_REG(index));
1882
1883	/*
1884	 * Figure out the internal value for pwmctrl and pwmchan
1885	 * based on the current settings
1886	 */
1887	v = (data->pwm[CONTROL][index] >> 5) & 7;
1888
1889	if (v == 3)
1890		data->pwmctl[index] = 0;
1891	else if (v == 7)
1892		data->pwmctl[index] = 1;
1893	else if (v == 4) {
1894		/*
1895		 * The fan is disabled - we don't want to
1896		 * support that, so change to manual mode and
1897		 * set the duty cycle to 0 instead
1898		 */
1899		data->pwm[INPUT][index] = 0;
1900		data->pwm[CONTROL][index] &= ~0xE0;
1901		data->pwm[CONTROL][index] |= (7 << 5);
1902
1903		i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
1904					  data->pwm[INPUT][index]);
1905
1906		i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
1907					  data->pwm[CONTROL][index]);
1908
1909		data->pwmctl[index] = 1;
1910	} else {
1911		data->pwmctl[index] = 2;
1912
1913		switch (v) {
1914		case 0:
1915			data->pwmchan[index] = 1;
1916			break;
1917		case 1:
1918			data->pwmchan[index] = 2;
1919			break;
1920		case 2:
1921			data->pwmchan[index] = 4;
1922			break;
1923		case 5:
1924			data->pwmchan[index] = 6;
1925			break;
1926		case 6:
1927			data->pwmchan[index] = 7;
1928			break;
1929		}
1930	}
1931}
1932
1933static int adt7475_update_measure(struct device *dev)
1934{
1935	struct adt7475_data *data = dev_get_drvdata(dev);
1936	struct i2c_client *client = data->client;
1937	u16 ext;
1938	int i;
1939	int ret;
1940
1941	ret = adt7475_read(REG_STATUS2);
1942	if (ret < 0)
1943		return ret;
1944	data->alarms = ret << 8;
1945
1946	ret = adt7475_read(REG_STATUS1);
1947	if (ret < 0)
1948		return ret;
1949	data->alarms |= ret;
 
1950
1951	ret = adt7475_read(REG_EXTEND2);
1952	if (ret < 0)
1953		return ret;
 
 
 
 
 
 
1954
1955	ext = (ret << 8);
 
 
 
 
 
 
 
 
 
 
1956
1957	ret = adt7475_read(REG_EXTEND1);
1958	if (ret < 0)
1959		return ret;
 
 
 
1960
1961	ext |= ret;
 
 
 
 
 
1962
1963	for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
1964		if (!(data->has_voltage & (1 << i)))
1965			continue;
1966		ret = adt7475_read(VOLTAGE_REG(i));
1967		if (ret < 0)
1968			return ret;
1969		data->voltage[INPUT][i] =
1970			(ret << 2) |
1971			((ext >> (i * 2)) & 3);
1972	}
1973
1974	for (i = 0; i < ADT7475_TEMP_COUNT; i++) {
1975		ret = adt7475_read(TEMP_REG(i));
1976		if (ret < 0)
1977			return ret;
1978		data->temp[INPUT][i] =
1979			(ret << 2) |
1980			((ext >> ((i + 5) * 2)) & 3);
1981	}
1982
1983	if (data->has_voltage & (1 << 5)) {
1984		ret = adt7475_read(REG_STATUS4);
1985		if (ret < 0)
1986			return ret;
1987		data->alarms |= ret << 24;
1988
1989		ret = adt7475_read(REG_EXTEND3);
1990		if (ret < 0)
1991			return ret;
1992		ext = ret;
1993
1994		ret = adt7475_read(REG_VTT);
1995		if (ret < 0)
1996			return ret;
1997		data->voltage[INPUT][5] = ret << 2 |
1998			((ext >> 4) & 3);
1999	}
2000
2001	if (data->has_voltage & (1 << 6)) {
2002		ret = adt7475_read(REG_STATUS4);
2003		if (ret < 0)
2004			return ret;
2005		data->alarms |= ret << 24;
2006
2007		ret = adt7475_read(REG_EXTEND3);
2008		if (ret < 0)
2009			return ret;
2010		ext = ret;
2011
2012		ret = adt7475_read(REG_IMON);
2013		if (ret < 0)
2014			return ret;
2015		data->voltage[INPUT][6] = ret << 2 |
2016			((ext >> 6) & 3);
2017	}
2018
2019	for (i = 0; i < ADT7475_TACH_COUNT; i++) {
2020		if (i == 3 && !data->has_fan4)
2021			continue;
2022		ret = adt7475_read_word(client, TACH_REG(i));
2023		if (ret < 0)
2024			return ret;
2025		data->tach[INPUT][i] = ret;
2026	}
 
2027
2028	/* Updated by hw when in auto mode */
2029	for (i = 0; i < ADT7475_PWM_COUNT; i++) {
2030		if (i == 1 && !data->has_pwm2)
2031			continue;
2032		ret = adt7475_read(PWM_REG(i));
2033		if (ret < 0)
2034			return ret;
2035		data->pwm[INPUT][i] = ret;
2036	}
2037
2038	if (data->has_vid) {
2039		ret = adt7475_read(REG_VID);
2040		if (ret < 0)
2041			return ret;
2042		data->vid = ret & 0x3f;
2043	}
 
 
 
 
 
 
 
 
2044
2045	return 0;
2046}
 
 
 
 
2047
2048static struct adt7475_data *adt7475_update_device(struct device *dev)
2049{
2050	struct adt7475_data *data = dev_get_drvdata(dev);
2051	int ret;
 
 
 
 
2052
2053	mutex_lock(&data->lock);
 
 
2054
2055	/* Measurement values update every 2 seconds */
2056	if (time_after(jiffies, data->measure_updated + HZ * 2) ||
2057	    !data->valid) {
2058		ret = adt7475_update_measure(dev);
2059		if (ret) {
2060			data->valid = false;
2061			mutex_unlock(&data->lock);
2062			return ERR_PTR(ret);
2063		}
2064		data->measure_updated = jiffies;
2065		data->valid = true;
2066	}
2067
2068	mutex_unlock(&data->lock);
2069
2070	return data;
2071}
2072
2073module_i2c_driver(adt7475_driver);
2074
2075MODULE_AUTHOR("Advanced Micro Devices, Inc");
2076MODULE_DESCRIPTION("adt7475 driver");
2077MODULE_LICENSE("GPL");