adt7470.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * A hwmon driver for the Analog Devices ADT7470
   4 * Copyright (C) 2007 IBM
   5 *
   6 * Author: Darrick J. Wong <darrick.wong@oracle.com>
   7 */
   8
   9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11#include <linux/module.h>
  12#include <linux/jiffies.h>
  13#include <linux/i2c.h>
  14#include <linux/hwmon.h>
  15#include <linux/hwmon-sysfs.h>
  16#include <linux/err.h>
  17#include <linux/mutex.h>
  18#include <linux/delay.h>
  19#include <linux/log2.h>
  20#include <linux/kthread.h>
  21#include <linux/regmap.h>
  22#include <linux/sched.h>
  23#include <linux/slab.h>
  24#include <linux/util_macros.h>
  25
  26/* Addresses to scan */
  27static const unsigned short normal_i2c[] = { 0x2C, 0x2E, 0x2F, I2C_CLIENT_END };
  28
  29/* ADT7470 registers */
  30#define ADT7470_REG_BASE_ADDR			0x20
  31#define ADT7470_REG_TEMP_BASE_ADDR		0x20
  32#define ADT7470_REG_TEMP_MAX_ADDR		0x29
  33#define ADT7470_REG_FAN_BASE_ADDR		0x2A
  34#define ADT7470_REG_FAN_MAX_ADDR		0x31
  35#define ADT7470_REG_PWM_BASE_ADDR		0x32
  36#define ADT7470_REG_PWM_MAX_ADDR		0x35
  37#define ADT7470_REG_PWM_MAX_BASE_ADDR		0x38
  38#define ADT7470_REG_PWM_MAX_MAX_ADDR		0x3B
  39#define ADT7470_REG_CFG				0x40
  40#define		ADT7470_STRT_MASK		0x01
  41#define		ADT7470_TEST_MASK		0x02
  42#define		ADT7470_FSPD_MASK		0x04
  43#define		ADT7470_T05_STB_MASK		0x80
  44#define ADT7470_REG_ALARM1			0x41
  45#define		ADT7470_R1T_ALARM		0x01
  46#define		ADT7470_R2T_ALARM		0x02
  47#define		ADT7470_R3T_ALARM		0x04
  48#define		ADT7470_R4T_ALARM		0x08
  49#define		ADT7470_R5T_ALARM		0x10
  50#define		ADT7470_R6T_ALARM		0x20
  51#define		ADT7470_R7T_ALARM		0x40
  52#define		ADT7470_OOL_ALARM		0x80
  53#define ADT7470_REG_ALARM2			0x42
  54#define		ADT7470_R8T_ALARM		0x01
  55#define		ADT7470_R9T_ALARM		0x02
  56#define		ADT7470_R10T_ALARM		0x04
  57#define		ADT7470_FAN1_ALARM		0x10
  58#define		ADT7470_FAN2_ALARM		0x20
  59#define		ADT7470_FAN3_ALARM		0x40
  60#define		ADT7470_FAN4_ALARM		0x80
  61#define ADT7470_REG_TEMP_LIMITS_BASE_ADDR	0x44
  62#define ADT7470_REG_TEMP_LIMITS_MAX_ADDR	0x57
  63#define ADT7470_REG_FAN_MIN_BASE_ADDR		0x58
  64#define ADT7470_REG_FAN_MIN_MAX_ADDR		0x5F
  65#define ADT7470_REG_FAN_MAX_BASE_ADDR		0x60
  66#define ADT7470_REG_FAN_MAX_MAX_ADDR		0x67
  67#define ADT7470_REG_PWM_CFG_BASE_ADDR		0x68
  68#define ADT7470_REG_PWM12_CFG			0x68
  69#define		ADT7470_PWM2_AUTO_MASK		0x40
  70#define		ADT7470_PWM1_AUTO_MASK		0x80
  71#define		ADT7470_PWM_AUTO_MASK		0xC0
  72#define ADT7470_REG_PWM34_CFG			0x69
  73#define		ADT7470_PWM3_AUTO_MASK		0x40
  74#define		ADT7470_PWM4_AUTO_MASK		0x80
  75#define	ADT7470_REG_PWM_MIN_BASE_ADDR		0x6A
  76#define ADT7470_REG_PWM_MIN_MAX_ADDR		0x6D
  77#define ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR	0x6E
  78#define ADT7470_REG_PWM_TEMP_MIN_MAX_ADDR	0x71
  79#define ADT7470_REG_CFG_2			0x74
  80#define ADT7470_REG_ACOUSTICS12			0x75
  81#define ADT7470_REG_ACOUSTICS34			0x76
  82#define ADT7470_REG_DEVICE			0x3D
  83#define ADT7470_REG_VENDOR			0x3E
  84#define ADT7470_REG_REVISION			0x3F
  85#define ADT7470_REG_ALARM1_MASK			0x72
  86#define ADT7470_REG_ALARM2_MASK			0x73
  87#define ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR	0x7C
  88#define ADT7470_REG_PWM_AUTO_TEMP_MAX_ADDR	0x7D
  89#define ADT7470_REG_MAX_ADDR			0x81
  90
  91#define ADT7470_TEMP_COUNT	10
  92#define ADT7470_TEMP_REG(x)	(ADT7470_REG_TEMP_BASE_ADDR + (x))
  93#define ADT7470_TEMP_MIN_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
  94#define ADT7470_TEMP_MAX_REG(x) (ADT7470_REG_TEMP_LIMITS_BASE_ADDR + \
  95				((x) * 2) + 1)
  96
  97#define ADT7470_FAN_COUNT	4
  98#define ADT7470_REG_FAN(x)	(ADT7470_REG_FAN_BASE_ADDR + ((x) * 2))
  99#define ADT7470_REG_FAN_MIN(x)	(ADT7470_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
 100#define ADT7470_REG_FAN_MAX(x)	(ADT7470_REG_FAN_MAX_BASE_ADDR + ((x) * 2))
 101
 102#define ADT7470_PWM_COUNT	4
 103#define ADT7470_REG_PWM(x)	(ADT7470_REG_PWM_BASE_ADDR + (x))
 104#define ADT7470_REG_PWM_MAX(x)	(ADT7470_REG_PWM_MAX_BASE_ADDR + (x))
 105#define ADT7470_REG_PWM_MIN(x)	(ADT7470_REG_PWM_MIN_BASE_ADDR + (x))
 106#define ADT7470_REG_PWM_TMIN(x)	(ADT7470_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
 107#define ADT7470_REG_PWM_CFG(x)	(ADT7470_REG_PWM_CFG_BASE_ADDR + ((x) / 2))
 108#define ADT7470_REG_PWM_AUTO_TEMP(x)	(ADT7470_REG_PWM_AUTO_TEMP_BASE_ADDR + \
 109					((x) / 2))
 110
 111#define ALARM2(x)		((x) << 8)
 112
 113#define ADT7470_VENDOR		0x41
 114#define ADT7470_DEVICE		0x70
 115/* datasheet only mentions a revision 2 */
 116#define ADT7470_REVISION	0x02
 117
 118/* "all temps" according to hwmon sysfs interface spec */
 119#define ADT7470_PWM_ALL_TEMPS	0x3FF
 120
 121/* How often do we reread sensors values? (In jiffies) */
 122#define SENSOR_REFRESH_INTERVAL	(5 * HZ)
 123
 124/* How often do we reread sensor limit values? (In jiffies) */
 125#define LIMIT_REFRESH_INTERVAL	(60 * HZ)
 126
 127/* Wait at least 200ms per sensor for 10 sensors */
 128#define TEMP_COLLECTION_TIME	2000
 129
 130/* auto update thing won't fire more than every 2s */
 131#define AUTO_UPDATE_INTERVAL	2000
 132
 133/* datasheet says to divide this number by the fan reading to get fan rpm */
 134#define FAN_PERIOD_TO_RPM(x)	((90000 * 60) / (x))
 135#define FAN_RPM_TO_PERIOD	FAN_PERIOD_TO_RPM
 136#define FAN_PERIOD_INVALID	65535
 137#define FAN_DATA_VALID(x)	((x) && (x) != FAN_PERIOD_INVALID)
 138
 139/* Config registers 1 and 2 include fields for selecting the PWM frequency */
 140#define ADT7470_CFG_LF		0x40
 141#define ADT7470_FREQ_MASK	0x70
 142#define ADT7470_FREQ_SHIFT	4
 143
 144struct adt7470_data {
 145	struct regmap		*regmap;
 146	struct mutex		lock;
 147	char			sensors_valid;
 148	char			limits_valid;
 149	unsigned long		sensors_last_updated;	/* In jiffies */
 150	unsigned long		limits_last_updated;	/* In jiffies */
 151
 152	int			num_temp_sensors;	/* -1 = probe */
 153	int			temperatures_probed;
 154
 155	s8			temp[ADT7470_TEMP_COUNT];
 156	s8			temp_min[ADT7470_TEMP_COUNT];
 157	s8			temp_max[ADT7470_TEMP_COUNT];
 158	u16			fan[ADT7470_FAN_COUNT];
 159	u16			fan_min[ADT7470_FAN_COUNT];
 160	u16			fan_max[ADT7470_FAN_COUNT];
 161	u16			alarm;
 162	u16			alarms_mask;
 163	u8			force_pwm_max;
 164	u8			pwm[ADT7470_PWM_COUNT];
 165	u8			pwm_max[ADT7470_PWM_COUNT];
 166	u8			pwm_automatic[ADT7470_PWM_COUNT];
 167	u8			pwm_min[ADT7470_PWM_COUNT];
 168	s8			pwm_tmin[ADT7470_PWM_COUNT];
 169	u8			pwm_auto_temp[ADT7470_PWM_COUNT];
 170
 171	struct task_struct	*auto_update;
 172	unsigned int		auto_update_interval;
 173};
 174
 175/*
 176 * 16-bit registers on the ADT7470 are low-byte first.  The data sheet says
 177 * that the low byte must be read before the high byte.
 178 */
 179static inline int adt7470_read_word_data(struct adt7470_data *data, unsigned int reg,
 180					 unsigned int *val)
 181{
 182	u8 regval[2];
 183	int err;
 184
 185	err = regmap_bulk_read(data->regmap, reg, &regval, 2);
 186	if (err < 0)
 187		return err;
 188
 189	*val = regval[0] | (regval[1] << 8);
 190
 191	return 0;
 192}
 193
 194static inline int adt7470_write_word_data(struct adt7470_data *data, unsigned int reg,
 195					  unsigned int val)
 196{
 197	u8 regval[2];
 198
 199	regval[0] = val & 0xFF;
 200	regval[1] = val >> 8;
 201
 202	return regmap_bulk_write(data->regmap, reg, &regval, 2);
 203}
 204
 205/* Probe for temperature sensors.  Assumes lock is held */
 206static int adt7470_read_temperatures(struct adt7470_data *data)
 207{
 208	unsigned long res;
 209	unsigned int pwm_cfg[2];
 210	int err;
 211	int i;
 212	u8 pwm[ADT7470_FAN_COUNT];
 213
 214	/* save pwm[1-4] config register */
 215	err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(0), &pwm_cfg[0]);
 216	if (err < 0)
 217		return err;
 218	err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(2), &pwm_cfg[1]);
 219	if (err < 0)
 220		return err;
 221
 222	/* set manual pwm to whatever it is set to now */
 223	err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &pwm[0],
 224			       ADT7470_PWM_COUNT);
 225	if (err < 0)
 226		return err;
 227
 228	/* put pwm in manual mode */
 229	err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(0),
 230				 ADT7470_PWM_AUTO_MASK, 0);
 231	if (err < 0)
 232		return err;
 233	err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(2),
 234				 ADT7470_PWM_AUTO_MASK, 0);
 235	if (err < 0)
 236		return err;
 237
 238	/* write pwm control to whatever it was */
 239	err = regmap_bulk_write(data->regmap, ADT7470_REG_PWM(0), &pwm[0],
 240				ADT7470_PWM_COUNT);
 241	if (err < 0)
 242		return err;
 243
 244	/* start reading temperature sensors */
 245	err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
 246				 ADT7470_T05_STB_MASK, ADT7470_T05_STB_MASK);
 247	if (err < 0)
 248		return err;
 249
 250	/* Delay is 200ms * number of temp sensors. */
 251	res = msleep_interruptible((data->num_temp_sensors >= 0 ?
 252				    data->num_temp_sensors * 200 :
 253				    TEMP_COLLECTION_TIME));
 254
 255	/* done reading temperature sensors */
 256	err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
 257				 ADT7470_T05_STB_MASK, 0);
 258	if (err < 0)
 259		return err;
 260
 261	/* restore pwm[1-4] config registers */
 262	err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(0), pwm_cfg[0]);
 263	if (err < 0)
 264		return err;
 265	err = regmap_write(data->regmap, ADT7470_REG_PWM_CFG(2), pwm_cfg[1]);
 266	if (err < 0)
 267		return err;
 268
 269	if (res)
 270		return -EAGAIN;
 271
 272	/* Only count fans if we have to */
 273	if (data->num_temp_sensors >= 0)
 274		return 0;
 275
 276	err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],
 277			       ADT7470_TEMP_COUNT);
 278	if (err < 0)
 279		return err;
 280	for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
 281		if (data->temp[i])
 282			data->num_temp_sensors = i + 1;
 283	}
 284	data->temperatures_probed = 1;
 285	return 0;
 286}
 287
 288static int adt7470_update_thread(void *p)
 289{
 290	struct i2c_client *client = p;
 291	struct adt7470_data *data = i2c_get_clientdata(client);
 292
 293	while (!kthread_should_stop()) {
 294		mutex_lock(&data->lock);
 295		adt7470_read_temperatures(data);
 296		mutex_unlock(&data->lock);
 297
 298		if (kthread_should_stop())
 299			break;
 300
 301		schedule_timeout_interruptible(msecs_to_jiffies(data->auto_update_interval));
 302	}
 303
 304	return 0;
 305}
 306
 307static int adt7470_update_sensors(struct adt7470_data *data)
 308{
 309	unsigned int val;
 310	int err;
 311	int i;
 312
 313	if (!data->temperatures_probed)
 314		err = adt7470_read_temperatures(data);
 315	else
 316		err = regmap_bulk_read(data->regmap, ADT7470_TEMP_REG(0), &data->temp[0],
 317				       ADT7470_TEMP_COUNT);
 318	if (err < 0)
 319		return err;
 320
 321	for (i = 0; i < ADT7470_FAN_COUNT; i++) {
 322		err = adt7470_read_word_data(data, ADT7470_REG_FAN(i), &val);
 323		if (err < 0)
 324			return err;
 325		data->fan[i] =	val;
 326	}
 327
 328	err = regmap_bulk_read(data->regmap, ADT7470_REG_PWM(0), &data->pwm[0], ADT7470_PWM_COUNT);
 329	if (err < 0)
 330		return err;
 331
 332	for (i = 0; i < ADT7470_PWM_COUNT; i++) {
 333		unsigned int mask;
 334
 335		if (i % 2)
 336			mask = ADT7470_PWM2_AUTO_MASK;
 337		else
 338			mask = ADT7470_PWM1_AUTO_MASK;
 339
 340		err = regmap_read(data->regmap, ADT7470_REG_PWM_CFG(i), &val);
 341		if (err < 0)
 342			return err;
 343		data->pwm_automatic[i] = !!(val & mask);
 344
 345		err = regmap_read(data->regmap, ADT7470_REG_PWM_AUTO_TEMP(i), &val);
 346		if (err < 0)
 347			return err;
 348		if (!(i % 2))
 349			data->pwm_auto_temp[i] = val >> 4;
 350		else
 351			data->pwm_auto_temp[i] = val & 0xF;
 352	}
 353
 354	err = regmap_read(data->regmap, ADT7470_REG_CFG, &val);
 355	if (err < 0)
 356		return err;
 357	data->force_pwm_max = !!(val & ADT7470_FSPD_MASK);
 358
 359	err = regmap_read(data->regmap, ADT7470_REG_ALARM1, &val);
 360	if (err < 0)
 361		return err;
 362	data->alarm = val;
 363	if (data->alarm & ADT7470_OOL_ALARM) {
 364		err = regmap_read(data->regmap, ADT7470_REG_ALARM2, &val);
 365		if (err < 0)
 366			return err;
 367		data->alarm |= ALARM2(val);
 368	}
 369
 370	err = adt7470_read_word_data(data, ADT7470_REG_ALARM1_MASK, &val);
 371	if (err < 0)
 372		return err;
 373	data->alarms_mask = val;
 374
 375	return 0;
 376}
 377
 378static int adt7470_update_limits(struct adt7470_data *data)
 379{
 380	unsigned int val;
 381	int err;
 382	int i;
 383
 384	for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
 385		err = regmap_read(data->regmap, ADT7470_TEMP_MIN_REG(i), &val);
 386		if (err < 0)
 387			return err;
 388		data->temp_min[i] = (s8)val;
 389		err = regmap_read(data->regmap, ADT7470_TEMP_MAX_REG(i), &val);
 390		if (err < 0)
 391			return err;
 392		data->temp_max[i] = (s8)val;
 393	}
 394
 395	for (i = 0; i < ADT7470_FAN_COUNT; i++) {
 396		err = adt7470_read_word_data(data, ADT7470_REG_FAN_MIN(i), &val);
 397		if (err < 0)
 398			return err;
 399		data->fan_min[i] = val;
 400		err = adt7470_read_word_data(data, ADT7470_REG_FAN_MAX(i), &val);
 401		if (err < 0)
 402			return err;
 403		data->fan_max[i] = val;
 404	}
 405
 406	for (i = 0; i < ADT7470_PWM_COUNT; i++) {
 407		err = regmap_read(data->regmap, ADT7470_REG_PWM_MAX(i), &val);
 408		if (err < 0)
 409			return err;
 410		data->pwm_max[i] = val;
 411		err = regmap_read(data->regmap, ADT7470_REG_PWM_MIN(i), &val);
 412		if (err < 0)
 413			return err;
 414		data->pwm_min[i] = val;
 415		err = regmap_read(data->regmap, ADT7470_REG_PWM_TMIN(i), &val);
 416		if (err < 0)
 417			return err;
 418		data->pwm_tmin[i] = (s8)val;
 419	}
 420
 421	return 0;
 422}
 423
 424static struct adt7470_data *adt7470_update_device(struct device *dev)
 425{
 426	struct adt7470_data *data = dev_get_drvdata(dev);
 427	unsigned long local_jiffies = jiffies;
 428	int need_sensors = 1;
 429	int need_limits = 1;
 430	int err;
 431
 432	/*
 433	 * Figure out if we need to update the shadow registers.
 434	 * Lockless means that we may occasionally report out of
 435	 * date data.
 436	 */
 437	if (time_before(local_jiffies, data->sensors_last_updated +
 438			SENSOR_REFRESH_INTERVAL) &&
 439	    data->sensors_valid)
 440		need_sensors = 0;
 441
 442	if (time_before(local_jiffies, data->limits_last_updated +
 443			LIMIT_REFRESH_INTERVAL) &&
 444	    data->limits_valid)
 445		need_limits = 0;
 446
 447	if (!need_sensors && !need_limits)
 448		return data;
 449
 450	mutex_lock(&data->lock);
 451	if (need_sensors) {
 452		err = adt7470_update_sensors(data);
 453		if (err < 0)
 454			goto out;
 455		data->sensors_last_updated = local_jiffies;
 456		data->sensors_valid = 1;
 457	}
 458
 459	if (need_limits) {
 460		err = adt7470_update_limits(data);
 461		if (err < 0)
 462			goto out;
 463		data->limits_last_updated = local_jiffies;
 464		data->limits_valid = 1;
 465	}
 466out:
 467	mutex_unlock(&data->lock);
 468
 469	return err < 0 ? ERR_PTR(err) : data;
 470}
 471
 472static ssize_t auto_update_interval_show(struct device *dev,
 473					 struct device_attribute *devattr,
 474					 char *buf)
 475{
 476	struct adt7470_data *data = adt7470_update_device(dev);
 477
 478	if (IS_ERR(data))
 479		return PTR_ERR(data);
 480
 481	return sprintf(buf, "%d\n", data->auto_update_interval);
 482}
 483
 484static ssize_t auto_update_interval_store(struct device *dev,
 485					  struct device_attribute *devattr,
 486					  const char *buf, size_t count)
 487{
 488	struct adt7470_data *data = dev_get_drvdata(dev);
 489	long temp;
 490
 491	if (kstrtol(buf, 10, &temp))
 492		return -EINVAL;
 493
 494	temp = clamp_val(temp, 0, 60000);
 495
 496	mutex_lock(&data->lock);
 497	data->auto_update_interval = temp;
 498	mutex_unlock(&data->lock);
 499
 500	return count;
 501}
 502
 503static ssize_t num_temp_sensors_show(struct device *dev,
 504				     struct device_attribute *devattr,
 505				     char *buf)
 506{
 507	struct adt7470_data *data = adt7470_update_device(dev);
 508
 509	if (IS_ERR(data))
 510		return PTR_ERR(data);
 511
 512	return sprintf(buf, "%d\n", data->num_temp_sensors);
 513}
 514
 515static ssize_t num_temp_sensors_store(struct device *dev,
 516				      struct device_attribute *devattr,
 517				      const char *buf, size_t count)
 518{
 519	struct adt7470_data *data = dev_get_drvdata(dev);
 520	long temp;
 521
 522	if (kstrtol(buf, 10, &temp))
 523		return -EINVAL;
 524
 525	temp = clamp_val(temp, -1, 10);
 526
 527	mutex_lock(&data->lock);
 528	data->num_temp_sensors = temp;
 529	if (temp < 0)
 530		data->temperatures_probed = 0;
 531	mutex_unlock(&data->lock);
 532
 533	return count;
 534}
 535
 536static int adt7470_temp_read(struct device *dev, u32 attr, int channel, long *val)
 537{
 538	struct adt7470_data *data = adt7470_update_device(dev);
 539
 540	if (IS_ERR(data))
 541		return PTR_ERR(data);
 542
 543	switch (attr) {
 544	case hwmon_temp_input:
 545		*val = 1000 * data->temp[channel];
 546		break;
 547	case hwmon_temp_min:
 548		*val = 1000 * data->temp_min[channel];
 549		break;
 550	case hwmon_temp_max:
 551		*val = 1000 * data->temp_max[channel];
 552		break;
 553	case hwmon_temp_alarm:
 554		*val = !!(data->alarm & channel);
 555		break;
 556	default:
 557		return -EOPNOTSUPP;
 558	}
 559
 560	return 0;
 561}
 562
 563static int adt7470_temp_write(struct device *dev, u32 attr, int channel, long val)
 564{
 565	struct adt7470_data *data = dev_get_drvdata(dev);
 566	int err;
 567
 568	val = clamp_val(val, -128000, 127000);
 569	val = DIV_ROUND_CLOSEST(val, 1000);
 570
 571	switch (attr) {
 572	case hwmon_temp_min:
 573		mutex_lock(&data->lock);
 574		data->temp_min[channel] = val;
 575		err = regmap_write(data->regmap, ADT7470_TEMP_MIN_REG(channel), val);
 576		mutex_unlock(&data->lock);
 577		break;
 578	case hwmon_temp_max:
 579		mutex_lock(&data->lock);
 580		data->temp_max[channel] = val;
 581		err = regmap_write(data->regmap, ADT7470_TEMP_MAX_REG(channel), val);
 582		mutex_unlock(&data->lock);
 583		break;
 584	default:
 585		return -EOPNOTSUPP;
 586	}
 587
 588	return err;
 589}
 590
 591static ssize_t alarm_mask_show(struct device *dev,
 592			       struct device_attribute *devattr, char *buf)
 593{
 594	struct adt7470_data *data = adt7470_update_device(dev);
 595
 596	if (IS_ERR(data))
 597		return PTR_ERR(data);
 598
 599	return sprintf(buf, "%x\n", data->alarms_mask);
 600}
 601
 602static ssize_t alarm_mask_store(struct device *dev,
 603				struct device_attribute *devattr,
 604				const char *buf, size_t count)
 605{
 606	struct adt7470_data *data = dev_get_drvdata(dev);
 607	long mask;
 608	int err;
 609
 610	if (kstrtoul(buf, 0, &mask))
 611		return -EINVAL;
 612
 613	if (mask & ~0xffff)
 614		return -EINVAL;
 615
 616	mutex_lock(&data->lock);
 617	data->alarms_mask = mask;
 618	err = adt7470_write_word_data(data, ADT7470_REG_ALARM1_MASK, mask);
 619	mutex_unlock(&data->lock);
 620
 621	return err < 0 ? err : count;
 622}
 623
 624static int adt7470_fan_read(struct device *dev, u32 attr, int channel, long *val)
 625{
 626	struct adt7470_data *data = adt7470_update_device(dev);
 627
 628	if (IS_ERR(data))
 629		return PTR_ERR(data);
 630
 631	switch (attr) {
 632	case hwmon_fan_input:
 633		if (FAN_DATA_VALID(data->fan[channel]))
 634			*val = FAN_PERIOD_TO_RPM(data->fan[channel]);
 635		else
 636			*val = 0;
 637		break;
 638	case hwmon_fan_min:
 639		if (FAN_DATA_VALID(data->fan_min[channel]))
 640			*val = FAN_PERIOD_TO_RPM(data->fan_min[channel]);
 641		else
 642			*val = 0;
 643		break;
 644	case hwmon_fan_max:
 645		if (FAN_DATA_VALID(data->fan_max[channel]))
 646			*val = FAN_PERIOD_TO_RPM(data->fan_max[channel]);
 647		else
 648			*val = 0;
 649		break;
 650	case hwmon_fan_alarm:
 651		*val = !!(data->alarm & (1 << (12 + channel)));
 652		break;
 653	default:
 654		return -EOPNOTSUPP;
 655	}
 656
 657	return 0;
 658}
 659
 660static int adt7470_fan_write(struct device *dev, u32 attr, int channel, long val)
 661{
 662	struct adt7470_data *data = dev_get_drvdata(dev);
 663	int err;
 664
 665	if (val <= 0)
 666		return -EINVAL;
 667
 668	val = FAN_RPM_TO_PERIOD(val);
 669	val = clamp_val(val, 1, 65534);
 670
 671	switch (attr) {
 672	case hwmon_fan_min:
 673		mutex_lock(&data->lock);
 674		data->fan_min[channel] = val;
 675		err = adt7470_write_word_data(data, ADT7470_REG_FAN_MIN(channel), val);
 676		mutex_unlock(&data->lock);
 677		break;
 678	case hwmon_fan_max:
 679		mutex_lock(&data->lock);
 680		data->fan_max[channel] = val;
 681		err = adt7470_write_word_data(data, ADT7470_REG_FAN_MAX(channel), val);
 682		mutex_unlock(&data->lock);
 683		break;
 684	default:
 685		return -EOPNOTSUPP;
 686	}
 687
 688	return err;
 689}
 690
 691static ssize_t force_pwm_max_show(struct device *dev,
 692				  struct device_attribute *devattr, char *buf)
 693{
 694	struct adt7470_data *data = adt7470_update_device(dev);
 695
 696	if (IS_ERR(data))
 697		return PTR_ERR(data);
 698
 699	return sprintf(buf, "%d\n", data->force_pwm_max);
 700}
 701
 702static ssize_t force_pwm_max_store(struct device *dev,
 703				   struct device_attribute *devattr,
 704				   const char *buf, size_t count)
 705{
 706	struct adt7470_data *data = dev_get_drvdata(dev);
 707	long temp;
 708	int err;
 709
 710	if (kstrtol(buf, 10, &temp))
 711		return -EINVAL;
 712
 713	mutex_lock(&data->lock);
 714	data->force_pwm_max = temp;
 715	err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
 716				 ADT7470_FSPD_MASK,
 717				 temp ? ADT7470_FSPD_MASK : 0);
 718	mutex_unlock(&data->lock);
 719
 720	return err < 0 ? err : count;
 721}
 722
 723/* These are the valid PWM frequencies to the nearest Hz */
 724static const int adt7470_freq_map[] = {
 725	11, 15, 22, 29, 35, 44, 59, 88, 1400, 22500
 726};
 727
 728static int pwm1_freq_get(struct device *dev)
 729{
 730	struct adt7470_data *data = dev_get_drvdata(dev);
 731	unsigned int regs[2] = {ADT7470_REG_CFG, ADT7470_REG_CFG_2};
 732	u8 cfg_reg[2];
 733	int index;
 734	int err;
 735
 736	err = regmap_multi_reg_read(data->regmap, regs, cfg_reg, 2);
 737	if (err)
 738		return err;
 739
 740	index = (cfg_reg[1] & ADT7470_FREQ_MASK) >> ADT7470_FREQ_SHIFT;
 741	if (!(cfg_reg[0] & ADT7470_CFG_LF))
 742		index += 8;
 743	if (index >= ARRAY_SIZE(adt7470_freq_map))
 744		index = ARRAY_SIZE(adt7470_freq_map) - 1;
 745
 746	return adt7470_freq_map[index];
 747}
 748
 749static int adt7470_pwm_read(struct device *dev, u32 attr, int channel, long *val)
 750{
 751	struct adt7470_data *data = adt7470_update_device(dev);
 752
 753	if (IS_ERR(data))
 754		return PTR_ERR(data);
 755
 756	switch (attr) {
 757	case hwmon_pwm_input:
 758		*val = data->pwm[channel];
 759		break;
 760	case hwmon_pwm_enable:
 761		*val = 1 + data->pwm_automatic[channel];
 762		break;
 763	case hwmon_pwm_freq:
 764		*val = pwm1_freq_get(dev);
 765		break;
 766	default:
 767		return -EOPNOTSUPP;
 768	}
 769
 770	return 0;
 771}
 772
 773static int pwm1_freq_set(struct device *dev, long freq)
 774{
 775	struct adt7470_data *data = dev_get_drvdata(dev);
 776	unsigned int low_freq = ADT7470_CFG_LF;
 777	int index;
 778	int err;
 779
 780	/* Round the user value given to the closest available frequency */
 781	index = find_closest(freq, adt7470_freq_map,
 782			     ARRAY_SIZE(adt7470_freq_map));
 783
 784	if (index >= 8) {
 785		index -= 8;
 786		low_freq = 0;
 787	}
 788
 789	mutex_lock(&data->lock);
 790	/* Configuration Register 1 */
 791	err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
 792				 ADT7470_CFG_LF, low_freq);
 793	if (err < 0)
 794		goto out;
 795
 796	/* Configuration Register 2 */
 797	err = regmap_update_bits(data->regmap, ADT7470_REG_CFG_2,
 798				 ADT7470_FREQ_MASK,
 799				 index << ADT7470_FREQ_SHIFT);
 800out:
 801	mutex_unlock(&data->lock);
 802
 803	return err;
 804}
 805
 806static int adt7470_pwm_write(struct device *dev, u32 attr, int channel, long val)
 807{
 808	struct adt7470_data *data = dev_get_drvdata(dev);
 809	unsigned int pwm_auto_reg_mask;
 810	int err;
 811
 812	switch (attr) {
 813	case hwmon_pwm_input:
 814		val = clamp_val(val, 0, 255);
 815		mutex_lock(&data->lock);
 816		data->pwm[channel] = val;
 817		err = regmap_write(data->regmap, ADT7470_REG_PWM(channel),
 818				   data->pwm[channel]);
 819		mutex_unlock(&data->lock);
 820		break;
 821	case hwmon_pwm_enable:
 822		if (channel % 2)
 823			pwm_auto_reg_mask = ADT7470_PWM2_AUTO_MASK;
 824		else
 825			pwm_auto_reg_mask = ADT7470_PWM1_AUTO_MASK;
 826
 827		if (val != 2 && val != 1)
 828			return -EINVAL;
 829		val--;
 830
 831		mutex_lock(&data->lock);
 832		data->pwm_automatic[channel] = val;
 833		err = regmap_update_bits(data->regmap, ADT7470_REG_PWM_CFG(channel),
 834					 pwm_auto_reg_mask,
 835					 val ? pwm_auto_reg_mask : 0);
 836		mutex_unlock(&data->lock);
 837		break;
 838	case hwmon_pwm_freq:
 839		err = pwm1_freq_set(dev, val);
 840		break;
 841	default:
 842		return -EOPNOTSUPP;
 843	}
 844
 845	return err;
 846}
 847
 848static ssize_t pwm_max_show(struct device *dev,
 849			    struct device_attribute *devattr, char *buf)
 850{
 851	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 852	struct adt7470_data *data = adt7470_update_device(dev);
 853
 854	if (IS_ERR(data))
 855		return PTR_ERR(data);
 856
 857	return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
 858}
 859
 860static ssize_t pwm_max_store(struct device *dev,
 861			     struct device_attribute *devattr,
 862			     const char *buf, size_t count)
 863{
 864	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 865	struct adt7470_data *data = dev_get_drvdata(dev);
 866	long temp;
 867	int err;
 868
 869	if (kstrtol(buf, 10, &temp))
 870		return -EINVAL;
 871
 872	temp = clamp_val(temp, 0, 255);
 873
 874	mutex_lock(&data->lock);
 875	data->pwm_max[attr->index] = temp;
 876	err = regmap_write(data->regmap, ADT7470_REG_PWM_MAX(attr->index),
 877			   temp);
 878	mutex_unlock(&data->lock);
 879
 880	return err < 0 ? err : count;
 881}
 882
 883static ssize_t pwm_min_show(struct device *dev,
 884			    struct device_attribute *devattr, char *buf)
 885{
 886	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 887	struct adt7470_data *data = adt7470_update_device(dev);
 888
 889	if (IS_ERR(data))
 890		return PTR_ERR(data);
 891
 892	return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
 893}
 894
 895static ssize_t pwm_min_store(struct device *dev,
 896			     struct device_attribute *devattr,
 897			     const char *buf, size_t count)
 898{
 899	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 900	struct adt7470_data *data = dev_get_drvdata(dev);
 901	long temp;
 902	int err;
 903
 904	if (kstrtol(buf, 10, &temp))
 905		return -EINVAL;
 906
 907	temp = clamp_val(temp, 0, 255);
 908
 909	mutex_lock(&data->lock);
 910	data->pwm_min[attr->index] = temp;
 911	err = regmap_write(data->regmap, ADT7470_REG_PWM_MIN(attr->index),
 912			   temp);
 913	mutex_unlock(&data->lock);
 914
 915	return err < 0 ? err : count;
 916}
 917
 918static ssize_t pwm_tmax_show(struct device *dev,
 919			     struct device_attribute *devattr, char *buf)
 920{
 921	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 922	struct adt7470_data *data = adt7470_update_device(dev);
 923
 924	if (IS_ERR(data))
 925		return PTR_ERR(data);
 926
 927	/* the datasheet says that tmax = tmin + 20C */
 928	return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
 929}
 930
 931static ssize_t pwm_tmin_show(struct device *dev,
 932			     struct device_attribute *devattr, char *buf)
 933{
 934	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 935	struct adt7470_data *data = adt7470_update_device(dev);
 936
 937	if (IS_ERR(data))
 938		return PTR_ERR(data);
 939
 940	return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
 941}
 942
 943static ssize_t pwm_tmin_store(struct device *dev,
 944			      struct device_attribute *devattr,
 945			      const char *buf, size_t count)
 946{
 947	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 948	struct adt7470_data *data = dev_get_drvdata(dev);
 949	long temp;
 950	int err;
 951
 952	if (kstrtol(buf, 10, &temp))
 953		return -EINVAL;
 954
 955	temp = clamp_val(temp, -128000, 127000);
 956	temp = DIV_ROUND_CLOSEST(temp, 1000);
 957
 958	mutex_lock(&data->lock);
 959	data->pwm_tmin[attr->index] = temp;
 960	err = regmap_write(data->regmap, ADT7470_REG_PWM_TMIN(attr->index),
 961			   temp);
 962	mutex_unlock(&data->lock);
 963
 964	return err < 0 ? err : count;
 965}
 966
 967static ssize_t pwm_auto_temp_show(struct device *dev,
 968				  struct device_attribute *devattr, char *buf)
 969{
 970	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 971	struct adt7470_data *data = adt7470_update_device(dev);
 972	u8 ctrl;
 973
 974	if (IS_ERR(data))
 975		return PTR_ERR(data);
 976
 977	ctrl = data->pwm_auto_temp[attr->index];
 978	if (ctrl)
 979		return sprintf(buf, "%d\n", 1 << (ctrl - 1));
 980	else
 981		return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
 982}
 983
 984static int cvt_auto_temp(int input)
 985{
 986	if (input == ADT7470_PWM_ALL_TEMPS)
 987		return 0;
 988	if (input < 1 || !is_power_of_2(input))
 989		return -EINVAL;
 990	return ilog2(input) + 1;
 991}
 992
 993static ssize_t pwm_auto_temp_store(struct device *dev,
 994				   struct device_attribute *devattr,
 995				   const char *buf, size_t count)
 996{
 997	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 998	struct adt7470_data *data = dev_get_drvdata(dev);
 999	int pwm_auto_reg = ADT7470_REG_PWM_AUTO_TEMP(attr->index);
1000	unsigned int mask, val;
1001	long temp;
1002	int err;
1003
1004	if (kstrtol(buf, 10, &temp))
1005		return -EINVAL;
1006
1007	temp = cvt_auto_temp(temp);
1008	if (temp < 0)
1009		return temp;
1010
1011	mutex_lock(&data->lock);
1012	data->pwm_automatic[attr->index] = temp;
1013
1014	if (!(attr->index % 2)) {
1015		mask = 0xF0;
1016		val = (temp << 4) & 0xF0;
1017	} else {
1018		mask = 0x0F;
1019		val = temp & 0x0F;
1020	}
1021
1022	err = regmap_update_bits(data->regmap, pwm_auto_reg, mask, val);
1023	mutex_unlock(&data->lock);
1024
1025	return err < 0 ? err : count;
1026}
1027
1028static DEVICE_ATTR_RW(alarm_mask);
1029static DEVICE_ATTR_RW(num_temp_sensors);
1030static DEVICE_ATTR_RW(auto_update_interval);
1031
1032static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0);
1033
1034static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0);
1035static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1);
1036static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2);
1037static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3);
1038
1039static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0);
1040static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1);
1041static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2);
1042static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3);
1043
1044static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp, pwm_tmin, 0);
1045static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_temp, pwm_tmin, 1);
1046static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_temp, pwm_tmin, 2);
1047static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_temp, pwm_tmin, 3);
1048
1049static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_temp, pwm_tmax, 0);
1050static SENSOR_DEVICE_ATTR_RO(pwm2_auto_point2_temp, pwm_tmax, 1);
1051static SENSOR_DEVICE_ATTR_RO(pwm3_auto_point2_temp, pwm_tmax, 2);
1052static SENSOR_DEVICE_ATTR_RO(pwm4_auto_point2_temp, pwm_tmax, 3);
1053
1054static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0);
1055static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1);
1056static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2);
1057static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3);
1058
1059static struct attribute *adt7470_attrs[] = {
1060	&dev_attr_alarm_mask.attr,
1061	&dev_attr_num_temp_sensors.attr,
1062	&dev_attr_auto_update_interval.attr,
1063	&sensor_dev_attr_force_pwm_max.dev_attr.attr,
1064	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1065	&sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1066	&sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1067	&sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1068	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1069	&sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1070	&sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1071	&sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1072	&sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
1073	&sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
1074	&sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
1075	&sensor_dev_attr_pwm4_auto_point1_temp.dev_attr.attr,
1076	&sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
1077	&sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
1078	&sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
1079	&sensor_dev_attr_pwm4_auto_point2_temp.dev_attr.attr,
1080	&sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1081	&sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1082	&sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1083	&sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1084	NULL
1085};
1086
1087ATTRIBUTE_GROUPS(adt7470);
1088
1089static int adt7470_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
1090			int channel, long *val)
1091{
1092	switch (type) {
1093	case hwmon_temp:
1094		return adt7470_temp_read(dev, attr, channel, val);
1095	case hwmon_fan:
1096		return adt7470_fan_read(dev, attr, channel, val);
1097	case hwmon_pwm:
1098		return adt7470_pwm_read(dev, attr, channel, val);
1099	default:
1100		return -EOPNOTSUPP;
1101	}
1102}
1103
1104static int adt7470_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
1105			 int channel, long val)
1106{
1107	switch (type) {
1108	case hwmon_temp:
1109		return adt7470_temp_write(dev, attr, channel, val);
1110	case hwmon_fan:
1111		return adt7470_fan_write(dev, attr, channel, val);
1112	case hwmon_pwm:
1113		return adt7470_pwm_write(dev, attr, channel, val);
1114	default:
1115		return -EOPNOTSUPP;
1116	}
1117}
1118
1119static umode_t adt7470_is_visible(const void *_data, enum hwmon_sensor_types type,
1120				  u32 attr, int channel)
1121{
1122	umode_t mode = 0;
1123
1124	switch (type) {
1125	case hwmon_temp:
1126		switch (attr) {
1127		case hwmon_temp:
1128		case hwmon_temp_alarm:
1129			mode = 0444;
1130			break;
1131		case hwmon_temp_min:
1132		case hwmon_temp_max:
1133			mode = 0644;
1134			break;
1135		default:
1136			break;
1137		}
1138		break;
1139	case hwmon_fan:
1140		switch (attr) {
1141		case hwmon_fan_input:
1142		case hwmon_fan_alarm:
1143			mode = 0444;
1144			break;
1145		case hwmon_fan_min:
1146		case hwmon_fan_max:
1147			mode = 0644;
1148			break;
1149		default:
1150			break;
1151		}
1152		break;
1153	case hwmon_pwm:
1154		switch (attr) {
1155		case hwmon_pwm_input:
1156		case hwmon_pwm_enable:
1157			mode = 0644;
1158			break;
1159		case hwmon_pwm_freq:
1160			if (channel == 0)
1161				mode = 0644;
1162			else
1163				mode = 0;
1164			break;
1165		default:
1166			break;
1167		}
1168		break;
1169	default:
1170		break;
1171	}
1172
1173	return mode;
1174}
1175
1176static const struct hwmon_ops adt7470_hwmon_ops = {
1177	.is_visible = adt7470_is_visible,
1178	.read = adt7470_read,
1179	.write = adt7470_write,
1180};
1181
1182static const struct hwmon_channel_info * const adt7470_info[] = {
1183	HWMON_CHANNEL_INFO(temp,
1184			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1185			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1186			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1187			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1188			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1189			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1190			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1191			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1192			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM,
1193			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | HWMON_T_ALARM),
1194	HWMON_CHANNEL_INFO(fan,
1195			   HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,
1196			   HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,
1197			   HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM,
1198			   HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX | HWMON_F_DIV | HWMON_F_ALARM),
1199	HWMON_CHANNEL_INFO(pwm,
1200			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE | HWMON_PWM_FREQ,
1201			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
1202			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
1203			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
1204	NULL
1205};
1206
1207static const struct hwmon_chip_info adt7470_chip_info = {
1208	.ops = &adt7470_hwmon_ops,
1209	.info = adt7470_info,
1210};
1211
1212/* Return 0 if detection is successful, -ENODEV otherwise */
1213static int adt7470_detect(struct i2c_client *client,
1214			  struct i2c_board_info *info)
1215{
1216	struct i2c_adapter *adapter = client->adapter;
1217	int vendor, device, revision;
1218
1219	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1220		return -ENODEV;
1221
1222	vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
1223	if (vendor != ADT7470_VENDOR)
1224		return -ENODEV;
1225
1226	device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
1227	if (device != ADT7470_DEVICE)
1228		return -ENODEV;
1229
1230	revision = i2c_smbus_read_byte_data(client, ADT7470_REG_REVISION);
1231	if (revision != ADT7470_REVISION)
1232		return -ENODEV;
1233
1234	strscpy(info->type, "adt7470", I2C_NAME_SIZE);
1235
1236	return 0;
1237}
1238
1239static const struct regmap_config adt7470_regmap_config = {
1240	.reg_bits = 8,
1241	.val_bits = 8,
1242	.use_single_read = true,
1243	.use_single_write = true,
1244};
1245
1246static int adt7470_probe(struct i2c_client *client)
1247{
1248	struct device *dev = &client->dev;
1249	struct adt7470_data *data;
1250	struct device *hwmon_dev;
1251	int err;
1252
1253	data = devm_kzalloc(dev, sizeof(struct adt7470_data), GFP_KERNEL);
1254	if (!data)
1255		return -ENOMEM;
1256
1257	data->num_temp_sensors = -1;
1258	data->auto_update_interval = AUTO_UPDATE_INTERVAL;
1259	data->regmap = devm_regmap_init_i2c(client, &adt7470_regmap_config);
1260	if (IS_ERR(data->regmap))
1261		return PTR_ERR(data->regmap);
1262
1263	i2c_set_clientdata(client, data);
1264	mutex_init(&data->lock);
1265
1266	dev_info(&client->dev, "%s chip found\n", client->name);
1267
1268	/* Initialize the ADT7470 chip */
1269	err = regmap_update_bits(data->regmap, ADT7470_REG_CFG,
1270				 ADT7470_STRT_MASK | ADT7470_TEST_MASK,
1271				 ADT7470_STRT_MASK | ADT7470_TEST_MASK);
1272	if (err < 0)
1273		return err;
1274
1275	/* Register sysfs hooks */
1276	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,
1277							 &adt7470_chip_info,
1278							 adt7470_groups);
1279
1280	if (IS_ERR(hwmon_dev))
1281		return PTR_ERR(hwmon_dev);
1282
1283	data->auto_update = kthread_run(adt7470_update_thread, client, "%s",
1284					dev_name(hwmon_dev));
1285	if (IS_ERR(data->auto_update))
1286		return PTR_ERR(data->auto_update);
1287
1288	return 0;
1289}
1290
1291static void adt7470_remove(struct i2c_client *client)
1292{
1293	struct adt7470_data *data = i2c_get_clientdata(client);
1294
1295	kthread_stop(data->auto_update);
1296}
1297
1298static const struct i2c_device_id adt7470_id[] = {
1299	{ "adt7470" },
1300	{ }
1301};
1302MODULE_DEVICE_TABLE(i2c, adt7470_id);
1303
1304static struct i2c_driver adt7470_driver = {
1305	.class		= I2C_CLASS_HWMON,
1306	.driver = {
1307		.name	= "adt7470",
1308	},
1309	.probe		= adt7470_probe,
1310	.remove		= adt7470_remove,
1311	.id_table	= adt7470_id,
1312	.detect		= adt7470_detect,
1313	.address_list	= normal_i2c,
1314};
1315
1316module_i2c_driver(adt7470_driver);
1317
1318MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1319MODULE_DESCRIPTION("ADT7470 driver");
1320MODULE_LICENSE("GPL");