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 */
  25static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
  26
  27static int gpio_input[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
  28				-1, -1, -1, -1, -1, -1, -1, -1 };
  29static int gpio_output[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
  30				-1, -1, -1, -1, -1, -1, -1, -1 };
  31static int gpio_inverted[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
  32				-1, -1, -1, -1, -1, -1, -1, -1 };
  33static int gpio_normal[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
  34				-1, -1, -1, -1, -1, -1, -1, -1 };
  35static int gpio_fan[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  36module_param_array(gpio_input, int, NULL, 0);
  37MODULE_PARM_DESC(gpio_input, "List of GPIO pins (0-16) to program as inputs");
  38module_param_array(gpio_output, int, NULL, 0);
  39MODULE_PARM_DESC(gpio_output,
  40		 "List of GPIO pins (0-16) to program as outputs");
  41module_param_array(gpio_inverted, int, NULL, 0);
  42MODULE_PARM_DESC(gpio_inverted,
  43		 "List of GPIO pins (0-16) to program as inverted");
  44module_param_array(gpio_normal, int, NULL, 0);
  45MODULE_PARM_DESC(gpio_normal,
  46		 "List of GPIO pins (0-16) to program as normal/non-inverted");
  47module_param_array(gpio_fan, int, NULL, 0);
  48MODULE_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 */
  92static 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	};
  97static 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	};
 102static 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 */
 114static u16 ADM1026_REG_TEMP[] = { 0x1f, 0x28, 0x29 };
 115static u16 ADM1026_REG_TEMP_MIN[] = { 0x69, 0x48, 0x49 };
 116static u16 ADM1026_REG_TEMP_MAX[] = { 0x68, 0x40, 0x41 };
 117static u16 ADM1026_REG_TEMP_TMIN[] = { 0x10, 0x11, 0x12 };
 118static u16 ADM1026_REG_TEMP_THERM[] = { 0x0d, 0x0e, 0x0f };
 119static 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 */
 180static 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
 251struct pwm_data {
 252	u8 pwm;
 253	u8 enable;
 254	u8 auto_pwm_min;
 255};
 256
 257struct adm1026_data {
 258	struct i2c_client *client;
 259	const struct attribute_group *groups[3];
 260
 261	struct mutex update_lock;
 262	int valid;		/* !=0 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
 291static 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, reg) & 0xff;
 298	} else {
 299		/* EEPROM, do nothing */
 300		res = 0;
 301	}
 302	return res;
 303}
 304
 305static 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, reg, value);
 312	} else {
 313		/* EEPROM, do nothing */
 314		res = 0;
 315	}
 316	return res;
 317}
 318
 319static 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, 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, 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				ADM1026_REG_IN_MIN[i]);
 385			data->in_max[i] = adm1026_read_value(client,
 386				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				ADM1026_REG_TEMP_MIN[i]);
 406			data->temp_max[i] = adm1026_read_value(client,
 407				ADM1026_REG_TEMP_MAX[i]);
 408			data->temp_tmin[i] = adm1026_read_value(client,
 409				ADM1026_REG_TEMP_TMIN[i]);
 410			data->temp_crit[i] = adm1026_read_value(client,
 411				ADM1026_REG_TEMP_THERM[i]);
 412			data->temp_offset[i] = adm1026_read_value(client,
 413				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 = 1;
 463	mutex_unlock(&data->update_lock);
 464	return data;
 465}
 466
 467static 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, "%d\n", INS_FROM_REG(nr, data->in[nr]));
 474}
 475static 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, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
 482}
 483static 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(buf, 10, &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, ADM1026_REG_IN_MIN[nr], data->in_min[nr]);
 500	mutex_unlock(&data->update_lock);
 501	return count;
 502}
 503static 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, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
 510}
 511static 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(buf, 10, &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, ADM1026_REG_IN_MAX[nr], data->in_max[nr]);
 528	mutex_unlock(&data->update_lock);
 529	return count;
 530}
 531
 532static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
 533static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
 534static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
 535static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
 536static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
 537static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
 538static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
 539static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
 540static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
 541static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
 542static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
 543static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
 544static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
 545static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
 546static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
 547static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
 548static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
 549static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
 550static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);
 551static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
 552static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
 553static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);
 554static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
 555static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
 556static SENSOR_DEVICE_ATTR_RO(in8_input, in, 8);
 557static SENSOR_DEVICE_ATTR_RW(in8_min, in_min, 8);
 558static SENSOR_DEVICE_ATTR_RW(in8_max, in_max, 8);
 559static SENSOR_DEVICE_ATTR_RO(in9_input, in, 9);
 560static SENSOR_DEVICE_ATTR_RW(in9_min, in_min, 9);
 561static SENSOR_DEVICE_ATTR_RW(in9_max, in_max, 9);
 562static SENSOR_DEVICE_ATTR_RO(in10_input, in, 10);
 563static SENSOR_DEVICE_ATTR_RW(in10_min, in_min, 10);
 564static SENSOR_DEVICE_ATTR_RW(in10_max, in_max, 10);
 565static SENSOR_DEVICE_ATTR_RO(in11_input, in, 11);
 566static SENSOR_DEVICE_ATTR_RW(in11_min, in_min, 11);
 567static SENSOR_DEVICE_ATTR_RW(in11_max, in_max, 11);
 568static SENSOR_DEVICE_ATTR_RO(in12_input, in, 12);
 569static SENSOR_DEVICE_ATTR_RW(in12_min, in_min, 12);
 570static SENSOR_DEVICE_ATTR_RW(in12_max, in_max, 12);
 571static SENSOR_DEVICE_ATTR_RO(in13_input, in, 13);
 572static SENSOR_DEVICE_ATTR_RW(in13_min, in_min, 13);
 573static SENSOR_DEVICE_ATTR_RW(in13_max, in_max, 13);
 574static SENSOR_DEVICE_ATTR_RO(in14_input, in, 14);
 575static SENSOR_DEVICE_ATTR_RW(in14_min, in_min, 14);
 576static SENSOR_DEVICE_ATTR_RW(in14_max, in_max, 14);
 577static SENSOR_DEVICE_ATTR_RO(in15_input, in, 15);
 578static SENSOR_DEVICE_ATTR_RW(in15_min, in_min, 15);
 579static SENSOR_DEVICE_ATTR_RW(in15_max, in_max, 15);
 580
 581static 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, "%d\n", INS_FROM_REG(16, data->in[16]) -
 586		NEG12_OFFSET);
 587}
 588static 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, "%d\n", INS_FROM_REG(16, data->in_min[16])
 593		- NEG12_OFFSET);
 594}
 595static 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(buf, 10, &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, ADM1026_REG_IN_MIN[16], data->in_min[16]);
 614	mutex_unlock(&data->update_lock);
 615	return count;
 616}
 617static 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, "%d\n", INS_FROM_REG(16, data->in_max[16])
 622			- NEG12_OFFSET);
 623}
 624static 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(buf, 10, &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, ADM1026_REG_IN_MAX[16], data->in_max[16]);
 643	mutex_unlock(&data->update_lock);
 644	return count;
 645}
 646
 647static SENSOR_DEVICE_ATTR_RO(in16_input, in16, 16);
 648static SENSOR_DEVICE_ATTR_RW(in16_min, in16_min, 16);
 649static SENSOR_DEVICE_ATTR_RW(in16_max, in16_max, 16);
 
 
 
 650
 651/* Now add fan read/write functions */
 652
 653static 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, "%d\n", FAN_FROM_REG(data->fan[nr],
 660		data->fan_div[nr]));
 661}
 662static 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, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 669		data->fan_div[nr]));
 670}
 671static 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(buf, 10, &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		data->fan_min[nr]);
 690	mutex_unlock(&data->update_lock);
 691	return count;
 692}
 693
 694static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
 695static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
 696static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
 697static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
 698static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2);
 699static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2);
 700static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3);
 701static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3);
 702static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4);
 703static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4);
 704static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5);
 705static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5);
 706static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6);
 707static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6);
 708static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7);
 709static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7);
 710
 711/* Adjust fan_min to account for new fan divisor */
 712static 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), new_min);
 727}
 728
 729/* Now add fan_div read/write functions */
 730static 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, "%d\n", data->fan_div[nr]);
 737}
 738static 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(buf, 10, &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				    (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				    (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, nr, orig_div);
 776
 777	mutex_unlock(&data->update_lock);
 778	return count;
 779}
 780
 781static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
 782static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
 783static SENSOR_DEVICE_ATTR_RW(fan3_div, fan_div, 2);
 784static SENSOR_DEVICE_ATTR_RW(fan4_div, fan_div, 3);
 785static SENSOR_DEVICE_ATTR_RW(fan5_div, fan_div, 4);
 786static SENSOR_DEVICE_ATTR_RW(fan6_div, fan_div, 5);
 787static SENSOR_DEVICE_ATTR_RW(fan7_div, fan_div, 6);
 788static SENSOR_DEVICE_ATTR_RW(fan8_div, fan_div, 7);
 
 
 
 
 789
 790/* Temps */
 791static 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, "%d\n", TEMP_FROM_REG(data->temp[nr]));
 798}
 799static 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, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
 806}
 807static 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(buf, 10, &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, ADM1026_REG_TEMP_MIN[nr],
 825		data->temp_min[nr]);
 826	mutex_unlock(&data->update_lock);
 827	return count;
 828}
 829static 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, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
 836}
 837static 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(buf, 10, &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, ADM1026_REG_TEMP_MAX[nr],
 855		data->temp_max[nr]);
 856	mutex_unlock(&data->update_lock);
 857	return count;
 858}
 859
 860static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
 861static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
 862static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
 863static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
 864static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
 865static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
 866static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
 867static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
 868static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
 869
 870static 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, "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
 877}
 878static 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(buf, 10, &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, ADM1026_REG_TEMP_OFFSET[nr],
 896		data->temp_offset[nr]);
 897	mutex_unlock(&data->update_lock);
 898	return count;
 899}
 900
 901static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
 902static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
 903static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
 904
 905static 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, "%d\n", TEMP_FROM_REG(
 913		ADM1026_FAN_ACTIVATION_TEMP_HYST + data->temp_tmin[nr]));
 914}
 915static 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, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr] +
 923		ADM1026_FAN_CONTROL_TEMP_RANGE));
 924}
 925static 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, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr]));
 933}
 934static 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(buf, 10, &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, ADM1026_REG_TEMP_TMIN[nr],
 952		data->temp_tmin[nr]);
 953	mutex_unlock(&data->update_lock);
 954	return count;
 955}
 956
 957static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, temp_auto_point1_temp, 0);
 958static SENSOR_DEVICE_ATTR_RO(temp1_auto_point1_temp_hyst,
 959			     temp_auto_point1_temp_hyst, 0);
 960static SENSOR_DEVICE_ATTR_RO(temp1_auto_point2_temp, temp_auto_point2_temp, 0);
 961static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, temp_auto_point1_temp, 1);
 962static SENSOR_DEVICE_ATTR_RO(temp2_auto_point1_temp_hyst,
 963			     temp_auto_point1_temp_hyst, 1);
 964static SENSOR_DEVICE_ATTR_RO(temp2_auto_point2_temp, temp_auto_point2_temp, 1);
 965static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, temp_auto_point1_temp, 2);
 966static SENSOR_DEVICE_ATTR_RO(temp3_auto_point1_temp_hyst,
 967			     temp_auto_point1_temp_hyst, 2);
 968static SENSOR_DEVICE_ATTR_RO(temp3_auto_point2_temp, temp_auto_point2_temp, 2);
 969
 970static 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, "%d\n", (data->config1 & CFG1_THERM_HOT) >> 4);
 975}
 976static 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(buf, 10, &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, data->config1);
 994	mutex_unlock(&data->update_lock);
 995
 996	return count;
 997}
 998
 999static DEVICE_ATTR(temp1_crit_enable, 0644, show_temp_crit_enable,
1000		   set_temp_crit_enable);
1001static DEVICE_ATTR(temp2_crit_enable, 0644, show_temp_crit_enable,
1002		   set_temp_crit_enable);
1003static DEVICE_ATTR(temp3_crit_enable, 0644, show_temp_crit_enable,
1004		   set_temp_crit_enable);
 
