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