1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* adm1026.c - Part of lm_sensors, Linux kernel modules for hardware
4	* monitoring
5	* Copyright (C) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com>
6	* Copyright (C) 2004 Justin Thiessen <jthiessen@penguincomputing.com>
7	*
8	* Chip details at:
9	*
10	* <https://www.onsemi.com/PowerSolutions/product.do?id=ADM1026>
11	*/
12
13	#include <linux/module.h>
14	#include <linux/init.h>
15	#include <linux/slab.h>
16	#include <linux/jiffies.h>
17	#include <linux/i2c.h>
18	#include <linux/hwmon.h>
19	#include <linux/hwmon-sysfs.h>
20	#include <linux/hwmon-vid.h>
21	#include <linux/err.h>
22	#include <linux/mutex.h>
23
24	/* Addresses to scan */
25	static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
26
27	static int gpio_input[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
28	-1, -1, -1, -1, -1, -1, -1, -1 };
29	static int gpio_output[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
30	-1, -1, -1, -1, -1, -1, -1, -1 };
31	static int gpio_inverted[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
32	-1, -1, -1, -1, -1, -1, -1, -1 };
33	static int gpio_normal[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
34	-1, -1, -1, -1, -1, -1, -1, -1 };
35	static int gpio_fan[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
36	module_param_array(gpio_input, int, NULL, 0);
37	MODULE_PARM_DESC(gpio_input, "List of GPIO pins (0-16) to program as inputs");
38	module_param_array(gpio_output, int, NULL, 0);
39	MODULE_PARM_DESC(gpio_output,
40	"List of GPIO pins (0-16) to program as outputs");
41	module_param_array(gpio_inverted, int, NULL, 0);
42	MODULE_PARM_DESC(gpio_inverted,
43	"List of GPIO pins (0-16) to program as inverted");
44	module_param_array(gpio_normal, int, NULL, 0);
45	MODULE_PARM_DESC(gpio_normal,
46	"List of GPIO pins (0-16) to program as normal/non-inverted");
47	module_param_array(gpio_fan, int, NULL, 0);
48	MODULE_PARM_DESC(gpio_fan, "List of GPIO pins (0-7) to program as fan tachs");
49
50	/* Many ADM1026 constants specified below */
51
52	/* The ADM1026 registers */
53	#define ADM1026_REG_CONFIG1 0x00
54	#define CFG1_MONITOR 0x01
55	#define CFG1_INT_ENABLE 0x02
56	#define CFG1_INT_CLEAR 0x04
57	#define CFG1_AIN8_9 0x08
58	#define CFG1_THERM_HOT 0x10
59	#define CFG1_DAC_AFC 0x20
60	#define CFG1_PWM_AFC 0x40
61	#define CFG1_RESET 0x80
62
63	#define ADM1026_REG_CONFIG2 0x01
64	/* CONFIG2 controls FAN0/GPIO0 through FAN7/GPIO7 */
65
66	#define ADM1026_REG_CONFIG3 0x07
67	#define CFG3_GPIO16_ENABLE 0x01
68	#define CFG3_CI_CLEAR 0x02
69	#define CFG3_VREF_250 0x04
70	#define CFG3_GPIO16_DIR 0x40
71	#define CFG3_GPIO16_POL 0x80
72
73	#define ADM1026_REG_E2CONFIG 0x13
74	#define E2CFG_READ 0x01
75	#define E2CFG_WRITE 0x02
76	#define E2CFG_ERASE 0x04
77	#define E2CFG_ROM 0x08
78	#define E2CFG_CLK_EXT 0x80
79
80	/*
81	* There are 10 general analog inputs and 7 dedicated inputs
82	* They are:
83	* 0 - 9 = AIN0 - AIN9
84	* 10 = Vbat
85	* 11 = 3.3V Standby
86	* 12 = 3.3V Main
87	* 13 = +5V
88	* 14 = Vccp (CPU core voltage)
89	* 15 = +12V
90	* 16 = -12V
91	*/
92	static u16 ADM1026_REG_IN[] = {
93	0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
94	0x36, 0x37, 0x27, 0x29, 0x26, 0x2a,
95	0x2b, 0x2c, 0x2d, 0x2e, 0x2f
96	};
97	static u16 ADM1026_REG_IN_MIN[] = {
98	0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d,
99	0x5e, 0x5f, 0x6d, 0x49, 0x6b, 0x4a,
100	0x4b, 0x4c, 0x4d, 0x4e, 0x4f
101	};
102	static u16 ADM1026_REG_IN_MAX[] = {
103	0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
104	0x56, 0x57, 0x6c, 0x41, 0x6a, 0x42,
105	0x43, 0x44, 0x45, 0x46, 0x47
106	};
107
108	/*
109	* Temperatures are:
110	* 0 - Internal
111	* 1 - External 1
112	* 2 - External 2
113	*/
114	static u16 ADM1026_REG_TEMP[] = { 0x1f, 0x28, 0x29 };
115	static u16 ADM1026_REG_TEMP_MIN[] = { 0x69, 0x48, 0x49 };
116	static u16 ADM1026_REG_TEMP_MAX[] = { 0x68, 0x40, 0x41 };
117	static u16 ADM1026_REG_TEMP_TMIN[] = { 0x10, 0x11, 0x12 };
118	static u16 ADM1026_REG_TEMP_THERM[] = { 0x0d, 0x0e, 0x0f };
119	static u16 ADM1026_REG_TEMP_OFFSET[] = { 0x1e, 0x6e, 0x6f };
120
121	#define ADM1026_REG_FAN(nr) (0x38 + (nr))
122	#define ADM1026_REG_FAN_MIN(nr) (0x60 + (nr))
123	#define ADM1026_REG_FAN_DIV_0_3 0x02
124	#define ADM1026_REG_FAN_DIV_4_7 0x03
125
126	#define ADM1026_REG_DAC 0x04
127	#define ADM1026_REG_PWM 0x05
128
129	#define ADM1026_REG_GPIO_CFG_0_3 0x08
130	#define ADM1026_REG_GPIO_CFG_4_7 0x09
131	#define ADM1026_REG_GPIO_CFG_8_11 0x0a
132	#define ADM1026_REG_GPIO_CFG_12_15 0x0b
133	/* CFG_16 in REG_CFG3 */
134	#define ADM1026_REG_GPIO_STATUS_0_7 0x24
135	#define ADM1026_REG_GPIO_STATUS_8_15 0x25
136	/* STATUS_16 in REG_STATUS4 */
137	#define ADM1026_REG_GPIO_MASK_0_7 0x1c
138	#define ADM1026_REG_GPIO_MASK_8_15 0x1d
139	/* MASK_16 in REG_MASK4 */
140
141	#define ADM1026_REG_COMPANY 0x16
142	#define ADM1026_REG_VERSTEP 0x17
143	/* These are the recognized values for the above regs */
144	#define ADM1026_COMPANY_ANALOG_DEV 0x41
145	#define ADM1026_VERSTEP_GENERIC 0x40
146	#define ADM1026_VERSTEP_ADM1026 0x44
147
148	#define ADM1026_REG_MASK1 0x18
149	#define ADM1026_REG_MASK2 0x19
150	#define ADM1026_REG_MASK3 0x1a
151	#define ADM1026_REG_MASK4 0x1b
152
153	#define ADM1026_REG_STATUS1 0x20
154	#define ADM1026_REG_STATUS2 0x21
155	#define ADM1026_REG_STATUS3 0x22
156	#define ADM1026_REG_STATUS4 0x23
157
158	#define ADM1026_FAN_ACTIVATION_TEMP_HYST -6
159	#define ADM1026_FAN_CONTROL_TEMP_RANGE 20
160	#define ADM1026_PWM_MAX 255
161
162	/*
163	* Conversions. Rounding and limit checking is only done on the TO_REG
164	* variants. Note that you should be a bit careful with which arguments
165	* these macros are called: arguments may be evaluated more than once.
166	*/
167
168	/*
169	* IN are scaled according to built-in resistors. These are the
170	* voltages corresponding to 3/4 of full scale (192 or 0xc0)
171	* NOTE: The -12V input needs an additional factor to account
172	* for the Vref pullup resistor.
173	* NEG12_OFFSET = SCALE * Vref / V-192 - Vref
174	* = 13875 * 2.50 / 1.875 - 2500
175	* = 16000
176	*
177	* The values in this table are based on Table II, page 15 of the
178	* datasheet.
179	*/
180	static int adm1026_scaling[] = { /* .001 Volts */
181	2250, 2250, 2250, 2250, 2250, 2250,
182	1875, 1875, 1875, 1875, 3000, 3330,
183	3330, 4995, 2250, 12000, 13875
184	};
185	#define NEG12_OFFSET 16000
186	#define SCALE(val, from, to) (((val)*(to) + ((from)/2))/(from))
187	#define INS_TO_REG(n, val) \
188	SCALE(clamp_val(val, 0, 255 * adm1026_scaling[n] / 192), \
189	adm1026_scaling[n], 192)
190	#define INS_FROM_REG(n, val) (SCALE(val, 192, adm1026_scaling[n]))
191
192	/*
193	* FAN speed is measured using 22.5kHz clock and counts for 2 pulses
194	* and we assume a 2 pulse-per-rev fan tach signal
195	* 22500 kHz * 60 (sec/min) * 2 (pulse) / 2 (pulse/rev) == 1350000
196	*/
197	#define FAN_TO_REG(val, div) ((val) <= 0 ? 0xff : \
198	clamp_val(1350000 / ((val) * (div)), \
199	1, 254))
200	#define FAN_FROM_REG(val, div) ((val) == 0 ? -1 : (val) == 0xff ? 0 : \
201	1350000 / ((val) * (div)))
202	#define DIV_FROM_REG(val) (1 << (val))
203	#define DIV_TO_REG(val) ((val) >= 8 ? 3 : (val) >= 4 ? 2 : (val) >= 2 ? 1 : 0)
204
205	/* Temperature is reported in 1 degC increments */
206	#define TEMP_TO_REG(val) DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), \
207	1000)
208	#define TEMP_FROM_REG(val) ((val) * 1000)
209	#define OFFSET_TO_REG(val) DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), \
210	1000)
211	#define OFFSET_FROM_REG(val) ((val) * 1000)
212
213	#define PWM_TO_REG(val) (clamp_val(val, 0, 255))
214	#define PWM_FROM_REG(val) (val)
215
216	#define PWM_MIN_TO_REG(val) ((val) & 0xf0)
217	#define PWM_MIN_FROM_REG(val) (((val) & 0xf0) + ((val) >> 4))
218
219	/*
220	* Analog output is a voltage, and scaled to millivolts. The datasheet
221	* indicates that the DAC could be used to drive the fans, but in our
222	* example board (Arima HDAMA) it isn't connected to the fans at all.
223	*/
224	#define DAC_TO_REG(val) DIV_ROUND_CLOSEST(clamp_val(val, 0, 2500) * 255, \
225	2500)
226	#define DAC_FROM_REG(val) (((val) * 2500) / 255)
227
228	/*
229	* Chip sampling rates
230	*
231	* Some sensors are not updated more frequently than once per second
232	* so it doesn't make sense to read them more often than that.
233	* We cache the results and return the saved data if the driver
234	* is called again before a second has elapsed.
235	*
236	* Also, there is significant configuration data for this chip
237	* So, we keep the config data up to date in the cache
238	* when it is written and only sample it once every 5 *minutes*
239	*/
240	#define ADM1026_DATA_INTERVAL (1 * HZ)
241	#define ADM1026_CONFIG_INTERVAL (5 * 60 * HZ)
242
243	/*
244	* We allow for multiple chips in a single system.
245	*
246	* For each registered ADM1026, we need to keep state information
247	* at client->data. The adm1026_data structure is dynamically
248	* allocated, when a new client structure is allocated.
249	*/
250
251	struct pwm_data {
252	u8 pwm;
253	u8 enable;
254	u8 auto_pwm_min;
255	};
256
257	struct adm1026_data {
258	struct i2c_client *client;
259	const struct attribute_group *groups[3];
260
261	struct mutex update_lock;
262	bool valid; /* true if following fields are valid */
263	unsigned long last_reading; /* In jiffies */
264	unsigned long last_config; /* In jiffies */
265
266	u8 in[17]; /* Register value */
267	u8 in_max[17]; /* Register value */
268	u8 in_min[17]; /* Register value */
269	s8 temp[3]; /* Register value */
270	s8 temp_min[3]; /* Register value */
271	s8 temp_max[3]; /* Register value */
272	s8 temp_tmin[3]; /* Register value */
273	s8 temp_crit[3]; /* Register value */
274	s8 temp_offset[3]; /* Register value */
275	u8 fan[8]; /* Register value */
276	u8 fan_min[8]; /* Register value */
277	u8 fan_div[8]; /* Decoded value */
278	struct pwm_data pwm1; /* Pwm control values */
279	u8 vrm; /* VRM version */
280	u8 analog_out; /* Register value (DAC) */
281	long alarms; /* Register encoding, combined */
282	long alarm_mask; /* Register encoding, combined */
283	long gpio; /* Register encoding, combined */
284	long gpio_mask; /* Register encoding, combined */
285	u8 gpio_config[17]; /* Decoded value */
286	u8 config1; /* Register value */
287	u8 config2; /* Register value */
288	u8 config3; /* Register value */
289	};
290
291	static int adm1026_read_value(struct i2c_client *client, u8 reg)
292	{
293	int res;
294
295	if (reg < 0x80) {
296	/* "RAM" locations */
297	res = i2c_smbus_read_byte_data(client, command: reg) & 0xff;
298	} else {
299	/* EEPROM, do nothing */
300	res = 0;
301	}
302	return res;
303	}
304
305	static int adm1026_write_value(struct i2c_client *client, u8 reg, int value)
306	{
307	int res;
308
309	if (reg < 0x80) {
310	/* "RAM" locations */
311	res = i2c_smbus_write_byte_data(client, command: reg, value);
312	} else {
313	/* EEPROM, do nothing */
314	res = 0;
315	}
316	return res;
317	}
318
319	static struct adm1026_data *adm1026_update_device(struct device *dev)
320	{
321	struct adm1026_data *data = dev_get_drvdata(dev);
322	struct i2c_client *client = data->client;
323	int i;
324	long value, alarms, gpio;
325
326	mutex_lock(&data->update_lock);
327	if (!data->valid
328	|| time_after(jiffies,
329	data->last_reading + ADM1026_DATA_INTERVAL)) {
330	/* Things that change quickly */
331	dev_dbg(&client->dev, "Reading sensor values\n");
332	for (i = 0; i <= 16; ++i) {
333	data->in[i] =
334	adm1026_read_value(client, reg: ADM1026_REG_IN[i]);
335	}
336
337	for (i = 0; i <= 7; ++i) {
338	data->fan[i] =
339	adm1026_read_value(client, ADM1026_REG_FAN(i));
340	}
341
342	for (i = 0; i <= 2; ++i) {
343	/*
344	* NOTE: temp[] is s8 and we assume 2's complement
345	* "conversion" in the assignment
346	*/
347	data->temp[i] =
348	adm1026_read_value(client, reg: ADM1026_REG_TEMP[i]);
349	}
350
351	data->pwm1.pwm = adm1026_read_value(client,
352	ADM1026_REG_PWM);
353	data->analog_out = adm1026_read_value(client,
354	ADM1026_REG_DAC);
355	/* GPIO16 is MSbit of alarms, move it to gpio */
356	alarms = adm1026_read_value(client, ADM1026_REG_STATUS4);
357	gpio = alarms & 0x80 ? 0x0100 : 0; /* GPIO16 */
358	alarms &= 0x7f;
359	alarms <<= 8;
360	alarms |= adm1026_read_value(client, ADM1026_REG_STATUS3);
361	alarms <<= 8;
362	alarms |= adm1026_read_value(client, ADM1026_REG_STATUS2);
363	alarms <<= 8;
364	alarms |= adm1026_read_value(client, ADM1026_REG_STATUS1);
365	data->alarms = alarms;
366
367	/* Read the GPIO values */
368	gpio |= adm1026_read_value(client,
369	ADM1026_REG_GPIO_STATUS_8_15);
370	gpio <<= 8;
371	gpio |= adm1026_read_value(client,
372	ADM1026_REG_GPIO_STATUS_0_7);
373	data->gpio = gpio;
374
375	data->last_reading = jiffies;
376	} /* last_reading */
377
378	if (!data->valid ||
379	time_after(jiffies, data->last_config + ADM1026_CONFIG_INTERVAL)) {
380	/* Things that don't change often */
381	dev_dbg(&client->dev, "Reading config values\n");
382	for (i = 0; i <= 16; ++i) {
383	data->in_min[i] = adm1026_read_value(client,
384	reg: ADM1026_REG_IN_MIN[i]);
385	data->in_max[i] = adm1026_read_value(client,
386	reg: ADM1026_REG_IN_MAX[i]);
387	}
388
389	value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3)
390	| (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7)
391	<< 8);
392	for (i = 0; i <= 7; ++i) {
393	data->fan_min[i] = adm1026_read_value(client,
394	ADM1026_REG_FAN_MIN(i));
395	data->fan_div[i] = DIV_FROM_REG(value & 0x03);
396	value >>= 2;
397	}
398
399	for (i = 0; i <= 2; ++i) {
400	/*
401	* NOTE: temp_xxx[] are s8 and we assume 2's
402	* complement "conversion" in the assignment
403	*/
404	data->temp_min[i] = adm1026_read_value(client,
405	reg: ADM1026_REG_TEMP_MIN[i]);
406	data->temp_max[i] = adm1026_read_value(client,
407	reg: ADM1026_REG_TEMP_MAX[i]);
408	data->temp_tmin[i] = adm1026_read_value(client,
409	reg: ADM1026_REG_TEMP_TMIN[i]);
410	data->temp_crit[i] = adm1026_read_value(client,
411	reg: ADM1026_REG_TEMP_THERM[i]);
412	data->temp_offset[i] = adm1026_read_value(client,
413	reg: ADM1026_REG_TEMP_OFFSET[i]);
414	}
415
416	/* Read the STATUS/alarm masks */
417	alarms = adm1026_read_value(client, ADM1026_REG_MASK4);
418	gpio = alarms & 0x80 ? 0x0100 : 0; /* GPIO16 */
419	alarms = (alarms & 0x7f) << 8;
420	alarms |= adm1026_read_value(client, ADM1026_REG_MASK3);
421	alarms <<= 8;
422	alarms |= adm1026_read_value(client, ADM1026_REG_MASK2);
423	alarms <<= 8;
424	alarms |= adm1026_read_value(client, ADM1026_REG_MASK1);
425	data->alarm_mask = alarms;
426
427	/* Read the GPIO values */
428	gpio |= adm1026_read_value(client,
429	ADM1026_REG_GPIO_MASK_8_15);
430	gpio <<= 8;
431	gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_0_7);
432	data->gpio_mask = gpio;
433
434	/* Read various values from CONFIG1 */
435	data->config1 = adm1026_read_value(client,
436	ADM1026_REG_CONFIG1);
437	if (data->config1 & CFG1_PWM_AFC) {
438	data->pwm1.enable = 2;
439	data->pwm1.auto_pwm_min =
440	PWM_MIN_FROM_REG(data->pwm1.pwm);
441	}
442	/* Read the GPIO config */
443	data->config2 = adm1026_read_value(client,
444	ADM1026_REG_CONFIG2);
445	data->config3 = adm1026_read_value(client,
446	ADM1026_REG_CONFIG3);
447	data->gpio_config[16] = (data->config3 >> 6) & 0x03;
448
449	value = 0;
450	for (i = 0; i <= 15; ++i) {
451	if ((i & 0x03) == 0) {
452	value = adm1026_read_value(client,
453	ADM1026_REG_GPIO_CFG_0_3 + i/4);
454	}
455	data->gpio_config[i] = value & 0x03;
456	value >>= 2;
457	}
458
459	data->last_config = jiffies;
460	} /* last_config */
461
462	data->valid = true;
463	mutex_unlock(lock: &data->update_lock);
464	return data;
465	}
466
467	static ssize_t in_show(struct device *dev, struct device_attribute *attr,
468	char *buf)
469	{
470	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
471	int nr = sensor_attr->index;
472	struct adm1026_data *data = adm1026_update_device(dev);
473	return sprintf(buf, fmt: "%d\n", INS_FROM_REG(nr, data->in[nr]));
474	}
475	static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
476	char *buf)
477	{
478	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
479	int nr = sensor_attr->index;
480	struct adm1026_data *data = adm1026_update_device(dev);
481	return sprintf(buf, fmt: "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
482	}
483	static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
484	const char *buf, size_t count)
485	{
486	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
487	int nr = sensor_attr->index;
488	struct adm1026_data *data = dev_get_drvdata(dev);
489	struct i2c_client *client = data->client;
490	long val;
491	int err;
492
493	err = kstrtol(s: buf, base: 10, res: &val);
494	if (err)
495	return err;
496
497	mutex_lock(&data->update_lock);
498	data->in_min[nr] = INS_TO_REG(nr, val);
499	adm1026_write_value(client, reg: ADM1026_REG_IN_MIN[nr], value: data->in_min[nr]);
500	mutex_unlock(lock: &data->update_lock);
501	return count;
502	}
503	static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
504	char *buf)
505	{
506	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
507	int nr = sensor_attr->index;
508	struct adm1026_data *data = adm1026_update_device(dev);
509	return sprintf(buf, fmt: "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
510	}
511	static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
512	const char *buf, size_t count)
513	{
514	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
515	int nr = sensor_attr->index;
516	struct adm1026_data *data = dev_get_drvdata(dev);
517	struct i2c_client *client = data->client;
518	long val;
519	int err;
520
521	err = kstrtol(s: buf, base: 10, res: &val);
522	if (err)
523	return err;
524
525	mutex_lock(&data->update_lock);
526	data->in_max[nr] = INS_TO_REG(nr, val);
527	adm1026_write_value(client, reg: ADM1026_REG_IN_MAX[nr], value: data->in_max[nr]);
528	mutex_unlock(lock: &data->update_lock);
529	return count;
530	}
531
532	static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
533	static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
534	static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
535	static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
536	static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
537	static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
538	static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
539	static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
540	static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
541	static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
542	static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
543	static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
544	static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
545	static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
546	static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
547	static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
548	static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
549	static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
550	static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);
551	static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
552	static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
553	static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);
554	static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
555	static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
556	static SENSOR_DEVICE_ATTR_RO(in8_input, in, 8);
557	static SENSOR_DEVICE_ATTR_RW(in8_min, in_min, 8);
558	static SENSOR_DEVICE_ATTR_RW(in8_max, in_max, 8);
559	static SENSOR_DEVICE_ATTR_RO(in9_input, in, 9);
560	static SENSOR_DEVICE_ATTR_RW(in9_min, in_min, 9);
561	static SENSOR_DEVICE_ATTR_RW(in9_max, in_max, 9);
562	static SENSOR_DEVICE_ATTR_RO(in10_input, in, 10);
563	static SENSOR_DEVICE_ATTR_RW(in10_min, in_min, 10);
564	static SENSOR_DEVICE_ATTR_RW(in10_max, in_max, 10);
565	static SENSOR_DEVICE_ATTR_RO(in11_input, in, 11);
566	static SENSOR_DEVICE_ATTR_RW(in11_min, in_min, 11);
567	static SENSOR_DEVICE_ATTR_RW(in11_max, in_max, 11);
568	static SENSOR_DEVICE_ATTR_RO(in12_input, in, 12);
569	static SENSOR_DEVICE_ATTR_RW(in12_min, in_min, 12);
570	static SENSOR_DEVICE_ATTR_RW(in12_max, in_max, 12);
571	static SENSOR_DEVICE_ATTR_RO(in13_input, in, 13);
572	static SENSOR_DEVICE_ATTR_RW(in13_min, in_min, 13);
573	static SENSOR_DEVICE_ATTR_RW(in13_max, in_max, 13);
574	static SENSOR_DEVICE_ATTR_RO(in14_input, in, 14);
575	static SENSOR_DEVICE_ATTR_RW(in14_min, in_min, 14);
576	static SENSOR_DEVICE_ATTR_RW(in14_max, in_max, 14);
577	static SENSOR_DEVICE_ATTR_RO(in15_input, in, 15);
578	static SENSOR_DEVICE_ATTR_RW(in15_min, in_min, 15);
579	static SENSOR_DEVICE_ATTR_RW(in15_max, in_max, 15);
580
581	static ssize_t in16_show(struct device *dev, struct device_attribute *attr,
582	char *buf)
583	{
584	struct adm1026_data *data = adm1026_update_device(dev);
585	return sprintf(buf, fmt: "%d\n", INS_FROM_REG(16, data->in[16]) -
586	NEG12_OFFSET);
587	}
588	static ssize_t in16_min_show(struct device *dev,
589	struct device_attribute *attr, char *buf)
590	{
591	struct adm1026_data *data = adm1026_update_device(dev);
592	return sprintf(buf, fmt: "%d\n", INS_FROM_REG(16, data->in_min[16])
593	- NEG12_OFFSET);
594	}
595	static ssize_t in16_min_store(struct device *dev,
596	struct device_attribute *attr, const char *buf,
597	size_t count)
598	{
599	struct adm1026_data *data = dev_get_drvdata(dev);
600	struct i2c_client *client = data->client;
601	long val;
602	int err;
603
604	err = kstrtol(s: buf, base: 10, res: &val);
605	if (err)
606	return err;
607
608	mutex_lock(&data->update_lock);
609	data->in_min[16] = INS_TO_REG(16,
610	clamp_val(val, INT_MIN,
611	INT_MAX - NEG12_OFFSET) +
612	NEG12_OFFSET);
613	adm1026_write_value(client, reg: ADM1026_REG_IN_MIN[16], value: data->in_min[16]);
614	mutex_unlock(lock: &data->update_lock);
615	return count;
616	}
617	static ssize_t in16_max_show(struct device *dev,
618	struct device_attribute *attr, char *buf)
619	{
620	struct adm1026_data *data = adm1026_update_device(dev);
621	return sprintf(buf, fmt: "%d\n", INS_FROM_REG(16, data->in_max[16])
622	- NEG12_OFFSET);
623	}
624	static ssize_t in16_max_store(struct device *dev,
625	struct device_attribute *attr, const char *buf,
626	size_t count)
627	{
628	struct adm1026_data *data = dev_get_drvdata(dev);
629	struct i2c_client *client = data->client;
630	long val;
631	int err;
632
633	err = kstrtol(s: buf, base: 10, res: &val);
634	if (err)
635	return err;
636
637	mutex_lock(&data->update_lock);
638	data->in_max[16] = INS_TO_REG(16,
639	clamp_val(val, INT_MIN,
640	INT_MAX - NEG12_OFFSET) +
641	NEG12_OFFSET);
642	adm1026_write_value(client, reg: ADM1026_REG_IN_MAX[16], value: data->in_max[16]);
643	mutex_unlock(lock: &data->update_lock);
644	return count;
645	}
646
647	static SENSOR_DEVICE_ATTR_RO(in16_input, in16, 16);
648	static SENSOR_DEVICE_ATTR_RW(in16_min, in16_min, 16);
649	static SENSOR_DEVICE_ATTR_RW(in16_max, in16_max, 16);
650
651	/* Now add fan read/write functions */
652
653	static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
654	char *buf)
655	{
656	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
657	int nr = sensor_attr->index;
658	struct adm1026_data *data = adm1026_update_device(dev);
659	return sprintf(buf, fmt: "%d\n", FAN_FROM_REG(data->fan[nr],
660	data->fan_div[nr]));
661	}
662	static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
663	char *buf)
664	{
665	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
666	int nr = sensor_attr->index;
667	struct adm1026_data *data = adm1026_update_device(dev);
668	return sprintf(buf, fmt: "%d\n", FAN_FROM_REG(data->fan_min[nr],
669	data->fan_div[nr]));
670	}
671	static ssize_t fan_min_store(struct device *dev,
672	struct device_attribute *attr, const char *buf,
673	size_t count)
674	{
675	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
676	int nr = sensor_attr->index;
677	struct adm1026_data *data = dev_get_drvdata(dev);
678	struct i2c_client *client = data->client;
679	long val;
680	int err;
681
682	err = kstrtol(s: buf, base: 10, res: &val);
683	if (err)
684	return err;
685
686	mutex_lock(&data->update_lock);
687	data->fan_min[nr] = FAN_TO_REG(val, data->fan_div[nr]);
688	adm1026_write_value(client, ADM1026_REG_FAN_MIN(nr),
689	value: data->fan_min[nr]);
690	mutex_unlock(lock: &data->update_lock);
691	return count;
692	}
693
694	static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
695	static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
696	static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
697	static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
698	static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
699	static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
700	static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
701	static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
702	static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
703	static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
704	static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
705	static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
706	static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
707	static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
708	static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
709	static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
710
711	/* Adjust fan_min to account for new fan divisor */
712	static void fixup_fan_min(struct device *dev, int fan, int old_div)
713	{
714	struct adm1026_data *data = dev_get_drvdata(dev);
715	struct i2c_client *client = data->client;
716	int new_min;
717	int new_div = data->fan_div[fan];
718
719	/* 0 and 0xff are special. Don't adjust them */
720	if (data->fan_min[fan] == 0 || data->fan_min[fan] == 0xff)
721	return;
722
723	new_min = data->fan_min[fan] * old_div / new_div;
724	new_min = clamp_val(new_min, 1, 254);
725	data->fan_min[fan] = new_min;
726	adm1026_write_value(client, ADM1026_REG_FAN_MIN(fan), value: new_min);
727	}
728
729	/* Now add fan_div read/write functions */
730	static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
731	char *buf)
732	{
733	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
734	int nr = sensor_attr->index;
735	struct adm1026_data *data = adm1026_update_device(dev);
736	return sprintf(buf, fmt: "%d\n", data->fan_div[nr]);
737	}
738	static ssize_t fan_div_store(struct device *dev,
739	struct device_attribute *attr, const char *buf,
740	size_t count)
741	{
742	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
743	int nr = sensor_attr->index;
744	struct adm1026_data *data = dev_get_drvdata(dev);
745	struct i2c_client *client = data->client;
746	long val;
747	int orig_div, new_div;
748	int err;
749
750	err = kstrtol(s: buf, base: 10, res: &val);
751	if (err)
752	return err;
753
754	new_div = DIV_TO_REG(val);
755
756	mutex_lock(&data->update_lock);
757	orig_div = data->fan_div[nr];
758	data->fan_div[nr] = DIV_FROM_REG(new_div);
759
760	if (nr < 4) { /* 0 <= nr < 4 */
761	adm1026_write_value(client, ADM1026_REG_FAN_DIV_0_3,
762	value: (DIV_TO_REG(data->fan_div[0]) << 0) |
763	(DIV_TO_REG(data->fan_div[1]) << 2) |
764	(DIV_TO_REG(data->fan_div[2]) << 4) |
765	(DIV_TO_REG(data->fan_div[3]) << 6));
766	} else { /* 3 < nr < 8 */
767	adm1026_write_value(client, ADM1026_REG_FAN_DIV_4_7,
768	value: (DIV_TO_REG(data->fan_div[4]) << 0) |
769	(DIV_TO_REG(data->fan_div[5]) << 2) |
770	(DIV_TO_REG(data->fan_div[6]) << 4) |
771	(DIV_TO_REG(data->fan_div[7]) << 6));
772	}
773
774	if (data->fan_div[nr] != orig_div)
775	fixup_fan_min(dev, fan: nr, old_div: orig_div);
776
777	mutex_unlock(lock: &data->update_lock);
778	return count;
779	}
780
781	static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
782	static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
783	static SENSOR_DEVICE_ATTR_RW(fan3_div, fan_div, 2);
784	static SENSOR_DEVICE_ATTR_RW(fan4_div, fan_div, 3);
785	static SENSOR_DEVICE_ATTR_RW(fan5_div, fan_div, 4);
786	static SENSOR_DEVICE_ATTR_RW(fan6_div, fan_div, 5);
787	static SENSOR_DEVICE_ATTR_RW(fan7_div, fan_div, 6);
788	static SENSOR_DEVICE_ATTR_RW(fan8_div, fan_div, 7);
789
790	/* Temps */
791	static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
792	char *buf)
793	{
794	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
795	int nr = sensor_attr->index;
796	struct adm1026_data *data = adm1026_update_device(dev);
797	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(data->temp[nr]));
798	}
799	static ssize_t temp_min_show(struct device *dev,
800	struct device_attribute *attr, char *buf)
801	{
802	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
803	int nr = sensor_attr->index;
804	struct adm1026_data *data = adm1026_update_device(dev);
805	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
806	}
807	static ssize_t temp_min_store(struct device *dev,
808	struct device_attribute *attr, const char *buf,
809	size_t count)
810	{
811	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
812	int nr = sensor_attr->index;
813	struct adm1026_data *data = dev_get_drvdata(dev);
814	struct i2c_client *client = data->client;
815	long val;
816	int err;
817
818	err = kstrtol(s: buf, base: 10, res: &val);
819	if (err)
820	return err;
821
822	mutex_lock(&data->update_lock);
823	data->temp_min[nr] = TEMP_TO_REG(val);
824	adm1026_write_value(client, reg: ADM1026_REG_TEMP_MIN[nr],
825	value: data->temp_min[nr]);
826	mutex_unlock(lock: &data->update_lock);
827	return count;
828	}
829	static ssize_t temp_max_show(struct device *dev,
830	struct device_attribute *attr, char *buf)
831	{
832	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
833	int nr = sensor_attr->index;
834	struct adm1026_data *data = adm1026_update_device(dev);
835	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
836	}
837	static ssize_t temp_max_store(struct device *dev,
838	struct device_attribute *attr, const char *buf,
839	size_t count)
840	{
841	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
842	int nr = sensor_attr->index;
843	struct adm1026_data *data = dev_get_drvdata(dev);
844	struct i2c_client *client = data->client;
845	long val;
846	int err;
847
848	err = kstrtol(s: buf, base: 10, res: &val);
849	if (err)
850	return err;
851
852	mutex_lock(&data->update_lock);
853	data->temp_max[nr] = TEMP_TO_REG(val);
854	adm1026_write_value(client, reg: ADM1026_REG_TEMP_MAX[nr],
855	value: data->temp_max[nr]);
856	mutex_unlock(lock: &data->update_lock);
857	return count;
858	}
859
860	static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
861	static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
862	static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
863	static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
864	static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
865	static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
866	static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
867	static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
868	static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
869
870	static ssize_t temp_offset_show(struct device *dev,
871	struct device_attribute *attr, char *buf)
872	{
873	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
874	int nr = sensor_attr->index;
875	struct adm1026_data *data = adm1026_update_device(dev);
876	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
877	}
878	static ssize_t temp_offset_store(struct device *dev,
879	struct device_attribute *attr,
880	const char *buf, size_t count)
881	{
882	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
883	int nr = sensor_attr->index;
884	struct adm1026_data *data = dev_get_drvdata(dev);
885	struct i2c_client *client = data->client;
886	long val;
887	int err;
888
889	err = kstrtol(s: buf, base: 10, res: &val);
890	if (err)
891	return err;
892
893	mutex_lock(&data->update_lock);
894	data->temp_offset[nr] = TEMP_TO_REG(val);
895	adm1026_write_value(client, reg: ADM1026_REG_TEMP_OFFSET[nr],
896	value: data->temp_offset[nr]);
897	mutex_unlock(lock: &data->update_lock);
898	return count;
899	}
900
901	static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
902	static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
903	static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
904
905	static ssize_t temp_auto_point1_temp_hyst_show(struct device *dev,
906	struct device_attribute *attr,
907	char *buf)
908	{
909	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
910	int nr = sensor_attr->index;
911	struct adm1026_data *data = adm1026_update_device(dev);
912	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(
913	ADM1026_FAN_ACTIVATION_TEMP_HYST + data->temp_tmin[nr]));
914	}
915	static ssize_t temp_auto_point2_temp_show(struct device *dev,
916	struct device_attribute *attr,
917	char *buf)
918	{
919	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
920	int nr = sensor_attr->index;
921	struct adm1026_data *data = adm1026_update_device(dev);
922	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(data->temp_tmin[nr] +
923	ADM1026_FAN_CONTROL_TEMP_RANGE));
924	}
925	static ssize_t temp_auto_point1_temp_show(struct device *dev,
926	struct device_attribute *attr,
927	char *buf)
928	{
929	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
930	int nr = sensor_attr->index;
931	struct adm1026_data *data = adm1026_update_device(dev);
932	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(data->temp_tmin[nr]));
933	}
934	static ssize_t temp_auto_point1_temp_store(struct device *dev,
935	struct device_attribute *attr,
936	const char *buf, size_t count)
937	{
938	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
939	int nr = sensor_attr->index;
940	struct adm1026_data *data = dev_get_drvdata(dev);
941	struct i2c_client *client = data->client;
942	long val;
943	int err;
944
945	err = kstrtol(s: buf, base: 10, res: &val);
946	if (err)
947	return err;
948
949	mutex_lock(&data->update_lock);
950	data->temp_tmin[nr] = TEMP_TO_REG(val);
951	adm1026_write_value(client, reg: ADM1026_REG_TEMP_TMIN[nr],
952	value: data->temp_tmin[nr]);
953	mutex_unlock(lock: &data->update_lock);
954	return count;
955	}
956
957	static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, temp_auto_point1_temp, 0);
958	static SENSOR_DEVICE_ATTR_RO(temp1_auto_point1_temp_hyst,
959	temp_auto_point1_temp_hyst, 0);
960	static SENSOR_DEVICE_ATTR_RO(temp1_auto_point2_temp, temp_auto_point2_temp, 0);
961	static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, temp_auto_point1_temp, 1);
962	static SENSOR_DEVICE_ATTR_RO(temp2_auto_point1_temp_hyst,
963	temp_auto_point1_temp_hyst, 1);
964	static SENSOR_DEVICE_ATTR_RO(temp2_auto_point2_temp, temp_auto_point2_temp, 1);
965	static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, temp_auto_point1_temp, 2);
966	static SENSOR_DEVICE_ATTR_RO(temp3_auto_point1_temp_hyst,
967	temp_auto_point1_temp_hyst, 2);
968	static SENSOR_DEVICE_ATTR_RO(temp3_auto_point2_temp, temp_auto_point2_temp, 2);
969
970	static ssize_t show_temp_crit_enable(struct device *dev,
971	struct device_attribute *attr, char *buf)
972	{
973	struct adm1026_data *data = adm1026_update_device(dev);
974	return sprintf(buf, fmt: "%d\n", (data->config1 & CFG1_THERM_HOT) >> 4);
975	}
976	static ssize_t set_temp_crit_enable(struct device *dev,
977	struct device_attribute *attr, const char *buf, size_t count)
978	{
979	struct adm1026_data *data = dev_get_drvdata(dev);
980	struct i2c_client *client = data->client;
981	unsigned long val;
982	int err;
983
984	err = kstrtoul(s: buf, base: 10, res: &val);
985	if (err)
986	return err;
987
988	if (val > 1)
989	return -EINVAL;
990
991	mutex_lock(&data->update_lock);
992	data->config1 = (data->config1 & ~CFG1_THERM_HOT) | (val << 4);
993	adm1026_write_value(client, ADM1026_REG_CONFIG1, value: data->config1);
994	mutex_unlock(lock: &data->update_lock);
995
996	return count;
997	}
998
999	static DEVICE_ATTR(temp1_crit_enable, 0644, show_temp_crit_enable,
1000	set_temp_crit_enable);
1001	static DEVICE_ATTR(temp2_crit_enable, 0644, show_temp_crit_enable,
1002	set_temp_crit_enable);
1003	static DEVICE_ATTR(temp3_crit_enable, 0644, show_temp_crit_enable,
1004	set_temp_crit_enable);
1005
1006	static ssize_t temp_crit_show(struct device *dev,
1007	struct device_attribute *attr, char *buf)
1008	{
1009	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1010	int nr = sensor_attr->index;
1011	struct adm1026_data *data = adm1026_update_device(dev);
1012	return sprintf(buf, fmt: "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
1013	}
1014	static ssize_t temp_crit_store(struct device *dev,
1015	struct device_attribute *attr, const char *buf,
1016	size_t count)
1017	{
1018	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1019	int nr = sensor_attr->index;
1020	struct adm1026_data *data = dev_get_drvdata(dev);
1021	struct i2c_client *client = data->client;
1022	long val;
1023	int err;
1024
1025	err = kstrtol(s: buf, base: 10, res: &val);
1026	if (err)
1027	return err;
1028
1029	mutex_lock(&data->update_lock);
1030	data->temp_crit[nr] = TEMP_TO_REG(val);
1031	adm1026_write_value(client, reg: ADM1026_REG_TEMP_THERM[nr],
1032	value: data->temp_crit[nr]);
1033	mutex_unlock(lock: &data->update_lock);
1034	return count;
1035	}
1036
1037	static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
1038	static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
1039	static SENSOR_DEVICE_ATTR_RW(temp3_crit, temp_crit, 2);
1040
1041	static ssize_t analog_out_show(struct device *dev,
1042	struct device_attribute *attr, char *buf)
1043	{
1044	struct adm1026_data *data = adm1026_update_device(dev);
1045	return sprintf(buf, fmt: "%d\n", DAC_FROM_REG(data->analog_out));
1046	}
1047	static ssize_t analog_out_store(struct device *dev,
1048	struct device_attribute *attr,
1049	const char *buf, size_t count)
1050	{
1051	struct adm1026_data *data = dev_get_drvdata(dev);
1052	struct i2c_client *client = data->client;
1053	long val;
1054	int err;
1055
1056	err = kstrtol(s: buf, base: 10, res: &val);
1057	if (err)
1058	return err;
1059
1060	mutex_lock(&data->update_lock);
1061	data->analog_out = DAC_TO_REG(val);
1062	adm1026_write_value(client, ADM1026_REG_DAC, value: data->analog_out);
1063	mutex_unlock(lock: &data->update_lock);
1064	return count;
1065	}
1066
1067	static DEVICE_ATTR_RW(analog_out);
1068
1069	static ssize_t cpu0_vid_show(struct device *dev,
1070	struct device_attribute *attr, char *buf)
1071	{
1072	struct adm1026_data *data = adm1026_update_device(dev);
1073	int vid = (data->gpio >> 11) & 0x1f;
1074
1075	dev_dbg(dev, "Setting VID from GPIO11-15.\n");
1076	return sprintf(buf, fmt: "%d\n", vid_from_reg(val: vid, vrm: data->vrm));
1077	}
1078
1079	static DEVICE_ATTR_RO(cpu0_vid);
1080
1081	static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
1082	char *buf)
1083	{
1084	struct adm1026_data *data = dev_get_drvdata(dev);
1085	return sprintf(buf, fmt: "%d\n", data->vrm);
1086	}
1087
1088	static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
1089	const char *buf, size_t count)
1090	{
1091	struct adm1026_data *data = dev_get_drvdata(dev);
1092	unsigned long val;
1093	int err;
1094
1095	err = kstrtoul(s: buf, base: 10, res: &val);
1096	if (err)
1097	return err;
1098
1099	if (val > 255)
1100	return -EINVAL;
1101
1102	data->vrm = val;
1103	return count;
1104	}
1105
1106	static DEVICE_ATTR_RW(vrm);
1107
1108	static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
1109	char *buf)
1110	{
1111	struct adm1026_data *data = adm1026_update_device(dev);
1112	return sprintf(buf, fmt: "%ld\n", data->alarms);
1113	}
1114
1115	static DEVICE_ATTR_RO(alarms);
1116
1117	static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
1118	char *buf)
1119	{
1120	struct adm1026_data *data = adm1026_update_device(dev);
1121	int bitnr = to_sensor_dev_attr(attr)->index;
1122	return sprintf(buf, fmt: "%ld\n", (data->alarms >> bitnr) & 1);
1123	}
1124
1125	static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 0);
1126	static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1);
1127	static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm, 1);
1128	static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm, 2);
1129	static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm, 3);
1130	static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm, 4);
1131	static SENSOR_DEVICE_ATTR_RO(in14_alarm, alarm, 5);
1132	static SENSOR_DEVICE_ATTR_RO(in15_alarm, alarm, 6);
1133	static SENSOR_DEVICE_ATTR_RO(in16_alarm, alarm, 7);
1134	static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 8);
1135	static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 9);
1136	static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 10);
1137	static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 11);
1138	static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 12);
1139	static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 13);
1140	static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 14);
1141	static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 15);
1142	static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 16);
1143	static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 17);
1144	static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 18);
1145	static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm, 19);
1146	static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm, 20);
1147	static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm, 21);
1148	static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm, 22);
1149	static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm, 23);
1150	static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 24);
1151	static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm, 25);
1152	static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm, 26);
1153
1154	static ssize_t alarm_mask_show(struct device *dev,
1155	struct device_attribute *attr, char *buf)
1156	{
1157	struct adm1026_data *data = adm1026_update_device(dev);
1158	return sprintf(buf, fmt: "%ld\n", data->alarm_mask);
1159	}
1160	static ssize_t alarm_mask_store(struct device *dev,
1161	struct device_attribute *attr,
1162	const char *buf, size_t count)
1163	{
1164	struct adm1026_data *data = dev_get_drvdata(dev);
1165	struct i2c_client *client = data->client;
1166	unsigned long mask;
1167	long val;
1168	int err;
1169
1170	err = kstrtol(s: buf, base: 10, res: &val);
1171	if (err)
1172	return err;
1173
1174	mutex_lock(&data->update_lock);
1175	data->alarm_mask = val & 0x7fffffff;
1176	mask = data->alarm_mask
1177	| (data->gpio_mask & 0x10000 ? 0x80000000 : 0);
1178	adm1026_write_value(client, ADM1026_REG_MASK1,
1179	value: mask & 0xff);
1180	mask >>= 8;
1181	adm1026_write_value(client, ADM1026_REG_MASK2,
1182	value: mask & 0xff);
1183	mask >>= 8;
1184	adm1026_write_value(client, ADM1026_REG_MASK3,
1185	value: mask & 0xff);
1186	mask >>= 8;
1187	adm1026_write_value(client, ADM1026_REG_MASK4,
1188	value: mask & 0xff);
1189	mutex_unlock(lock: &data->update_lock);
1190	return count;
1191	}
1192
1193	static DEVICE_ATTR_RW(alarm_mask);
1194
1195	static ssize_t gpio_show(struct device *dev, struct device_attribute *attr,
1196	char *buf)
1197	{
1198	struct adm1026_data *data = adm1026_update_device(dev);
1199	return sprintf(buf, fmt: "%ld\n", data->gpio);
1200	}
1201	static ssize_t gpio_store(struct device *dev, struct device_attribute *attr,
1202	const char *buf, size_t count)
1203	{
1204	struct adm1026_data *data = dev_get_drvdata(dev);
1205	struct i2c_client *client = data->client;
1206	long gpio;
1207	long val;
1208	int err;
1209
1210	err = kstrtol(s: buf, base: 10, res: &val);
1211	if (err)
1212	return err;
1213
1214	mutex_lock(&data->update_lock);
1215	data->gpio = val & 0x1ffff;
1216	gpio = data->gpio;
1217	adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_0_7, value: gpio & 0xff);
1218	gpio >>= 8;
1219	adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_8_15, value: gpio & 0xff);
1220	gpio = ((gpio >> 1) & 0x80) | (data->alarms >> 24 & 0x7f);
1221	adm1026_write_value(client, ADM1026_REG_STATUS4, value: gpio & 0xff);
1222	mutex_unlock(lock: &data->update_lock);
1223	return count;
1224	}
1225
1226	static DEVICE_ATTR_RW(gpio);
1227
1228	static ssize_t gpio_mask_show(struct device *dev,
1229	struct device_attribute *attr,
1230	char *buf)
1231	{
1232	struct adm1026_data *data = adm1026_update_device(dev);
1233	return sprintf(buf, fmt: "%ld\n", data->gpio_mask);
1234	}
1235	static ssize_t gpio_mask_store(struct device *dev,
1236	struct device_attribute *attr, const char *buf,
1237	size_t count)
1238	{
1239	struct adm1026_data *data = dev_get_drvdata(dev);
1240	struct i2c_client *client = data->client;
1241	long mask;
1242	long val;
1243	int err;
1244
1245	err = kstrtol(s: buf, base: 10, res: &val);
1246	if (err)
1247	return err;
1248
1249	mutex_lock(&data->update_lock);
1250	data->gpio_mask = val & 0x1ffff;
1251	mask = data->gpio_mask;
1252	adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7, value: mask & 0xff);
1253	mask >>= 8;
1254	adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15, value: mask & 0xff);
1255	mask = ((mask >> 1) & 0x80) | (data->alarm_mask >> 24 & 0x7f);
1256	adm1026_write_value(client, ADM1026_REG_MASK1, value: mask & 0xff);
1257	mutex_unlock(lock: &data->update_lock);
1258	return count;
1259	}
1260
1261	static DEVICE_ATTR_RW(gpio_mask);
1262
1263	static ssize_t pwm1_show(struct device *dev, struct device_attribute *attr,
1264	char *buf)
1265	{
1266	struct adm1026_data *data = adm1026_update_device(dev);
1267	return sprintf(buf, fmt: "%d\n", PWM_FROM_REG(data->pwm1.pwm));
1268	}
1269
1270	static ssize_t pwm1_store(struct device *dev, struct device_attribute *attr,
1271	const char *buf, size_t count)
1272	{
1273	struct adm1026_data *data = dev_get_drvdata(dev);
1274	struct i2c_client *client = data->client;
1275
1276	if (data->pwm1.enable == 1) {
1277	long val;
1278	int err;
1279
1280	err = kstrtol(s: buf, base: 10, res: &val);
1281	if (err)
1282	return err;
1283
1284	mutex_lock(&data->update_lock);
1285	data->pwm1.pwm = PWM_TO_REG(val);
1286	adm1026_write_value(client, ADM1026_REG_PWM, value: data->pwm1.pwm);
1287	mutex_unlock(lock: &data->update_lock);
1288	}
1289	return count;
1290	}
1291
1292	static ssize_t temp1_auto_point1_pwm_show(struct device *dev,
1293	struct device_attribute *attr,
1294	char *buf)
1295	{
1296	struct adm1026_data *data = adm1026_update_device(dev);
1297	return sprintf(buf, fmt: "%d\n", data->pwm1.auto_pwm_min);
1298	}
1299
1300	static ssize_t temp1_auto_point1_pwm_store(struct device *dev,
1301	struct device_attribute *attr,
1302	const char *buf, size_t count)
1303	{
1304	struct adm1026_data *data = dev_get_drvdata(dev);
1305	struct i2c_client *client = data->client;
1306	unsigned long val;
1307	int err;
1308
1309	err = kstrtoul(s: buf, base: 10, res: &val);
1310	if (err)
1311	return err;
1312
1313	mutex_lock(&data->update_lock);
1314	data->pwm1.auto_pwm_min = clamp_val(val, 0, 255);
1315	if (data->pwm1.enable == 2) { /* apply immediately */
1316	data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
1317	PWM_MIN_TO_REG(data->pwm1.auto_pwm_min));
1318	adm1026_write_value(client, ADM1026_REG_PWM, value: data->pwm1.pwm);
1319	}
1320	mutex_unlock(lock: &data->update_lock);
1321	return count;
1322	}
1323
1324	static ssize_t temp1_auto_point2_pwm_show(struct device *dev,
1325	struct device_attribute *attr,
1326	char *buf)
1327	{
1328	return sprintf(buf, fmt: "%d\n", ADM1026_PWM_MAX);
1329	}
1330
1331	static ssize_t pwm1_enable_show(struct device *dev,
1332	struct device_attribute *attr, char *buf)
1333	{
1334	struct adm1026_data *data = adm1026_update_device(dev);
1335	return sprintf(buf, fmt: "%d\n", data->pwm1.enable);
1336	}
1337
1338	static ssize_t pwm1_enable_store(struct device *dev,
1339	struct device_attribute *attr,
1340	const char *buf, size_t count)
1341	{
1342	struct adm1026_data *data = dev_get_drvdata(dev);
1343	struct i2c_client *client = data->client;
1344	int old_enable;
1345	unsigned long val;
1346	int err;
1347
1348	err = kstrtoul(s: buf, base: 10, res: &val);
1349	if (err)
1350	return err;
1351
1352	if (val >= 3)
1353	return -EINVAL;
1354
1355	mutex_lock(&data->update_lock);
1356	old_enable = data->pwm1.enable;
1357	data->pwm1.enable = val;
1358	data->config1 = (data->config1 & ~CFG1_PWM_AFC)
1359	| ((val == 2) ? CFG1_PWM_AFC : 0);
1360	adm1026_write_value(client, ADM1026_REG_CONFIG1, value: data->config1);
1361	if (val == 2) { /* apply pwm1_auto_pwm_min to pwm1 */
1362	data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
1363	PWM_MIN_TO_REG(data->pwm1.auto_pwm_min));
1364	adm1026_write_value(client, ADM1026_REG_PWM, value: data->pwm1.pwm);
1365	} else if (!((old_enable == 1) && (val == 1))) {
1366	/* set pwm to safe value */
1367	data->pwm1.pwm = 255;
1368	adm1026_write_value(client, ADM1026_REG_PWM, value: data->pwm1.pwm);
1369	}
1370	mutex_unlock(lock: &data->update_lock);
1371
1372	return count;
1373	}
1374
1375	/* enable PWM fan control */
1376	static DEVICE_ATTR_RW(pwm1);
1377	static DEVICE_ATTR(pwm2, 0644, pwm1_show, pwm1_store);
1378	static DEVICE_ATTR(pwm3, 0644, pwm1_show, pwm1_store);
1379	static DEVICE_ATTR_RW(pwm1_enable);
1380	static DEVICE_ATTR(pwm2_enable, 0644, pwm1_enable_show,
1381	pwm1_enable_store);
1382	static DEVICE_ATTR(pwm3_enable, 0644, pwm1_enable_show,
1383	pwm1_enable_store);
1384	static DEVICE_ATTR_RW(temp1_auto_point1_pwm);
1385	static DEVICE_ATTR(temp2_auto_point1_pwm, 0644,
1386	temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
1387	static DEVICE_ATTR(temp3_auto_point1_pwm, 0644,
1388	temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
1389
1390	static DEVICE_ATTR_RO(temp1_auto_point2_pwm);
1391	static DEVICE_ATTR(temp2_auto_point2_pwm, 0444, temp1_auto_point2_pwm_show,
1392	NULL);
1393	static DEVICE_ATTR(temp3_auto_point2_pwm, 0444, temp1_auto_point2_pwm_show,
1394	NULL);
1395
1396	static struct attribute *adm1026_attributes[] = {
1397	&sensor_dev_attr_in0_input.dev_attr.attr,
1398	&sensor_dev_attr_in0_max.dev_attr.attr,
1399	&sensor_dev_attr_in0_min.dev_attr.attr,
1400	&sensor_dev_attr_in0_alarm.dev_attr.attr,
1401	&sensor_dev_attr_in1_input.dev_attr.attr,
1402	&sensor_dev_attr_in1_max.dev_attr.attr,
1403	&sensor_dev_attr_in1_min.dev_attr.attr,
1404	&sensor_dev_attr_in1_alarm.dev_attr.attr,
1405	&sensor_dev_attr_in2_input.dev_attr.attr,
1406	&sensor_dev_attr_in2_max.dev_attr.attr,
1407	&sensor_dev_attr_in2_min.dev_attr.attr,
1408	&sensor_dev_attr_in2_alarm.dev_attr.attr,
1409	&sensor_dev_attr_in3_input.dev_attr.attr,
1410	&sensor_dev_attr_in3_max.dev_attr.attr,
1411	&sensor_dev_attr_in3_min.dev_attr.attr,
1412	&sensor_dev_attr_in3_alarm.dev_attr.attr,
1413	&sensor_dev_attr_in4_input.dev_attr.attr,
1414	&sensor_dev_attr_in4_max.dev_attr.attr,
1415	&sensor_dev_attr_in4_min.dev_attr.attr,
1416	&sensor_dev_attr_in4_alarm.dev_attr.attr,
1417	&sensor_dev_attr_in5_input.dev_attr.attr,
1418	&sensor_dev_attr_in5_max.dev_attr.attr,
1419	&sensor_dev_attr_in5_min.dev_attr.attr,
1420	&sensor_dev_attr_in5_alarm.dev_attr.attr,
1421	&sensor_dev_attr_in6_input.dev_attr.attr,
1422	&sensor_dev_attr_in6_max.dev_attr.attr,
1423	&sensor_dev_attr_in6_min.dev_attr.attr,
1424	&sensor_dev_attr_in6_alarm.dev_attr.attr,
1425	&sensor_dev_attr_in7_input.dev_attr.attr,
1426	&sensor_dev_attr_in7_max.dev_attr.attr,
1427	&sensor_dev_attr_in7_min.dev_attr.attr,
1428	&sensor_dev_attr_in7_alarm.dev_attr.attr,
1429	&sensor_dev_attr_in10_input.dev_attr.attr,
1430	&sensor_dev_attr_in10_max.dev_attr.attr,
1431	&sensor_dev_attr_in10_min.dev_attr.attr,
1432	&sensor_dev_attr_in10_alarm.dev_attr.attr,
1433	&sensor_dev_attr_in11_input.dev_attr.attr,
1434	&sensor_dev_attr_in11_max.dev_attr.attr,
1435	&sensor_dev_attr_in11_min.dev_attr.attr,
1436	&sensor_dev_attr_in11_alarm.dev_attr.attr,
1437	&sensor_dev_attr_in12_input.dev_attr.attr,
1438	&sensor_dev_attr_in12_max.dev_attr.attr,
1439	&sensor_dev_attr_in12_min.dev_attr.attr,
1440	&sensor_dev_attr_in12_alarm.dev_attr.attr,
1441	&sensor_dev_attr_in13_input.dev_attr.attr,
1442	&sensor_dev_attr_in13_max.dev_attr.attr,
1443	&sensor_dev_attr_in13_min.dev_attr.attr,
1444	&sensor_dev_attr_in13_alarm.dev_attr.attr,
1445	&sensor_dev_attr_in14_input.dev_attr.attr,
1446	&sensor_dev_attr_in14_max.dev_attr.attr,
1447	&sensor_dev_attr_in14_min.dev_attr.attr,
1448	&sensor_dev_attr_in14_alarm.dev_attr.attr,
1449	&sensor_dev_attr_in15_input.dev_attr.attr,
1450	&sensor_dev_attr_in15_max.dev_attr.attr,
1451	&sensor_dev_attr_in15_min.dev_attr.attr,
1452	&sensor_dev_attr_in15_alarm.dev_attr.attr,
1453	&sensor_dev_attr_in16_input.dev_attr.attr,
1454	&sensor_dev_attr_in16_max.dev_attr.attr,
1455	&sensor_dev_attr_in16_min.dev_attr.attr,
1456	&sensor_dev_attr_in16_alarm.dev_attr.attr,
1457	&sensor_dev_attr_fan1_input.dev_attr.attr,
1458	&sensor_dev_attr_fan1_div.dev_attr.attr,
1459	&sensor_dev_attr_fan1_min.dev_attr.attr,
1460	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
1461	&sensor_dev_attr_fan2_input.dev_attr.attr,
1462	&sensor_dev_attr_fan2_div.dev_attr.attr,
1463	&sensor_dev_attr_fan2_min.dev_attr.attr,
1464	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
1465	&sensor_dev_attr_fan3_input.dev_attr.attr,
1466	&sensor_dev_attr_fan3_div.dev_attr.attr,
1467	&sensor_dev_attr_fan3_min.dev_attr.attr,
1468	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
1469	&sensor_dev_attr_fan4_input.dev_attr.attr,
1470	&sensor_dev_attr_fan4_div.dev_attr.attr,
1471	&sensor_dev_attr_fan4_min.dev_attr.attr,
1472	&sensor_dev_attr_fan4_alarm.dev_attr.attr,
1473	&sensor_dev_attr_fan5_input.dev_attr.attr,
1474	&sensor_dev_attr_fan5_div.dev_attr.attr,
1475	&sensor_dev_attr_fan5_min.dev_attr.attr,
1476	&sensor_dev_attr_fan5_alarm.dev_attr.attr,
1477	&sensor_dev_attr_fan6_input.dev_attr.attr,
1478	&sensor_dev_attr_fan6_div.dev_attr.attr,
1479	&sensor_dev_attr_fan6_min.dev_attr.attr,
1480	&sensor_dev_attr_fan6_alarm.dev_attr.attr,
1481	&sensor_dev_attr_fan7_input.dev_attr.attr,
1482	&sensor_dev_attr_fan7_div.dev_attr.attr,
1483	&sensor_dev_attr_fan7_min.dev_attr.attr,
1484	&sensor_dev_attr_fan7_alarm.dev_attr.attr,
1485	&sensor_dev_attr_fan8_input.dev_attr.attr,
1486	&sensor_dev_attr_fan8_div.dev_attr.attr,
1487	&sensor_dev_attr_fan8_min.dev_attr.attr,
1488	&sensor_dev_attr_fan8_alarm.dev_attr.attr,
1489	&sensor_dev_attr_temp1_input.dev_attr.attr,
1490	&sensor_dev_attr_temp1_max.dev_attr.attr,
1491	&sensor_dev_attr_temp1_min.dev_attr.attr,
1492	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
1493	&sensor_dev_attr_temp2_input.dev_attr.attr,
1494	&sensor_dev_attr_temp2_max.dev_attr.attr,
1495	&sensor_dev_attr_temp2_min.dev_attr.attr,
1496	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
1497	&sensor_dev_attr_temp1_offset.dev_attr.attr,
1498	&sensor_dev_attr_temp2_offset.dev_attr.attr,
1499	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1500	&sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1501	&sensor_dev_attr_temp1_auto_point1_temp_hyst.dev_attr.attr,
1502	&sensor_dev_attr_temp2_auto_point1_temp_hyst.dev_attr.attr,
1503	&sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1504	&sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1505	&sensor_dev_attr_temp1_crit.dev_attr.attr,
1506	&sensor_dev_attr_temp2_crit.dev_attr.attr,
1507	&dev_attr_temp1_crit_enable.attr,
1508	&dev_attr_temp2_crit_enable.attr,
1509	&dev_attr_cpu0_vid.attr,
1510	&dev_attr_vrm.attr,
1511	&dev_attr_alarms.attr,
1512	&dev_attr_alarm_mask.attr,
1513	&dev_attr_gpio.attr,
1514	&dev_attr_gpio_mask.attr,
1515	&dev_attr_pwm1.attr,
1516	&dev_attr_pwm2.attr,
1517	&dev_attr_pwm3.attr,
1518	&dev_attr_pwm1_enable.attr,
1519	&dev_attr_pwm2_enable.attr,
1520	&dev_attr_pwm3_enable.attr,
1521	&dev_attr_temp1_auto_point1_pwm.attr,
1522	&dev_attr_temp2_auto_point1_pwm.attr,
1523	&dev_attr_temp1_auto_point2_pwm.attr,
1524	&dev_attr_temp2_auto_point2_pwm.attr,
1525	&dev_attr_analog_out.attr,
1526	NULL
1527	};
1528
1529	static const struct attribute_group adm1026_group = {
1530	.attrs = adm1026_attributes,
1531	};
1532
1533	static struct attribute *adm1026_attributes_temp3[] = {
1534	&sensor_dev_attr_temp3_input.dev_attr.attr,
1535	&sensor_dev_attr_temp3_max.dev_attr.attr,
1536	&sensor_dev_attr_temp3_min.dev_attr.attr,
1537	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
1538	&sensor_dev_attr_temp3_offset.dev_attr.attr,
1539	&sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1540	&sensor_dev_attr_temp3_auto_point1_temp_hyst.dev_attr.attr,
1541	&sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1542	&sensor_dev_attr_temp3_crit.dev_attr.attr,
1543	&dev_attr_temp3_crit_enable.attr,
1544	&dev_attr_temp3_auto_point1_pwm.attr,
1545	&dev_attr_temp3_auto_point2_pwm.attr,
1546	NULL
1547	};
1548
1549	static const struct attribute_group adm1026_group_temp3 = {
1550	.attrs = adm1026_attributes_temp3,
1551	};
1552
1553	static struct attribute *adm1026_attributes_in8_9[] = {
1554	&sensor_dev_attr_in8_input.dev_attr.attr,
1555	&sensor_dev_attr_in8_max.dev_attr.attr,
1556	&sensor_dev_attr_in8_min.dev_attr.attr,
1557	&sensor_dev_attr_in8_alarm.dev_attr.attr,
1558	&sensor_dev_attr_in9_input.dev_attr.attr,
1559	&sensor_dev_attr_in9_max.dev_attr.attr,
1560	&sensor_dev_attr_in9_min.dev_attr.attr,
1561	&sensor_dev_attr_in9_alarm.dev_attr.attr,
1562	NULL
1563	};
1564
1565	static const struct attribute_group adm1026_group_in8_9 = {
1566	.attrs = adm1026_attributes_in8_9,
1567	};
1568
1569	/* Return 0 if detection is successful, -ENODEV otherwise */
1570	static int adm1026_detect(struct i2c_client *client,
1571	struct i2c_board_info *info)
1572	{
1573	struct i2c_adapter *adapter = client->adapter;
1574	int address = client->addr;
1575	int company, verstep;
1576
1577	if (!i2c_check_functionality(adap: adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1578	/* We need to be able to do byte I/O */
1579	return -ENODEV;
1580	}
1581
1582	/* Now, we do the remaining detection. */
1583
1584	company = adm1026_read_value(client, ADM1026_REG_COMPANY);
1585	verstep = adm1026_read_value(client, ADM1026_REG_VERSTEP);
1586
1587	dev_dbg(&adapter->dev,
1588	"Detecting device at %d,0x%02x with COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
1589	i2c_adapter_id(client->adapter), client->addr,
1590	company, verstep);
1591
1592	/* Determine the chip type. */
1593	dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x...\n",
1594	i2c_adapter_id(adapter), address);
1595	if (company == ADM1026_COMPANY_ANALOG_DEV
1596	&& verstep == ADM1026_VERSTEP_ADM1026) {
1597	/* Analog Devices ADM1026 */
1598	} else if (company == ADM1026_COMPANY_ANALOG_DEV
1599	&& (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
1600	dev_err(&adapter->dev,
1601	"Unrecognized stepping 0x%02x. Defaulting to ADM1026.\n",
1602	verstep);
1603	} else if ((verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
1604	dev_err(&adapter->dev,
1605	"Found version/stepping 0x%02x. Assuming generic ADM1026.\n",
1606	verstep);
1607	} else {
1608	dev_dbg(&adapter->dev, "Autodetection failed\n");
1609	/* Not an ADM1026... */
1610	return -ENODEV;
1611	}
1612
1613	strscpy(p: info->type, q: "adm1026", I2C_NAME_SIZE);
1614
1615	return 0;
1616	}
1617
1618	static void adm1026_print_gpio(struct i2c_client *client)
1619	{
1620	struct adm1026_data *data = i2c_get_clientdata(client);
1621	int i;
1622
1623	dev_dbg(&client->dev, "GPIO config is:\n");
1624	for (i = 0; i <= 7; ++i) {
1625	if (data->config2 & (1 << i)) {
1626	dev_dbg(&client->dev, "\t%sGP%s%d\n",
1627	data->gpio_config[i] & 0x02 ? "" : "!",
1628	data->gpio_config[i] & 0x01 ? "OUT" : "IN",
1629	i);
1630	} else {
1631	dev_dbg(&client->dev, "\tFAN%d\n", i);
1632	}
1633	}
1634	for (i = 8; i <= 15; ++i) {
1635	dev_dbg(&client->dev, "\t%sGP%s%d\n",
1636	data->gpio_config[i] & 0x02 ? "" : "!",
1637	data->gpio_config[i] & 0x01 ? "OUT" : "IN",
1638	i);
1639	}
1640	if (data->config3 & CFG3_GPIO16_ENABLE) {
1641	dev_dbg(&client->dev, "\t%sGP%s16\n",
1642	data->gpio_config[16] & 0x02 ? "" : "!",
1643	data->gpio_config[16] & 0x01 ? "OUT" : "IN");
1644	} else {
1645	/* GPIO16 is THERM */
1646	dev_dbg(&client->dev, "\tTHERM\n");
1647	}
1648	}
1649
1650	static void adm1026_fixup_gpio(struct i2c_client *client)
1651	{
1652	struct adm1026_data *data = i2c_get_clientdata(client);
1653	int i;
1654	int value;
1655
1656	/* Make the changes requested. */
1657	/*
1658	* We may need to unlock/stop monitoring or soft-reset the
1659	* chip before we can make changes. This hasn't been
1660	* tested much. FIXME
1661	*/
1662
1663	/* Make outputs */
1664	for (i = 0; i <= 16; ++i) {
1665	if (gpio_output[i] >= 0 && gpio_output[i] <= 16)
1666	data->gpio_config[gpio_output[i]] |= 0x01;
1667	/* if GPIO0-7 is output, it isn't a FAN tach */
1668	if (gpio_output[i] >= 0 && gpio_output[i] <= 7)
1669	data->config2 |= 1 << gpio_output[i];
1670	}
1671
1672	/* Input overrides output */
1673	for (i = 0; i <= 16; ++i) {
1674	if (gpio_input[i] >= 0 && gpio_input[i] <= 16)
1675	data->gpio_config[gpio_input[i]] &= ~0x01;
1676	/* if GPIO0-7 is input, it isn't a FAN tach */
1677	if (gpio_input[i] >= 0 && gpio_input[i] <= 7)
1678	data->config2 |= 1 << gpio_input[i];
1679	}
1680
1681	/* Inverted */
1682	for (i = 0; i <= 16; ++i) {
1683	if (gpio_inverted[i] >= 0 && gpio_inverted[i] <= 16)
1684	data->gpio_config[gpio_inverted[i]] &= ~0x02;
1685	}
1686
1687	/* Normal overrides inverted */
1688	for (i = 0; i <= 16; ++i) {
1689	if (gpio_normal[i] >= 0 && gpio_normal[i] <= 16)
1690	data->gpio_config[gpio_normal[i]] |= 0x02;
1691	}
1692
1693	/* Fan overrides input and output */
1694	for (i = 0; i <= 7; ++i) {
1695	if (gpio_fan[i] >= 0 && gpio_fan[i] <= 7)
1696	data->config2 &= ~(1 << gpio_fan[i]);
1697	}
1698
1699	/* Write new configs to registers */
1700	adm1026_write_value(client, ADM1026_REG_CONFIG2, value: data->config2);
1701	data->config3 = (data->config3 & 0x3f)
1702	| ((data->gpio_config[16] & 0x03) << 6);
1703	adm1026_write_value(client, ADM1026_REG_CONFIG3, value: data->config3);
1704	for (i = 15, value = 0; i >= 0; --i) {
1705	value <<= 2;
1706	value |= data->gpio_config[i] & 0x03;
1707	if ((i & 0x03) == 0) {
1708	adm1026_write_value(client,
1709	ADM1026_REG_GPIO_CFG_0_3 + i/4,
1710	value);
1711	value = 0;
1712	}
1713	}
1714
1715	/* Print the new config */
1716	adm1026_print_gpio(client);
1717	}
1718
1719	static void adm1026_init_client(struct i2c_client *client)
1720	{
1721	int value, i;
1722	struct adm1026_data *data = i2c_get_clientdata(client);
1723
1724	dev_dbg(&client->dev, "Initializing device\n");
1725	/* Read chip config */
1726	data->config1 = adm1026_read_value(client, ADM1026_REG_CONFIG1);
1727	data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
1728	data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
1729
1730	/* Inform user of chip config */
1731	dev_dbg(&client->dev, "ADM1026_REG_CONFIG1 is: 0x%02x\n",
1732	data->config1);
1733	if ((data->config1 & CFG1_MONITOR) == 0) {
1734	dev_dbg(&client->dev,
1735	"Monitoring not currently enabled.\n");
1736	}
1737	if (data->config1 & CFG1_INT_ENABLE) {
1738	dev_dbg(&client->dev,
1739	"SMBALERT interrupts are enabled.\n");
1740	}
1741	if (data->config1 & CFG1_AIN8_9) {
1742	dev_dbg(&client->dev,
1743	"in8 and in9 enabled. temp3 disabled.\n");
1744	} else {
1745	dev_dbg(&client->dev,
1746	"temp3 enabled. in8 and in9 disabled.\n");
1747	}
1748	if (data->config1 & CFG1_THERM_HOT) {
1749	dev_dbg(&client->dev,
1750	"Automatic THERM, PWM, and temp limits enabled.\n");
1751	}
1752
1753	if (data->config3 & CFG3_GPIO16_ENABLE) {
1754	dev_dbg(&client->dev,
1755	"GPIO16 enabled. THERM pin disabled.\n");
1756	} else {
1757	dev_dbg(&client->dev,
1758	"THERM pin enabled. GPIO16 disabled.\n");
1759	}
1760	if (data->config3 & CFG3_VREF_250)
1761	dev_dbg(&client->dev, "Vref is 2.50 Volts.\n");
1762	else
1763	dev_dbg(&client->dev, "Vref is 1.82 Volts.\n");
1764	/* Read and pick apart the existing GPIO configuration */
1765	value = 0;
1766	for (i = 0; i <= 15; ++i) {
1767	if ((i & 0x03) == 0) {
1768	value = adm1026_read_value(client,
1769	ADM1026_REG_GPIO_CFG_0_3 + i / 4);
1770	}
1771	data->gpio_config[i] = value & 0x03;
1772	value >>= 2;
1773	}
1774	data->gpio_config[16] = (data->config3 >> 6) & 0x03;
1775
1776	/* ... and then print it */
1777	adm1026_print_gpio(client);
1778
1779	/*
1780	* If the user asks us to reprogram the GPIO config, then
1781	* do it now.
1782	*/
1783	if (gpio_input[0] != -1 || gpio_output[0] != -1
1784	|| gpio_inverted[0] != -1 || gpio_normal[0] != -1
1785	|| gpio_fan[0] != -1) {
1786	adm1026_fixup_gpio(client);
1787	}
1788
1789	/*
1790	* WE INTENTIONALLY make no changes to the limits,
1791	* offsets, pwms, fans and zones. If they were
1792	* configured, we don't want to mess with them.
1793	* If they weren't, the default is 100% PWM, no
1794	* control and will suffice until 'sensors -s'
1795	* can be run by the user. We DO set the default
1796	* value for pwm1.auto_pwm_min to its maximum
1797	* so that enabling automatic pwm fan control
1798	* without first setting a value for pwm1.auto_pwm_min
1799	* will not result in potentially dangerous fan speed decrease.
1800	*/
1801	data->pwm1.auto_pwm_min = 255;
1802	/* Start monitoring */
1803	value = adm1026_read_value(client, ADM1026_REG_CONFIG1);
1804	/* Set MONITOR, clear interrupt acknowledge and s/w reset */
1805	value = (value | CFG1_MONITOR) & (~CFG1_INT_CLEAR & ~CFG1_RESET);
1806	dev_dbg(&client->dev, "Setting CONFIG to: 0x%02x\n", value);
1807	data->config1 = value;
1808	adm1026_write_value(client, ADM1026_REG_CONFIG1, value);
1809
1810	/* initialize fan_div[] to hardware defaults */
1811	value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3) |
1812	(adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7) << 8);
1813	for (i = 0; i <= 7; ++i) {
1814	data->fan_div[i] = DIV_FROM_REG(value & 0x03);
1815	value >>= 2;
1816	}
1817	}
1818
1819	static int adm1026_probe(struct i2c_client *client)
1820	{
1821	struct device *dev = &client->dev;
1822	struct device *hwmon_dev;
1823	struct adm1026_data *data;
1824
1825	data = devm_kzalloc(dev, size: sizeof(struct adm1026_data), GFP_KERNEL);
1826	if (!data)
1827	return -ENOMEM;
1828
1829	i2c_set_clientdata(client, data);
1830	data->client = client;
1831	mutex_init(&data->update_lock);
1832
1833	/* Set the VRM version */
1834	data->vrm = vid_which_vrm();
1835
1836	/* Initialize the ADM1026 chip */
1837	adm1026_init_client(client);
1838
1839	/* sysfs hooks */
1840	data->groups[0] = &adm1026_group;
1841	if (data->config1 & CFG1_AIN8_9)
1842	data->groups[1] = &adm1026_group_in8_9;
1843	else
1844	data->groups[1] = &adm1026_group_temp3;
1845
1846	hwmon_dev = devm_hwmon_device_register_with_groups(dev, name: client->name,
1847	drvdata: data, groups: data->groups);
1848	return PTR_ERR_OR_ZERO(ptr: hwmon_dev);
1849	}
1850
1851	static const struct i2c_device_id adm1026_id[] = {
1852	{ "adm1026", 0 },
1853	{ }
1854	};
1855	MODULE_DEVICE_TABLE(i2c, adm1026_id);
1856
1857	static struct i2c_driver adm1026_driver = {
1858	.class = I2C_CLASS_HWMON,
1859	.driver = {
1860	.name = "adm1026",
1861	},
1862	.probe = adm1026_probe,
1863	.id_table = adm1026_id,
1864	.detect = adm1026_detect,
1865	.address_list = normal_i2c,
1866	};
1867
1868	module_i2c_driver(adm1026_driver);
1869
1870	MODULE_LICENSE("GPL");
1871	MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
1872	"Justin Thiessen <jthiessen@penguincomputing.com>");
1873	MODULE_DESCRIPTION("ADM1026 driver");
1874