1005
1006static 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, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
1013}
1014static 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(buf, 10, &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, ADM1026_REG_TEMP_THERM[nr],
1032		data->temp_crit[nr]);
1033	mutex_unlock(&data->update_lock);
1034	return count;
1035}
1036
1037static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
1038static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
1039static SENSOR_DEVICE_ATTR_RW(temp3_crit, temp_crit, 2);
 
 
 
 
1040
1041static 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, "%d\n", DAC_FROM_REG(data->analog_out));
1046}
1047static 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(buf, 10, &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, data->analog_out);
1063	mutex_unlock(&data->update_lock);
1064	return count;
1065}
1066
1067static DEVICE_ATTR_RW(analog_out);
 
1068
1069static 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, "%d\n", vid_from_reg(vid, data->vrm));
1077}
1078
1079static DEVICE_ATTR_RO(cpu0_vid);
1080
1081static 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, "%d\n", data->vrm);
1086}
1087
1088static 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(buf, 10, &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
1106static DEVICE_ATTR_RW(vrm);
1107
1108static 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, "%ld\n", data->alarms);
1113}
1114
1115static DEVICE_ATTR_RO(alarms);
1116
1117static 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, "%ld\n", (data->alarms >> bitnr) & 1);
1123}
1124
1125static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 0);
1126static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1);
1127static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm, 1);
1128static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm, 2);
1129static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm, 3);
1130static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm, 4);
1131static SENSOR_DEVICE_ATTR_RO(in14_alarm, alarm, 5);
1132static SENSOR_DEVICE_ATTR_RO(in15_alarm, alarm, 6);
1133static SENSOR_DEVICE_ATTR_RO(in16_alarm, alarm, 7);
1134static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 8);
1135static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 9);
1136static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 10);
1137static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 11);
1138static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 12);
1139static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 13);
1140static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 14);
1141static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 15);
1142static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 16);
1143static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 17);
1144static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 18);
1145static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm, 19);
1146static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm, 20);
1147static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm, 21);
1148static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm, 22);
1149static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm, 23);
1150static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 24);
1151static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm, 25);
1152static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm, 26);
1153
1154static 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, "%ld\n", data->alarm_mask);
1159}
1160static 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(buf, 10, &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		mask & 0xff);
1180	mask >>= 8;
1181	adm1026_write_value(client, ADM1026_REG_MASK2,
1182		mask & 0xff);
1183	mask >>= 8;
1184	adm1026_write_value(client, ADM1026_REG_MASK3,
1185		mask & 0xff);
1186	mask >>= 8;
1187	adm1026_write_value(client, ADM1026_REG_MASK4,
1188		mask & 0xff);
1189	mutex_unlock(&data->update_lock);
1190	return count;
1191}
1192
1193static DEVICE_ATTR_RW(alarm_mask);
 
 
1194
1195static 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, "%ld\n", data->gpio);
1200}
1201static 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(buf, 10, &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, gpio & 0xff);
1218	gpio >>= 8;
1219	adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_8_15, gpio & 0xff);
1220	gpio = ((gpio >> 1) & 0x80) | (data->alarms >> 24 & 0x7f);
1221	adm1026_write_value(client, ADM1026_REG_STATUS4, gpio & 0xff);
1222	mutex_unlock(&data->update_lock);
1223	return count;
1224}
1225
1226static DEVICE_ATTR_RW(gpio);
1227
1228static 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, "%ld\n", data->gpio_mask);
1234}
1235static 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(buf, 10, &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, mask & 0xff);
1253	mask >>= 8;
1254	adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15, mask & 0xff);
1255	mask = ((mask >> 1) & 0x80) | (data->alarm_mask >> 24 & 0x7f);
1256	adm1026_write_value(client, ADM1026_REG_MASK1, mask & 0xff);
1257	mutex_unlock(&data->update_lock);
1258	return count;
1259}
1260
1261static DEVICE_ATTR_RW(gpio_mask);
1262
1263static 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, "%d\n", PWM_FROM_REG(data->pwm1.pwm));
1268}
1269
1270static 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(buf, 10, &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, data->pwm1.pwm);
1287		mutex_unlock(&data->update_lock);
1288	}
1289	return count;
1290}
1291
1292static 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, "%d\n", data->pwm1.auto_pwm_min);
1298}
1299
1300static 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(buf, 10, &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, data->pwm1.pwm);
1319	}
1320	mutex_unlock(&data->update_lock);
1321	return count;
1322}
1323
1324static ssize_t temp1_auto_point2_pwm_show(struct device *dev,
1325					  struct device_attribute *attr,
1326					  char *buf)
1327{
1328	return sprintf(buf, "%d\n", ADM1026_PWM_MAX);
1329}
1330
1331static 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, "%d\n", data->pwm1.enable);
1336}
1337
1338static 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(buf, 10, &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, 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, 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, data->pwm1.pwm);
1369	}
1370	mutex_unlock(&data->update_lock);
1371
1372	return count;
1373}
1374
1375/* enable PWM fan control */
1376static DEVICE_ATTR_RW(pwm1);
1377static DEVICE_ATTR(pwm2, 0644, pwm1_show, pwm1_store);
1378static DEVICE_ATTR(pwm3, 0644, pwm1_show, pwm1_store);
1379static DEVICE_ATTR_RW(pwm1_enable);
1380static DEVICE_ATTR(pwm2_enable, 0644, pwm1_enable_show,
1381		   pwm1_enable_store);
1382static DEVICE_ATTR(pwm3_enable, 0644, pwm1_enable_show,
1383		   pwm1_enable_store);
1384static DEVICE_ATTR_RW(temp1_auto_point1_pwm);
1385static DEVICE_ATTR(temp2_auto_point1_pwm, 0644,
1386		   temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
1387static DEVICE_ATTR(temp3_auto_point1_pwm, 0644,
1388		   temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
1389
1390static DEVICE_ATTR_RO(temp1_auto_point2_pwm);
1391static DEVICE_ATTR(temp2_auto_point2_pwm, 0444, temp1_auto_point2_pwm_show,
1392		   NULL);
1393static DEVICE_ATTR(temp3_auto_point2_pwm, 0444, temp1_auto_point2_pwm_show,
1394		   NULL);
1395
1396static 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
1529static const struct attribute_group adm1026_group = {
1530	.attrs = adm1026_attributes,
1531};
1532
1533static 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
1549static const struct attribute_group adm1026_group_temp3 = {
1550	.attrs = adm1026_attributes_temp3,
1551};
1552
1553static 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
1565static 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 */
1570static 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(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	strlcpy(info->type, "adm1026", I2C_NAME_SIZE);
1614
1615	return 0;
1616}
1617
1618static 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
1650static 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, data->config2);
1701	data->config3 = (data->config3 & 0x3f)
1702			| ((data->gpio_config[16] & 0x03) << 6);
1703	adm1026_write_value(client, ADM1026_REG_CONFIG3, 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
1719static 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
1819static int adm1026_probe(struct i2c_client *client,
1820			 const struct i2c_device_id *id)
1821{
1822	struct device *dev = &client->dev;
1823	struct device *hwmon_dev;
1824	struct adm1026_data *data;
1825
1826	data = devm_kzalloc(dev, sizeof(struct adm1026_data), GFP_KERNEL);
1827	if (!data)
1828		return -ENOMEM;
1829
1830	i2c_set_clientdata(client, data);
1831	data->client = client;
1832	mutex_init(&data->update_lock);
1833
1834	/* Set the VRM version */
1835	data->vrm = vid_which_vrm();
1836
1837	/* Initialize the ADM1026 chip */
1838	adm1026_init_client(client);
1839
1840	/* sysfs hooks */
1841	data->groups[0] = &adm1026_group;
1842	if (data->config1 & CFG1_AIN8_9)
1843		data->groups[1] = &adm1026_group_in8_9;
1844	else
1845		data->groups[1] = &adm1026_group_temp3;
1846
1847	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1848							   data, data->groups);
1849	return PTR_ERR_OR_ZERO(hwmon_dev);
1850}
1851
1852static const struct i2c_device_id adm1026_id[] = {
1853	{ "adm1026", 0 },
1854	{ }
1855};
1856MODULE_DEVICE_TABLE(i2c, adm1026_id);
1857
1858static struct i2c_driver adm1026_driver = {
1859	.class		= I2C_CLASS_HWMON,
1860	.driver = {
1861		.name	= "adm1026",
1862	},
1863	.probe		= adm1026_probe,
1864	.id_table	= adm1026_id,
1865	.detect		= adm1026_detect,
1866	.address_list	= normal_i2c,
1867};
1868
1869module_i2c_driver(adm1026_driver);
1870
1871MODULE_LICENSE("GPL");
1872MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
1873	      "Justin Thiessen <jthiessen@penguincomputing.com>");
1874MODULE_DESCRIPTION("ADM1026 driver");