xref: /linux/drivers/hwmon/adt7475.c (revision 2ecff39791bd3b33c8dcf0d241fa740dba7b79e6)
1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21c301fc5SJordan Crouse /*
31c301fc5SJordan Crouse  * adt7475 - Thermal sensor driver for the ADT7475 chip and derivatives
41c301fc5SJordan Crouse  * Copyright (C) 2007-2008, Advanced Micro Devices, Inc.
51c301fc5SJordan Crouse  * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
61c301fc5SJordan Crouse  * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com>
77c81c60fSJean Delvare  * Copyright (C) 2009 Jean Delvare <jdelvare@suse.de>
83d849981SJean Delvare  *
91c301fc5SJordan Crouse  * Derived from the lm83 driver by Jean Delvare
101c301fc5SJordan Crouse  */
111c301fc5SJordan Crouse 
121c301fc5SJordan Crouse #include <linux/module.h>
134e2496e4SJavier Martinez Canillas #include <linux/of_device.h>
141c301fc5SJordan Crouse #include <linux/init.h>
151c301fc5SJordan Crouse #include <linux/slab.h>
161c301fc5SJordan Crouse #include <linux/i2c.h>
171c301fc5SJordan Crouse #include <linux/hwmon.h>
181c301fc5SJordan Crouse #include <linux/hwmon-sysfs.h>
1954fe4671SJean Delvare #include <linux/hwmon-vid.h>
201c301fc5SJordan Crouse #include <linux/err.h>
21dcd8f392SJean Delvare #include <linux/jiffies.h>
22*2ecff397SLogan Shaw #include <linux/of.h>
23e4651640SChris Packham #include <linux/util_macros.h>
241c301fc5SJordan Crouse 
251c301fc5SJordan Crouse /* Indexes for the sysfs hooks */
261c301fc5SJordan Crouse 
271c301fc5SJordan Crouse #define INPUT		0
281c301fc5SJordan Crouse #define MIN		1
291c301fc5SJordan Crouse #define MAX		2
301c301fc5SJordan Crouse #define CONTROL		3
311c301fc5SJordan Crouse #define OFFSET		3
321c301fc5SJordan Crouse #define AUTOMIN		4
331c301fc5SJordan Crouse #define THERM		5
341c301fc5SJordan Crouse #define HYSTERSIS	6
351c301fc5SJordan Crouse 
369ed5bc24SGuenter Roeck /*
379ed5bc24SGuenter Roeck  * These are unique identifiers for the sysfs functions - unlike the
389ed5bc24SGuenter Roeck  * numbers above, these are not also indexes into an array
391c301fc5SJordan Crouse  */
401c301fc5SJordan Crouse 
411c301fc5SJordan Crouse #define ALARM		9
421c301fc5SJordan Crouse #define FAULT		10
431c301fc5SJordan Crouse 
441c301fc5SJordan Crouse /* 7475 Common Registers */
451c301fc5SJordan Crouse 
46d07ca4adSJean Delvare #define REG_DEVREV2		0x12	/* ADT7490 only */
47d07ca4adSJean Delvare 
483d849981SJean Delvare #define REG_VTT			0x1E	/* ADT7490 only */
493d849981SJean Delvare #define REG_EXTEND3		0x1F	/* ADT7490 only */
503d849981SJean Delvare 
51cffb9dd0SJean Delvare #define REG_VOLTAGE_BASE	0x20
521c301fc5SJordan Crouse #define REG_TEMP_BASE		0x25
531c301fc5SJordan Crouse #define REG_TACH_BASE		0x28
541c301fc5SJordan Crouse #define REG_PWM_BASE		0x30
551c301fc5SJordan Crouse #define REG_PWM_MAX_BASE	0x38
561c301fc5SJordan Crouse 
571c301fc5SJordan Crouse #define REG_DEVID		0x3D
581c301fc5SJordan Crouse #define REG_VENDID		0x3E
59d656b6fdSJean Delvare #define REG_DEVID2		0x3F
601c301fc5SJordan Crouse 
614abdf38dSChris Packham #define REG_CONFIG1		0x40
624abdf38dSChris Packham 
631c301fc5SJordan Crouse #define REG_STATUS1		0x41
641c301fc5SJordan Crouse #define REG_STATUS2		0x42
651c301fc5SJordan Crouse 
66d8d2ee07SJean Delvare #define REG_VID			0x43	/* ADT7476 only */
67d8d2ee07SJean Delvare 
68cffb9dd0SJean Delvare #define REG_VOLTAGE_MIN_BASE	0x44
69cffb9dd0SJean Delvare #define REG_VOLTAGE_MAX_BASE	0x45
701c301fc5SJordan Crouse 
711c301fc5SJordan Crouse #define REG_TEMP_MIN_BASE	0x4E
721c301fc5SJordan Crouse #define REG_TEMP_MAX_BASE	0x4F
731c301fc5SJordan Crouse 
741c301fc5SJordan Crouse #define REG_TACH_MIN_BASE	0x54
751c301fc5SJordan Crouse 
761c301fc5SJordan Crouse #define REG_PWM_CONFIG_BASE	0x5C
771c301fc5SJordan Crouse 
781c301fc5SJordan Crouse #define REG_TEMP_TRANGE_BASE	0x5F
791c301fc5SJordan Crouse 
801d58f5efSChris Packham #define REG_ENHANCE_ACOUSTICS1	0x62
811d58f5efSChris Packham #define REG_ENHANCE_ACOUSTICS2	0x63
821d58f5efSChris Packham 
831c301fc5SJordan Crouse #define REG_PWM_MIN_BASE	0x64
841c301fc5SJordan Crouse 
851c301fc5SJordan Crouse #define REG_TEMP_TMIN_BASE	0x67
861c301fc5SJordan Crouse #define REG_TEMP_THERM_BASE	0x6A
871c301fc5SJordan Crouse 
881c301fc5SJordan Crouse #define REG_REMOTE1_HYSTERSIS	0x6D
891c301fc5SJordan Crouse #define REG_REMOTE2_HYSTERSIS	0x6E
901c301fc5SJordan Crouse 
911c301fc5SJordan Crouse #define REG_TEMP_OFFSET_BASE	0x70
921c301fc5SJordan Crouse 
93ebfaf1fbSJean Delvare #define REG_CONFIG2		0x73
94ebfaf1fbSJean Delvare 
951c301fc5SJordan Crouse #define REG_EXTEND1		0x76
961c301fc5SJordan Crouse #define REG_EXTEND2		0x77
97378933c9SJean Delvare 
98378933c9SJean Delvare #define REG_CONFIG3		0x78
991c301fc5SJordan Crouse #define REG_CONFIG5		0x7C
100f99318b2SJean Delvare #define REG_CONFIG4		0x7D
101f99318b2SJean Delvare 
1023d849981SJean Delvare #define REG_STATUS4		0x81	/* ADT7490 only */
1033d849981SJean Delvare 
1043d849981SJean Delvare #define REG_VTT_MIN		0x84	/* ADT7490 only */
1053d849981SJean Delvare #define REG_VTT_MAX		0x86	/* ADT7490 only */
1063d849981SJean Delvare 
107d8d2ee07SJean Delvare #define VID_VIDSEL		0x80	/* ADT7476 only */
108d8d2ee07SJean Delvare 
109ebfaf1fbSJean Delvare #define CONFIG2_ATTN		0x20
110ebfaf1fbSJean Delvare 
111378933c9SJean Delvare #define CONFIG3_SMBALERT	0x01
112378933c9SJean Delvare #define CONFIG3_THERM		0x02
113378933c9SJean Delvare 
114378933c9SJean Delvare #define CONFIG4_PINFUNC		0x03
115f99318b2SJean Delvare #define CONFIG4_MAXDUTY		0x08
116ebfaf1fbSJean Delvare #define CONFIG4_ATTN_IN10	0x30
117ebfaf1fbSJean Delvare #define CONFIG4_ATTN_IN43	0xC0
1181c301fc5SJordan Crouse 
1191c301fc5SJordan Crouse #define CONFIG5_TWOSCOMP	0x01
1201c301fc5SJordan Crouse #define CONFIG5_TEMPOFFSET	0x02
12154fe4671SJean Delvare #define CONFIG5_VIDGPIO		0x10	/* ADT7476 only */
1221c301fc5SJordan Crouse 
1231c301fc5SJordan Crouse /* ADT7475 Settings */
1241c301fc5SJordan Crouse 
125cffb9dd0SJean Delvare #define ADT7475_VOLTAGE_COUNT	5	/* Not counting Vtt */
1261c301fc5SJordan Crouse #define ADT7475_TEMP_COUNT	3
1271c301fc5SJordan Crouse #define ADT7475_TACH_COUNT	4
1281c301fc5SJordan Crouse #define ADT7475_PWM_COUNT	3
1291c301fc5SJordan Crouse 
1301c301fc5SJordan Crouse /* Macro to read the registers */
1311c301fc5SJordan Crouse 
1321c301fc5SJordan Crouse #define adt7475_read(reg) i2c_smbus_read_byte_data(client, (reg))
1331c301fc5SJordan Crouse 
1341c301fc5SJordan Crouse /* Macros to easily index the registers */
1351c301fc5SJordan Crouse 
1361c301fc5SJordan Crouse #define TACH_REG(idx) (REG_TACH_BASE + ((idx) * 2))
1371c301fc5SJordan Crouse #define TACH_MIN_REG(idx) (REG_TACH_MIN_BASE + ((idx) * 2))
1381c301fc5SJordan Crouse 
1391c301fc5SJordan Crouse #define PWM_REG(idx) (REG_PWM_BASE + (idx))
1401c301fc5SJordan Crouse #define PWM_MAX_REG(idx) (REG_PWM_MAX_BASE + (idx))
1411c301fc5SJordan Crouse #define PWM_MIN_REG(idx) (REG_PWM_MIN_BASE + (idx))
1421c301fc5SJordan Crouse #define PWM_CONFIG_REG(idx) (REG_PWM_CONFIG_BASE + (idx))
1431c301fc5SJordan Crouse 
1441c301fc5SJordan Crouse #define VOLTAGE_REG(idx) (REG_VOLTAGE_BASE + (idx))
1451c301fc5SJordan Crouse #define VOLTAGE_MIN_REG(idx) (REG_VOLTAGE_MIN_BASE + ((idx) * 2))
1461c301fc5SJordan Crouse #define VOLTAGE_MAX_REG(idx) (REG_VOLTAGE_MAX_BASE + ((idx) * 2))
1471c301fc5SJordan Crouse 
1481c301fc5SJordan Crouse #define TEMP_REG(idx) (REG_TEMP_BASE + (idx))
1491c301fc5SJordan Crouse #define TEMP_MIN_REG(idx) (REG_TEMP_MIN_BASE + ((idx) * 2))
1501c301fc5SJordan Crouse #define TEMP_MAX_REG(idx) (REG_TEMP_MAX_BASE + ((idx) * 2))
1511c301fc5SJordan Crouse #define TEMP_TMIN_REG(idx) (REG_TEMP_TMIN_BASE + (idx))
1521c301fc5SJordan Crouse #define TEMP_THERM_REG(idx) (REG_TEMP_THERM_BASE + (idx))
1531c301fc5SJordan Crouse #define TEMP_OFFSET_REG(idx) (REG_TEMP_OFFSET_BASE + (idx))
1541c301fc5SJordan Crouse #define TEMP_TRANGE_REG(idx) (REG_TEMP_TRANGE_BASE + (idx))
1551c301fc5SJordan Crouse 
156918ee91cSJean Delvare static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
1571c301fc5SJordan Crouse 
158e5e9f44cSJean Delvare enum chips { adt7473, adt7475, adt7476, adt7490 };
1591c301fc5SJordan Crouse 
1601c301fc5SJordan Crouse static const struct i2c_device_id adt7475_id[] = {
161b180d050SJean Delvare 	{ "adt7473", adt7473 },
1621c301fc5SJordan Crouse 	{ "adt7475", adt7475 },
163d8d2ee07SJean Delvare 	{ "adt7476", adt7476 },
1643d849981SJean Delvare 	{ "adt7490", adt7490 },
1651c301fc5SJordan Crouse 	{ }
1661c301fc5SJordan Crouse };
1671c301fc5SJordan Crouse MODULE_DEVICE_TABLE(i2c, adt7475_id);
1681c301fc5SJordan Crouse 
169fe339dbfSGuenter Roeck static const struct of_device_id __maybe_unused adt7475_of_match[] = {
1704e2496e4SJavier Martinez Canillas 	{
1714e2496e4SJavier Martinez Canillas 		.compatible = "adi,adt7473",
1724e2496e4SJavier Martinez Canillas 		.data = (void *)adt7473
1734e2496e4SJavier Martinez Canillas 	},
1744e2496e4SJavier Martinez Canillas 	{
1754e2496e4SJavier Martinez Canillas 		.compatible = "adi,adt7475",
1764e2496e4SJavier Martinez Canillas 		.data = (void *)adt7475
1774e2496e4SJavier Martinez Canillas 	},
1784e2496e4SJavier Martinez Canillas 	{
1794e2496e4SJavier Martinez Canillas 		.compatible = "adi,adt7476",
1804e2496e4SJavier Martinez Canillas 		.data = (void *)adt7476
1814e2496e4SJavier Martinez Canillas 	},
1824e2496e4SJavier Martinez Canillas 	{
1834e2496e4SJavier Martinez Canillas 		.compatible = "adi,adt7490",
1844e2496e4SJavier Martinez Canillas 		.data = (void *)adt7490
1854e2496e4SJavier Martinez Canillas 	},
1864e2496e4SJavier Martinez Canillas 	{ },
1874e2496e4SJavier Martinez Canillas };
1884e2496e4SJavier Martinez Canillas MODULE_DEVICE_TABLE(of, adt7475_of_match);
1894e2496e4SJavier Martinez Canillas 
1901c301fc5SJordan Crouse struct adt7475_data {
191c64fce7fSGrant McEwan 	struct i2c_client *client;
1921c301fc5SJordan Crouse 	struct mutex lock;
1931c301fc5SJordan Crouse 
1941c301fc5SJordan Crouse 	unsigned long measure_updated;
195b36fb171STokunori Ikegami 	bool valid;
1961c301fc5SJordan Crouse 
197*2ecff397SLogan Shaw 	u8 config2;
198f99318b2SJean Delvare 	u8 config4;
1991c301fc5SJordan Crouse 	u8 config5;
200cffb9dd0SJean Delvare 	u8 has_voltage;
201ebfaf1fbSJean Delvare 	u8 bypass_attn;		/* Bypass voltage attenuator */
202378933c9SJean Delvare 	u8 has_pwm2:1;
203378933c9SJean Delvare 	u8 has_fan4:1;
20454fe4671SJean Delvare 	u8 has_vid:1;
2053d849981SJean Delvare 	u32 alarms;
206cffb9dd0SJean Delvare 	u16 voltage[3][6];
2071c301fc5SJordan Crouse 	u16 temp[7][3];
2081c301fc5SJordan Crouse 	u16 tach[2][4];
2091c301fc5SJordan Crouse 	u8 pwm[4][3];
2101c301fc5SJordan Crouse 	u8 range[3];
2111c301fc5SJordan Crouse 	u8 pwmctl[3];
2121c301fc5SJordan Crouse 	u8 pwmchan[3];
2131d58f5efSChris Packham 	u8 enh_acoustics[2];
21454fe4671SJean Delvare 
21554fe4671SJean Delvare 	u8 vid;
21654fe4671SJean Delvare 	u8 vrm;
217c64fce7fSGrant McEwan 	const struct attribute_group *groups[9];
2181c301fc5SJordan Crouse };
2191c301fc5SJordan Crouse 
2201c301fc5SJordan Crouse static struct i2c_driver adt7475_driver;
2211c301fc5SJordan Crouse static struct adt7475_data *adt7475_update_device(struct device *dev);
2221c301fc5SJordan Crouse static void adt7475_read_hystersis(struct i2c_client *client);
2231c301fc5SJordan Crouse static void adt7475_read_pwm(struct i2c_client *client, int index);
2241c301fc5SJordan Crouse 
2251c301fc5SJordan Crouse /* Given a temp value, convert it to register value */
2261c301fc5SJordan Crouse 
2271c301fc5SJordan Crouse static inline u16 temp2reg(struct adt7475_data *data, long val)
2281c301fc5SJordan Crouse {
2291c301fc5SJordan Crouse 	u16 ret;
2301c301fc5SJordan Crouse 
2311c301fc5SJordan Crouse 	if (!(data->config5 & CONFIG5_TWOSCOMP)) {
2322a844c14SGuenter Roeck 		val = clamp_val(val, -64000, 191000);
2331c301fc5SJordan Crouse 		ret = (val + 64500) / 1000;
2341c301fc5SJordan Crouse 	} else {
2352a844c14SGuenter Roeck 		val = clamp_val(val, -128000, 127000);
2361c301fc5SJordan Crouse 		if (val < -500)
2371c301fc5SJordan Crouse 			ret = (256500 + val) / 1000;
2381c301fc5SJordan Crouse 		else
2391c301fc5SJordan Crouse 			ret = (val + 500) / 1000;
2401c301fc5SJordan Crouse 	}
2411c301fc5SJordan Crouse 
2421c301fc5SJordan Crouse 	return ret << 2;
2431c301fc5SJordan Crouse }
2441c301fc5SJordan Crouse 
2451c301fc5SJordan Crouse /* Given a register value, convert it to a real temp value */
2461c301fc5SJordan Crouse 
2471c301fc5SJordan Crouse static inline int reg2temp(struct adt7475_data *data, u16 reg)
2481c301fc5SJordan Crouse {
2491c301fc5SJordan Crouse 	if (data->config5 & CONFIG5_TWOSCOMP) {
2501c301fc5SJordan Crouse 		if (reg >= 512)
2511c301fc5SJordan Crouse 			return (reg - 1024) * 250;
2521c301fc5SJordan Crouse 		else
2531c301fc5SJordan Crouse 			return reg * 250;
2541c301fc5SJordan Crouse 	} else
2551c301fc5SJordan Crouse 		return (reg - 256) * 250;
2561c301fc5SJordan Crouse }
2571c301fc5SJordan Crouse 
2581c301fc5SJordan Crouse static inline int tach2rpm(u16 tach)
2591c301fc5SJordan Crouse {
2601c301fc5SJordan Crouse 	if (tach == 0 || tach == 0xFFFF)
2611c301fc5SJordan Crouse 		return 0;
2621c301fc5SJordan Crouse 
2631c301fc5SJordan Crouse 	return (90000 * 60) / tach;
2641c301fc5SJordan Crouse }
2651c301fc5SJordan Crouse 
2661c301fc5SJordan Crouse static inline u16 rpm2tach(unsigned long rpm)
2671c301fc5SJordan Crouse {
2681c301fc5SJordan Crouse 	if (rpm == 0)
2691c301fc5SJordan Crouse 		return 0;
2701c301fc5SJordan Crouse 
2712a844c14SGuenter Roeck 	return clamp_val((90000 * 60) / rpm, 1, 0xFFFF);
2721c301fc5SJordan Crouse }
2731c301fc5SJordan Crouse 
274cffb9dd0SJean Delvare /* Scaling factors for voltage inputs, taken from the ADT7490 datasheet */
275cffb9dd0SJean Delvare static const int adt7473_in_scaling[ADT7475_VOLTAGE_COUNT + 1][2] = {
276cffb9dd0SJean Delvare 	{ 45, 94 },	/* +2.5V */
277cffb9dd0SJean Delvare 	{ 175, 525 },	/* Vccp */
278cffb9dd0SJean Delvare 	{ 68, 71 },	/* Vcc */
279cffb9dd0SJean Delvare 	{ 93, 47 },	/* +5V */
280cffb9dd0SJean Delvare 	{ 120, 20 },	/* +12V */
281cffb9dd0SJean Delvare 	{ 45, 45 },	/* Vtt */
282cffb9dd0SJean Delvare };
283cffb9dd0SJean Delvare 
284ebfaf1fbSJean Delvare static inline int reg2volt(int channel, u16 reg, u8 bypass_attn)
2851c301fc5SJordan Crouse {
286cffb9dd0SJean Delvare 	const int *r = adt7473_in_scaling[channel];
287cffb9dd0SJean Delvare 
288ebfaf1fbSJean Delvare 	if (bypass_attn & (1 << channel))
289ebfaf1fbSJean Delvare 		return DIV_ROUND_CLOSEST(reg * 2250, 1024);
290cffb9dd0SJean Delvare 	return DIV_ROUND_CLOSEST(reg * (r[0] + r[1]) * 2250, r[1] * 1024);
2911c301fc5SJordan Crouse }
2921c301fc5SJordan Crouse 
293ebfaf1fbSJean Delvare static inline u16 volt2reg(int channel, long volt, u8 bypass_attn)
2941c301fc5SJordan Crouse {
295cffb9dd0SJean Delvare 	const int *r = adt7473_in_scaling[channel];
296cffb9dd0SJean Delvare 	long reg;
2971c301fc5SJordan Crouse 
298ebfaf1fbSJean Delvare 	if (bypass_attn & (1 << channel))
299cf3ca187SLuuk Paulussen 		reg = DIV_ROUND_CLOSEST(volt * 1024, 2250);
300ebfaf1fbSJean Delvare 	else
301cf3ca187SLuuk Paulussen 		reg = DIV_ROUND_CLOSEST(volt * r[1] * 1024,
302cf3ca187SLuuk Paulussen 					(r[0] + r[1]) * 2250);
3032a844c14SGuenter Roeck 	return clamp_val(reg, 0, 1023) & (0xff << 2);
3041c301fc5SJordan Crouse }
3051c301fc5SJordan Crouse 
306f196dec6SDan Carpenter static int adt7475_read_word(struct i2c_client *client, int reg)
3071c301fc5SJordan Crouse {
308f196dec6SDan Carpenter 	int val1, val2;
3091c301fc5SJordan Crouse 
310f196dec6SDan Carpenter 	val1 = i2c_smbus_read_byte_data(client, reg);
311f196dec6SDan Carpenter 	if (val1 < 0)
312f196dec6SDan Carpenter 		return val1;
313f196dec6SDan Carpenter 	val2 = i2c_smbus_read_byte_data(client, reg + 1);
314f196dec6SDan Carpenter 	if (val2 < 0)
315f196dec6SDan Carpenter 		return val2;
3161c301fc5SJordan Crouse 
317f196dec6SDan Carpenter 	return val1 | (val2 << 8);
3181c301fc5SJordan Crouse }
3191c301fc5SJordan Crouse 
3201c301fc5SJordan Crouse static void adt7475_write_word(struct i2c_client *client, int reg, u16 val)
3211c301fc5SJordan Crouse {
3221c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, reg + 1, val >> 8);
3231c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, reg, val & 0xFF);
3241c301fc5SJordan Crouse }
3251c301fc5SJordan Crouse 
326c24f9ba9SGuenter Roeck static ssize_t voltage_show(struct device *dev, struct device_attribute *attr,
3271c301fc5SJordan Crouse 			    char *buf)
3281c301fc5SJordan Crouse {
3291c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
3301c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
3311c301fc5SJordan Crouse 	unsigned short val;
3321c301fc5SJordan Crouse 
3334afec79fSTokunori Ikegami 	if (IS_ERR(data))
3344afec79fSTokunori Ikegami 		return PTR_ERR(data);
3354afec79fSTokunori Ikegami 
3361c301fc5SJordan Crouse 	switch (sattr->nr) {
3371c301fc5SJordan Crouse 	case ALARM:
3381c301fc5SJordan Crouse 		return sprintf(buf, "%d\n",
339cffb9dd0SJean Delvare 			       (data->alarms >> sattr->index) & 1);
3401c301fc5SJordan Crouse 	default:
3411c301fc5SJordan Crouse 		val = data->voltage[sattr->nr][sattr->index];
342ebfaf1fbSJean Delvare 		return sprintf(buf, "%d\n",
343ebfaf1fbSJean Delvare 			       reg2volt(sattr->index, val, data->bypass_attn));
3441c301fc5SJordan Crouse 	}
3451c301fc5SJordan Crouse }
3461c301fc5SJordan Crouse 
347c24f9ba9SGuenter Roeck static ssize_t voltage_store(struct device *dev,
348c24f9ba9SGuenter Roeck 			     struct device_attribute *attr, const char *buf,
349c24f9ba9SGuenter Roeck 			     size_t count)
3501c301fc5SJordan Crouse {
3511c301fc5SJordan Crouse 
3521c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
353c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
354c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
3551c301fc5SJordan Crouse 	unsigned char reg;
3561c301fc5SJordan Crouse 	long val;
3571c301fc5SJordan Crouse 
358179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
3591c301fc5SJordan Crouse 		return -EINVAL;
3601c301fc5SJordan Crouse 
3611c301fc5SJordan Crouse 	mutex_lock(&data->lock);
3621c301fc5SJordan Crouse 
363ebfaf1fbSJean Delvare 	data->voltage[sattr->nr][sattr->index] =
364ebfaf1fbSJean Delvare 				volt2reg(sattr->index, val, data->bypass_attn);
3651c301fc5SJordan Crouse 
3663d849981SJean Delvare 	if (sattr->index < ADT7475_VOLTAGE_COUNT) {
3671c301fc5SJordan Crouse 		if (sattr->nr == MIN)
3681c301fc5SJordan Crouse 			reg = VOLTAGE_MIN_REG(sattr->index);
3691c301fc5SJordan Crouse 		else
3701c301fc5SJordan Crouse 			reg = VOLTAGE_MAX_REG(sattr->index);
3713d849981SJean Delvare 	} else {
3723d849981SJean Delvare 		if (sattr->nr == MIN)
3733d849981SJean Delvare 			reg = REG_VTT_MIN;
3743d849981SJean Delvare 		else
3753d849981SJean Delvare 			reg = REG_VTT_MAX;
3763d849981SJean Delvare 	}
3771c301fc5SJordan Crouse 
3781c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, reg,
3791c301fc5SJordan Crouse 				  data->voltage[sattr->nr][sattr->index] >> 2);
3801c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
3811c301fc5SJordan Crouse 
3821c301fc5SJordan Crouse 	return count;
3831c301fc5SJordan Crouse }
3841c301fc5SJordan Crouse 
385c24f9ba9SGuenter Roeck static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
3861c301fc5SJordan Crouse 			 char *buf)
3871c301fc5SJordan Crouse {
3881c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
3891c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
3901c301fc5SJordan Crouse 	int out;
3911c301fc5SJordan Crouse 
3924afec79fSTokunori Ikegami 	if (IS_ERR(data))
3934afec79fSTokunori Ikegami 		return PTR_ERR(data);
3944afec79fSTokunori Ikegami 
3951c301fc5SJordan Crouse 	switch (sattr->nr) {
3961c301fc5SJordan Crouse 	case HYSTERSIS:
3971c301fc5SJordan Crouse 		mutex_lock(&data->lock);
3981c301fc5SJordan Crouse 		out = data->temp[sattr->nr][sattr->index];
3991c301fc5SJordan Crouse 		if (sattr->index != 1)
4001c301fc5SJordan Crouse 			out = (out >> 4) & 0xF;
4011c301fc5SJordan Crouse 		else
4021c301fc5SJordan Crouse 			out = (out & 0xF);
4039ed5bc24SGuenter Roeck 		/*
4049ed5bc24SGuenter Roeck 		 * Show the value as an absolute number tied to
4059ed5bc24SGuenter Roeck 		 * THERM
4069ed5bc24SGuenter Roeck 		 */
4071c301fc5SJordan Crouse 		out = reg2temp(data, data->temp[THERM][sattr->index]) -
4081c301fc5SJordan Crouse 			out * 1000;
4091c301fc5SJordan Crouse 		mutex_unlock(&data->lock);
4101c301fc5SJordan Crouse 		break;
4111c301fc5SJordan Crouse 
4121c301fc5SJordan Crouse 	case OFFSET:
4139ed5bc24SGuenter Roeck 		/*
4149ed5bc24SGuenter Roeck 		 * Offset is always 2's complement, regardless of the
4159ed5bc24SGuenter Roeck 		 * setting in CONFIG5
4169ed5bc24SGuenter Roeck 		 */
4171c301fc5SJordan Crouse 		mutex_lock(&data->lock);
4181c301fc5SJordan Crouse 		out = (s8)data->temp[sattr->nr][sattr->index];
4191c301fc5SJordan Crouse 		if (data->config5 & CONFIG5_TEMPOFFSET)
4201c301fc5SJordan Crouse 			out *= 1000;
4211c301fc5SJordan Crouse 		else
4221c301fc5SJordan Crouse 			out *= 500;
4231c301fc5SJordan Crouse 		mutex_unlock(&data->lock);
4241c301fc5SJordan Crouse 		break;
4251c301fc5SJordan Crouse 
4261c301fc5SJordan Crouse 	case ALARM:
4271c301fc5SJordan Crouse 		out = (data->alarms >> (sattr->index + 4)) & 1;
4281c301fc5SJordan Crouse 		break;
4291c301fc5SJordan Crouse 
4301c301fc5SJordan Crouse 	case FAULT:
4311c301fc5SJordan Crouse 		/* Note - only for remote1 and remote2 */
432cf312e07SJean Delvare 		out = !!(data->alarms & (sattr->index ? 0x8000 : 0x4000));
4331c301fc5SJordan Crouse 		break;
4341c301fc5SJordan Crouse 
4351c301fc5SJordan Crouse 	default:
4361c301fc5SJordan Crouse 		/* All other temp values are in the configured format */
4371c301fc5SJordan Crouse 		out = reg2temp(data, data->temp[sattr->nr][sattr->index]);
4381c301fc5SJordan Crouse 	}
4391c301fc5SJordan Crouse 
4401c301fc5SJordan Crouse 	return sprintf(buf, "%d\n", out);
4411c301fc5SJordan Crouse }
4421c301fc5SJordan Crouse 
443c24f9ba9SGuenter Roeck static ssize_t temp_store(struct device *dev, struct device_attribute *attr,
4441c301fc5SJordan Crouse 			  const char *buf, size_t count)
4451c301fc5SJordan Crouse {
4461c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
447c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
448c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
4491c301fc5SJordan Crouse 	unsigned char reg = 0;
4501c301fc5SJordan Crouse 	u8 out;
4511c301fc5SJordan Crouse 	int temp;
4521c301fc5SJordan Crouse 	long val;
4531c301fc5SJordan Crouse 
454179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
4551c301fc5SJordan Crouse 		return -EINVAL;
4561c301fc5SJordan Crouse 
4571c301fc5SJordan Crouse 	mutex_lock(&data->lock);
4581c301fc5SJordan Crouse 
4591c301fc5SJordan Crouse 	/* We need the config register in all cases for temp <-> reg conv. */
4601c301fc5SJordan Crouse 	data->config5 = adt7475_read(REG_CONFIG5);
4611c301fc5SJordan Crouse 
4621c301fc5SJordan Crouse 	switch (sattr->nr) {
4631c301fc5SJordan Crouse 	case OFFSET:
4641c301fc5SJordan Crouse 		if (data->config5 & CONFIG5_TEMPOFFSET) {
4652a844c14SGuenter Roeck 			val = clamp_val(val, -63000, 127000);
4661c301fc5SJordan Crouse 			out = data->temp[OFFSET][sattr->index] = val / 1000;
4671c301fc5SJordan Crouse 		} else {
4682a844c14SGuenter Roeck 			val = clamp_val(val, -63000, 64000);
4691c301fc5SJordan Crouse 			out = data->temp[OFFSET][sattr->index] = val / 500;
4701c301fc5SJordan Crouse 		}
4711c301fc5SJordan Crouse 		break;
4721c301fc5SJordan Crouse 
4731c301fc5SJordan Crouse 	case HYSTERSIS:
4749ed5bc24SGuenter Roeck 		/*
4759ed5bc24SGuenter Roeck 		 * The value will be given as an absolute value, turn it
4769ed5bc24SGuenter Roeck 		 * into an offset based on THERM
4779ed5bc24SGuenter Roeck 		 */
4781c301fc5SJordan Crouse 
4791c301fc5SJordan Crouse 		/* Read fresh THERM and HYSTERSIS values from the chip */
4801c301fc5SJordan Crouse 		data->temp[THERM][sattr->index] =
4811c301fc5SJordan Crouse 			adt7475_read(TEMP_THERM_REG(sattr->index)) << 2;
4821c301fc5SJordan Crouse 		adt7475_read_hystersis(client);
4831c301fc5SJordan Crouse 
4841c301fc5SJordan Crouse 		temp = reg2temp(data, data->temp[THERM][sattr->index]);
4852a844c14SGuenter Roeck 		val = clamp_val(val, temp - 15000, temp);
4861c301fc5SJordan Crouse 		val = (temp - val) / 1000;
4871c301fc5SJordan Crouse 
4881c301fc5SJordan Crouse 		if (sattr->index != 1) {
4891c301fc5SJordan Crouse 			data->temp[HYSTERSIS][sattr->index] &= 0xF0;
4901c301fc5SJordan Crouse 			data->temp[HYSTERSIS][sattr->index] |= (val & 0xF) << 4;
4911c301fc5SJordan Crouse 		} else {
4921c301fc5SJordan Crouse 			data->temp[HYSTERSIS][sattr->index] &= 0x0F;
4931c301fc5SJordan Crouse 			data->temp[HYSTERSIS][sattr->index] |= (val & 0xF);
4941c301fc5SJordan Crouse 		}
4951c301fc5SJordan Crouse 
4961c301fc5SJordan Crouse 		out = data->temp[HYSTERSIS][sattr->index];
4971c301fc5SJordan Crouse 		break;
4981c301fc5SJordan Crouse 
4991c301fc5SJordan Crouse 	default:
5001c301fc5SJordan Crouse 		data->temp[sattr->nr][sattr->index] = temp2reg(data, val);
5011c301fc5SJordan Crouse 
5029ed5bc24SGuenter Roeck 		/*
5039ed5bc24SGuenter Roeck 		 * We maintain an extra 2 digits of precision for simplicity
5049ed5bc24SGuenter Roeck 		 * - shift those back off before writing the value
5059ed5bc24SGuenter Roeck 		 */
5061c301fc5SJordan Crouse 		out = (u8) (data->temp[sattr->nr][sattr->index] >> 2);
5071c301fc5SJordan Crouse 	}
5081c301fc5SJordan Crouse 
5091c301fc5SJordan Crouse 	switch (sattr->nr) {
5101c301fc5SJordan Crouse 	case MIN:
5111c301fc5SJordan Crouse 		reg = TEMP_MIN_REG(sattr->index);
5121c301fc5SJordan Crouse 		break;
5131c301fc5SJordan Crouse 	case MAX:
5141c301fc5SJordan Crouse 		reg = TEMP_MAX_REG(sattr->index);
5151c301fc5SJordan Crouse 		break;
5161c301fc5SJordan Crouse 	case OFFSET:
5171c301fc5SJordan Crouse 		reg = TEMP_OFFSET_REG(sattr->index);
5181c301fc5SJordan Crouse 		break;
5191c301fc5SJordan Crouse 	case AUTOMIN:
5201c301fc5SJordan Crouse 		reg = TEMP_TMIN_REG(sattr->index);
5211c301fc5SJordan Crouse 		break;
5221c301fc5SJordan Crouse 	case THERM:
5231c301fc5SJordan Crouse 		reg = TEMP_THERM_REG(sattr->index);
5241c301fc5SJordan Crouse 		break;
5251c301fc5SJordan Crouse 	case HYSTERSIS:
5261c301fc5SJordan Crouse 		if (sattr->index != 2)
5271c301fc5SJordan Crouse 			reg = REG_REMOTE1_HYSTERSIS;
5281c301fc5SJordan Crouse 		else
5291c301fc5SJordan Crouse 			reg = REG_REMOTE2_HYSTERSIS;
5301c301fc5SJordan Crouse 
5311c301fc5SJordan Crouse 		break;
5321c301fc5SJordan Crouse 	}
5331c301fc5SJordan Crouse 
5341c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, reg, out);
5351c301fc5SJordan Crouse 
5361c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
5371c301fc5SJordan Crouse 	return count;
5381c301fc5SJordan Crouse }
5391c301fc5SJordan Crouse 
5408f05bcc3SChris Packham /* Assuming CONFIG6[SLOW] is 0 */
5418f05bcc3SChris Packham static const int ad7475_st_map[] = {
5428f05bcc3SChris Packham 	37500, 18800, 12500, 7500, 4700, 3100, 1600, 800,
5438f05bcc3SChris Packham };
5448f05bcc3SChris Packham 
545c24f9ba9SGuenter Roeck static ssize_t temp_st_show(struct device *dev, struct device_attribute *attr,
5468f05bcc3SChris Packham 			    char *buf)
5478f05bcc3SChris Packham {
5488f05bcc3SChris Packham 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
549c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
5508f05bcc3SChris Packham 	long val;
5518f05bcc3SChris Packham 
5528f05bcc3SChris Packham 	switch (sattr->index) {
5538f05bcc3SChris Packham 	case 0:
5548f05bcc3SChris Packham 		val = data->enh_acoustics[0] & 0xf;
5558f05bcc3SChris Packham 		break;
5568f05bcc3SChris Packham 	case 1:
5578f05bcc3SChris Packham 		val = (data->enh_acoustics[1] >> 4) & 0xf;
5588f05bcc3SChris Packham 		break;
5598f05bcc3SChris Packham 	case 2:
5608f05bcc3SChris Packham 	default:
5618f05bcc3SChris Packham 		val = data->enh_acoustics[1] & 0xf;
5628f05bcc3SChris Packham 		break;
5638f05bcc3SChris Packham 	}
5648f05bcc3SChris Packham 
5658f05bcc3SChris Packham 	if (val & 0x8)
5668f05bcc3SChris Packham 		return sprintf(buf, "%d\n", ad7475_st_map[val & 0x7]);
5678f05bcc3SChris Packham 	else
5688f05bcc3SChris Packham 		return sprintf(buf, "0\n");
5698f05bcc3SChris Packham }
5708f05bcc3SChris Packham 
571c24f9ba9SGuenter Roeck static ssize_t temp_st_store(struct device *dev,
572c24f9ba9SGuenter Roeck 			     struct device_attribute *attr, const char *buf,
573c24f9ba9SGuenter Roeck 			     size_t count)
5748f05bcc3SChris Packham {
5758f05bcc3SChris Packham 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
576c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
577c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
5788f05bcc3SChris Packham 	unsigned char reg;
5798f05bcc3SChris Packham 	int shift, idx;
5808f05bcc3SChris Packham 	ulong val;
5818f05bcc3SChris Packham 
5828f05bcc3SChris Packham 	if (kstrtoul(buf, 10, &val))
5838f05bcc3SChris Packham 		return -EINVAL;
5848f05bcc3SChris Packham 
5858f05bcc3SChris Packham 	switch (sattr->index) {
5868f05bcc3SChris Packham 	case 0:
5878f05bcc3SChris Packham 		reg = REG_ENHANCE_ACOUSTICS1;
5888f05bcc3SChris Packham 		shift = 0;
5898f05bcc3SChris Packham 		idx = 0;
5908f05bcc3SChris Packham 		break;
5918f05bcc3SChris Packham 	case 1:
5928f05bcc3SChris Packham 		reg = REG_ENHANCE_ACOUSTICS2;
5938f05bcc3SChris Packham 		shift = 0;
5948f05bcc3SChris Packham 		idx = 1;
5958f05bcc3SChris Packham 		break;
5968f05bcc3SChris Packham 	case 2:
5978f05bcc3SChris Packham 	default:
5988f05bcc3SChris Packham 		reg = REG_ENHANCE_ACOUSTICS2;
5998f05bcc3SChris Packham 		shift = 4;
6008f05bcc3SChris Packham 		idx = 1;
6018f05bcc3SChris Packham 		break;
6028f05bcc3SChris Packham 	}
6038f05bcc3SChris Packham 
6048f05bcc3SChris Packham 	if (val > 0) {
6058f05bcc3SChris Packham 		val = find_closest_descending(val, ad7475_st_map,
6068f05bcc3SChris Packham 					      ARRAY_SIZE(ad7475_st_map));
6078f05bcc3SChris Packham 		val |= 0x8;
6088f05bcc3SChris Packham 	}
6098f05bcc3SChris Packham 
6108f05bcc3SChris Packham 	mutex_lock(&data->lock);
6118f05bcc3SChris Packham 
6128f05bcc3SChris Packham 	data->enh_acoustics[idx] &= ~(0xf << shift);
6138f05bcc3SChris Packham 	data->enh_acoustics[idx] |= (val << shift);
6148f05bcc3SChris Packham 
6158f05bcc3SChris Packham 	i2c_smbus_write_byte_data(client, reg, data->enh_acoustics[idx]);
6168f05bcc3SChris Packham 
6178f05bcc3SChris Packham 	mutex_unlock(&data->lock);
6188f05bcc3SChris Packham 
6198f05bcc3SChris Packham 	return count;
6208f05bcc3SChris Packham }
6218f05bcc3SChris Packham 
6229ed5bc24SGuenter Roeck /*
6239ed5bc24SGuenter Roeck  * Table of autorange values - the user will write the value in millidegrees,
6249ed5bc24SGuenter Roeck  * and we'll convert it
6259ed5bc24SGuenter Roeck  */
6261c301fc5SJordan Crouse static const int autorange_table[] = {
6271c301fc5SJordan Crouse 	2000, 2500, 3330, 4000, 5000, 6670, 8000,
6281c301fc5SJordan Crouse 	10000, 13330, 16000, 20000, 26670, 32000, 40000,
6291c301fc5SJordan Crouse 	53330, 80000
6301c301fc5SJordan Crouse };
6311c301fc5SJordan Crouse 
632c24f9ba9SGuenter Roeck static ssize_t point2_show(struct device *dev, struct device_attribute *attr,
6331c301fc5SJordan Crouse 			   char *buf)
6341c301fc5SJordan Crouse {
6351c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
6361c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
6371c301fc5SJordan Crouse 	int out, val;
6381c301fc5SJordan Crouse 
6394afec79fSTokunori Ikegami 	if (IS_ERR(data))
6404afec79fSTokunori Ikegami 		return PTR_ERR(data);
6414afec79fSTokunori Ikegami 
6421c301fc5SJordan Crouse 	mutex_lock(&data->lock);
6431c301fc5SJordan Crouse 	out = (data->range[sattr->index] >> 4) & 0x0F;
6441c301fc5SJordan Crouse 	val = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
6451c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
6461c301fc5SJordan Crouse 
6471c301fc5SJordan Crouse 	return sprintf(buf, "%d\n", val + autorange_table[out]);
6481c301fc5SJordan Crouse }
6491c301fc5SJordan Crouse 
650c24f9ba9SGuenter Roeck static ssize_t point2_store(struct device *dev, struct device_attribute *attr,
6511c301fc5SJordan Crouse 			    const char *buf, size_t count)
6521c301fc5SJordan Crouse {
653c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
654c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
6551c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
6561c301fc5SJordan Crouse 	int temp;
6571c301fc5SJordan Crouse 	long val;
6581c301fc5SJordan Crouse 
659179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
6601c301fc5SJordan Crouse 		return -EINVAL;
6611c301fc5SJordan Crouse 
6621c301fc5SJordan Crouse 	mutex_lock(&data->lock);
6631c301fc5SJordan Crouse 
6641c301fc5SJordan Crouse 	/* Get a fresh copy of the needed registers */
6651c301fc5SJordan Crouse 	data->config5 = adt7475_read(REG_CONFIG5);
6661c301fc5SJordan Crouse 	data->temp[AUTOMIN][sattr->index] =
6671c301fc5SJordan Crouse 		adt7475_read(TEMP_TMIN_REG(sattr->index)) << 2;
6681c301fc5SJordan Crouse 	data->range[sattr->index] =
6691c301fc5SJordan Crouse 		adt7475_read(TEMP_TRANGE_REG(sattr->index));
6701c301fc5SJordan Crouse 
6719ed5bc24SGuenter Roeck 	/*
6729ed5bc24SGuenter Roeck 	 * The user will write an absolute value, so subtract the start point
6739ed5bc24SGuenter Roeck 	 * to figure the range
6749ed5bc24SGuenter Roeck 	 */
6751c301fc5SJordan Crouse 	temp = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
6762a844c14SGuenter Roeck 	val = clamp_val(val, temp + autorange_table[0],
6771c301fc5SJordan Crouse 		temp + autorange_table[ARRAY_SIZE(autorange_table) - 1]);
6781c301fc5SJordan Crouse 	val -= temp;
6791c301fc5SJordan Crouse 
6801c301fc5SJordan Crouse 	/* Find the nearest table entry to what the user wrote */
681e4651640SChris Packham 	val = find_closest(val, autorange_table, ARRAY_SIZE(autorange_table));
6821c301fc5SJordan Crouse 
6831c301fc5SJordan Crouse 	data->range[sattr->index] &= ~0xF0;
6841c301fc5SJordan Crouse 	data->range[sattr->index] |= val << 4;
6851c301fc5SJordan Crouse 
6861c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
6871c301fc5SJordan Crouse 				  data->range[sattr->index]);
6881c301fc5SJordan Crouse 
6891c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
6901c301fc5SJordan Crouse 	return count;
6911c301fc5SJordan Crouse }
6921c301fc5SJordan Crouse 
693c24f9ba9SGuenter Roeck static ssize_t tach_show(struct device *dev, struct device_attribute *attr,
6941c301fc5SJordan Crouse 			 char *buf)
6951c301fc5SJordan Crouse {
6961c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
6971c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
6981c301fc5SJordan Crouse 	int out;
6991c301fc5SJordan Crouse 
7004afec79fSTokunori Ikegami 	if (IS_ERR(data))
7014afec79fSTokunori Ikegami 		return PTR_ERR(data);
7024afec79fSTokunori Ikegami 
7031c301fc5SJordan Crouse 	if (sattr->nr == ALARM)
7041c301fc5SJordan Crouse 		out = (data->alarms >> (sattr->index + 10)) & 1;
7051c301fc5SJordan Crouse 	else
7061c301fc5SJordan Crouse 		out = tach2rpm(data->tach[sattr->nr][sattr->index]);
7071c301fc5SJordan Crouse 
7081c301fc5SJordan Crouse 	return sprintf(buf, "%d\n", out);
7091c301fc5SJordan Crouse }
7101c301fc5SJordan Crouse 
711c24f9ba9SGuenter Roeck static ssize_t tach_store(struct device *dev, struct device_attribute *attr,
7121c301fc5SJordan Crouse 			  const char *buf, size_t count)
7131c301fc5SJordan Crouse {
7141c301fc5SJordan Crouse 
7151c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
716c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
717c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
7181c301fc5SJordan Crouse 	unsigned long val;
7191c301fc5SJordan Crouse 
720179c4fdbSFrans Meulenbroeks 	if (kstrtoul(buf, 10, &val))
7211c301fc5SJordan Crouse 		return -EINVAL;
7221c301fc5SJordan Crouse 
7231c301fc5SJordan Crouse 	mutex_lock(&data->lock);
7241c301fc5SJordan Crouse 
7251c301fc5SJordan Crouse 	data->tach[MIN][sattr->index] = rpm2tach(val);
7261c301fc5SJordan Crouse 
7271c301fc5SJordan Crouse 	adt7475_write_word(client, TACH_MIN_REG(sattr->index),
7281c301fc5SJordan Crouse 			   data->tach[MIN][sattr->index]);
7291c301fc5SJordan Crouse 
7301c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
7311c301fc5SJordan Crouse 	return count;
7321c301fc5SJordan Crouse }
7331c301fc5SJordan Crouse 
734c24f9ba9SGuenter Roeck static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
7351c301fc5SJordan Crouse 			char *buf)
7361c301fc5SJordan Crouse {
7371c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
7381c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
7391c301fc5SJordan Crouse 
7404afec79fSTokunori Ikegami 	if (IS_ERR(data))
7414afec79fSTokunori Ikegami 		return PTR_ERR(data);
7424afec79fSTokunori Ikegami 
7431c301fc5SJordan Crouse 	return sprintf(buf, "%d\n", data->pwm[sattr->nr][sattr->index]);
7441c301fc5SJordan Crouse }
7451c301fc5SJordan Crouse 
746c24f9ba9SGuenter Roeck static ssize_t pwmchan_show(struct device *dev, struct device_attribute *attr,
7471c301fc5SJordan Crouse 			    char *buf)
7481c301fc5SJordan Crouse {
7491c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
7501c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
7511c301fc5SJordan Crouse 
7524afec79fSTokunori Ikegami 	if (IS_ERR(data))
7534afec79fSTokunori Ikegami 		return PTR_ERR(data);
7544afec79fSTokunori Ikegami 
7551c301fc5SJordan Crouse 	return sprintf(buf, "%d\n", data->pwmchan[sattr->index]);
7561c301fc5SJordan Crouse }
7571c301fc5SJordan Crouse 
758c24f9ba9SGuenter Roeck static ssize_t pwmctrl_show(struct device *dev, struct device_attribute *attr,
7591c301fc5SJordan Crouse 			    char *buf)
7601c301fc5SJordan Crouse {
7611c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
7621c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
7631c301fc5SJordan Crouse 
7644afec79fSTokunori Ikegami 	if (IS_ERR(data))
7654afec79fSTokunori Ikegami 		return PTR_ERR(data);
7664afec79fSTokunori Ikegami 
7671c301fc5SJordan Crouse 	return sprintf(buf, "%d\n", data->pwmctl[sattr->index]);
7681c301fc5SJordan Crouse }
7691c301fc5SJordan Crouse 
770c24f9ba9SGuenter Roeck static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
7711c301fc5SJordan Crouse 			 const char *buf, size_t count)
7721c301fc5SJordan Crouse {
7731c301fc5SJordan Crouse 
7741c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
775c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
776c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
7771c301fc5SJordan Crouse 	unsigned char reg = 0;
7781c301fc5SJordan Crouse 	long val;
7791c301fc5SJordan Crouse 
780179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
7811c301fc5SJordan Crouse 		return -EINVAL;
7821c301fc5SJordan Crouse 
7831c301fc5SJordan Crouse 	mutex_lock(&data->lock);
7841c301fc5SJordan Crouse 
7851c301fc5SJordan Crouse 	switch (sattr->nr) {
7861c301fc5SJordan Crouse 	case INPUT:
7871c301fc5SJordan Crouse 		/* Get a fresh value for CONTROL */
7881c301fc5SJordan Crouse 		data->pwm[CONTROL][sattr->index] =
7891c301fc5SJordan Crouse 			adt7475_read(PWM_CONFIG_REG(sattr->index));
7901c301fc5SJordan Crouse 
7919ed5bc24SGuenter Roeck 		/*
7929ed5bc24SGuenter Roeck 		 * If we are not in manual mode, then we shouldn't allow
7939ed5bc24SGuenter Roeck 		 * the user to set the pwm speed
7949ed5bc24SGuenter Roeck 		 */
7951c301fc5SJordan Crouse 		if (((data->pwm[CONTROL][sattr->index] >> 5) & 7) != 7) {
7961c301fc5SJordan Crouse 			mutex_unlock(&data->lock);
7971c301fc5SJordan Crouse 			return count;
7981c301fc5SJordan Crouse 		}
7991c301fc5SJordan Crouse 
8001c301fc5SJordan Crouse 		reg = PWM_REG(sattr->index);
8011c301fc5SJordan Crouse 		break;
8021c301fc5SJordan Crouse 
8031c301fc5SJordan Crouse 	case MIN:
8041c301fc5SJordan Crouse 		reg = PWM_MIN_REG(sattr->index);
8051c301fc5SJordan Crouse 		break;
8061c301fc5SJordan Crouse 
8071c301fc5SJordan Crouse 	case MAX:
8081c301fc5SJordan Crouse 		reg = PWM_MAX_REG(sattr->index);
8091c301fc5SJordan Crouse 		break;
8101c301fc5SJordan Crouse 	}
8111c301fc5SJordan Crouse 
8122a844c14SGuenter Roeck 	data->pwm[sattr->nr][sattr->index] = clamp_val(val, 0, 0xFF);
8131c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, reg,
8141c301fc5SJordan Crouse 				  data->pwm[sattr->nr][sattr->index]);
8151d58f5efSChris Packham 	mutex_unlock(&data->lock);
8161d58f5efSChris Packham 
8171d58f5efSChris Packham 	return count;
8181d58f5efSChris Packham }
8191d58f5efSChris Packham 
820c24f9ba9SGuenter Roeck static ssize_t stall_disable_show(struct device *dev,
8211d58f5efSChris Packham 				  struct device_attribute *attr, char *buf)
8221d58f5efSChris Packham {
8231d58f5efSChris Packham 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
824c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
825c64fce7fSGrant McEwan 
8261d58f5efSChris Packham 	u8 mask = BIT(5 + sattr->index);
8271d58f5efSChris Packham 
8281d58f5efSChris Packham 	return sprintf(buf, "%d\n", !!(data->enh_acoustics[0] & mask));
8291d58f5efSChris Packham }
8301d58f5efSChris Packham 
831c24f9ba9SGuenter Roeck static ssize_t stall_disable_store(struct device *dev,
832c24f9ba9SGuenter Roeck 				   struct device_attribute *attr,
833c24f9ba9SGuenter Roeck 				   const char *buf, size_t count)
8341d58f5efSChris Packham {
8351d58f5efSChris Packham 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
836c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
837c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
8381d58f5efSChris Packham 	long val;
8391d58f5efSChris Packham 	u8 mask = BIT(5 + sattr->index);
8401d58f5efSChris Packham 
8411d58f5efSChris Packham 	if (kstrtol(buf, 10, &val))
8421d58f5efSChris Packham 		return -EINVAL;
8431d58f5efSChris Packham 
8441d58f5efSChris Packham 	mutex_lock(&data->lock);
8451d58f5efSChris Packham 
8461d58f5efSChris Packham 	data->enh_acoustics[0] &= ~mask;
8471d58f5efSChris Packham 	if (val)
8481d58f5efSChris Packham 		data->enh_acoustics[0] |= mask;
8491d58f5efSChris Packham 
8501d58f5efSChris Packham 	i2c_smbus_write_byte_data(client, REG_ENHANCE_ACOUSTICS1,
8511d58f5efSChris Packham 				  data->enh_acoustics[0]);
8521c301fc5SJordan Crouse 
8531c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
8541c301fc5SJordan Crouse 
8551c301fc5SJordan Crouse 	return count;
8561c301fc5SJordan Crouse }
8571c301fc5SJordan Crouse 
8581c301fc5SJordan Crouse /* Called by set_pwmctrl and set_pwmchan */
8591c301fc5SJordan Crouse 
8601c301fc5SJordan Crouse static int hw_set_pwm(struct i2c_client *client, int index,
8611c301fc5SJordan Crouse 		      unsigned int pwmctl, unsigned int pwmchan)
8621c301fc5SJordan Crouse {
8631c301fc5SJordan Crouse 	struct adt7475_data *data = i2c_get_clientdata(client);
8641c301fc5SJordan Crouse 	long val = 0;
8651c301fc5SJordan Crouse 
8661c301fc5SJordan Crouse 	switch (pwmctl) {
8671c301fc5SJordan Crouse 	case 0:
8681c301fc5SJordan Crouse 		val = 0x03;	/* Run at full speed */
8691c301fc5SJordan Crouse 		break;
8701c301fc5SJordan Crouse 	case 1:
8711c301fc5SJordan Crouse 		val = 0x07;	/* Manual mode */
8721c301fc5SJordan Crouse 		break;
8731c301fc5SJordan Crouse 	case 2:
8741c301fc5SJordan Crouse 		switch (pwmchan) {
8751c301fc5SJordan Crouse 		case 1:
8761c301fc5SJordan Crouse 			/* Remote1 controls PWM */
8771c301fc5SJordan Crouse 			val = 0x00;
8781c301fc5SJordan Crouse 			break;
8791c301fc5SJordan Crouse 		case 2:
8801c301fc5SJordan Crouse 			/* local controls PWM */
8811c301fc5SJordan Crouse 			val = 0x01;
8821c301fc5SJordan Crouse 			break;
8831c301fc5SJordan Crouse 		case 4:
8841c301fc5SJordan Crouse 			/* remote2 controls PWM */
8851c301fc5SJordan Crouse 			val = 0x02;
8861c301fc5SJordan Crouse 			break;
8871c301fc5SJordan Crouse 		case 6:
8881c301fc5SJordan Crouse 			/* local/remote2 control PWM */
8891c301fc5SJordan Crouse 			val = 0x05;
8901c301fc5SJordan Crouse 			break;
8911c301fc5SJordan Crouse 		case 7:
8921c301fc5SJordan Crouse 			/* All three control PWM */
8931c301fc5SJordan Crouse 			val = 0x06;
8941c301fc5SJordan Crouse 			break;
8951c301fc5SJordan Crouse 		default:
8961c301fc5SJordan Crouse 			return -EINVAL;
8971c301fc5SJordan Crouse 		}
8981c301fc5SJordan Crouse 		break;
8991c301fc5SJordan Crouse 	default:
9001c301fc5SJordan Crouse 		return -EINVAL;
9011c301fc5SJordan Crouse 	}
9021c301fc5SJordan Crouse 
9031c301fc5SJordan Crouse 	data->pwmctl[index] = pwmctl;
9041c301fc5SJordan Crouse 	data->pwmchan[index] = pwmchan;
9051c301fc5SJordan Crouse 
9061c301fc5SJordan Crouse 	data->pwm[CONTROL][index] &= ~0xE0;
9071c301fc5SJordan Crouse 	data->pwm[CONTROL][index] |= (val & 7) << 5;
9081c301fc5SJordan Crouse 
9091c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
9101c301fc5SJordan Crouse 				  data->pwm[CONTROL][index]);
9111c301fc5SJordan Crouse 
9121c301fc5SJordan Crouse 	return 0;
9131c301fc5SJordan Crouse }
9141c301fc5SJordan Crouse 
915c24f9ba9SGuenter Roeck static ssize_t pwmchan_store(struct device *dev,
916c24f9ba9SGuenter Roeck 			     struct device_attribute *attr, const char *buf,
917c24f9ba9SGuenter Roeck 			     size_t count)
9181c301fc5SJordan Crouse {
9191c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
920c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
921c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
9221c301fc5SJordan Crouse 	int r;
9231c301fc5SJordan Crouse 	long val;
9241c301fc5SJordan Crouse 
925179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
9261c301fc5SJordan Crouse 		return -EINVAL;
9271c301fc5SJordan Crouse 
9281c301fc5SJordan Crouse 	mutex_lock(&data->lock);
9291c301fc5SJordan Crouse 	/* Read Modify Write PWM values */
9301c301fc5SJordan Crouse 	adt7475_read_pwm(client, sattr->index);
9311c301fc5SJordan Crouse 	r = hw_set_pwm(client, sattr->index, data->pwmctl[sattr->index], val);
9321c301fc5SJordan Crouse 	if (r)
9331c301fc5SJordan Crouse 		count = r;
9341c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
9351c301fc5SJordan Crouse 
9361c301fc5SJordan Crouse 	return count;
9371c301fc5SJordan Crouse }
9381c301fc5SJordan Crouse 
939c24f9ba9SGuenter Roeck static ssize_t pwmctrl_store(struct device *dev,
940c24f9ba9SGuenter Roeck 			     struct device_attribute *attr, const char *buf,
941c24f9ba9SGuenter Roeck 			     size_t count)
9421c301fc5SJordan Crouse {
9431c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
944c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
945c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
9461c301fc5SJordan Crouse 	int r;
9471c301fc5SJordan Crouse 	long val;
9481c301fc5SJordan Crouse 
949179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
9501c301fc5SJordan Crouse 		return -EINVAL;
9511c301fc5SJordan Crouse 
9521c301fc5SJordan Crouse 	mutex_lock(&data->lock);
9531c301fc5SJordan Crouse 	/* Read Modify Write PWM values */
9541c301fc5SJordan Crouse 	adt7475_read_pwm(client, sattr->index);
9551c301fc5SJordan Crouse 	r = hw_set_pwm(client, sattr->index, val, data->pwmchan[sattr->index]);
9561c301fc5SJordan Crouse 	if (r)
9571c301fc5SJordan Crouse 		count = r;
9581c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
9591c301fc5SJordan Crouse 
9601c301fc5SJordan Crouse 	return count;
9611c301fc5SJordan Crouse }
9621c301fc5SJordan Crouse 
9631c301fc5SJordan Crouse /* List of frequencies for the PWM */
9641c301fc5SJordan Crouse static const int pwmfreq_table[] = {
9653490c92aSChris Packham 	11, 14, 22, 29, 35, 44, 58, 88, 22500
9661c301fc5SJordan Crouse };
9671c301fc5SJordan Crouse 
968c24f9ba9SGuenter Roeck static ssize_t pwmfreq_show(struct device *dev, struct device_attribute *attr,
9691c301fc5SJordan Crouse 			    char *buf)
9701c301fc5SJordan Crouse {
9711c301fc5SJordan Crouse 	struct adt7475_data *data = adt7475_update_device(dev);
9721c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
9739d19371dSDan Carpenter 	int idx;
9741c301fc5SJordan Crouse 
9754afec79fSTokunori Ikegami 	if (IS_ERR(data))
9764afec79fSTokunori Ikegami 		return PTR_ERR(data);
9779d19371dSDan Carpenter 	idx = clamp_val(data->range[sattr->index] & 0xf, 0,
9789d19371dSDan Carpenter 			ARRAY_SIZE(pwmfreq_table) - 1);
9794afec79fSTokunori Ikegami 
9809d19371dSDan Carpenter 	return sprintf(buf, "%d\n", pwmfreq_table[idx]);
9811c301fc5SJordan Crouse }
9821c301fc5SJordan Crouse 
983c24f9ba9SGuenter Roeck static ssize_t pwmfreq_store(struct device *dev,
984c24f9ba9SGuenter Roeck 			     struct device_attribute *attr, const char *buf,
985c24f9ba9SGuenter Roeck 			     size_t count)
9861c301fc5SJordan Crouse {
9871c301fc5SJordan Crouse 	struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
988c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
989c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
9901c301fc5SJordan Crouse 	int out;
9911c301fc5SJordan Crouse 	long val;
9921c301fc5SJordan Crouse 
993179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
9941c301fc5SJordan Crouse 		return -EINVAL;
9951c301fc5SJordan Crouse 
996e4651640SChris Packham 	out = find_closest(val, pwmfreq_table, ARRAY_SIZE(pwmfreq_table));
9971c301fc5SJordan Crouse 
9981c301fc5SJordan Crouse 	mutex_lock(&data->lock);
9991c301fc5SJordan Crouse 
10001c301fc5SJordan Crouse 	data->range[sattr->index] =
10011c301fc5SJordan Crouse 		adt7475_read(TEMP_TRANGE_REG(sattr->index));
10023490c92aSChris Packham 	data->range[sattr->index] &= ~0xf;
10031c301fc5SJordan Crouse 	data->range[sattr->index] |= out;
10041c301fc5SJordan Crouse 
10051c301fc5SJordan Crouse 	i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
10061c301fc5SJordan Crouse 				  data->range[sattr->index]);
10071c301fc5SJordan Crouse 
10081c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
10091c301fc5SJordan Crouse 	return count;
10101c301fc5SJordan Crouse }
10111c301fc5SJordan Crouse 
10121d05303cSJulia Lawall static ssize_t pwm_use_point2_pwm_at_crit_show(struct device *dev,
10131d05303cSJulia Lawall 					struct device_attribute *devattr,
10141d05303cSJulia Lawall 					char *buf)
1015f99318b2SJean Delvare {
1016f99318b2SJean Delvare 	struct adt7475_data *data = adt7475_update_device(dev);
10179d19371dSDan Carpenter 
10189d19371dSDan Carpenter 	if (IS_ERR(data))
10199d19371dSDan Carpenter 		return PTR_ERR(data);
10209d19371dSDan Carpenter 
1021f99318b2SJean Delvare 	return sprintf(buf, "%d\n", !!(data->config4 & CONFIG4_MAXDUTY));
1022f99318b2SJean Delvare }
1023f99318b2SJean Delvare 
10241d05303cSJulia Lawall static ssize_t pwm_use_point2_pwm_at_crit_store(struct device *dev,
1025f99318b2SJean Delvare 					struct device_attribute *devattr,
1026f99318b2SJean Delvare 					const char *buf, size_t count)
1027f99318b2SJean Delvare {
1028c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
1029c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
1030f99318b2SJean Delvare 	long val;
1031f99318b2SJean Delvare 
1032179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
1033f99318b2SJean Delvare 		return -EINVAL;
1034f99318b2SJean Delvare 	if (val != 0 && val != 1)
1035f99318b2SJean Delvare 		return -EINVAL;
1036f99318b2SJean Delvare 
1037f99318b2SJean Delvare 	mutex_lock(&data->lock);
1038f99318b2SJean Delvare 	data->config4 = i2c_smbus_read_byte_data(client, REG_CONFIG4);
1039f99318b2SJean Delvare 	if (val)
1040f99318b2SJean Delvare 		data->config4 |= CONFIG4_MAXDUTY;
1041f99318b2SJean Delvare 	else
1042f99318b2SJean Delvare 		data->config4 &= ~CONFIG4_MAXDUTY;
1043f99318b2SJean Delvare 	i2c_smbus_write_byte_data(client, REG_CONFIG4, data->config4);
1044f99318b2SJean Delvare 	mutex_unlock(&data->lock);
1045f99318b2SJean Delvare 
1046f99318b2SJean Delvare 	return count;
1047f99318b2SJean Delvare }
1048f99318b2SJean Delvare 
10491d05303cSJulia Lawall static ssize_t vrm_show(struct device *dev, struct device_attribute *devattr,
105054fe4671SJean Delvare 			char *buf)
105154fe4671SJean Delvare {
105254fe4671SJean Delvare 	struct adt7475_data *data = dev_get_drvdata(dev);
105354fe4671SJean Delvare 	return sprintf(buf, "%d\n", (int)data->vrm);
105454fe4671SJean Delvare }
105554fe4671SJean Delvare 
10561d05303cSJulia Lawall static ssize_t vrm_store(struct device *dev, struct device_attribute *devattr,
105754fe4671SJean Delvare 			 const char *buf, size_t count)
105854fe4671SJean Delvare {
105954fe4671SJean Delvare 	struct adt7475_data *data = dev_get_drvdata(dev);
106054fe4671SJean Delvare 	long val;
106154fe4671SJean Delvare 
1062179c4fdbSFrans Meulenbroeks 	if (kstrtol(buf, 10, &val))
106354fe4671SJean Delvare 		return -EINVAL;
106454fe4671SJean Delvare 	if (val < 0 || val > 255)
106554fe4671SJean Delvare 		return -EINVAL;
106654fe4671SJean Delvare 	data->vrm = val;
106754fe4671SJean Delvare 
106854fe4671SJean Delvare 	return count;
106954fe4671SJean Delvare }
107054fe4671SJean Delvare 
10711d05303cSJulia Lawall static ssize_t cpu0_vid_show(struct device *dev,
10721d05303cSJulia Lawall 			     struct device_attribute *devattr, char *buf)
107354fe4671SJean Delvare {
107454fe4671SJean Delvare 	struct adt7475_data *data = adt7475_update_device(dev);
10754afec79fSTokunori Ikegami 
10764afec79fSTokunori Ikegami 	if (IS_ERR(data))
10774afec79fSTokunori Ikegami 		return PTR_ERR(data);
10784afec79fSTokunori Ikegami 
107954fe4671SJean Delvare 	return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
108054fe4671SJean Delvare }
108154fe4671SJean Delvare 
1082c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in0_input, voltage, INPUT, 0);
1083c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in0_max, voltage, MAX, 0);
1084c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in0_min, voltage, MIN, 0);
1085c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, voltage, ALARM, 0);
1086c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in1_input, voltage, INPUT, 1);
1087c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in1_max, voltage, MAX, 1);
1088c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in1_min, voltage, MIN, 1);
1089c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in1_alarm, voltage, ALARM, 1);
1090c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in2_input, voltage, INPUT, 2);
1091c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in2_max, voltage, MAX, 2);
1092c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in2_min, voltage, MIN, 2);
1093c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, voltage, ALARM, 2);
1094c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in3_input, voltage, INPUT, 3);
1095c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in3_max, voltage, MAX, 3);
1096c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in3_min, voltage, MIN, 3);
1097c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, voltage, ALARM, 3);
1098c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in4_input, voltage, INPUT, 4);
1099c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in4_max, voltage, MAX, 4);
1100c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in4_min, voltage, MIN, 4);
1101c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, voltage, ALARM, 8);
1102c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in5_input, voltage, INPUT, 5);
1103c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in5_max, voltage, MAX, 5);
1104c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(in5_min, voltage, MIN, 5);
1105c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(in5_alarm, voltage, ALARM, 31);
1106c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, INPUT, 0);
1107c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp1_alarm, temp, ALARM, 0);
1108c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp1_fault, temp, FAULT, 0);
1109c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, MAX, 0);
1110c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, MIN, 0);
1111c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_offset, temp, OFFSET, 0);
1112c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point1_temp, temp, AUTOMIN, 0);
1113c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, point2, 0, 0);
1114c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, THERM, 0);
1115c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_crit_hyst, temp, HYSTERSIS, 0);
1116c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp1_smoothing, temp_st, 0, 0);
1117c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, INPUT, 1);
1118c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp2_alarm, temp, ALARM, 1);
1119c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, MAX, 1);
1120c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, MIN, 1);
1121c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_offset, temp, OFFSET, 1);
1122c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp, AUTOMIN, 1);
1123c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, point2, 0, 1);
1124c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, THERM, 1);
1125c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_crit_hyst, temp, HYSTERSIS, 1);
1126c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp2_smoothing, temp_st, 0, 1);
1127c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, INPUT, 2);
1128c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp3_alarm, temp, ALARM, 2);
1129c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, temp, FAULT, 2);
1130c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, MAX, 2);
1131c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, MIN, 2);
1132c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_offset, temp, OFFSET, 2);
1133c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_auto_point1_temp, temp, AUTOMIN, 2);
1134c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_auto_point2_temp, point2, 0, 2);
1135c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, THERM, 2);
1136c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_crit_hyst, temp, HYSTERSIS, 2);
1137c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(temp3_smoothing, temp_st, 0, 2);
1138c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan1_input, tach, INPUT, 0);
1139c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(fan1_min, tach, MIN, 0);
1140c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan1_alarm, tach, ALARM, 0);
1141c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan2_input, tach, INPUT, 1);
1142c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(fan2_min, tach, MIN, 1);
1143c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan2_alarm, tach, ALARM, 1);
1144c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan3_input, tach, INPUT, 2);
1145c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(fan3_min, tach, MIN, 2);
1146c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan3_alarm, tach, ALARM, 2);
1147c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan4_input, tach, INPUT, 3);
1148c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(fan4_min, tach, MIN, 3);
1149c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RO(fan4_alarm, tach, ALARM, 3);
1150c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm1, pwm, INPUT, 0);
1151c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm1_freq, pwmfreq, INPUT, 0);
1152c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm1_enable, pwmctrl, INPUT, 0);
1153c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_channels_temp, pwmchan, INPUT, 0);
1154c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, pwm, MIN, 0);
1155c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, pwm, MAX, 0);
1156c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm1_stall_disable, stall_disable, 0, 0);
1157c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm2, pwm, INPUT, 1);
1158c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm2_freq, pwmfreq, INPUT, 1);
1159c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm2_enable, pwmctrl, INPUT, 1);
1160c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_channels_temp, pwmchan, INPUT, 1);
1161c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, pwm, MIN, 1);
1162c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, pwm, MAX, 1);
1163c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm2_stall_disable, stall_disable, 0, 1);
1164c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm3, pwm, INPUT, 2);
1165c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm3_freq, pwmfreq, INPUT, 2);
1166c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm3_enable, pwmctrl, INPUT, 2);
1167c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_channels_temp, pwmchan, INPUT, 2);
1168c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_pwm, pwm, MIN, 2);
1169c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_pwm, pwm, MAX, 2);
1170c24f9ba9SGuenter Roeck static SENSOR_DEVICE_ATTR_2_RW(pwm3_stall_disable, stall_disable, 0, 2);
11711c301fc5SJordan Crouse 
1172f99318b2SJean Delvare /* Non-standard name, might need revisiting */
11731d05303cSJulia Lawall static DEVICE_ATTR_RW(pwm_use_point2_pwm_at_crit);
1174f99318b2SJean Delvare 
11751d05303cSJulia Lawall static DEVICE_ATTR_RW(vrm);
11761d05303cSJulia Lawall static DEVICE_ATTR_RO(cpu0_vid);
117754fe4671SJean Delvare 
11781c301fc5SJordan Crouse static struct attribute *adt7475_attrs[] = {
11791c301fc5SJordan Crouse 	&sensor_dev_attr_in1_input.dev_attr.attr,
11801c301fc5SJordan Crouse 	&sensor_dev_attr_in1_max.dev_attr.attr,
11811c301fc5SJordan Crouse 	&sensor_dev_attr_in1_min.dev_attr.attr,
11821c301fc5SJordan Crouse 	&sensor_dev_attr_in1_alarm.dev_attr.attr,
11831c301fc5SJordan Crouse 	&sensor_dev_attr_in2_input.dev_attr.attr,
11841c301fc5SJordan Crouse 	&sensor_dev_attr_in2_max.dev_attr.attr,
11851c301fc5SJordan Crouse 	&sensor_dev_attr_in2_min.dev_attr.attr,
11861c301fc5SJordan Crouse 	&sensor_dev_attr_in2_alarm.dev_attr.attr,
11871c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_input.dev_attr.attr,
11881c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
11891c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_fault.dev_attr.attr,
11901c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_max.dev_attr.attr,
11911c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_min.dev_attr.attr,
11921c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_offset.dev_attr.attr,
11931c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
11941c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
11951c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_crit.dev_attr.attr,
11961c301fc5SJordan Crouse 	&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
11978f05bcc3SChris Packham 	&sensor_dev_attr_temp1_smoothing.dev_attr.attr,
11981c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_input.dev_attr.attr,
11991c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
12001c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_max.dev_attr.attr,
12011c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_min.dev_attr.attr,
12021c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_offset.dev_attr.attr,
12031c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
12041c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
12051c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_crit.dev_attr.attr,
12061c301fc5SJordan Crouse 	&sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
12078f05bcc3SChris Packham 	&sensor_dev_attr_temp2_smoothing.dev_attr.attr,
12081c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_input.dev_attr.attr,
12091c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_fault.dev_attr.attr,
12101c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
12111c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_max.dev_attr.attr,
12121c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_min.dev_attr.attr,
12131c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_offset.dev_attr.attr,
12141c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
12151c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
12161c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_crit.dev_attr.attr,
12171c301fc5SJordan Crouse 	&sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
12188f05bcc3SChris Packham 	&sensor_dev_attr_temp3_smoothing.dev_attr.attr,
12191c301fc5SJordan Crouse 	&sensor_dev_attr_fan1_input.dev_attr.attr,
12201c301fc5SJordan Crouse 	&sensor_dev_attr_fan1_min.dev_attr.attr,
12211c301fc5SJordan Crouse 	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
12221c301fc5SJordan Crouse 	&sensor_dev_attr_fan2_input.dev_attr.attr,
12231c301fc5SJordan Crouse 	&sensor_dev_attr_fan2_min.dev_attr.attr,
12241c301fc5SJordan Crouse 	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
12251c301fc5SJordan Crouse 	&sensor_dev_attr_fan3_input.dev_attr.attr,
12261c301fc5SJordan Crouse 	&sensor_dev_attr_fan3_min.dev_attr.attr,
12271c301fc5SJordan Crouse 	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
12281c301fc5SJordan Crouse 	&sensor_dev_attr_pwm1.dev_attr.attr,
12291c301fc5SJordan Crouse 	&sensor_dev_attr_pwm1_freq.dev_attr.attr,
12301c301fc5SJordan Crouse 	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
123184d2a314SJean Delvare 	&sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
12321c301fc5SJordan Crouse 	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
12331c301fc5SJordan Crouse 	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
12341d58f5efSChris Packham 	&sensor_dev_attr_pwm1_stall_disable.dev_attr.attr,
12351c301fc5SJordan Crouse 	&sensor_dev_attr_pwm3.dev_attr.attr,
12361c301fc5SJordan Crouse 	&sensor_dev_attr_pwm3_freq.dev_attr.attr,
12371c301fc5SJordan Crouse 	&sensor_dev_attr_pwm3_enable.dev_attr.attr,
123884d2a314SJean Delvare 	&sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
12391c301fc5SJordan Crouse 	&sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
12401c301fc5SJordan Crouse 	&sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
12411d58f5efSChris Packham 	&sensor_dev_attr_pwm3_stall_disable.dev_attr.attr,
1242f99318b2SJean Delvare 	&dev_attr_pwm_use_point2_pwm_at_crit.attr,
12431c301fc5SJordan Crouse 	NULL,
12441c301fc5SJordan Crouse };
12451c301fc5SJordan Crouse 
1246378933c9SJean Delvare static struct attribute *fan4_attrs[] = {
1247378933c9SJean Delvare 	&sensor_dev_attr_fan4_input.dev_attr.attr,
1248378933c9SJean Delvare 	&sensor_dev_attr_fan4_min.dev_attr.attr,
1249378933c9SJean Delvare 	&sensor_dev_attr_fan4_alarm.dev_attr.attr,
1250378933c9SJean Delvare 	NULL
1251378933c9SJean Delvare };
1252378933c9SJean Delvare 
1253378933c9SJean Delvare static struct attribute *pwm2_attrs[] = {
1254378933c9SJean Delvare 	&sensor_dev_attr_pwm2.dev_attr.attr,
1255378933c9SJean Delvare 	&sensor_dev_attr_pwm2_freq.dev_attr.attr,
1256378933c9SJean Delvare 	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
1257378933c9SJean Delvare 	&sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1258378933c9SJean Delvare 	&sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1259378933c9SJean Delvare 	&sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
12601d58f5efSChris Packham 	&sensor_dev_attr_pwm2_stall_disable.dev_attr.attr,
1261378933c9SJean Delvare 	NULL
1262378933c9SJean Delvare };
1263378933c9SJean Delvare 
1264378933c9SJean Delvare static struct attribute *in0_attrs[] = {
12653d849981SJean Delvare 	&sensor_dev_attr_in0_input.dev_attr.attr,
12663d849981SJean Delvare 	&sensor_dev_attr_in0_max.dev_attr.attr,
12673d849981SJean Delvare 	&sensor_dev_attr_in0_min.dev_attr.attr,
12683d849981SJean Delvare 	&sensor_dev_attr_in0_alarm.dev_attr.attr,
1269378933c9SJean Delvare 	NULL
1270378933c9SJean Delvare };
1271378933c9SJean Delvare 
1272d8d2ee07SJean Delvare static struct attribute *in3_attrs[] = {
12733d849981SJean Delvare 	&sensor_dev_attr_in3_input.dev_attr.attr,
12743d849981SJean Delvare 	&sensor_dev_attr_in3_max.dev_attr.attr,
12753d849981SJean Delvare 	&sensor_dev_attr_in3_min.dev_attr.attr,
12763d849981SJean Delvare 	&sensor_dev_attr_in3_alarm.dev_attr.attr,
1277d8d2ee07SJean Delvare 	NULL
1278d8d2ee07SJean Delvare };
1279d8d2ee07SJean Delvare 
1280d8d2ee07SJean Delvare static struct attribute *in4_attrs[] = {
12813d849981SJean Delvare 	&sensor_dev_attr_in4_input.dev_attr.attr,
12823d849981SJean Delvare 	&sensor_dev_attr_in4_max.dev_attr.attr,
12833d849981SJean Delvare 	&sensor_dev_attr_in4_min.dev_attr.attr,
12843d849981SJean Delvare 	&sensor_dev_attr_in4_alarm.dev_attr.attr,
1285d8d2ee07SJean Delvare 	NULL
1286d8d2ee07SJean Delvare };
1287d8d2ee07SJean Delvare 
1288d8d2ee07SJean Delvare static struct attribute *in5_attrs[] = {
12893d849981SJean Delvare 	&sensor_dev_attr_in5_input.dev_attr.attr,
12903d849981SJean Delvare 	&sensor_dev_attr_in5_max.dev_attr.attr,
12913d849981SJean Delvare 	&sensor_dev_attr_in5_min.dev_attr.attr,
12923d849981SJean Delvare 	&sensor_dev_attr_in5_alarm.dev_attr.attr,
12933d849981SJean Delvare 	NULL
12943d849981SJean Delvare };
12953d849981SJean Delvare 
129654fe4671SJean Delvare static struct attribute *vid_attrs[] = {
129754fe4671SJean Delvare 	&dev_attr_cpu0_vid.attr,
129854fe4671SJean Delvare 	&dev_attr_vrm.attr,
129954fe4671SJean Delvare 	NULL
130054fe4671SJean Delvare };
130154fe4671SJean Delvare 
1302f5397be8SArvind Yadav static const struct attribute_group adt7475_attr_group = { .attrs = adt7475_attrs };
1303f5397be8SArvind Yadav static const struct attribute_group fan4_attr_group = { .attrs = fan4_attrs };
1304f5397be8SArvind Yadav static const struct attribute_group pwm2_attr_group = { .attrs = pwm2_attrs };
1305f5397be8SArvind Yadav static const struct attribute_group in0_attr_group = { .attrs = in0_attrs };
1306f5397be8SArvind Yadav static const struct attribute_group in3_attr_group = { .attrs = in3_attrs };
1307f5397be8SArvind Yadav static const struct attribute_group in4_attr_group = { .attrs = in4_attrs };
1308f5397be8SArvind Yadav static const struct attribute_group in5_attr_group = { .attrs = in5_attrs };
1309f5397be8SArvind Yadav static const struct attribute_group vid_attr_group = { .attrs = vid_attrs };
13101c301fc5SJordan Crouse 
1311310ec792SJean Delvare static int adt7475_detect(struct i2c_client *client,
13121c301fc5SJordan Crouse 			  struct i2c_board_info *info)
13131c301fc5SJordan Crouse {
13141c301fc5SJordan Crouse 	struct i2c_adapter *adapter = client->adapter;
1315d656b6fdSJean Delvare 	int vendid, devid, devid2;
1316b180d050SJean Delvare 	const char *name;
13171c301fc5SJordan Crouse 
13181c301fc5SJordan Crouse 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
13191c301fc5SJordan Crouse 		return -ENODEV;
13201c301fc5SJordan Crouse 
1321b180d050SJean Delvare 	vendid = adt7475_read(REG_VENDID);
1322d656b6fdSJean Delvare 	devid2 = adt7475_read(REG_DEVID2);
1323d656b6fdSJean Delvare 	if (vendid != 0x41 ||		/* Analog Devices */
1324d656b6fdSJean Delvare 	    (devid2 & 0xf8) != 0x68)
1325d656b6fdSJean Delvare 		return -ENODEV;
1326b180d050SJean Delvare 
1327d656b6fdSJean Delvare 	devid = adt7475_read(REG_DEVID);
1328d656b6fdSJean Delvare 	if (devid == 0x73)
1329b180d050SJean Delvare 		name = "adt7473";
1330d656b6fdSJean Delvare 	else if (devid == 0x75 && client->addr == 0x2e)
1331b180d050SJean Delvare 		name = "adt7475";
1332d8d2ee07SJean Delvare 	else if (devid == 0x76)
1333d8d2ee07SJean Delvare 		name = "adt7476";
13343d849981SJean Delvare 	else if ((devid2 & 0xfc) == 0x6c)
13353d849981SJean Delvare 		name = "adt7490";
1336b180d050SJean Delvare 	else {
1337b180d050SJean Delvare 		dev_dbg(&adapter->dev,
1338d8d2ee07SJean Delvare 			"Couldn't detect an ADT7473/75/76/90 part at "
1339b180d050SJean Delvare 			"0x%02x\n", (unsigned int)client->addr);
13401c301fc5SJordan Crouse 		return -ENODEV;
13411c301fc5SJordan Crouse 	}
13421c301fc5SJordan Crouse 
1343b180d050SJean Delvare 	strlcpy(info->type, name, I2C_NAME_SIZE);
13441c301fc5SJordan Crouse 
13451c301fc5SJordan Crouse 	return 0;
13461c301fc5SJordan Crouse }
13471c301fc5SJordan Crouse 
1348702afeadSTokunori Ikegami static int adt7475_update_limits(struct i2c_client *client)
13495cf943edSTokunori Ikegami {
13505cf943edSTokunori Ikegami 	struct adt7475_data *data = i2c_get_clientdata(client);
13515cf943edSTokunori Ikegami 	int i;
1352702afeadSTokunori Ikegami 	int ret;
13535cf943edSTokunori Ikegami 
1354702afeadSTokunori Ikegami 	ret = adt7475_read(REG_CONFIG4);
1355702afeadSTokunori Ikegami 	if (ret < 0)
1356702afeadSTokunori Ikegami 		return ret;
1357702afeadSTokunori Ikegami 	data->config4 = ret;
1358702afeadSTokunori Ikegami 
1359702afeadSTokunori Ikegami 	ret = adt7475_read(REG_CONFIG5);
1360702afeadSTokunori Ikegami 	if (ret < 0)
1361702afeadSTokunori Ikegami 		return ret;
1362702afeadSTokunori Ikegami 	data->config5 = ret;
13635cf943edSTokunori Ikegami 
13645cf943edSTokunori Ikegami 	for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
13655cf943edSTokunori Ikegami 		if (!(data->has_voltage & (1 << i)))
13665cf943edSTokunori Ikegami 			continue;
13675cf943edSTokunori Ikegami 		/* Adjust values so they match the input precision */
1368702afeadSTokunori Ikegami 		ret = adt7475_read(VOLTAGE_MIN_REG(i));
1369702afeadSTokunori Ikegami 		if (ret < 0)
1370702afeadSTokunori Ikegami 			return ret;
1371702afeadSTokunori Ikegami 		data->voltage[MIN][i] = ret << 2;
1372702afeadSTokunori Ikegami 
1373702afeadSTokunori Ikegami 		ret = adt7475_read(VOLTAGE_MAX_REG(i));
1374702afeadSTokunori Ikegami 		if (ret < 0)
1375702afeadSTokunori Ikegami 			return ret;
1376702afeadSTokunori Ikegami 		data->voltage[MAX][i] = ret << 2;
13775cf943edSTokunori Ikegami 	}
13785cf943edSTokunori Ikegami 
13795cf943edSTokunori Ikegami 	if (data->has_voltage & (1 << 5)) {
1380702afeadSTokunori Ikegami 		ret = adt7475_read(REG_VTT_MIN);
1381702afeadSTokunori Ikegami 		if (ret < 0)
1382702afeadSTokunori Ikegami 			return ret;
1383702afeadSTokunori Ikegami 		data->voltage[MIN][5] = ret << 2;
1384702afeadSTokunori Ikegami 
1385702afeadSTokunori Ikegami 		ret = adt7475_read(REG_VTT_MAX);
1386702afeadSTokunori Ikegami 		if (ret < 0)
1387702afeadSTokunori Ikegami 			return ret;
1388702afeadSTokunori Ikegami 		data->voltage[MAX][5] = ret << 2;
13895cf943edSTokunori Ikegami 	}
13905cf943edSTokunori Ikegami 
13915cf943edSTokunori Ikegami 	for (i = 0; i < ADT7475_TEMP_COUNT; i++) {
13925cf943edSTokunori Ikegami 		/* Adjust values so they match the input precision */
1393702afeadSTokunori Ikegami 		ret = adt7475_read(TEMP_MIN_REG(i));
1394702afeadSTokunori Ikegami 		if (ret < 0)
1395702afeadSTokunori Ikegami 			return ret;
1396702afeadSTokunori Ikegami 		data->temp[MIN][i] = ret << 2;
1397702afeadSTokunori Ikegami 
1398702afeadSTokunori Ikegami 		ret = adt7475_read(TEMP_MAX_REG(i));
1399702afeadSTokunori Ikegami 		if (ret < 0)
1400702afeadSTokunori Ikegami 			return ret;
1401702afeadSTokunori Ikegami 		data->temp[MAX][i] = ret << 2;
1402702afeadSTokunori Ikegami 
1403702afeadSTokunori Ikegami 		ret = adt7475_read(TEMP_TMIN_REG(i));
1404702afeadSTokunori Ikegami 		if (ret < 0)
1405702afeadSTokunori Ikegami 			return ret;
1406702afeadSTokunori Ikegami 		data->temp[AUTOMIN][i] = ret << 2;
1407702afeadSTokunori Ikegami 
1408702afeadSTokunori Ikegami 		ret = adt7475_read(TEMP_THERM_REG(i));
1409702afeadSTokunori Ikegami 		if (ret < 0)
1410702afeadSTokunori Ikegami 			return ret;
1411702afeadSTokunori Ikegami 		data->temp[THERM][i] = ret << 2;
1412702afeadSTokunori Ikegami 
1413702afeadSTokunori Ikegami 		ret = adt7475_read(TEMP_OFFSET_REG(i));
1414702afeadSTokunori Ikegami 		if (ret < 0)
1415702afeadSTokunori Ikegami 			return ret;
1416702afeadSTokunori Ikegami 		data->temp[OFFSET][i] = ret;
14175cf943edSTokunori Ikegami 	}
14185cf943edSTokunori Ikegami 	adt7475_read_hystersis(client);
14195cf943edSTokunori Ikegami 
14205cf943edSTokunori Ikegami 	for (i = 0; i < ADT7475_TACH_COUNT; i++) {
14215cf943edSTokunori Ikegami 		if (i == 3 && !data->has_fan4)
14225cf943edSTokunori Ikegami 			continue;
1423702afeadSTokunori Ikegami 		ret = adt7475_read_word(client, TACH_MIN_REG(i));
1424702afeadSTokunori Ikegami 		if (ret < 0)
1425702afeadSTokunori Ikegami 			return ret;
1426702afeadSTokunori Ikegami 		data->tach[MIN][i] = ret;
14275cf943edSTokunori Ikegami 	}
14285cf943edSTokunori Ikegami 
14295cf943edSTokunori Ikegami 	for (i = 0; i < ADT7475_PWM_COUNT; i++) {
14305cf943edSTokunori Ikegami 		if (i == 1 && !data->has_pwm2)
14315cf943edSTokunori Ikegami 			continue;
1432702afeadSTokunori Ikegami 		ret = adt7475_read(PWM_MAX_REG(i));
1433702afeadSTokunori Ikegami 		if (ret < 0)
1434702afeadSTokunori Ikegami 			return ret;
1435702afeadSTokunori Ikegami 		data->pwm[MAX][i] = ret;
1436702afeadSTokunori Ikegami 
1437702afeadSTokunori Ikegami 		ret = adt7475_read(PWM_MIN_REG(i));
1438702afeadSTokunori Ikegami 		if (ret < 0)
1439702afeadSTokunori Ikegami 			return ret;
1440702afeadSTokunori Ikegami 		data->pwm[MIN][i] = ret;
14415cf943edSTokunori Ikegami 		/* Set the channel and control information */
14425cf943edSTokunori Ikegami 		adt7475_read_pwm(client, i);
14435cf943edSTokunori Ikegami 	}
14445cf943edSTokunori Ikegami 
1445702afeadSTokunori Ikegami 	ret = adt7475_read(TEMP_TRANGE_REG(0));
1446702afeadSTokunori Ikegami 	if (ret < 0)
1447702afeadSTokunori Ikegami 		return ret;
1448702afeadSTokunori Ikegami 	data->range[0] = ret;
1449702afeadSTokunori Ikegami 
1450702afeadSTokunori Ikegami 	ret = adt7475_read(TEMP_TRANGE_REG(1));
1451702afeadSTokunori Ikegami 	if (ret < 0)
1452702afeadSTokunori Ikegami 		return ret;
1453702afeadSTokunori Ikegami 	data->range[1] = ret;
1454702afeadSTokunori Ikegami 
1455702afeadSTokunori Ikegami 	ret = adt7475_read(TEMP_TRANGE_REG(2));
1456702afeadSTokunori Ikegami 	if (ret < 0)
1457702afeadSTokunori Ikegami 		return ret;
1458702afeadSTokunori Ikegami 	data->range[2] = ret;
1459702afeadSTokunori Ikegami 
1460702afeadSTokunori Ikegami 	return 0;
14615cf943edSTokunori Ikegami }
14625cf943edSTokunori Ikegami 
1463*2ecff397SLogan Shaw static int set_property_bit(const struct i2c_client *client, char *property,
1464*2ecff397SLogan Shaw 			    u8 *config, u8 bit_index)
1465*2ecff397SLogan Shaw {
1466*2ecff397SLogan Shaw 	u32 prop_value = 0;
1467*2ecff397SLogan Shaw 	int ret = of_property_read_u32(client->dev.of_node, property,
1468*2ecff397SLogan Shaw 					&prop_value);
1469*2ecff397SLogan Shaw 
1470*2ecff397SLogan Shaw 	if (!ret) {
1471*2ecff397SLogan Shaw 		if (prop_value)
1472*2ecff397SLogan Shaw 			*config |= (1 << bit_index);
1473*2ecff397SLogan Shaw 		else
1474*2ecff397SLogan Shaw 			*config &= ~(1 << bit_index);
1475*2ecff397SLogan Shaw 	}
1476*2ecff397SLogan Shaw 
1477*2ecff397SLogan Shaw 	return ret;
1478*2ecff397SLogan Shaw }
1479*2ecff397SLogan Shaw 
1480*2ecff397SLogan Shaw static int load_attenuators(const struct i2c_client *client, int chip,
1481*2ecff397SLogan Shaw 			    struct adt7475_data *data)
1482*2ecff397SLogan Shaw {
1483*2ecff397SLogan Shaw 	int ret;
1484*2ecff397SLogan Shaw 
1485*2ecff397SLogan Shaw 	if (chip == adt7476 || chip == adt7490) {
1486*2ecff397SLogan Shaw 		set_property_bit(client, "adi,bypass-attenuator-in0",
1487*2ecff397SLogan Shaw 				 &data->config4, 4);
1488*2ecff397SLogan Shaw 		set_property_bit(client, "adi,bypass-attenuator-in1",
1489*2ecff397SLogan Shaw 				 &data->config4, 5);
1490*2ecff397SLogan Shaw 		set_property_bit(client, "adi,bypass-attenuator-in3",
1491*2ecff397SLogan Shaw 				 &data->config4, 6);
1492*2ecff397SLogan Shaw 		set_property_bit(client, "adi,bypass-attenuator-in4",
1493*2ecff397SLogan Shaw 				 &data->config4, 7);
1494*2ecff397SLogan Shaw 
1495*2ecff397SLogan Shaw 		ret = i2c_smbus_write_byte_data(client, REG_CONFIG4,
1496*2ecff397SLogan Shaw 						data->config4);
1497*2ecff397SLogan Shaw 		if (ret < 0)
1498*2ecff397SLogan Shaw 			return ret;
1499*2ecff397SLogan Shaw 	} else if (chip == adt7473 || chip == adt7475) {
1500*2ecff397SLogan Shaw 		set_property_bit(client, "adi,bypass-attenuator-in1",
1501*2ecff397SLogan Shaw 				 &data->config2, 5);
1502*2ecff397SLogan Shaw 
1503*2ecff397SLogan Shaw 		ret = i2c_smbus_write_byte_data(client, REG_CONFIG2,
1504*2ecff397SLogan Shaw 						data->config2);
1505*2ecff397SLogan Shaw 		if (ret < 0)
1506*2ecff397SLogan Shaw 			return ret;
1507*2ecff397SLogan Shaw 	}
1508*2ecff397SLogan Shaw 
1509*2ecff397SLogan Shaw 	return 0;
1510*2ecff397SLogan Shaw }
1511*2ecff397SLogan Shaw 
15121c301fc5SJordan Crouse static int adt7475_probe(struct i2c_client *client,
15131c301fc5SJordan Crouse 			 const struct i2c_device_id *id)
15141c301fc5SJordan Crouse {
15154e2496e4SJavier Martinez Canillas 	enum chips chip;
151699b8c83aSFrans Meulenbroeks 	static const char * const names[] = {
1517d07ca4adSJean Delvare 		[adt7473] = "ADT7473",
1518d07ca4adSJean Delvare 		[adt7475] = "ADT7475",
1519d8d2ee07SJean Delvare 		[adt7476] = "ADT7476",
1520d07ca4adSJean Delvare 		[adt7490] = "ADT7490",
1521d07ca4adSJean Delvare 	};
1522d07ca4adSJean Delvare 
15231c301fc5SJordan Crouse 	struct adt7475_data *data;
1524c64fce7fSGrant McEwan 	struct device *hwmon_dev;
1525c64fce7fSGrant McEwan 	int i, ret = 0, revision, group_num = 0;
1526*2ecff397SLogan Shaw 	u8 config3;
15271c301fc5SJordan Crouse 
1528e3ecb2eeSGuenter Roeck 	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
15291c301fc5SJordan Crouse 	if (data == NULL)
15301c301fc5SJordan Crouse 		return -ENOMEM;
15311c301fc5SJordan Crouse 
15321c301fc5SJordan Crouse 	mutex_init(&data->lock);
1533c64fce7fSGrant McEwan 	data->client = client;
15341c301fc5SJordan Crouse 	i2c_set_clientdata(client, data);
15351c301fc5SJordan Crouse 
15364e2496e4SJavier Martinez Canillas 	if (client->dev.of_node)
15374e2496e4SJavier Martinez Canillas 		chip = (enum chips)of_device_get_match_data(&client->dev);
15384e2496e4SJavier Martinez Canillas 	else
15394e2496e4SJavier Martinez Canillas 		chip = id->driver_data;
15404e2496e4SJavier Martinez Canillas 
1541cffb9dd0SJean Delvare 	/* Initialize device-specific values */
15424e2496e4SJavier Martinez Canillas 	switch (chip) {
1543d8d2ee07SJean Delvare 	case adt7476:
1544d8d2ee07SJean Delvare 		data->has_voltage = 0x0e;	/* in1 to in3 */
1545d8d2ee07SJean Delvare 		revision = adt7475_read(REG_DEVID2) & 0x07;
1546d8d2ee07SJean Delvare 		break;
15473d849981SJean Delvare 	case adt7490:
1548378933c9SJean Delvare 		data->has_voltage = 0x3e;	/* in1 to in5 */
1549378933c9SJean Delvare 		revision = adt7475_read(REG_DEVID2) & 0x03;
1550d07ca4adSJean Delvare 		if (revision == 0x03)
1551d07ca4adSJean Delvare 			revision += adt7475_read(REG_DEVREV2);
15523d849981SJean Delvare 		break;
1553cffb9dd0SJean Delvare 	default:
1554cffb9dd0SJean Delvare 		data->has_voltage = 0x06;	/* in1, in2 */
1555378933c9SJean Delvare 		revision = adt7475_read(REG_DEVID2) & 0x07;
1556378933c9SJean Delvare 	}
1557378933c9SJean Delvare 
1558378933c9SJean Delvare 	config3 = adt7475_read(REG_CONFIG3);
1559378933c9SJean Delvare 	/* Pin PWM2 may alternatively be used for ALERT output */
1560378933c9SJean Delvare 	if (!(config3 & CONFIG3_SMBALERT))
1561378933c9SJean Delvare 		data->has_pwm2 = 1;
1562378933c9SJean Delvare 	/* Meaning of this bit is inverted for the ADT7473-1 */
1563378933c9SJean Delvare 	if (id->driver_data == adt7473 && revision >= 1)
1564378933c9SJean Delvare 		data->has_pwm2 = !data->has_pwm2;
1565378933c9SJean Delvare 
1566378933c9SJean Delvare 	data->config4 = adt7475_read(REG_CONFIG4);
1567378933c9SJean Delvare 	/* Pin TACH4 may alternatively be used for THERM */
1568378933c9SJean Delvare 	if ((data->config4 & CONFIG4_PINFUNC) == 0x0)
1569378933c9SJean Delvare 		data->has_fan4 = 1;
1570378933c9SJean Delvare 
15719ed5bc24SGuenter Roeck 	/*
15729ed5bc24SGuenter Roeck 	 * THERM configuration is more complex on the ADT7476 and ADT7490,
15739ed5bc24SGuenter Roeck 	 * because 2 different pins (TACH4 and +2.5 Vin) can be used for
15749ed5bc24SGuenter Roeck 	 * this function
15759ed5bc24SGuenter Roeck 	 */
1576378933c9SJean Delvare 	if (id->driver_data == adt7490) {
1577378933c9SJean Delvare 		if ((data->config4 & CONFIG4_PINFUNC) == 0x1 &&
1578378933c9SJean Delvare 		    !(config3 & CONFIG3_THERM))
1579378933c9SJean Delvare 			data->has_fan4 = 1;
1580d8d2ee07SJean Delvare 	}
1581d8d2ee07SJean Delvare 	if (id->driver_data == adt7476 || id->driver_data == adt7490) {
1582378933c9SJean Delvare 		if (!(config3 & CONFIG3_THERM) ||
1583378933c9SJean Delvare 		    (data->config4 & CONFIG4_PINFUNC) == 0x1)
1584378933c9SJean Delvare 			data->has_voltage |= (1 << 0);		/* in0 */
1585cffb9dd0SJean Delvare 	}
1586cffb9dd0SJean Delvare 
15879ed5bc24SGuenter Roeck 	/*
15889ed5bc24SGuenter Roeck 	 * On the ADT7476, the +12V input pin may instead be used as VID5,
15899ed5bc24SGuenter Roeck 	 * and VID pins may alternatively be used as GPIO
15909ed5bc24SGuenter Roeck 	 */
1591d8d2ee07SJean Delvare 	if (id->driver_data == adt7476) {
1592d8d2ee07SJean Delvare 		u8 vid = adt7475_read(REG_VID);
1593d8d2ee07SJean Delvare 		if (!(vid & VID_VIDSEL))
1594d8d2ee07SJean Delvare 			data->has_voltage |= (1 << 4);		/* in4 */
159554fe4671SJean Delvare 
159654fe4671SJean Delvare 		data->has_vid = !(adt7475_read(REG_CONFIG5) & CONFIG5_VIDGPIO);
1597d8d2ee07SJean Delvare 	}
1598d8d2ee07SJean Delvare 
1599ebfaf1fbSJean Delvare 	/* Voltage attenuators can be bypassed, globally or individually */
1600*2ecff397SLogan Shaw 	data->config2 = adt7475_read(REG_CONFIG2);
1601*2ecff397SLogan Shaw 	ret = load_attenuators(client, chip, data);
1602*2ecff397SLogan Shaw 	if (ret)
1603*2ecff397SLogan Shaw 		dev_warn(&client->dev, "Error configuring attenuator bypass\n");
1604*2ecff397SLogan Shaw 
1605*2ecff397SLogan Shaw 	if (data->config2 & CONFIG2_ATTN) {
1606ebfaf1fbSJean Delvare 		data->bypass_attn = (0x3 << 3) | 0x3;
1607ebfaf1fbSJean Delvare 	} else {
1608ebfaf1fbSJean Delvare 		data->bypass_attn = ((data->config4 & CONFIG4_ATTN_IN10) >> 4) |
1609ebfaf1fbSJean Delvare 				    ((data->config4 & CONFIG4_ATTN_IN43) >> 3);
1610ebfaf1fbSJean Delvare 	}
1611ebfaf1fbSJean Delvare 	data->bypass_attn &= data->has_voltage;
1612ebfaf1fbSJean Delvare 
16139ed5bc24SGuenter Roeck 	/*
16149ed5bc24SGuenter Roeck 	 * Call adt7475_read_pwm for all pwm's as this will reprogram any
16159ed5bc24SGuenter Roeck 	 * pwm's which are disabled to manual mode with 0% duty cycle
16169ed5bc24SGuenter Roeck 	 */
16171c301fc5SJordan Crouse 	for (i = 0; i < ADT7475_PWM_COUNT; i++)
16181c301fc5SJordan Crouse 		adt7475_read_pwm(client, i);
16191c301fc5SJordan Crouse 
16204abdf38dSChris Packham 	/* Start monitoring */
16214abdf38dSChris Packham 	switch (chip) {
16224abdf38dSChris Packham 	case adt7475:
16234abdf38dSChris Packham 	case adt7476:
16244abdf38dSChris Packham 		i2c_smbus_write_byte_data(client, REG_CONFIG1,
16254abdf38dSChris Packham 					  adt7475_read(REG_CONFIG1) | 0x01);
16264abdf38dSChris Packham 		break;
16274abdf38dSChris Packham 	default:
16284abdf38dSChris Packham 		break;
16294abdf38dSChris Packham 	}
16304abdf38dSChris Packham 
1631c64fce7fSGrant McEwan 	data->groups[group_num++] = &adt7475_attr_group;
16321c301fc5SJordan Crouse 
1633378933c9SJean Delvare 	/* Features that can be disabled individually */
1634378933c9SJean Delvare 	if (data->has_fan4) {
1635c64fce7fSGrant McEwan 		data->groups[group_num++] = &fan4_attr_group;
1636378933c9SJean Delvare 	}
1637378933c9SJean Delvare 	if (data->has_pwm2) {
1638c64fce7fSGrant McEwan 		data->groups[group_num++] = &pwm2_attr_group;
1639378933c9SJean Delvare 	}
1640378933c9SJean Delvare 	if (data->has_voltage & (1 << 0)) {
1641c64fce7fSGrant McEwan 		data->groups[group_num++] = &in0_attr_group;
1642378933c9SJean Delvare 	}
1643d8d2ee07SJean Delvare 	if (data->has_voltage & (1 << 3)) {
1644c64fce7fSGrant McEwan 		data->groups[group_num++] = &in3_attr_group;
1645d8d2ee07SJean Delvare 	}
1646d8d2ee07SJean Delvare 	if (data->has_voltage & (1 << 4)) {
1647c64fce7fSGrant McEwan 		data->groups[group_num++] = &in4_attr_group;
1648d8d2ee07SJean Delvare 	}
1649d8d2ee07SJean Delvare 	if (data->has_voltage & (1 << 5)) {
1650c64fce7fSGrant McEwan 		data->groups[group_num++] = &in5_attr_group;
1651d8d2ee07SJean Delvare 	}
165254fe4671SJean Delvare 	if (data->has_vid) {
165354fe4671SJean Delvare 		data->vrm = vid_which_vrm();
1654c64fce7fSGrant McEwan 		data->groups[group_num] = &vid_attr_group;
165554fe4671SJean Delvare 	}
1656378933c9SJean Delvare 
1657c64fce7fSGrant McEwan 	/* register device with all the acquired attributes */
1658c64fce7fSGrant McEwan 	hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
1659c64fce7fSGrant McEwan 							   client->name, data,
1660c64fce7fSGrant McEwan 							   data->groups);
1661c64fce7fSGrant McEwan 
1662c64fce7fSGrant McEwan 	if (IS_ERR(hwmon_dev)) {
1663c64fce7fSGrant McEwan 		ret = PTR_ERR(hwmon_dev);
1664c64fce7fSGrant McEwan 		return ret;
16651c301fc5SJordan Crouse 	}
16661c301fc5SJordan Crouse 
1667d07ca4adSJean Delvare 	dev_info(&client->dev, "%s device, revision %d\n",
1668d07ca4adSJean Delvare 		 names[id->driver_data], revision);
1669d8d2ee07SJean Delvare 	if ((data->has_voltage & 0x11) || data->has_fan4 || data->has_pwm2)
167054fe4671SJean Delvare 		dev_info(&client->dev, "Optional features:%s%s%s%s%s\n",
1671d07ca4adSJean Delvare 			 (data->has_voltage & (1 << 0)) ? " in0" : "",
1672d8d2ee07SJean Delvare 			 (data->has_voltage & (1 << 4)) ? " in4" : "",
1673d07ca4adSJean Delvare 			 data->has_fan4 ? " fan4" : "",
167454fe4671SJean Delvare 			 data->has_pwm2 ? " pwm2" : "",
167554fe4671SJean Delvare 			 data->has_vid ? " vid" : "");
1676ebfaf1fbSJean Delvare 	if (data->bypass_attn)
1677ebfaf1fbSJean Delvare 		dev_info(&client->dev, "Bypassing attenuators on:%s%s%s%s\n",
1678ebfaf1fbSJean Delvare 			 (data->bypass_attn & (1 << 0)) ? " in0" : "",
1679ebfaf1fbSJean Delvare 			 (data->bypass_attn & (1 << 1)) ? " in1" : "",
1680ebfaf1fbSJean Delvare 			 (data->bypass_attn & (1 << 3)) ? " in3" : "",
1681ebfaf1fbSJean Delvare 			 (data->bypass_attn & (1 << 4)) ? " in4" : "");
1682d07ca4adSJean Delvare 
16835cf943edSTokunori Ikegami 	/* Limits and settings, should never change update more than once */
16844afec79fSTokunori Ikegami 	ret = adt7475_update_limits(client);
16854afec79fSTokunori Ikegami 	if (ret)
16861c301fc5SJordan Crouse 		return ret;
16871c301fc5SJordan Crouse 
16881c301fc5SJordan Crouse 	return 0;
16891c301fc5SJordan Crouse }
16901c301fc5SJordan Crouse 
16911c301fc5SJordan Crouse static struct i2c_driver adt7475_driver = {
16921c301fc5SJordan Crouse 	.class		= I2C_CLASS_HWMON,
16931c301fc5SJordan Crouse 	.driver = {
16941c301fc5SJordan Crouse 		.name	= "adt7475",
16954e2496e4SJavier Martinez Canillas 		.of_match_table = of_match_ptr(adt7475_of_match),
16961c301fc5SJordan Crouse 	},
16971c301fc5SJordan Crouse 	.probe		= adt7475_probe,
16981c301fc5SJordan Crouse 	.id_table	= adt7475_id,
16991c301fc5SJordan Crouse 	.detect		= adt7475_detect,
1700c3813d6aSJean Delvare 	.address_list	= normal_i2c,
17011c301fc5SJordan Crouse };
17021c301fc5SJordan Crouse 
17031c301fc5SJordan Crouse static void adt7475_read_hystersis(struct i2c_client *client)
17041c301fc5SJordan Crouse {
17051c301fc5SJordan Crouse 	struct adt7475_data *data = i2c_get_clientdata(client);
17061c301fc5SJordan Crouse 
17071c301fc5SJordan Crouse 	data->temp[HYSTERSIS][0] = (u16) adt7475_read(REG_REMOTE1_HYSTERSIS);
17081c301fc5SJordan Crouse 	data->temp[HYSTERSIS][1] = data->temp[HYSTERSIS][0];
17091c301fc5SJordan Crouse 	data->temp[HYSTERSIS][2] = (u16) adt7475_read(REG_REMOTE2_HYSTERSIS);
17101c301fc5SJordan Crouse }
17111c301fc5SJordan Crouse 
17121c301fc5SJordan Crouse static void adt7475_read_pwm(struct i2c_client *client, int index)
17131c301fc5SJordan Crouse {
17141c301fc5SJordan Crouse 	struct adt7475_data *data = i2c_get_clientdata(client);
17151c301fc5SJordan Crouse 	unsigned int v;
17161c301fc5SJordan Crouse 
17171c301fc5SJordan Crouse 	data->pwm[CONTROL][index] = adt7475_read(PWM_CONFIG_REG(index));
17181c301fc5SJordan Crouse 
17199ed5bc24SGuenter Roeck 	/*
17209ed5bc24SGuenter Roeck 	 * Figure out the internal value for pwmctrl and pwmchan
17219ed5bc24SGuenter Roeck 	 * based on the current settings
17229ed5bc24SGuenter Roeck 	 */
17231c301fc5SJordan Crouse 	v = (data->pwm[CONTROL][index] >> 5) & 7;
17241c301fc5SJordan Crouse 
17251c301fc5SJordan Crouse 	if (v == 3)
17261c301fc5SJordan Crouse 		data->pwmctl[index] = 0;
17271c301fc5SJordan Crouse 	else if (v == 7)
17281c301fc5SJordan Crouse 		data->pwmctl[index] = 1;
17291c301fc5SJordan Crouse 	else if (v == 4) {
17309ed5bc24SGuenter Roeck 		/*
17319ed5bc24SGuenter Roeck 		 * The fan is disabled - we don't want to
17329ed5bc24SGuenter Roeck 		 * support that, so change to manual mode and
17339ed5bc24SGuenter Roeck 		 * set the duty cycle to 0 instead
17341c301fc5SJordan Crouse 		 */
17351c301fc5SJordan Crouse 		data->pwm[INPUT][index] = 0;
17361c301fc5SJordan Crouse 		data->pwm[CONTROL][index] &= ~0xE0;
17371c301fc5SJordan Crouse 		data->pwm[CONTROL][index] |= (7 << 5);
17381c301fc5SJordan Crouse 
17391c301fc5SJordan Crouse 		i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
17401c301fc5SJordan Crouse 					  data->pwm[INPUT][index]);
17411c301fc5SJordan Crouse 
17421c301fc5SJordan Crouse 		i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
17431c301fc5SJordan Crouse 					  data->pwm[CONTROL][index]);
17441c301fc5SJordan Crouse 
17451c301fc5SJordan Crouse 		data->pwmctl[index] = 1;
17461c301fc5SJordan Crouse 	} else {
17471c301fc5SJordan Crouse 		data->pwmctl[index] = 2;
17481c301fc5SJordan Crouse 
17491c301fc5SJordan Crouse 		switch (v) {
17501c301fc5SJordan Crouse 		case 0:
17511c301fc5SJordan Crouse 			data->pwmchan[index] = 1;
17521c301fc5SJordan Crouse 			break;
17531c301fc5SJordan Crouse 		case 1:
17541c301fc5SJordan Crouse 			data->pwmchan[index] = 2;
17551c301fc5SJordan Crouse 			break;
17561c301fc5SJordan Crouse 		case 2:
17571c301fc5SJordan Crouse 			data->pwmchan[index] = 4;
17581c301fc5SJordan Crouse 			break;
17591c301fc5SJordan Crouse 		case 5:
17601c301fc5SJordan Crouse 			data->pwmchan[index] = 6;
17611c301fc5SJordan Crouse 			break;
17621c301fc5SJordan Crouse 		case 6:
17631c301fc5SJordan Crouse 			data->pwmchan[index] = 7;
17641c301fc5SJordan Crouse 			break;
17651c301fc5SJordan Crouse 		}
17661c301fc5SJordan Crouse 	}
17671c301fc5SJordan Crouse }
17681c301fc5SJordan Crouse 
1769702afeadSTokunori Ikegami static int adt7475_update_measure(struct device *dev)
17701c301fc5SJordan Crouse {
1771c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
1772c64fce7fSGrant McEwan 	struct i2c_client *client = data->client;
17733d849981SJean Delvare 	u16 ext;
17741c301fc5SJordan Crouse 	int i;
1775702afeadSTokunori Ikegami 	int ret;
17761c301fc5SJordan Crouse 
1777702afeadSTokunori Ikegami 	ret = adt7475_read(REG_STATUS2);
1778702afeadSTokunori Ikegami 	if (ret < 0)
1779702afeadSTokunori Ikegami 		return ret;
1780702afeadSTokunori Ikegami 	data->alarms = ret << 8;
17811c301fc5SJordan Crouse 
1782702afeadSTokunori Ikegami 	ret = adt7475_read(REG_STATUS1);
1783702afeadSTokunori Ikegami 	if (ret < 0)
1784702afeadSTokunori Ikegami 		return ret;
1785702afeadSTokunori Ikegami 	data->alarms |= ret;
1786702afeadSTokunori Ikegami 
1787702afeadSTokunori Ikegami 	ret = adt7475_read(REG_EXTEND2);
1788702afeadSTokunori Ikegami 	if (ret < 0)
1789702afeadSTokunori Ikegami 		return ret;
1790702afeadSTokunori Ikegami 
1791702afeadSTokunori Ikegami 	ext = (ret << 8);
1792702afeadSTokunori Ikegami 
1793702afeadSTokunori Ikegami 	ret = adt7475_read(REG_EXTEND1);
1794702afeadSTokunori Ikegami 	if (ret < 0)
1795702afeadSTokunori Ikegami 		return ret;
1796702afeadSTokunori Ikegami 
1797702afeadSTokunori Ikegami 	ext |= ret;
1798702afeadSTokunori Ikegami 
1799cffb9dd0SJean Delvare 	for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
1800cffb9dd0SJean Delvare 		if (!(data->has_voltage & (1 << i)))
1801cffb9dd0SJean Delvare 			continue;
1802702afeadSTokunori Ikegami 		ret = adt7475_read(VOLTAGE_REG(i));
1803702afeadSTokunori Ikegami 		if (ret < 0)
1804702afeadSTokunori Ikegami 			return ret;
18051c301fc5SJordan Crouse 		data->voltage[INPUT][i] =
1806702afeadSTokunori Ikegami 			(ret << 2) |
1807cffb9dd0SJean Delvare 			((ext >> (i * 2)) & 3);
1808cffb9dd0SJean Delvare 	}
18091c301fc5SJordan Crouse 
1810702afeadSTokunori Ikegami 	for (i = 0; i < ADT7475_TEMP_COUNT; i++) {
1811702afeadSTokunori Ikegami 		ret = adt7475_read(TEMP_REG(i));
1812702afeadSTokunori Ikegami 		if (ret < 0)
1813702afeadSTokunori Ikegami 			return ret;
18141c301fc5SJordan Crouse 		data->temp[INPUT][i] =
1815702afeadSTokunori Ikegami 			(ret << 2) |
18163d849981SJean Delvare 			((ext >> ((i + 5) * 2)) & 3);
1817702afeadSTokunori Ikegami 	}
18183d849981SJean Delvare 
18193d849981SJean Delvare 	if (data->has_voltage & (1 << 5)) {
1820702afeadSTokunori Ikegami 		ret = adt7475_read(REG_STATUS4);
1821702afeadSTokunori Ikegami 		if (ret < 0)
1822702afeadSTokunori Ikegami 			return ret;
1823702afeadSTokunori Ikegami 		data->alarms |= ret << 24;
1824702afeadSTokunori Ikegami 
1825702afeadSTokunori Ikegami 		ret = adt7475_read(REG_EXTEND3);
1826702afeadSTokunori Ikegami 		if (ret < 0)
1827702afeadSTokunori Ikegami 			return ret;
1828702afeadSTokunori Ikegami 		ext = ret;
1829702afeadSTokunori Ikegami 
1830702afeadSTokunori Ikegami 		ret = adt7475_read(REG_VTT);
1831702afeadSTokunori Ikegami 		if (ret < 0)
1832702afeadSTokunori Ikegami 			return ret;
1833702afeadSTokunori Ikegami 		data->voltage[INPUT][5] = ret << 2 |
18343d849981SJean Delvare 			((ext >> 4) & 3);
18353d849981SJean Delvare 	}
18361c301fc5SJordan Crouse 
1837378933c9SJean Delvare 	for (i = 0; i < ADT7475_TACH_COUNT; i++) {
1838378933c9SJean Delvare 		if (i == 3 && !data->has_fan4)
1839378933c9SJean Delvare 			continue;
1840702afeadSTokunori Ikegami 		ret = adt7475_read_word(client, TACH_REG(i));
1841702afeadSTokunori Ikegami 		if (ret < 0)
1842702afeadSTokunori Ikegami 			return ret;
1843702afeadSTokunori Ikegami 		data->tach[INPUT][i] = ret;
1844378933c9SJean Delvare 	}
18451c301fc5SJordan Crouse 
18461c301fc5SJordan Crouse 	/* Updated by hw when in auto mode */
1847378933c9SJean Delvare 	for (i = 0; i < ADT7475_PWM_COUNT; i++) {
1848378933c9SJean Delvare 		if (i == 1 && !data->has_pwm2)
1849378933c9SJean Delvare 			continue;
1850702afeadSTokunori Ikegami 		ret = adt7475_read(PWM_REG(i));
1851702afeadSTokunori Ikegami 		if (ret < 0)
1852702afeadSTokunori Ikegami 			return ret;
1853702afeadSTokunori Ikegami 		data->pwm[INPUT][i] = ret;
1854378933c9SJean Delvare 	}
18551c301fc5SJordan Crouse 
1856702afeadSTokunori Ikegami 	if (data->has_vid) {
1857702afeadSTokunori Ikegami 		ret = adt7475_read(REG_VID);
1858702afeadSTokunori Ikegami 		if (ret < 0)
1859702afeadSTokunori Ikegami 			return ret;
1860702afeadSTokunori Ikegami 		data->vid = ret & 0x3f;
1861702afeadSTokunori Ikegami 	}
1862702afeadSTokunori Ikegami 
1863702afeadSTokunori Ikegami 	return 0;
18641c301fc5SJordan Crouse }
18651c301fc5SJordan Crouse 
18665cf943edSTokunori Ikegami static struct adt7475_data *adt7475_update_device(struct device *dev)
18675cf943edSTokunori Ikegami {
1868c64fce7fSGrant McEwan 	struct adt7475_data *data = dev_get_drvdata(dev);
18694afec79fSTokunori Ikegami 	int ret;
18705cf943edSTokunori Ikegami 
18715cf943edSTokunori Ikegami 	mutex_lock(&data->lock);
18725cf943edSTokunori Ikegami 
18735cf943edSTokunori Ikegami 	/* Measurement values update every 2 seconds */
18745cf943edSTokunori Ikegami 	if (time_after(jiffies, data->measure_updated + HZ * 2) ||
18751c301fc5SJordan Crouse 	    !data->valid) {
18764afec79fSTokunori Ikegami 		ret = adt7475_update_measure(dev);
18774afec79fSTokunori Ikegami 		if (ret) {
18784afec79fSTokunori Ikegami 			data->valid = false;
18794afec79fSTokunori Ikegami 			mutex_unlock(&data->lock);
18804afec79fSTokunori Ikegami 			return ERR_PTR(ret);
18814afec79fSTokunori Ikegami 		}
18825cf943edSTokunori Ikegami 		data->measure_updated = jiffies;
1883b36fb171STokunori Ikegami 		data->valid = true;
18841c301fc5SJordan Crouse 	}
18851c301fc5SJordan Crouse 
18861c301fc5SJordan Crouse 	mutex_unlock(&data->lock);
18871c301fc5SJordan Crouse 
18881c301fc5SJordan Crouse 	return data;
18891c301fc5SJordan Crouse }
18901c301fc5SJordan Crouse 
1891f0967eeaSAxel Lin module_i2c_driver(adt7475_driver);
18921c301fc5SJordan Crouse 
18931c301fc5SJordan Crouse MODULE_AUTHOR("Advanced Micro Devices, Inc");
18941c301fc5SJordan Crouse MODULE_DESCRIPTION("adt7475 driver");
18951c301fc5SJordan Crouse MODULE_LICENSE("GPL");
1896