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