amc6821.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * amc6821.c - Part of lm_sensors, Linux kernel modules for hardware
   4 *	       monitoring
   5 * Copyright (C) 2009 T. Mertelj <tomaz.mertelj@guest.arnes.si>
   6 *
   7 * Based on max6650.c:
   8 * Copyright (C) 2007 Hans J. Koch <hjk@hansjkoch.de>
   9 *
  10 * Conversion to regmap and with_info API:
  11 * Copyright (C) 2024 Guenter Roeck <linux@roeck-us.net>
  12 */
  13
  14#include <linux/bitfield.h>
  15#include <linux/bitops.h>
  16#include <linux/bits.h>
  17#include <linux/err.h>
  18#include <linux/hwmon.h>
  19#include <linux/hwmon-sysfs.h>
  20#include <linux/i2c.h>
  21#include <linux/init.h>
  22#include <linux/minmax.h>
  23#include <linux/module.h>
  24#include <linux/mutex.h>
  25#include <linux/of_platform.h>
  26#include <linux/pwm.h>
  27#include <linux/regmap.h>
  28#include <linux/slab.h>
  29#include <linux/thermal.h>
  30
  31#include <dt-bindings/pwm/pwm.h>
  32
  33/*
  34 * Addresses to scan.
  35 */
  36
  37static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e,
  38	0x4c, 0x4d, 0x4e, I2C_CLIENT_END};
  39
  40/*
  41 * Insmod parameters
  42 */
  43
  44static int pwminv = -1; /*Inverted PWM output. */
  45module_param(pwminv, int, 0444);
  46
  47static int init = 1; /*Power-on initialization.*/
  48module_param(init, int, 0444);
  49
  50#define AMC6821_REG_DEV_ID		0x3D
  51#define AMC6821_REG_COMP_ID		0x3E
  52#define AMC6821_REG_CONF1		0x00
  53#define AMC6821_REG_CONF2		0x01
  54#define AMC6821_REG_CONF3		0x3F
  55#define AMC6821_REG_CONF4		0x04
  56#define AMC6821_REG_STAT1		0x02
  57#define AMC6821_REG_STAT2		0x03
  58#define AMC6821_REG_TEMP_LO		0x06
  59#define AMC6821_REG_TDATA_LOW		0x08
  60#define AMC6821_REG_TDATA_HI		0x09
  61#define AMC6821_REG_LTEMP_HI		0x0A
  62#define AMC6821_REG_RTEMP_HI		0x0B
  63#define AMC6821_REG_LTEMP_LIMIT_MIN	0x15
  64#define AMC6821_REG_LTEMP_LIMIT_MAX	0x14
  65#define AMC6821_REG_RTEMP_LIMIT_MIN	0x19
  66#define AMC6821_REG_RTEMP_LIMIT_MAX	0x18
  67#define AMC6821_REG_LTEMP_CRIT		0x1B
  68#define AMC6821_REG_RTEMP_CRIT		0x1D
  69#define AMC6821_REG_PSV_TEMP		0x1C
  70#define AMC6821_REG_DCY			0x22
  71#define AMC6821_REG_LTEMP_FAN_CTRL	0x24
  72#define AMC6821_REG_RTEMP_FAN_CTRL	0x25
  73#define AMC6821_REG_DCY_LOW_TEMP	0x21
  74
  75#define AMC6821_REG_TACH_LLIMITL	0x10
  76#define AMC6821_REG_TACH_HLIMITL	0x12
  77#define AMC6821_REG_TACH_SETTINGL	0x1e
  78
  79#define AMC6821_CONF1_START		BIT(0)
  80#define AMC6821_CONF1_FAN_INT_EN	BIT(1)
  81#define AMC6821_CONF1_FANIE		BIT(2)
  82#define AMC6821_CONF1_PWMINV		BIT(3)
  83#define AMC6821_CONF1_FAN_FAULT_EN	BIT(4)
  84#define AMC6821_CONF1_FDRC0		BIT(5)
  85#define AMC6821_CONF1_FDRC1		BIT(6)
  86#define AMC6821_CONF1_THERMOVIE		BIT(7)
  87
  88#define AMC6821_CONF2_PWM_EN		BIT(0)
  89#define AMC6821_CONF2_TACH_MODE		BIT(1)
  90#define AMC6821_CONF2_TACH_EN		BIT(2)
  91#define AMC6821_CONF2_RTFIE		BIT(3)
  92#define AMC6821_CONF2_LTOIE		BIT(4)
  93#define AMC6821_CONF2_RTOIE		BIT(5)
  94#define AMC6821_CONF2_PSVIE		BIT(6)
  95#define AMC6821_CONF2_RST		BIT(7)
  96
  97#define AMC6821_CONF3_THERM_FAN_EN	BIT(7)
  98#define AMC6821_CONF3_REV_MASK		GENMASK(3, 0)
  99
 100#define AMC6821_CONF4_OVREN		BIT(4)
 101#define AMC6821_CONF4_TACH_FAST		BIT(5)
 102#define AMC6821_CONF4_PSPR		BIT(6)
 103#define AMC6821_CONF4_MODE		BIT(7)
 104
 105#define AMC6821_STAT1_RPM_ALARM		BIT(0)
 106#define AMC6821_STAT1_FANS		BIT(1)
 107#define AMC6821_STAT1_RTH		BIT(2)
 108#define AMC6821_STAT1_RTL		BIT(3)
 109#define AMC6821_STAT1_R_THERM		BIT(4)
 110#define AMC6821_STAT1_RTF		BIT(5)
 111#define AMC6821_STAT1_LTH		BIT(6)
 112#define AMC6821_STAT1_LTL		BIT(7)
 113
 114#define AMC6821_STAT2_RTC		BIT(3)
 115#define AMC6821_STAT2_LTC		BIT(4)
 116#define AMC6821_STAT2_LPSV		BIT(5)
 117#define AMC6821_STAT2_L_THERM		BIT(6)
 118#define AMC6821_STAT2_THERM_IN		BIT(7)
 119
 120#define AMC6821_TEMP_SLOPE_MASK		GENMASK(2, 0)
 121#define AMC6821_TEMP_LIMIT_MASK		GENMASK(7, 3)
 122
 123/*
 124 * Client data (each client gets its own)
 125 */
 126
 127struct amc6821_data {
 128	struct regmap *regmap;
 129	struct mutex update_lock;
 130	unsigned long fan_state;
 131	unsigned long fan_max_state;
 132	unsigned int *fan_cooling_levels;
 133	enum pwm_polarity pwm_polarity;
 134};
 135
 136/*
 137 * Return 0 on success or negative error code.
 138 *
 139 * temps returns set of three temperatures, in °C:
 140 * temps[0]: Passive cooling temperature, applies to both channels
 141 * temps[1]: Low temperature, start slope calculations
 142 * temps[2]: High temperature
 143 *
 144 * Channel 0: local, channel 1: remote.
 145 */
 146static int amc6821_get_auto_point_temps(struct regmap *regmap, int channel, u8 *temps)
 147{
 148	u32 regs[] = {
 149		AMC6821_REG_DCY_LOW_TEMP,
 150		AMC6821_REG_PSV_TEMP,
 151		channel ? AMC6821_REG_RTEMP_FAN_CTRL : AMC6821_REG_LTEMP_FAN_CTRL
 152	};
 153	u8 regvals[3];
 154	int slope;
 155	int err;
 156
 157	err = regmap_multi_reg_read(regmap, regs, regvals, 3);
 158	if (err)
 159		return err;
 160	temps[0] = regvals[1];
 161	temps[1] = FIELD_GET(AMC6821_TEMP_LIMIT_MASK, regvals[2]) * 4;
 162
 163	/* slope is 32 >> <slope bits> in °C */
 164	slope = 32 >> FIELD_GET(AMC6821_TEMP_SLOPE_MASK, regvals[2]);
 165	if (slope)
 166		temps[2] = temps[1] + DIV_ROUND_CLOSEST(255 - regvals[0], slope);
 167	else
 168		temps[2] = 255;
 169
 170	return 0;
 171}
 172
 173static int amc6821_temp_read_values(struct regmap *regmap, u32 attr, int channel, long *val)
 174{
 175	int reg, err;
 176	u32 regval;
 177
 178	switch (attr) {
 179	case hwmon_temp_input:
 180		reg = channel ? AMC6821_REG_RTEMP_HI : AMC6821_REG_LTEMP_HI;
 181		break;
 182	case hwmon_temp_min:
 183		reg = channel ? AMC6821_REG_RTEMP_LIMIT_MIN : AMC6821_REG_LTEMP_LIMIT_MIN;
 184		break;
 185	case hwmon_temp_max:
 186		reg = channel ? AMC6821_REG_RTEMP_LIMIT_MAX : AMC6821_REG_LTEMP_LIMIT_MAX;
 187		break;
 188	case hwmon_temp_crit:
 189		reg = channel ? AMC6821_REG_RTEMP_CRIT : AMC6821_REG_LTEMP_CRIT;
 190		break;
 191	default:
 192		return -EOPNOTSUPP;
 193	}
 194	err = regmap_read(regmap, reg, &regval);
 195	if (err)
 196		return err;
 197	*val = sign_extend32(regval, 7) * 1000;
 198	return 0;
 199}
 200
 201static int amc6821_read_alarms(struct regmap *regmap, enum hwmon_sensor_types type,
 202			       u32 attr, int channel, long *val)
 203{
 204	int reg, mask, err;
 205	u32 regval;
 206
 207	switch (type) {
 208	case hwmon_temp:
 209		switch (attr) {
 210		case hwmon_temp_min_alarm:
 211			reg = AMC6821_REG_STAT1;
 212			mask = channel ? AMC6821_STAT1_RTL : AMC6821_STAT1_LTL;
 213			break;
 214		case hwmon_temp_max_alarm:
 215			reg = AMC6821_REG_STAT1;
 216			mask = channel ? AMC6821_STAT1_RTH : AMC6821_STAT1_LTH;
 217			break;
 218		case hwmon_temp_crit_alarm:
 219			reg = AMC6821_REG_STAT2;
 220			mask = channel ? AMC6821_STAT2_RTC : AMC6821_STAT2_LTC;
 221			break;
 222		case hwmon_temp_fault:
 223			reg = AMC6821_REG_STAT1;
 224			mask = AMC6821_STAT1_RTF;
 225			break;
 226		default:
 227			return -EOPNOTSUPP;
 228		}
 229		break;
 230	case hwmon_fan:
 231		switch (attr) {
 232		case hwmon_fan_fault:
 233			reg = AMC6821_REG_STAT1;
 234			mask = AMC6821_STAT1_FANS;
 235			break;
 236		default:
 237			return -EOPNOTSUPP;
 238		}
 239		break;
 240	default:
 241		return -EOPNOTSUPP;
 242	}
 243	err = regmap_read(regmap, reg, &regval);
 244	if (err)
 245		return err;
 246	*val = !!(regval & mask);
 247	return 0;
 248}
 249
 250static int amc6821_temp_read(struct device *dev, u32 attr, int channel, long *val)
 251{
 252	struct amc6821_data *data = dev_get_drvdata(dev);
 253
 254	switch (attr) {
 255	case hwmon_temp_input:
 256	case hwmon_temp_min:
 257	case hwmon_temp_max:
 258	case hwmon_temp_crit:
 259		return amc6821_temp_read_values(data->regmap, attr, channel, val);
 260	case hwmon_temp_min_alarm:
 261	case hwmon_temp_max_alarm:
 262	case hwmon_temp_crit_alarm:
 263	case hwmon_temp_fault:
 264		return amc6821_read_alarms(data->regmap, hwmon_temp, attr, channel, val);
 265	default:
 266		return -EOPNOTSUPP;
 267	}
 268}
 269
 270static int amc6821_temp_write(struct device *dev, u32 attr, int channel, long val)
 271{
 272	struct amc6821_data *data = dev_get_drvdata(dev);
 273	int reg;
 274
 275	val = DIV_ROUND_CLOSEST(clamp_val(val, -128000, 127000), 1000);
 276
 277	switch (attr) {
 278	case hwmon_temp_min:
 279		reg = channel ? AMC6821_REG_RTEMP_LIMIT_MIN : AMC6821_REG_LTEMP_LIMIT_MIN;
 280		break;
 281	case hwmon_temp_max:
 282		reg = channel ? AMC6821_REG_RTEMP_LIMIT_MAX : AMC6821_REG_LTEMP_LIMIT_MAX;
 283		break;
 284	case hwmon_temp_crit:
 285		reg = channel ? AMC6821_REG_RTEMP_CRIT : AMC6821_REG_LTEMP_CRIT;
 286		break;
 287	default:
 288		return -EOPNOTSUPP;
 289	}
 290	return regmap_write(data->regmap, reg, val);
 291}
 292
 293static int amc6821_pwm_read(struct device *dev, u32 attr, long *val)
 294{
 295	struct amc6821_data *data = dev_get_drvdata(dev);
 296	struct regmap *regmap = data->regmap;
 297	u32 regval;
 298	int err;
 299
 300	switch (attr) {
 301	case hwmon_pwm_enable:
 302		err = regmap_read(regmap, AMC6821_REG_CONF1, &regval);
 303		if (err)
 304			return err;
 305		switch (regval & (AMC6821_CONF1_FDRC0 | AMC6821_CONF1_FDRC1)) {
 306		case 0:
 307			*val = 1;	/* manual */
 308			break;
 309		case AMC6821_CONF1_FDRC0:
 310			*val = 4;	/* target rpm (fan1_target) controlled */
 311			break;
 312		case AMC6821_CONF1_FDRC1:
 313			*val = 2;	/* remote temp controlled */
 314			break;
 315		default:
 316			*val = 3;	/* max(local, remote) temp controlled */
 317			break;
 318		}
 319		return 0;
 320	case hwmon_pwm_mode:
 321		err = regmap_read(regmap, AMC6821_REG_CONF2, &regval);
 322		if (err)
 323			return err;
 324		*val = !!(regval & AMC6821_CONF2_TACH_MODE);
 325		return 0;
 326	case hwmon_pwm_auto_channels_temp:
 327		err = regmap_read(regmap, AMC6821_REG_CONF1, &regval);
 328		if (err)
 329			return err;
 330		switch (regval & (AMC6821_CONF1_FDRC0 | AMC6821_CONF1_FDRC1)) {
 331		case 0:
 332		case AMC6821_CONF1_FDRC0:
 333			*val = 0;	/* manual or target rpm controlled */
 334			break;
 335		case AMC6821_CONF1_FDRC1:
 336			*val = 2;	/* remote temp controlled */
 337			break;
 338		default:
 339			*val = 3;	/* max(local, remote) temp controlled */
 340			break;
 341		}
 342		return 0;
 343	case hwmon_pwm_input:
 344		err = regmap_read(regmap, AMC6821_REG_DCY, &regval);
 345		if (err)
 346			return err;
 347		*val = regval;
 348		return 0;
 349	default:
 350		return -EOPNOTSUPP;
 351	}
 352}
 353
 354static int amc6821_pwm_write(struct device *dev, u32 attr, long val)
 355{
 356	struct amc6821_data *data = dev_get_drvdata(dev);
 357	struct regmap *regmap = data->regmap;
 358	u32 mode;
 359
 360	switch (attr) {
 361	case hwmon_pwm_enable:
 362		switch (val) {
 363		case 1:
 364			mode = 0;
 365			break;
 366		case 2:
 367			mode = AMC6821_CONF1_FDRC1;
 368			break;
 369		case 3:
 370			mode = AMC6821_CONF1_FDRC0 | AMC6821_CONF1_FDRC1;
 371			break;
 372		case 4:
 373			mode = AMC6821_CONF1_FDRC0;
 374			break;
 375		default:
 376			return -EINVAL;
 377		}
 378		return regmap_update_bits(regmap, AMC6821_REG_CONF1,
 379					  AMC6821_CONF1_FDRC0 | AMC6821_CONF1_FDRC1,
 380					  mode);
 381	case hwmon_pwm_mode:
 382		if (val < 0 || val > 1)
 383			return -EINVAL;
 384		return regmap_update_bits(regmap, AMC6821_REG_CONF2,
 385					  AMC6821_CONF2_TACH_MODE,
 386					  val ? AMC6821_CONF2_TACH_MODE : 0);
 387		break;
 388	case hwmon_pwm_input:
 389		if (val < 0 || val > 255)
 390			return -EINVAL;
 391		return regmap_write(regmap, AMC6821_REG_DCY, val);
 392	default:
 393		return -EOPNOTSUPP;
 394	}
 395}
 396
 397static int amc6821_fan_read_rpm(struct regmap *regmap, u32 attr, long *val)
 398{
 399	int reg, err;
 400	u8 regs[2];
 401	u32 regval;
 402
 403	switch (attr) {
 404	case hwmon_fan_input:
 405		reg = AMC6821_REG_TDATA_LOW;
 406		break;
 407	case hwmon_fan_min:
 408		reg = AMC6821_REG_TACH_LLIMITL;
 409		break;
 410	case hwmon_fan_max:
 411		reg = AMC6821_REG_TACH_HLIMITL;
 412		break;
 413	case hwmon_fan_target:
 414		reg = AMC6821_REG_TACH_SETTINGL;
 415		break;
 416	default:
 417		return -EOPNOTSUPP;
 418	}
 419
 420	err = regmap_bulk_read(regmap, reg, regs, 2);
 421	if (err)
 422		return err;
 423
 424	regval = (regs[1] << 8) | regs[0];
 425	*val = regval ? 6000000 / regval : 0;
 426
 427	return 0;
 428}
 429
 430static int amc6821_fan_read(struct device *dev, u32 attr, long *val)
 431{
 432	struct amc6821_data *data = dev_get_drvdata(dev);
 433	struct regmap *regmap = data->regmap;
 434	u32 regval;
 435	int err;
 436
 437	switch (attr) {
 438	case hwmon_fan_input:
 439	case hwmon_fan_min:
 440	case hwmon_fan_max:
 441	case hwmon_fan_target:
 442		return amc6821_fan_read_rpm(regmap, attr, val);
 443	case hwmon_fan_fault:
 444		return amc6821_read_alarms(regmap, hwmon_fan, attr, 0, val);
 445	case hwmon_fan_pulses:
 446		err = regmap_read(regmap, AMC6821_REG_CONF4, &regval);
 447		if (err)
 448			return err;
 449		*val = (regval & AMC6821_CONF4_PSPR) ? 4 : 2;
 450		return 0;
 451	default:
 452		return -EOPNOTSUPP;
 453	}
 454}
 455
 456static int amc6821_fan_write(struct device *dev, u32 attr, long val)
 457{
 458	struct amc6821_data *data = dev_get_drvdata(dev);
 459	struct regmap *regmap = data->regmap;
 460	u8 regs[2];
 461	int reg;
 462
 463	if (attr == hwmon_fan_pulses) {
 464		if (val != 2 && val != 4)
 465			return -EINVAL;
 466		return regmap_update_bits(regmap, AMC6821_REG_CONF4,
 467					 AMC6821_CONF4_PSPR,
 468					 val == 4 ? AMC6821_CONF4_PSPR : 0);
 469	}
 470
 471	if (val < 0)
 472		return -EINVAL;
 473
 474	switch (attr) {
 475	case hwmon_fan_min:
 476		if (!val)	/* no unlimited minimum speed */
 477			return -EINVAL;
 478		reg = AMC6821_REG_TACH_LLIMITL;
 479		break;
 480	case hwmon_fan_max:
 481		reg = AMC6821_REG_TACH_HLIMITL;
 482		break;
 483	case hwmon_fan_target:
 484		if (!val)	/* no unlimited target speed */
 485			return -EINVAL;
 486		reg = AMC6821_REG_TACH_SETTINGL;
 487		break;
 488	default:
 489		return -EOPNOTSUPP;
 490	}
 491
 492	val = val ? 6000000 / clamp_val(val, 1, 6000000) : 0;
 493	val = clamp_val(val, 0, 0xffff);
 494
 495	regs[0] = val & 0xff;
 496	regs[1] = val >> 8;
 497
 498	return regmap_bulk_write(data->regmap, reg, regs, 2);
 499}
 500
 501static ssize_t temp_auto_point_temp_show(struct device *dev,
 502					 struct device_attribute *devattr,
 503					 char *buf)
 504{
 505	struct amc6821_data *data = dev_get_drvdata(dev);
 506	int ix = to_sensor_dev_attr_2(devattr)->index;
 507	int nr = to_sensor_dev_attr_2(devattr)->nr;
 508	u8 temps[3];
 509	int err;
 510
 511	mutex_lock(&data->update_lock);
 512	err = amc6821_get_auto_point_temps(data->regmap, nr, temps);
 513	mutex_unlock(&data->update_lock);
 514	if (err)
 515		return err;
 516
 517	return sysfs_emit(buf, "%d\n", temps[ix] * 1000);
 518}
 519
 520static ssize_t pwm1_auto_point_pwm_show(struct device *dev,
 521					struct device_attribute *devattr,
 522					char *buf)
 523{
 524	struct amc6821_data *data = dev_get_drvdata(dev);
 525	int ix = to_sensor_dev_attr(devattr)->index;
 526	u32 val;
 527	int err;
 528
 529	switch (ix) {
 530	case 0:
 531		val = 0;
 532		break;
 533	case 1:
 534		err = regmap_read(data->regmap, AMC6821_REG_DCY_LOW_TEMP, &val);
 535		if (err)
 536			return err;
 537		break;
 538	default:
 539		val = 255;
 540		break;
 541	}
 542	return sysfs_emit(buf, "%d\n", val);
 543}
 544
 545/*
 546 * Set TEMP[0-4] (low temperature) and SLP[0-2] (slope) of local or remote
 547 * TEMP-FAN control register.
 548 *
 549 * Return 0 on success or negative error code.
 550 *
 551 * Channel 0: local, channel 1: remote
 552 */
 553static inline int set_slope_register(struct regmap *regmap, int channel, u8 *temps)
 554{
 555	u8 regval = FIELD_PREP(AMC6821_TEMP_LIMIT_MASK, temps[1] / 4);
 556	u8 tmp, dpwm;
 557	int err, dt;
 558	u32 pwm;
 559
 560	err = regmap_read(regmap, AMC6821_REG_DCY_LOW_TEMP, &pwm);
 561	if (err)
 562		return err;
 563
 564	dpwm = 255 - pwm;
 565
 566	dt = temps[2] - temps[1];
 567	for (tmp = 4; tmp > 0; tmp--) {
 568		if (dt * (32 >> tmp) >= dpwm)
 569			break;
 570	}
 571	regval |= FIELD_PREP(AMC6821_TEMP_SLOPE_MASK, tmp);
 572
 573	return regmap_write(regmap,
 574			    channel ? AMC6821_REG_RTEMP_FAN_CTRL : AMC6821_REG_LTEMP_FAN_CTRL,
 575			    regval);
 576}
 577
 578static ssize_t temp_auto_point_temp_store(struct device *dev,
 579					  struct device_attribute *attr,
 580					  const char *buf, size_t count)
 581{
 582	struct amc6821_data *data = dev_get_drvdata(dev);
 583	int ix = to_sensor_dev_attr_2(attr)->index;
 584	int nr = to_sensor_dev_attr_2(attr)->nr;
 585	struct regmap *regmap = data->regmap;
 586	u8 temps[3], otemps[3];
 587	long val;
 588	int ret;
 589
 590	ret = kstrtol(buf, 10, &val);
 591	if (ret)
 592		return ret;
 593
 594	mutex_lock(&data->update_lock);
 595
 596	ret = amc6821_get_auto_point_temps(data->regmap, nr, temps);
 597	if (ret)
 598		goto unlock;
 599
 600	switch (ix) {
 601	case 0:
 602		/*
 603		 * Passive cooling temperature. Range limit against low limit
 604		 * of both channels.
 605		 */
 606		ret = amc6821_get_auto_point_temps(data->regmap, 1 - nr, otemps);
 607		if (ret)
 608			goto unlock;
 609		val = DIV_ROUND_CLOSEST(clamp_val(val, 0, 63000), 1000);
 610		val = clamp_val(val, 0, min(temps[1], otemps[1]));
 611		ret = regmap_write(regmap, AMC6821_REG_PSV_TEMP, val);
 612		break;
 613	case 1:
 614		/*
 615		 * Low limit; must be between passive and high limit,
 616		 * and not exceed 124. Step size is 4 degrees C.
 617		 */
 618		val = clamp_val(val, DIV_ROUND_UP(temps[0], 4) * 4000, 124000);
 619		temps[1] = DIV_ROUND_CLOSEST(val, 4000) * 4;
 620		val = temps[1] / 4;
 621		/* Auto-adjust high limit if necessary */
 622		temps[2] = clamp_val(temps[2], temps[1] + 1, 255);
 623		ret = set_slope_register(regmap, nr, temps);
 624		break;
 625	case 2:
 626		/* high limit, must be higher than low limit */
 627		val = clamp_val(val, (temps[1] + 1) * 1000, 255000);
 628		temps[2] = DIV_ROUND_CLOSEST(val, 1000);
 629		ret = set_slope_register(regmap, nr, temps);
 630		break;
 631	default:
 632		ret = -EINVAL;
 633		break;
 634	}
 635unlock:
 636	mutex_unlock(&data->update_lock);
 637	return ret ? : count;
 638}
 639
 640static ssize_t pwm1_auto_point_pwm_store(struct device *dev,
 641					 struct device_attribute *attr,
 642					 const char *buf, size_t count)
 643{
 644	struct amc6821_data *data = dev_get_drvdata(dev);
 645	struct regmap *regmap = data->regmap;
 646	int i, ret;
 647	u8 val;
 648
 649	ret = kstrtou8(buf, 10, &val);
 650	if (ret)
 651		return ret;
 652
 653	mutex_lock(&data->update_lock);
 654	ret = regmap_write(regmap, AMC6821_REG_DCY_LOW_TEMP, val);
 655	if (ret)
 656		goto unlock;
 657
 658	for (i = 0; i < 2; i++) {
 659		u8 temps[3];
 660
 661		ret = amc6821_get_auto_point_temps(regmap, i, temps);
 662		if (ret)
 663			break;
 664		ret = set_slope_register(regmap, i, temps);
 665		if (ret)
 666			break;
 667	}
 668unlock:
 669	mutex_unlock(&data->update_lock);
 670	return ret ? : count;
 671}
 672
 673static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm, pwm1_auto_point_pwm, 0);
 674static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm1_auto_point_pwm, 1);
 675static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm, pwm1_auto_point_pwm, 2);
 676static SENSOR_DEVICE_ATTR_2_RO(temp1_auto_point1_temp, temp_auto_point_temp,
 677			       0, 0);
 678static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, temp_auto_point_temp,
 679			       0, 1);
 680static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point3_temp, temp_auto_point_temp,
 681			       0, 2);
 682
 683static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp_auto_point_temp,
 684			       1, 0);
 685static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, temp_auto_point_temp,
 686			       1, 1);
 687static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point3_temp, temp_auto_point_temp,
 688			       1, 2);
 689
 690static struct attribute *amc6821_attrs[] = {
 691	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
 692	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
 693	&sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
 694	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
 695	&sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
 696	&sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr,
 697	&sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
 698	&sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
 699	&sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr,
 700	NULL
 701};
 702ATTRIBUTE_GROUPS(amc6821);
 703
 704static int amc6821_read(struct device *dev, enum hwmon_sensor_types type,
 705			u32 attr, int channel, long *val)
 706{
 707	switch (type) {
 708	case hwmon_temp:
 709		return amc6821_temp_read(dev, attr, channel, val);
 710	case hwmon_fan:
 711		return amc6821_fan_read(dev, attr, val);
 712	case hwmon_pwm:
 713		return amc6821_pwm_read(dev, attr, val);
 714	default:
 715		return -EOPNOTSUPP;
 716	}
 717}
 718
 719static int amc6821_write(struct device *dev, enum hwmon_sensor_types type,
 720			 u32 attr, int channel, long val)
 721{
 722	switch (type) {
 723	case hwmon_temp:
 724		return amc6821_temp_write(dev, attr, channel, val);
 725	case hwmon_fan:
 726		return amc6821_fan_write(dev, attr, val);
 727	case hwmon_pwm:
 728		return amc6821_pwm_write(dev, attr, val);
 729	default:
 730		return -EOPNOTSUPP;
 731	}
 732}
 733
 734static umode_t amc6821_is_visible(const void *data,
 735				  enum hwmon_sensor_types type,
 736				  u32 attr, int channel)
 737{
 738	switch (type) {
 739	case hwmon_temp:
 740		switch (attr) {
 741		case hwmon_temp_input:
 742		case hwmon_temp_min_alarm:
 743		case hwmon_temp_max_alarm:
 744		case hwmon_temp_crit_alarm:
 745		case hwmon_temp_fault:
 746			return 0444;
 747		case hwmon_temp_min:
 748		case hwmon_temp_max:
 749		case hwmon_temp_crit:
 750			return 0644;
 751		default:
 752			return 0;
 753		}
 754	case hwmon_fan:
 755		switch (attr) {
 756		case hwmon_fan_input:
 757		case hwmon_fan_fault:
 758			return 0444;
 759		case hwmon_fan_pulses:
 760		case hwmon_fan_min:
 761		case hwmon_fan_max:
 762		case hwmon_fan_target:
 763			return 0644;
 764		default:
 765			return 0;
 766		}
 767	case hwmon_pwm:
 768		switch (attr) {
 769		case hwmon_pwm_mode:
 770		case hwmon_pwm_enable:
 771		case hwmon_pwm_input:
 772			return 0644;
 773		case hwmon_pwm_auto_channels_temp:
 774			return 0444;
 775		default:
 776			return 0;
 777		}
 778	default:
 779		return 0;
 780	}
 781}
 782
 783static const struct hwmon_channel_info * const amc6821_info[] = {
 784	HWMON_CHANNEL_INFO(temp,
 785			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
 786			   HWMON_T_CRIT | HWMON_T_MIN_ALARM |
 787			   HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM,
 788			   HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
 789			   HWMON_T_CRIT | HWMON_T_MIN_ALARM |
 790			   HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
 791			   HWMON_T_FAULT),
 792	HWMON_CHANNEL_INFO(fan,
 793			   HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_MAX |
 794			   HWMON_F_TARGET | HWMON_F_PULSES | HWMON_F_FAULT),
 795	HWMON_CHANNEL_INFO(pwm,
 796			   HWMON_PWM_INPUT | HWMON_PWM_ENABLE | HWMON_PWM_MODE |
 797			   HWMON_PWM_AUTO_CHANNELS_TEMP),
 798	NULL
 799};
 800
 801static const struct hwmon_ops amc6821_hwmon_ops = {
 802	.is_visible = amc6821_is_visible,
 803	.read = amc6821_read,
 804	.write = amc6821_write,
 805};
 806
 807static const struct hwmon_chip_info amc6821_chip_info = {
 808	.ops = &amc6821_hwmon_ops,
 809	.info = amc6821_info,
 810};
 811
 812static int amc6821_set_sw_dcy(struct amc6821_data *data, u8 duty_cycle)
 813{
 814	int ret;
 815
 816	ret = regmap_write(data->regmap, AMC6821_REG_DCY, duty_cycle);
 817	if (ret)
 818		return ret;
 819
 820	return regmap_update_bits(data->regmap, AMC6821_REG_CONF1,
 821				  AMC6821_CONF1_FDRC0 | AMC6821_CONF1_FDRC1, 0);
 822}
 823
 824static int amc6821_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state)
 825{
 826	struct amc6821_data *data = cdev->devdata;
 827
 828	if (!data)
 829		return -EINVAL;
 830
 831	*state = data->fan_max_state;
 832
 833	return 0;
 834}
 835
 836static int amc6821_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *state)
 837{
 838	struct amc6821_data *data = cdev->devdata;
 839
 840	if (!data)
 841		return -EINVAL;
 842
 843	*state = data->fan_state;
 844
 845	return 0;
 846}
 847
 848static int amc6821_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
 849{
 850	struct amc6821_data *data = cdev->devdata;
 851	int ret;
 852
 853	if (!data || state > data->fan_max_state)
 854		return -EINVAL;
 855
 856	ret = amc6821_set_sw_dcy(data, data->fan_cooling_levels[state]);
 857	if (ret)
 858		return ret;
 859
 860	data->fan_state = state;
 861
 862	return 0;
 863}
 864
 865static const struct thermal_cooling_device_ops amc6821_cooling_ops = {
 866	.get_max_state = amc6821_get_max_state,
 867	.get_cur_state = amc6821_get_cur_state,
 868	.set_cur_state = amc6821_set_cur_state,
 869};
 870
 871/* Return 0 if detection is successful, -ENODEV otherwise */
 872static int amc6821_detect(struct i2c_client *client, struct i2c_board_info *info)
 873{
 874	struct i2c_adapter *adapter = client->adapter;
 875	int address = client->addr;
 876	int dev_id, comp_id;
 877
 878	dev_dbg(&adapter->dev, "amc6821_detect called.\n");
 879
 880	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 881		dev_dbg(&adapter->dev,
 882			"amc6821: I2C bus doesn't support byte mode, "
 883			"skipping.\n");
 884		return -ENODEV;
 885	}
 886
 887	dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID);
 888	comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID);
 889	if (dev_id != 0x21 || comp_id != 0x49) {
 890		dev_dbg(&adapter->dev,
 891			"amc6821: detection failed at 0x%02x.\n",
 892			address);
 893		return -ENODEV;
 894	}
 895
 896	/*
 897	 * Bit 7 of the address register is ignored, so we can check the
 898	 * ID registers again
 899	 */
 900	dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID);
 901	comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID);
 902	if (dev_id != 0x21 || comp_id != 0x49) {
 903		dev_dbg(&adapter->dev,
 904			"amc6821: detection failed at 0x%02x.\n",
 905			address);
 906		return -ENODEV;
 907	}
 908
 909	dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address);
 910	strscpy(info->type, "amc6821", I2C_NAME_SIZE);
 911
 912	return 0;
 913}
 914
 915static enum pwm_polarity amc6821_pwm_polarity(struct i2c_client *client,
 916					      struct device_node *fan_np)
 917{
 918	enum pwm_polarity polarity = PWM_POLARITY_NORMAL;
 919	struct of_phandle_args args;
 920
 921	/*
 922	 * For backward compatibility, the pwminv module parameter takes
 923	 * always the precedence over any other device description
 924	 */
 925	if (pwminv == 0)
 926		return PWM_POLARITY_NORMAL;
 927	if (pwminv > 0)
 928		return PWM_POLARITY_INVERSED;
 929
 930	if (of_parse_phandle_with_args(fan_np, "pwms", "#pwm-cells", 0, &args))
 931		goto out;
 932	of_node_put(args.np);
 933
 934	if (args.args_count != 2)
 935		goto out;
 936
 937	if (args.args[1] & PWM_POLARITY_INVERTED)
 938		polarity = PWM_POLARITY_INVERSED;
 939out:
 940	return polarity;
 941}
 942
 943static int amc6821_of_fan_read_data(struct i2c_client *client,
 944				    struct amc6821_data *data,
 945				    struct device_node *fan_np)
 946{
 947	int num;
 948
 949	data->pwm_polarity = amc6821_pwm_polarity(client, fan_np);
 950
 951	num = of_property_count_u32_elems(fan_np, "cooling-levels");
 952	if (num <= 0)
 953		return 0;
 954
 955	data->fan_max_state = num - 1;
 956
 957	data->fan_cooling_levels = devm_kcalloc(&client->dev, num,
 958						sizeof(u32),
 959						GFP_KERNEL);
 960
 961	if (!data->fan_cooling_levels)
 962		return -ENOMEM;
 963
 964	return of_property_read_u32_array(fan_np, "cooling-levels",
 965					  data->fan_cooling_levels, num);
 966}
 967
 968static int amc6821_init_client(struct i2c_client *client, struct amc6821_data *data)
 969{
 970	struct regmap *regmap = data->regmap;
 971	u32 regval;
 972	int err;
 973
 974	if (init) {
 975		err = regmap_set_bits(regmap, AMC6821_REG_CONF4, AMC6821_CONF4_MODE);
 976		if (err)
 977			return err;
 978		err = regmap_clear_bits(regmap, AMC6821_REG_CONF3, AMC6821_CONF3_THERM_FAN_EN);
 979		if (err)
 980			return err;
 981		err = regmap_clear_bits(regmap, AMC6821_REG_CONF2,
 982					AMC6821_CONF2_RTFIE |
 983					AMC6821_CONF2_LTOIE |
 984					AMC6821_CONF2_RTOIE);
 985		if (err)
 986			return err;
 987
 988		regval = AMC6821_CONF1_START;
 989		if (data->pwm_polarity == PWM_POLARITY_INVERSED)
 990			regval |= AMC6821_CONF1_PWMINV;
 991
 992		err = regmap_update_bits(regmap, AMC6821_REG_CONF1,
 993					 AMC6821_CONF1_THERMOVIE | AMC6821_CONF1_FANIE |
 994					 AMC6821_CONF1_START | AMC6821_CONF1_PWMINV,
 995					 regval);
 996		if (err)
 997			return err;
 998
 999		/* Software DCY-control mode with fan enabled when cooling-levels present */
1000		if (data->fan_cooling_levels) {
1001			err = amc6821_set_sw_dcy(data,
1002						 data->fan_cooling_levels[data->fan_max_state]);
1003			if (err)
1004				return err;
1005		}
1006	}
1007	return 0;
1008}
1009
1010static bool amc6821_volatile_reg(struct device *dev, unsigned int reg)
1011{
1012	switch (reg) {
1013	case AMC6821_REG_STAT1:
1014	case AMC6821_REG_STAT2:
1015	case AMC6821_REG_TEMP_LO:
1016	case AMC6821_REG_TDATA_LOW:
1017	case AMC6821_REG_LTEMP_HI:
1018	case AMC6821_REG_RTEMP_HI:
1019	case AMC6821_REG_TDATA_HI:
1020		return true;
1021	default:
1022		return false;
1023	}
1024}
1025
1026static const struct regmap_config amc6821_regmap_config = {
1027	.reg_bits = 8,
1028	.val_bits = 8,
1029	.volatile_reg = amc6821_volatile_reg,
1030	.cache_type = REGCACHE_MAPLE,
1031};
1032
1033static int amc6821_probe(struct i2c_client *client)
1034{
1035	struct device *dev = &client->dev;
1036	struct amc6821_data *data;
1037	struct device *hwmon_dev;
1038	struct regmap *regmap;
1039	struct device_node *fan_np __free(device_node) = NULL;
1040	int err;
1041
1042	data = devm_kzalloc(dev, sizeof(struct amc6821_data), GFP_KERNEL);
1043	if (!data)
1044		return -ENOMEM;
1045
1046	regmap = devm_regmap_init_i2c(client, &amc6821_regmap_config);
1047	if (IS_ERR(regmap))
1048		return dev_err_probe(dev, PTR_ERR(regmap),
1049				     "Failed to initialize regmap\n");
1050	data->regmap = regmap;
1051
1052	fan_np = of_get_child_by_name(dev->of_node, "fan");
1053	if (fan_np) {
1054		err = amc6821_of_fan_read_data(client, data, fan_np);
1055		if (err)
1056			return dev_err_probe(dev, err,
1057					     "Failed to read fan device tree data\n");
1058	}
1059
1060	err = amc6821_init_client(client, data);
1061	if (err)
1062		return err;
1063
1064	if (of_device_is_compatible(dev->of_node, "tsd,mule")) {
1065		err = devm_of_platform_populate(dev);
1066		if (err)
1067			return dev_err_probe(dev, err,
1068				     "Failed to create sub-devices\n");
1069	}
1070
1071	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
1072							 data, &amc6821_chip_info,
1073							 amc6821_groups);
1074	if (IS_ERR(hwmon_dev))
1075		return dev_err_probe(dev, PTR_ERR(hwmon_dev),
1076				     "Failed to initialize hwmon\n");
1077
1078	if (IS_ENABLED(CONFIG_THERMAL) && fan_np && data->fan_cooling_levels)
1079		return PTR_ERR_OR_ZERO(devm_thermal_of_cooling_device_register(dev,
1080			fan_np, client->name, data, &amc6821_cooling_ops));
1081
1082	return 0;
1083}
1084
1085static const struct i2c_device_id amc6821_id[] = {
1086	{ "amc6821" },
1087	{ }
1088};
1089
1090MODULE_DEVICE_TABLE(i2c, amc6821_id);
1091
1092static const struct of_device_id __maybe_unused amc6821_of_match[] = {
1093	{
1094		.compatible = "ti,amc6821",
1095	},
1096	{
1097		.compatible = "tsd,mule",
1098	},
1099	{ }
1100};
1101
1102MODULE_DEVICE_TABLE(of, amc6821_of_match);
1103
1104static struct i2c_driver amc6821_driver = {
1105	.class = I2C_CLASS_HWMON,
1106	.driver = {
1107		.name	= "amc6821",
1108		.of_match_table = of_match_ptr(amc6821_of_match),
1109	},
1110	.probe = amc6821_probe,
1111	.id_table = amc6821_id,
1112	.detect = amc6821_detect,
1113	.address_list = normal_i2c,
1114};
1115
1116module_i2c_driver(amc6821_driver);
1117
1118MODULE_LICENSE("GPL");
1119MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
1120MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");