1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * adt7475 - Thermal sensor driver for the ADT7475 chip and derivatives 4 * Copyright (C) 2007-2008, Advanced Micro Devices, Inc. 5 * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net> 6 * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com> 7 * Copyright (C) 2009 Jean Delvare <jdelvare@suse.de> 8 * 9 * Derived from the lm83 driver by Jean Delvare 10 */ 11 12 #include <linux/module.h> 13 #include <linux/init.h> 14 #include <linux/slab.h> 15 #include <linux/i2c.h> 16 #include <linux/hwmon.h> 17 #include <linux/hwmon-sysfs.h> 18 #include <linux/hwmon-vid.h> 19 #include <linux/err.h> 20 #include <linux/jiffies.h> 21 #include <linux/of.h> 22 #include <linux/mod_devicetable.h> 23 #include <linux/property.h> 24 #include <linux/util_macros.h> 25 26 #include <dt-bindings/pwm/pwm.h> 27 28 /* Indexes for the sysfs hooks */ 29 enum adt_sysfs_id { 30 INPUT = 0, 31 MIN = 1, 32 MAX = 2, 33 CONTROL = 3, 34 OFFSET = 3, // Dup 35 AUTOMIN = 4, 36 THERM = 5, 37 HYSTERSIS = 6, 38 /* 39 * These are unique identifiers for the sysfs functions - unlike the 40 * numbers above, these are not also indexes into an array 41 */ 42 ALARM = 9, 43 FAULT = 10, 44 }; 45 46 47 /* 7475 Common Registers */ 48 49 #define REG_DEVREV2 0x12 /* ADT7490 only */ 50 #define REG_IMON 0x1D /* ADT7490 only */ 51 52 #define REG_VTT 0x1E /* ADT7490 only */ 53 #define REG_EXTEND3 0x1F /* ADT7490 only */ 54 55 #define REG_VOLTAGE_BASE 0x20 56 #define REG_TEMP_BASE 0x25 57 #define REG_TACH_BASE 0x28 58 #define REG_PWM_BASE 0x30 59 #define REG_PWM_MAX_BASE 0x38 60 61 #define REG_DEVID 0x3D 62 #define REG_VENDID 0x3E 63 #define REG_DEVID2 0x3F 64 65 #define REG_CONFIG1 0x40 66 67 #define REG_STATUS1 0x41 68 #define REG_STATUS2 0x42 69 70 #define REG_VID 0x43 /* ADT7476 only */ 71 72 #define REG_VOLTAGE_MIN_BASE 0x44 73 #define REG_VOLTAGE_MAX_BASE 0x45 74 75 #define REG_TEMP_MIN_BASE 0x4E 76 #define REG_TEMP_MAX_BASE 0x4F 77 78 #define REG_TACH_MIN_BASE 0x54 79 80 #define REG_PWM_CONFIG_BASE 0x5C 81 82 #define REG_TEMP_TRANGE_BASE 0x5F 83 84 #define REG_ENHANCE_ACOUSTICS1 0x62 85 #define REG_ENHANCE_ACOUSTICS2 0x63 86 87 #define REG_PWM_MIN_BASE 0x64 88 89 #define REG_TEMP_TMIN_BASE 0x67 90 #define REG_TEMP_THERM_BASE 0x6A 91 92 #define REG_REMOTE1_HYSTERSIS 0x6D 93 #define REG_REMOTE2_HYSTERSIS 0x6E 94 95 #define REG_TEMP_OFFSET_BASE 0x70 96 97 #define REG_CONFIG2 0x73 98 99 #define REG_EXTEND1 0x76 100 #define REG_EXTEND2 0x77 101 102 #define REG_CONFIG3 0x78 103 #define REG_CONFIG5 0x7C 104 #define REG_CONFIG4 0x7D 105 106 #define REG_STATUS4 0x81 /* ADT7490 only */ 107 108 #define REG_VTT_MIN 0x84 /* ADT7490 only */ 109 #define REG_VTT_MAX 0x86 /* ADT7490 only */ 110 111 #define REG_IMON_MIN 0x85 /* ADT7490 only */ 112 #define REG_IMON_MAX 0x87 /* ADT7490 only */ 113 114 #define VID_VIDSEL 0x80 /* ADT7476 only */ 115 116 #define CONFIG2_ATTN 0x20 117 118 #define CONFIG3_SMBALERT 0x01 119 #define CONFIG3_THERM 0x02 120 121 #define CONFIG4_PINFUNC 0x03 122 #define CONFIG4_THERM 0x01 123 #define CONFIG4_SMBALERT 0x02 124 #define CONFIG4_MAXDUTY 0x08 125 #define CONFIG4_ATTN_IN10 0x30 126 #define CONFIG4_ATTN_IN43 0xC0 127 128 #define CONFIG5_TWOSCOMP 0x01 129 #define CONFIG5_TEMPOFFSET 0x02 130 #define CONFIG5_VIDGPIO 0x10 /* ADT7476 only */ 131 132 /* ADT7475 Settings */ 133 134 #define ADT7475_VOLTAGE_COUNT 5 /* Not counting Vtt or Imon */ 135 #define ADT7475_TEMP_COUNT 3 136 #define ADT7475_TACH_COUNT 4 137 #define ADT7475_PWM_COUNT 3 138 139 /* Macro to read the registers */ 140 141 #define adt7475_read(reg) i2c_smbus_read_byte_data(client, (reg)) 142 143 /* Macros to easily index the registers */ 144 145 #define TACH_REG(idx) (REG_TACH_BASE + ((idx) * 2)) 146 #define TACH_MIN_REG(idx) (REG_TACH_MIN_BASE + ((idx) * 2)) 147 148 #define PWM_REG(idx) (REG_PWM_BASE + (idx)) 149 #define PWM_MAX_REG(idx) (REG_PWM_MAX_BASE + (idx)) 150 #define PWM_MIN_REG(idx) (REG_PWM_MIN_BASE + (idx)) 151 #define PWM_CONFIG_REG(idx) (REG_PWM_CONFIG_BASE + (idx)) 152 153 #define VOLTAGE_REG(idx) (REG_VOLTAGE_BASE + (idx)) 154 #define VOLTAGE_MIN_REG(idx) (REG_VOLTAGE_MIN_BASE + ((idx) * 2)) 155 #define VOLTAGE_MAX_REG(idx) (REG_VOLTAGE_MAX_BASE + ((idx) * 2)) 156 157 #define TEMP_REG(idx) (REG_TEMP_BASE + (idx)) 158 #define TEMP_MIN_REG(idx) (REG_TEMP_MIN_BASE + ((idx) * 2)) 159 #define TEMP_MAX_REG(idx) (REG_TEMP_MAX_BASE + ((idx) * 2)) 160 #define TEMP_TMIN_REG(idx) (REG_TEMP_TMIN_BASE + (idx)) 161 #define TEMP_THERM_REG(idx) (REG_TEMP_THERM_BASE + (idx)) 162 #define TEMP_OFFSET_REG(idx) (REG_TEMP_OFFSET_BASE + (idx)) 163 #define TEMP_TRANGE_REG(idx) (REG_TEMP_TRANGE_BASE + (idx)) 164 165 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 166 167 enum chips { adt7473, adt7475, adt7476, adt7490 }; 168 169 static const struct i2c_device_id adt7475_id[] = { 170 { .name = "adt7473", .driver_data = adt7473 }, 171 { .name = "adt7475", .driver_data = adt7475 }, 172 { .name = "adt7476", .driver_data = adt7476 }, 173 { .name = "adt7490", .driver_data = adt7490 }, 174 { } 175 }; 176 MODULE_DEVICE_TABLE(i2c, adt7475_id); 177 178 static const struct of_device_id adt7475_of_match[] = { 179 { 180 .compatible = "adi,adt7473", 181 .data = (void *)adt7473 182 }, 183 { 184 .compatible = "adi,adt7475", 185 .data = (void *)adt7475 186 }, 187 { 188 .compatible = "adi,adt7476", 189 .data = (void *)adt7476 190 }, 191 { 192 .compatible = "adi,adt7490", 193 .data = (void *)adt7490 194 }, 195 { }, 196 }; 197 MODULE_DEVICE_TABLE(of, adt7475_of_match); 198 199 struct adt7475_data { 200 struct i2c_client *client; 201 struct mutex lock; 202 203 unsigned long measure_updated; 204 bool valid; 205 206 u8 config2; 207 u8 config4; 208 u8 config5; 209 u8 has_voltage; 210 u8 bypass_attn; /* Bypass voltage attenuator */ 211 u8 has_pwm2:1; 212 u8 has_fan4:1; 213 u8 has_vid:1; 214 u32 alarms; 215 u16 voltage[3][7]; 216 u16 temp[7][3]; 217 u16 tach[2][4]; 218 u8 pwm[4][3]; 219 u8 range[3]; 220 u8 pwmctl[3]; 221 u8 pwmchan[3]; 222 u8 enh_acoustics[2]; 223 224 u8 vid; 225 u8 vrm; 226 const struct attribute_group *groups[10]; 227 }; 228 229 static struct i2c_driver adt7475_driver; 230 static struct adt7475_data *adt7475_update_device(struct device *dev); 231 static void adt7475_read_hystersis(struct i2c_client *client); 232 static void adt7475_read_pwm(struct i2c_client *client, int index); 233 234 /* Given a temp value, convert it to register value */ 235 236 static inline u16 temp2reg(struct adt7475_data *data, long val) 237 { 238 u16 ret; 239 240 if (!(data->config5 & CONFIG5_TWOSCOMP)) { 241 val = clamp_val(val, -64000, 191000); 242 ret = (val + 64500) / 1000; 243 } else { 244 val = clamp_val(val, -128000, 127000); 245 if (val < -500) 246 ret = (256500 + val) / 1000; 247 else 248 ret = (val + 500) / 1000; 249 } 250 251 return ret << 2; 252 } 253 254 /* Given a register value, convert it to a real temp value */ 255 256 static inline int reg2temp(struct adt7475_data *data, u16 reg) 257 { 258 if (data->config5 & CONFIG5_TWOSCOMP) { 259 if (reg >= 512) 260 return (reg - 1024) * 250; 261 else 262 return reg * 250; 263 } else 264 return (reg - 256) * 250; 265 } 266 267 static inline int tach2rpm(u16 tach) 268 { 269 if (tach == 0 || tach == 0xFFFF) 270 return 0; 271 272 return (90000 * 60) / tach; 273 } 274 275 static inline u16 rpm2tach(unsigned long rpm) 276 { 277 if (rpm == 0) 278 return 0; 279 280 return clamp_val((90000 * 60) / rpm, 1, 0xFFFF); 281 } 282 283 /* Scaling factors for voltage inputs, taken from the ADT7490 datasheet */ 284 static const int adt7473_in_scaling[ADT7475_VOLTAGE_COUNT + 2][2] = { 285 { 45, 94 }, /* +2.5V */ 286 { 175, 525 }, /* Vccp */ 287 { 68, 71 }, /* Vcc */ 288 { 93, 47 }, /* +5V */ 289 { 120, 20 }, /* +12V */ 290 { 45, 45 }, /* Vtt */ 291 { 45, 45 }, /* Imon */ 292 }; 293 294 static inline int reg2volt(int channel, u16 reg, u8 bypass_attn) 295 { 296 const int *r = adt7473_in_scaling[channel]; 297 298 if (bypass_attn & (1 << channel)) 299 return DIV_ROUND_CLOSEST(reg * 2250, 1024); 300 return DIV_ROUND_CLOSEST(reg * (r[0] + r[1]) * 2250, r[1] * 1024); 301 } 302 303 static inline u16 volt2reg(int channel, long volt, u8 bypass_attn) 304 { 305 const int *r = adt7473_in_scaling[channel]; 306 long reg; 307 308 if (bypass_attn & (1 << channel)) 309 reg = DIV_ROUND_CLOSEST(volt * 1024, 2250); 310 else 311 reg = DIV_ROUND_CLOSEST(volt * r[1] * 1024, 312 (r[0] + r[1]) * 2250); 313 return clamp_val(reg, 0, 1023) & (0xff << 2); 314 } 315 316 static int adt7475_read_word(struct i2c_client *client, int reg) 317 { 318 int val1, val2; 319 320 val1 = i2c_smbus_read_byte_data(client, reg); 321 if (val1 < 0) 322 return val1; 323 val2 = i2c_smbus_read_byte_data(client, reg + 1); 324 if (val2 < 0) 325 return val2; 326 327 return val1 | (val2 << 8); 328 } 329 330 static void adt7475_write_word(struct i2c_client *client, int reg, u16 val) 331 { 332 i2c_smbus_write_byte_data(client, reg + 1, val >> 8); 333 i2c_smbus_write_byte_data(client, reg, val & 0xFF); 334 } 335 336 static ssize_t voltage_show(struct device *dev, struct device_attribute *attr, 337 char *buf) 338 { 339 struct adt7475_data *data = adt7475_update_device(dev); 340 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 341 unsigned short val; 342 343 if (IS_ERR(data)) 344 return PTR_ERR(data); 345 346 switch (sattr->nr) { 347 case ALARM: 348 return sprintf(buf, "%d\n", 349 (data->alarms >> sattr->index) & 1); 350 default: 351 val = data->voltage[sattr->nr][sattr->index]; 352 return sprintf(buf, "%d\n", 353 reg2volt(sattr->index, val, data->bypass_attn)); 354 } 355 } 356 357 static ssize_t voltage_store(struct device *dev, 358 struct device_attribute *attr, const char *buf, 359 size_t count) 360 { 361 362 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 363 struct adt7475_data *data = dev_get_drvdata(dev); 364 struct i2c_client *client = data->client; 365 unsigned char reg; 366 long val; 367 368 if (kstrtol(buf, 10, &val)) 369 return -EINVAL; 370 371 mutex_lock(&data->lock); 372 373 data->voltage[sattr->nr][sattr->index] = 374 volt2reg(sattr->index, val, data->bypass_attn); 375 376 if (sattr->index < ADT7475_VOLTAGE_COUNT) { 377 if (sattr->nr == MIN) 378 reg = VOLTAGE_MIN_REG(sattr->index); 379 else 380 reg = VOLTAGE_MAX_REG(sattr->index); 381 } else if (sattr->index == 5) { 382 if (sattr->nr == MIN) 383 reg = REG_VTT_MIN; 384 else 385 reg = REG_VTT_MAX; 386 } else { 387 if (sattr->nr == MIN) 388 reg = REG_IMON_MIN; 389 else 390 reg = REG_IMON_MAX; 391 } 392 393 i2c_smbus_write_byte_data(client, reg, 394 data->voltage[sattr->nr][sattr->index] >> 2); 395 mutex_unlock(&data->lock); 396 397 return count; 398 } 399 400 static ssize_t temp_show(struct device *dev, struct device_attribute *attr, 401 char *buf) 402 { 403 struct adt7475_data *data = adt7475_update_device(dev); 404 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 405 int out; 406 407 if (IS_ERR(data)) 408 return PTR_ERR(data); 409 410 switch (sattr->nr) { 411 case HYSTERSIS: 412 mutex_lock(&data->lock); 413 out = data->temp[sattr->nr][sattr->index]; 414 if (sattr->index != 1) 415 out = (out >> 4) & 0xF; 416 else 417 out = (out & 0xF); 418 /* 419 * Show the value as an absolute number tied to 420 * THERM 421 */ 422 out = reg2temp(data, data->temp[THERM][sattr->index]) - 423 out * 1000; 424 mutex_unlock(&data->lock); 425 break; 426 427 case OFFSET: 428 /* 429 * Offset is always 2's complement, regardless of the 430 * setting in CONFIG5 431 */ 432 mutex_lock(&data->lock); 433 out = (s8)data->temp[sattr->nr][sattr->index]; 434 if (data->config5 & CONFIG5_TEMPOFFSET) 435 out *= 1000; 436 else 437 out *= 500; 438 mutex_unlock(&data->lock); 439 break; 440 441 case ALARM: 442 out = (data->alarms >> (sattr->index + 4)) & 1; 443 break; 444 445 case FAULT: 446 /* Note - only for remote1 and remote2 */ 447 out = !!(data->alarms & (sattr->index ? 0x8000 : 0x4000)); 448 break; 449 450 default: 451 /* All other temp values are in the configured format */ 452 out = reg2temp(data, data->temp[sattr->nr][sattr->index]); 453 } 454 455 return sprintf(buf, "%d\n", out); 456 } 457 458 static ssize_t temp_store(struct device *dev, struct device_attribute *attr, 459 const char *buf, size_t count) 460 { 461 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 462 struct adt7475_data *data = dev_get_drvdata(dev); 463 struct i2c_client *client = data->client; 464 unsigned char reg = 0; 465 u8 out; 466 int temp; 467 long val; 468 469 if (kstrtol(buf, 10, &val)) 470 return -EINVAL; 471 472 mutex_lock(&data->lock); 473 474 /* We need the config register in all cases for temp <-> reg conv. */ 475 data->config5 = adt7475_read(REG_CONFIG5); 476 477 switch (sattr->nr) { 478 case OFFSET: 479 if (data->config5 & CONFIG5_TEMPOFFSET) { 480 val = clamp_val(val, -63000, 127000); 481 out = data->temp[OFFSET][sattr->index] = val / 1000; 482 } else { 483 val = clamp_val(val, -63000, 64000); 484 out = data->temp[OFFSET][sattr->index] = val / 500; 485 } 486 break; 487 488 case HYSTERSIS: 489 /* 490 * The value will be given as an absolute value, turn it 491 * into an offset based on THERM 492 */ 493 494 /* Read fresh THERM and HYSTERSIS values from the chip */ 495 data->temp[THERM][sattr->index] = 496 adt7475_read(TEMP_THERM_REG(sattr->index)) << 2; 497 adt7475_read_hystersis(client); 498 499 temp = reg2temp(data, data->temp[THERM][sattr->index]); 500 val = clamp_val(val, temp - 15000, temp); 501 val = (temp - val) / 1000; 502 503 if (sattr->index != 1) { 504 data->temp[HYSTERSIS][sattr->index] &= 0x0F; 505 data->temp[HYSTERSIS][sattr->index] |= (val & 0xF) << 4; 506 } else { 507 data->temp[HYSTERSIS][sattr->index] &= 0xF0; 508 data->temp[HYSTERSIS][sattr->index] |= (val & 0xF); 509 } 510 511 out = data->temp[HYSTERSIS][sattr->index]; 512 break; 513 514 default: 515 data->temp[sattr->nr][sattr->index] = temp2reg(data, val); 516 517 /* 518 * We maintain an extra 2 digits of precision for simplicity 519 * - shift those back off before writing the value 520 */ 521 out = (u8) (data->temp[sattr->nr][sattr->index] >> 2); 522 } 523 524 switch (sattr->nr) { 525 case MIN: 526 reg = TEMP_MIN_REG(sattr->index); 527 break; 528 case MAX: 529 reg = TEMP_MAX_REG(sattr->index); 530 break; 531 case OFFSET: 532 reg = TEMP_OFFSET_REG(sattr->index); 533 break; 534 case AUTOMIN: 535 reg = TEMP_TMIN_REG(sattr->index); 536 break; 537 case THERM: 538 reg = TEMP_THERM_REG(sattr->index); 539 break; 540 case HYSTERSIS: 541 if (sattr->index != 2) 542 reg = REG_REMOTE1_HYSTERSIS; 543 else 544 reg = REG_REMOTE2_HYSTERSIS; 545 546 break; 547 } 548 549 i2c_smbus_write_byte_data(client, reg, out); 550 551 mutex_unlock(&data->lock); 552 return count; 553 } 554 555 /* Assuming CONFIG6[SLOW] is 0 */ 556 static const int ad7475_st_map[] = { 557 37500, 18800, 12500, 7500, 4700, 3100, 1600, 800, 558 }; 559 560 static ssize_t temp_st_show(struct device *dev, struct device_attribute *attr, 561 char *buf) 562 { 563 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 564 struct adt7475_data *data = dev_get_drvdata(dev); 565 long val; 566 567 switch (sattr->index) { 568 case 0: 569 val = data->enh_acoustics[0] & 0xf; 570 break; 571 case 1: 572 val = data->enh_acoustics[1] & 0xf; 573 break; 574 case 2: 575 default: 576 val = (data->enh_acoustics[1] >> 4) & 0xf; 577 break; 578 } 579 580 if (val & 0x8) 581 return sprintf(buf, "%d\n", ad7475_st_map[val & 0x7]); 582 else 583 return sprintf(buf, "0\n"); 584 } 585 586 static ssize_t temp_st_store(struct device *dev, 587 struct device_attribute *attr, const char *buf, 588 size_t count) 589 { 590 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 591 struct adt7475_data *data = dev_get_drvdata(dev); 592 struct i2c_client *client = data->client; 593 unsigned char reg; 594 int shift, idx; 595 ulong val; 596 597 if (kstrtoul(buf, 10, &val)) 598 return -EINVAL; 599 600 switch (sattr->index) { 601 case 0: 602 reg = REG_ENHANCE_ACOUSTICS1; 603 shift = 0; 604 idx = 0; 605 break; 606 case 1: 607 reg = REG_ENHANCE_ACOUSTICS2; 608 shift = 0; 609 idx = 1; 610 break; 611 case 2: 612 default: 613 reg = REG_ENHANCE_ACOUSTICS2; 614 shift = 4; 615 idx = 1; 616 break; 617 } 618 619 if (val > 0) { 620 val = find_closest_descending(val, ad7475_st_map, 621 ARRAY_SIZE(ad7475_st_map)); 622 val |= 0x8; 623 } 624 625 mutex_lock(&data->lock); 626 627 data->enh_acoustics[idx] &= ~(0xf << shift); 628 data->enh_acoustics[idx] |= (val << shift); 629 630 i2c_smbus_write_byte_data(client, reg, data->enh_acoustics[idx]); 631 632 mutex_unlock(&data->lock); 633 634 return count; 635 } 636 637 /* 638 * Table of autorange values - the user will write the value in millidegrees, 639 * and we'll convert it 640 */ 641 static const int autorange_table[] = { 642 2000, 2500, 3330, 4000, 5000, 6670, 8000, 643 10000, 13330, 16000, 20000, 26670, 32000, 40000, 644 53330, 80000 645 }; 646 647 static ssize_t point2_show(struct device *dev, struct device_attribute *attr, 648 char *buf) 649 { 650 struct adt7475_data *data = adt7475_update_device(dev); 651 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 652 int out, val; 653 654 if (IS_ERR(data)) 655 return PTR_ERR(data); 656 657 mutex_lock(&data->lock); 658 out = (data->range[sattr->index] >> 4) & 0x0F; 659 val = reg2temp(data, data->temp[AUTOMIN][sattr->index]); 660 mutex_unlock(&data->lock); 661 662 return sprintf(buf, "%d\n", val + autorange_table[out]); 663 } 664 665 static ssize_t point2_store(struct device *dev, struct device_attribute *attr, 666 const char *buf, size_t count) 667 { 668 struct adt7475_data *data = dev_get_drvdata(dev); 669 struct i2c_client *client = data->client; 670 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 671 int temp; 672 long val; 673 674 if (kstrtol(buf, 10, &val)) 675 return -EINVAL; 676 677 mutex_lock(&data->lock); 678 679 /* Get a fresh copy of the needed registers */ 680 data->config5 = adt7475_read(REG_CONFIG5); 681 data->temp[AUTOMIN][sattr->index] = 682 adt7475_read(TEMP_TMIN_REG(sattr->index)) << 2; 683 data->range[sattr->index] = 684 adt7475_read(TEMP_TRANGE_REG(sattr->index)); 685 686 /* 687 * The user will write an absolute value, so subtract the start point 688 * to figure the range 689 */ 690 temp = reg2temp(data, data->temp[AUTOMIN][sattr->index]); 691 val = clamp_val(val, temp + autorange_table[0], 692 temp + autorange_table[ARRAY_SIZE(autorange_table) - 1]); 693 val -= temp; 694 695 /* Find the nearest table entry to what the user wrote */ 696 val = find_closest(val, autorange_table, ARRAY_SIZE(autorange_table)); 697 698 data->range[sattr->index] &= ~0xF0; 699 data->range[sattr->index] |= val << 4; 700 701 i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index), 702 data->range[sattr->index]); 703 704 mutex_unlock(&data->lock); 705 return count; 706 } 707 708 static ssize_t tach_show(struct device *dev, struct device_attribute *attr, 709 char *buf) 710 { 711 struct adt7475_data *data = adt7475_update_device(dev); 712 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 713 int out; 714 715 if (IS_ERR(data)) 716 return PTR_ERR(data); 717 718 if (sattr->nr == ALARM) 719 out = (data->alarms >> (sattr->index + 10)) & 1; 720 else 721 out = tach2rpm(data->tach[sattr->nr][sattr->index]); 722 723 return sprintf(buf, "%d\n", out); 724 } 725 726 static ssize_t tach_store(struct device *dev, struct device_attribute *attr, 727 const char *buf, size_t count) 728 { 729 730 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 731 struct adt7475_data *data = dev_get_drvdata(dev); 732 struct i2c_client *client = data->client; 733 unsigned long val; 734 735 if (kstrtoul(buf, 10, &val)) 736 return -EINVAL; 737 738 mutex_lock(&data->lock); 739 740 data->tach[MIN][sattr->index] = rpm2tach(val); 741 742 adt7475_write_word(client, TACH_MIN_REG(sattr->index), 743 data->tach[MIN][sattr->index]); 744 745 mutex_unlock(&data->lock); 746 return count; 747 } 748 749 static ssize_t pwm_show(struct device *dev, struct device_attribute *attr, 750 char *buf) 751 { 752 struct adt7475_data *data = adt7475_update_device(dev); 753 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 754 755 if (IS_ERR(data)) 756 return PTR_ERR(data); 757 758 return sprintf(buf, "%d\n", data->pwm[sattr->nr][sattr->index]); 759 } 760 761 static ssize_t pwmchan_show(struct device *dev, struct device_attribute *attr, 762 char *buf) 763 { 764 struct adt7475_data *data = adt7475_update_device(dev); 765 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 766 767 if (IS_ERR(data)) 768 return PTR_ERR(data); 769 770 return sprintf(buf, "%d\n", data->pwmchan[sattr->index]); 771 } 772 773 static ssize_t pwmctrl_show(struct device *dev, struct device_attribute *attr, 774 char *buf) 775 { 776 struct adt7475_data *data = adt7475_update_device(dev); 777 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 778 779 if (IS_ERR(data)) 780 return PTR_ERR(data); 781 782 return sprintf(buf, "%d\n", data->pwmctl[sattr->index]); 783 } 784 785 static ssize_t pwm_store(struct device *dev, struct device_attribute *attr, 786 const char *buf, size_t count) 787 { 788 789 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 790 struct adt7475_data *data = dev_get_drvdata(dev); 791 struct i2c_client *client = data->client; 792 unsigned char reg = 0; 793 long val; 794 795 if (kstrtol(buf, 10, &val)) 796 return -EINVAL; 797 798 mutex_lock(&data->lock); 799 800 switch (sattr->nr) { 801 case INPUT: 802 /* Get a fresh value for CONTROL */ 803 data->pwm[CONTROL][sattr->index] = 804 adt7475_read(PWM_CONFIG_REG(sattr->index)); 805 806 /* 807 * If we are not in manual mode, then we shouldn't allow 808 * the user to set the pwm speed 809 */ 810 if (((data->pwm[CONTROL][sattr->index] >> 5) & 7) != 7) { 811 mutex_unlock(&data->lock); 812 return count; 813 } 814 815 reg = PWM_REG(sattr->index); 816 break; 817 818 case MIN: 819 reg = PWM_MIN_REG(sattr->index); 820 break; 821 822 case MAX: 823 reg = PWM_MAX_REG(sattr->index); 824 break; 825 } 826 827 data->pwm[sattr->nr][sattr->index] = clamp_val(val, 0, 0xFF); 828 i2c_smbus_write_byte_data(client, reg, 829 data->pwm[sattr->nr][sattr->index]); 830 mutex_unlock(&data->lock); 831 832 return count; 833 } 834 835 static ssize_t stall_disable_show(struct device *dev, 836 struct device_attribute *attr, char *buf) 837 { 838 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 839 struct adt7475_data *data = dev_get_drvdata(dev); 840 841 u8 mask = BIT(5 + sattr->index); 842 843 return sprintf(buf, "%d\n", !!(data->enh_acoustics[0] & mask)); 844 } 845 846 static ssize_t stall_disable_store(struct device *dev, 847 struct device_attribute *attr, 848 const char *buf, size_t count) 849 { 850 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 851 struct adt7475_data *data = dev_get_drvdata(dev); 852 struct i2c_client *client = data->client; 853 long val; 854 u8 mask = BIT(5 + sattr->index); 855 856 if (kstrtol(buf, 10, &val)) 857 return -EINVAL; 858 859 mutex_lock(&data->lock); 860 861 data->enh_acoustics[0] &= ~mask; 862 if (val) 863 data->enh_acoustics[0] |= mask; 864 865 i2c_smbus_write_byte_data(client, REG_ENHANCE_ACOUSTICS1, 866 data->enh_acoustics[0]); 867 868 mutex_unlock(&data->lock); 869 870 return count; 871 } 872 873 /* Called by set_pwmctrl and set_pwmchan */ 874 875 static int hw_set_pwm(struct i2c_client *client, int index, 876 unsigned int pwmctl, unsigned int pwmchan) 877 { 878 struct adt7475_data *data = i2c_get_clientdata(client); 879 long val = 0; 880 881 switch (pwmctl) { 882 case 0: 883 val = 0x03; /* Run at full speed */ 884 break; 885 case 1: 886 val = 0x07; /* Manual mode */ 887 break; 888 case 2: 889 switch (pwmchan) { 890 case 1: 891 /* Remote1 controls PWM */ 892 val = 0x00; 893 break; 894 case 2: 895 /* local controls PWM */ 896 val = 0x01; 897 break; 898 case 4: 899 /* remote2 controls PWM */ 900 val = 0x02; 901 break; 902 case 6: 903 /* local/remote2 control PWM */ 904 val = 0x05; 905 break; 906 case 7: 907 /* All three control PWM */ 908 val = 0x06; 909 break; 910 default: 911 return -EINVAL; 912 } 913 break; 914 default: 915 return -EINVAL; 916 } 917 918 data->pwmctl[index] = pwmctl; 919 data->pwmchan[index] = pwmchan; 920 921 data->pwm[CONTROL][index] &= ~0xE0; 922 data->pwm[CONTROL][index] |= (val & 7) << 5; 923 924 i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index), 925 data->pwm[CONTROL][index]); 926 927 return 0; 928 } 929 930 static ssize_t pwmchan_store(struct device *dev, 931 struct device_attribute *attr, const char *buf, 932 size_t count) 933 { 934 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 935 struct adt7475_data *data = dev_get_drvdata(dev); 936 struct i2c_client *client = data->client; 937 int r; 938 long val; 939 940 if (kstrtol(buf, 10, &val)) 941 return -EINVAL; 942 943 mutex_lock(&data->lock); 944 /* Read Modify Write PWM values */ 945 adt7475_read_pwm(client, sattr->index); 946 r = hw_set_pwm(client, sattr->index, data->pwmctl[sattr->index], val); 947 if (r) 948 count = r; 949 mutex_unlock(&data->lock); 950 951 return count; 952 } 953 954 static ssize_t pwmctrl_store(struct device *dev, 955 struct device_attribute *attr, const char *buf, 956 size_t count) 957 { 958 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 959 struct adt7475_data *data = dev_get_drvdata(dev); 960 struct i2c_client *client = data->client; 961 int r; 962 long val; 963 964 if (kstrtol(buf, 10, &val)) 965 return -EINVAL; 966 967 mutex_lock(&data->lock); 968 /* Read Modify Write PWM values */ 969 adt7475_read_pwm(client, sattr->index); 970 r = hw_set_pwm(client, sattr->index, val, data->pwmchan[sattr->index]); 971 if (r) 972 count = r; 973 mutex_unlock(&data->lock); 974 975 return count; 976 } 977 978 /* List of frequencies for the PWM */ 979 static const int pwmfreq_table[] = { 980 11, 14, 22, 29, 35, 44, 58, 88, 22500 981 }; 982 983 static ssize_t pwmfreq_show(struct device *dev, struct device_attribute *attr, 984 char *buf) 985 { 986 struct adt7475_data *data = adt7475_update_device(dev); 987 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 988 int idx; 989 990 if (IS_ERR(data)) 991 return PTR_ERR(data); 992 idx = clamp_val(data->range[sattr->index] & 0xf, 0, 993 ARRAY_SIZE(pwmfreq_table) - 1); 994 995 return sprintf(buf, "%d\n", pwmfreq_table[idx]); 996 } 997 998 static ssize_t pwmfreq_store(struct device *dev, 999 struct device_attribute *attr, const char *buf, 1000 size_t count) 1001 { 1002 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 1003 struct adt7475_data *data = dev_get_drvdata(dev); 1004 struct i2c_client *client = data->client; 1005 int out; 1006 long val; 1007 1008 if (kstrtol(buf, 10, &val)) 1009 return -EINVAL; 1010 1011 out = find_closest(val, pwmfreq_table, ARRAY_SIZE(pwmfreq_table)); 1012 1013 mutex_lock(&data->lock); 1014 1015 data->range[sattr->index] = 1016 adt7475_read(TEMP_TRANGE_REG(sattr->index)); 1017 data->range[sattr->index] &= ~0xf; 1018 data->range[sattr->index] |= out; 1019 1020 i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index), 1021 data->range[sattr->index]); 1022 1023 mutex_unlock(&data->lock); 1024 return count; 1025 } 1026 1027 static ssize_t pwm_use_point2_pwm_at_crit_show(struct device *dev, 1028 struct device_attribute *devattr, 1029 char *buf) 1030 { 1031 struct adt7475_data *data = adt7475_update_device(dev); 1032 1033 if (IS_ERR(data)) 1034 return PTR_ERR(data); 1035 1036 return sprintf(buf, "%d\n", !!(data->config4 & CONFIG4_MAXDUTY)); 1037 } 1038 1039 static ssize_t pwm_use_point2_pwm_at_crit_store(struct device *dev, 1040 struct device_attribute *devattr, 1041 const char *buf, size_t count) 1042 { 1043 struct adt7475_data *data = dev_get_drvdata(dev); 1044 struct i2c_client *client = data->client; 1045 long val; 1046 1047 if (kstrtol(buf, 10, &val)) 1048 return -EINVAL; 1049 if (val != 0 && val != 1) 1050 return -EINVAL; 1051 1052 mutex_lock(&data->lock); 1053 data->config4 = i2c_smbus_read_byte_data(client, REG_CONFIG4); 1054 if (val) 1055 data->config4 |= CONFIG4_MAXDUTY; 1056 else 1057 data->config4 &= ~CONFIG4_MAXDUTY; 1058 i2c_smbus_write_byte_data(client, REG_CONFIG4, data->config4); 1059 mutex_unlock(&data->lock); 1060 1061 return count; 1062 } 1063 1064 static ssize_t vrm_show(struct device *dev, struct device_attribute *devattr, 1065 char *buf) 1066 { 1067 struct adt7475_data *data = dev_get_drvdata(dev); 1068 return sprintf(buf, "%d\n", (int)data->vrm); 1069 } 1070 1071 static ssize_t vrm_store(struct device *dev, struct device_attribute *devattr, 1072 const char *buf, size_t count) 1073 { 1074 struct adt7475_data *data = dev_get_drvdata(dev); 1075 long val; 1076 1077 if (kstrtol(buf, 10, &val)) 1078 return -EINVAL; 1079 if (val < 0 || val > 255) 1080 return -EINVAL; 1081 data->vrm = val; 1082 1083 return count; 1084 } 1085 1086 static ssize_t cpu0_vid_show(struct device *dev, 1087 struct device_attribute *devattr, char *buf) 1088 { 1089 struct adt7475_data *data = adt7475_update_device(dev); 1090 1091 if (IS_ERR(data)) 1092 return PTR_ERR(data); 1093 1094 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 1095 } 1096 1097 static SENSOR_DEVICE_ATTR_2_RO(in0_input, voltage, INPUT, 0); 1098 static SENSOR_DEVICE_ATTR_2_RW(in0_max, voltage, MAX, 0); 1099 static SENSOR_DEVICE_ATTR_2_RW(in0_min, voltage, MIN, 0); 1100 static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, voltage, ALARM, 0); 1101 static SENSOR_DEVICE_ATTR_2_RO(in1_input, voltage, INPUT, 1); 1102 static SENSOR_DEVICE_ATTR_2_RW(in1_max, voltage, MAX, 1); 1103 static SENSOR_DEVICE_ATTR_2_RW(in1_min, voltage, MIN, 1); 1104 static SENSOR_DEVICE_ATTR_2_RO(in1_alarm, voltage, ALARM, 1); 1105 static SENSOR_DEVICE_ATTR_2_RO(in2_input, voltage, INPUT, 2); 1106 static SENSOR_DEVICE_ATTR_2_RW(in2_max, voltage, MAX, 2); 1107 static SENSOR_DEVICE_ATTR_2_RW(in2_min, voltage, MIN, 2); 1108 static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, voltage, ALARM, 2); 1109 static SENSOR_DEVICE_ATTR_2_RO(in3_input, voltage, INPUT, 3); 1110 static SENSOR_DEVICE_ATTR_2_RW(in3_max, voltage, MAX, 3); 1111 static SENSOR_DEVICE_ATTR_2_RW(in3_min, voltage, MIN, 3); 1112 static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, voltage, ALARM, 3); 1113 static SENSOR_DEVICE_ATTR_2_RO(in4_input, voltage, INPUT, 4); 1114 static SENSOR_DEVICE_ATTR_2_RW(in4_max, voltage, MAX, 4); 1115 static SENSOR_DEVICE_ATTR_2_RW(in4_min, voltage, MIN, 4); 1116 static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, voltage, ALARM, 8); 1117 static SENSOR_DEVICE_ATTR_2_RO(in5_input, voltage, INPUT, 5); 1118 static SENSOR_DEVICE_ATTR_2_RW(in5_max, voltage, MAX, 5); 1119 static SENSOR_DEVICE_ATTR_2_RW(in5_min, voltage, MIN, 5); 1120 static SENSOR_DEVICE_ATTR_2_RO(in5_alarm, voltage, ALARM, 31); 1121 static SENSOR_DEVICE_ATTR_2_RO(in6_input, voltage, INPUT, 6); 1122 static SENSOR_DEVICE_ATTR_2_RW(in6_max, voltage, MAX, 6); 1123 static SENSOR_DEVICE_ATTR_2_RW(in6_min, voltage, MIN, 6); 1124 static SENSOR_DEVICE_ATTR_2_RO(in6_alarm, voltage, ALARM, 30); 1125 static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, INPUT, 0); 1126 static SENSOR_DEVICE_ATTR_2_RO(temp1_alarm, temp, ALARM, 0); 1127 static SENSOR_DEVICE_ATTR_2_RO(temp1_fault, temp, FAULT, 0); 1128 static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, MAX, 0); 1129 static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, MIN, 0); 1130 static SENSOR_DEVICE_ATTR_2_RW(temp1_offset, temp, OFFSET, 0); 1131 static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point1_temp, temp, AUTOMIN, 0); 1132 static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, point2, 0, 0); 1133 static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, THERM, 0); 1134 static SENSOR_DEVICE_ATTR_2_RW(temp1_crit_hyst, temp, HYSTERSIS, 0); 1135 static SENSOR_DEVICE_ATTR_2_RW(temp1_smoothing, temp_st, 0, 0); 1136 static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, INPUT, 1); 1137 static SENSOR_DEVICE_ATTR_2_RO(temp2_alarm, temp, ALARM, 1); 1138 static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, MAX, 1); 1139 static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, MIN, 1); 1140 static SENSOR_DEVICE_ATTR_2_RW(temp2_offset, temp, OFFSET, 1); 1141 static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp, AUTOMIN, 1); 1142 static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, point2, 0, 1); 1143 static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, THERM, 1); 1144 static SENSOR_DEVICE_ATTR_2_RW(temp2_crit_hyst, temp, HYSTERSIS, 1); 1145 static SENSOR_DEVICE_ATTR_2_RW(temp2_smoothing, temp_st, 0, 1); 1146 static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, INPUT, 2); 1147 static SENSOR_DEVICE_ATTR_2_RO(temp3_alarm, temp, ALARM, 2); 1148 static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, temp, FAULT, 2); 1149 static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, MAX, 2); 1150 static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, MIN, 2); 1151 static SENSOR_DEVICE_ATTR_2_RW(temp3_offset, temp, OFFSET, 2); 1152 static SENSOR_DEVICE_ATTR_2_RW(temp3_auto_point1_temp, temp, AUTOMIN, 2); 1153 static SENSOR_DEVICE_ATTR_2_RW(temp3_auto_point2_temp, point2, 0, 2); 1154 static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, THERM, 2); 1155 static SENSOR_DEVICE_ATTR_2_RW(temp3_crit_hyst, temp, HYSTERSIS, 2); 1156 static SENSOR_DEVICE_ATTR_2_RW(temp3_smoothing, temp_st, 0, 2); 1157 static SENSOR_DEVICE_ATTR_2_RO(fan1_input, tach, INPUT, 0); 1158 static SENSOR_DEVICE_ATTR_2_RW(fan1_min, tach, MIN, 0); 1159 static SENSOR_DEVICE_ATTR_2_RO(fan1_alarm, tach, ALARM, 0); 1160 static SENSOR_DEVICE_ATTR_2_RO(fan2_input, tach, INPUT, 1); 1161 static SENSOR_DEVICE_ATTR_2_RW(fan2_min, tach, MIN, 1); 1162 static SENSOR_DEVICE_ATTR_2_RO(fan2_alarm, tach, ALARM, 1); 1163 static SENSOR_DEVICE_ATTR_2_RO(fan3_input, tach, INPUT, 2); 1164 static SENSOR_DEVICE_ATTR_2_RW(fan3_min, tach, MIN, 2); 1165 static SENSOR_DEVICE_ATTR_2_RO(fan3_alarm, tach, ALARM, 2); 1166 static SENSOR_DEVICE_ATTR_2_RO(fan4_input, tach, INPUT, 3); 1167 static SENSOR_DEVICE_ATTR_2_RW(fan4_min, tach, MIN, 3); 1168 static SENSOR_DEVICE_ATTR_2_RO(fan4_alarm, tach, ALARM, 3); 1169 static SENSOR_DEVICE_ATTR_2_RW(pwm1, pwm, INPUT, 0); 1170 static SENSOR_DEVICE_ATTR_2_RW(pwm1_freq, pwmfreq, INPUT, 0); 1171 static SENSOR_DEVICE_ATTR_2_RW(pwm1_enable, pwmctrl, INPUT, 0); 1172 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_channels_temp, pwmchan, INPUT, 0); 1173 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, pwm, MIN, 0); 1174 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, pwm, MAX, 0); 1175 static SENSOR_DEVICE_ATTR_2_RW(pwm1_stall_disable, stall_disable, 0, 0); 1176 static SENSOR_DEVICE_ATTR_2_RW(pwm2, pwm, INPUT, 1); 1177 static SENSOR_DEVICE_ATTR_2_RW(pwm2_freq, pwmfreq, INPUT, 1); 1178 static SENSOR_DEVICE_ATTR_2_RW(pwm2_enable, pwmctrl, INPUT, 1); 1179 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_channels_temp, pwmchan, INPUT, 1); 1180 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, pwm, MIN, 1); 1181 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, pwm, MAX, 1); 1182 static SENSOR_DEVICE_ATTR_2_RW(pwm2_stall_disable, stall_disable, 0, 1); 1183 static SENSOR_DEVICE_ATTR_2_RW(pwm3, pwm, INPUT, 2); 1184 static SENSOR_DEVICE_ATTR_2_RW(pwm3_freq, pwmfreq, INPUT, 2); 1185 static SENSOR_DEVICE_ATTR_2_RW(pwm3_enable, pwmctrl, INPUT, 2); 1186 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_channels_temp, pwmchan, INPUT, 2); 1187 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_pwm, pwm, MIN, 2); 1188 static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point2_pwm, pwm, MAX, 2); 1189 static SENSOR_DEVICE_ATTR_2_RW(pwm3_stall_disable, stall_disable, 0, 2); 1190 1191 /* Non-standard name, might need revisiting */ 1192 static DEVICE_ATTR_RW(pwm_use_point2_pwm_at_crit); 1193 1194 static DEVICE_ATTR_RW(vrm); 1195 static DEVICE_ATTR_RO(cpu0_vid); 1196 1197 static struct attribute *adt7475_attrs[] = { 1198 &sensor_dev_attr_in1_input.dev_attr.attr, 1199 &sensor_dev_attr_in1_max.dev_attr.attr, 1200 &sensor_dev_attr_in1_min.dev_attr.attr, 1201 &sensor_dev_attr_in1_alarm.dev_attr.attr, 1202 &sensor_dev_attr_in2_input.dev_attr.attr, 1203 &sensor_dev_attr_in2_max.dev_attr.attr, 1204 &sensor_dev_attr_in2_min.dev_attr.attr, 1205 &sensor_dev_attr_in2_alarm.dev_attr.attr, 1206 &sensor_dev_attr_temp1_input.dev_attr.attr, 1207 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1208 &sensor_dev_attr_temp1_fault.dev_attr.attr, 1209 &sensor_dev_attr_temp1_max.dev_attr.attr, 1210 &sensor_dev_attr_temp1_min.dev_attr.attr, 1211 &sensor_dev_attr_temp1_offset.dev_attr.attr, 1212 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr, 1213 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr, 1214 &sensor_dev_attr_temp1_crit.dev_attr.attr, 1215 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 1216 &sensor_dev_attr_temp1_smoothing.dev_attr.attr, 1217 &sensor_dev_attr_temp2_input.dev_attr.attr, 1218 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1219 &sensor_dev_attr_temp2_max.dev_attr.attr, 1220 &sensor_dev_attr_temp2_min.dev_attr.attr, 1221 &sensor_dev_attr_temp2_offset.dev_attr.attr, 1222 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr, 1223 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr, 1224 &sensor_dev_attr_temp2_crit.dev_attr.attr, 1225 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr, 1226 &sensor_dev_attr_temp2_smoothing.dev_attr.attr, 1227 &sensor_dev_attr_temp3_input.dev_attr.attr, 1228 &sensor_dev_attr_temp3_fault.dev_attr.attr, 1229 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1230 &sensor_dev_attr_temp3_max.dev_attr.attr, 1231 &sensor_dev_attr_temp3_min.dev_attr.attr, 1232 &sensor_dev_attr_temp3_offset.dev_attr.attr, 1233 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr, 1234 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr, 1235 &sensor_dev_attr_temp3_crit.dev_attr.attr, 1236 &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr, 1237 &sensor_dev_attr_temp3_smoothing.dev_attr.attr, 1238 &sensor_dev_attr_fan1_input.dev_attr.attr, 1239 &sensor_dev_attr_fan1_min.dev_attr.attr, 1240 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1241 &sensor_dev_attr_fan2_input.dev_attr.attr, 1242 &sensor_dev_attr_fan2_min.dev_attr.attr, 1243 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1244 &sensor_dev_attr_fan3_input.dev_attr.attr, 1245 &sensor_dev_attr_fan3_min.dev_attr.attr, 1246 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1247 &sensor_dev_attr_pwm1.dev_attr.attr, 1248 &sensor_dev_attr_pwm1_freq.dev_attr.attr, 1249 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1250 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr, 1251 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 1252 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 1253 &sensor_dev_attr_pwm1_stall_disable.dev_attr.attr, 1254 &sensor_dev_attr_pwm3.dev_attr.attr, 1255 &sensor_dev_attr_pwm3_freq.dev_attr.attr, 1256 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1257 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr, 1258 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 1259 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 1260 &sensor_dev_attr_pwm3_stall_disable.dev_attr.attr, 1261 &dev_attr_pwm_use_point2_pwm_at_crit.attr, 1262 NULL, 1263 }; 1264 1265 static struct attribute *fan4_attrs[] = { 1266 &sensor_dev_attr_fan4_input.dev_attr.attr, 1267 &sensor_dev_attr_fan4_min.dev_attr.attr, 1268 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 1269 NULL 1270 }; 1271 1272 static struct attribute *pwm2_attrs[] = { 1273 &sensor_dev_attr_pwm2.dev_attr.attr, 1274 &sensor_dev_attr_pwm2_freq.dev_attr.attr, 1275 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1276 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr, 1277 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 1278 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 1279 &sensor_dev_attr_pwm2_stall_disable.dev_attr.attr, 1280 NULL 1281 }; 1282 1283 static struct attribute *in0_attrs[] = { 1284 &sensor_dev_attr_in0_input.dev_attr.attr, 1285 &sensor_dev_attr_in0_max.dev_attr.attr, 1286 &sensor_dev_attr_in0_min.dev_attr.attr, 1287 &sensor_dev_attr_in0_alarm.dev_attr.attr, 1288 NULL 1289 }; 1290 1291 static struct attribute *in3_attrs[] = { 1292 &sensor_dev_attr_in3_input.dev_attr.attr, 1293 &sensor_dev_attr_in3_max.dev_attr.attr, 1294 &sensor_dev_attr_in3_min.dev_attr.attr, 1295 &sensor_dev_attr_in3_alarm.dev_attr.attr, 1296 NULL 1297 }; 1298 1299 static struct attribute *in4_attrs[] = { 1300 &sensor_dev_attr_in4_input.dev_attr.attr, 1301 &sensor_dev_attr_in4_max.dev_attr.attr, 1302 &sensor_dev_attr_in4_min.dev_attr.attr, 1303 &sensor_dev_attr_in4_alarm.dev_attr.attr, 1304 NULL 1305 }; 1306 1307 static struct attribute *in5_attrs[] = { 1308 &sensor_dev_attr_in5_input.dev_attr.attr, 1309 &sensor_dev_attr_in5_max.dev_attr.attr, 1310 &sensor_dev_attr_in5_min.dev_attr.attr, 1311 &sensor_dev_attr_in5_alarm.dev_attr.attr, 1312 NULL 1313 }; 1314 1315 static struct attribute *in6_attrs[] = { 1316 &sensor_dev_attr_in6_input.dev_attr.attr, 1317 &sensor_dev_attr_in6_max.dev_attr.attr, 1318 &sensor_dev_attr_in6_min.dev_attr.attr, 1319 &sensor_dev_attr_in6_alarm.dev_attr.attr, 1320 NULL 1321 }; 1322 1323 static struct attribute *vid_attrs[] = { 1324 &dev_attr_cpu0_vid.attr, 1325 &dev_attr_vrm.attr, 1326 NULL 1327 }; 1328 1329 static const struct attribute_group adt7475_attr_group = { .attrs = adt7475_attrs }; 1330 static const struct attribute_group fan4_attr_group = { .attrs = fan4_attrs }; 1331 static const struct attribute_group pwm2_attr_group = { .attrs = pwm2_attrs }; 1332 static const struct attribute_group in0_attr_group = { .attrs = in0_attrs }; 1333 static const struct attribute_group in3_attr_group = { .attrs = in3_attrs }; 1334 static const struct attribute_group in4_attr_group = { .attrs = in4_attrs }; 1335 static const struct attribute_group in5_attr_group = { .attrs = in5_attrs }; 1336 static const struct attribute_group in6_attr_group = { .attrs = in6_attrs }; 1337 static const struct attribute_group vid_attr_group = { .attrs = vid_attrs }; 1338 1339 static int adt7475_detect(struct i2c_client *client, 1340 struct i2c_board_info *info) 1341 { 1342 struct i2c_adapter *adapter = client->adapter; 1343 int vendid, devid, devid2; 1344 const char *name; 1345 1346 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1347 return -ENODEV; 1348 1349 vendid = adt7475_read(REG_VENDID); 1350 devid2 = adt7475_read(REG_DEVID2); 1351 if (vendid != 0x41 || /* Analog Devices */ 1352 (devid2 & 0xf8) != 0x68) 1353 return -ENODEV; 1354 1355 devid = adt7475_read(REG_DEVID); 1356 if (devid == 0x73) 1357 name = "adt7473"; 1358 else if (devid == 0x75 && client->addr == 0x2e) 1359 name = "adt7475"; 1360 else if (devid == 0x76) 1361 name = "adt7476"; 1362 else if ((devid2 & 0xfc) == 0x6c) 1363 name = "adt7490"; 1364 else { 1365 dev_dbg(&adapter->dev, 1366 "Couldn't detect an ADT7473/75/76/90 part at " 1367 "0x%02x\n", (unsigned int)client->addr); 1368 return -ENODEV; 1369 } 1370 1371 strscpy(info->type, name, I2C_NAME_SIZE); 1372 1373 return 0; 1374 } 1375 1376 static int adt7475_update_limits(struct i2c_client *client) 1377 { 1378 struct adt7475_data *data = i2c_get_clientdata(client); 1379 int i; 1380 int ret; 1381 1382 ret = adt7475_read(REG_CONFIG4); 1383 if (ret < 0) 1384 return ret; 1385 data->config4 = ret; 1386 1387 ret = adt7475_read(REG_CONFIG5); 1388 if (ret < 0) 1389 return ret; 1390 data->config5 = ret; 1391 1392 for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) { 1393 if (!(data->has_voltage & (1 << i))) 1394 continue; 1395 /* Adjust values so they match the input precision */ 1396 ret = adt7475_read(VOLTAGE_MIN_REG(i)); 1397 if (ret < 0) 1398 return ret; 1399 data->voltage[MIN][i] = ret << 2; 1400 1401 ret = adt7475_read(VOLTAGE_MAX_REG(i)); 1402 if (ret < 0) 1403 return ret; 1404 data->voltage[MAX][i] = ret << 2; 1405 } 1406 1407 if (data->has_voltage & (1 << 5)) { 1408 ret = adt7475_read(REG_VTT_MIN); 1409 if (ret < 0) 1410 return ret; 1411 data->voltage[MIN][5] = ret << 2; 1412 1413 ret = adt7475_read(REG_VTT_MAX); 1414 if (ret < 0) 1415 return ret; 1416 data->voltage[MAX][5] = ret << 2; 1417 } 1418 1419 if (data->has_voltage & (1 << 6)) { 1420 ret = adt7475_read(REG_IMON_MIN); 1421 if (ret < 0) 1422 return ret; 1423 data->voltage[MIN][6] = ret << 2; 1424 1425 ret = adt7475_read(REG_IMON_MAX); 1426 if (ret < 0) 1427 return ret; 1428 data->voltage[MAX][6] = ret << 2; 1429 } 1430 1431 for (i = 0; i < ADT7475_TEMP_COUNT; i++) { 1432 /* Adjust values so they match the input precision */ 1433 ret = adt7475_read(TEMP_MIN_REG(i)); 1434 if (ret < 0) 1435 return ret; 1436 data->temp[MIN][i] = ret << 2; 1437 1438 ret = adt7475_read(TEMP_MAX_REG(i)); 1439 if (ret < 0) 1440 return ret; 1441 data->temp[MAX][i] = ret << 2; 1442 1443 ret = adt7475_read(TEMP_TMIN_REG(i)); 1444 if (ret < 0) 1445 return ret; 1446 data->temp[AUTOMIN][i] = ret << 2; 1447 1448 ret = adt7475_read(TEMP_THERM_REG(i)); 1449 if (ret < 0) 1450 return ret; 1451 data->temp[THERM][i] = ret << 2; 1452 1453 ret = adt7475_read(TEMP_OFFSET_REG(i)); 1454 if (ret < 0) 1455 return ret; 1456 data->temp[OFFSET][i] = ret; 1457 } 1458 adt7475_read_hystersis(client); 1459 1460 for (i = 0; i < ADT7475_TACH_COUNT; i++) { 1461 if (i == 3 && !data->has_fan4) 1462 continue; 1463 ret = adt7475_read_word(client, TACH_MIN_REG(i)); 1464 if (ret < 0) 1465 return ret; 1466 data->tach[MIN][i] = ret; 1467 } 1468 1469 for (i = 0; i < ADT7475_PWM_COUNT; i++) { 1470 if (i == 1 && !data->has_pwm2) 1471 continue; 1472 ret = adt7475_read(PWM_MAX_REG(i)); 1473 if (ret < 0) 1474 return ret; 1475 data->pwm[MAX][i] = ret; 1476 1477 ret = adt7475_read(PWM_MIN_REG(i)); 1478 if (ret < 0) 1479 return ret; 1480 data->pwm[MIN][i] = ret; 1481 /* Set the channel and control information */ 1482 adt7475_read_pwm(client, i); 1483 } 1484 1485 ret = adt7475_read(TEMP_TRANGE_REG(0)); 1486 if (ret < 0) 1487 return ret; 1488 data->range[0] = ret; 1489 1490 ret = adt7475_read(TEMP_TRANGE_REG(1)); 1491 if (ret < 0) 1492 return ret; 1493 data->range[1] = ret; 1494 1495 ret = adt7475_read(TEMP_TRANGE_REG(2)); 1496 if (ret < 0) 1497 return ret; 1498 data->range[2] = ret; 1499 1500 return 0; 1501 } 1502 1503 static int load_config3(const struct i2c_client *client, const char *propname) 1504 { 1505 const char *function; 1506 u8 config3; 1507 int ret; 1508 1509 ret = device_property_read_string(&client->dev, propname, &function); 1510 if (!ret) { 1511 ret = adt7475_read(REG_CONFIG3); 1512 if (ret < 0) 1513 return ret; 1514 1515 config3 = ret & ~CONFIG3_SMBALERT; 1516 if (!strcmp("pwm2", function)) 1517 ; 1518 else if (!strcmp("smbalert#", function)) 1519 config3 |= CONFIG3_SMBALERT; 1520 else 1521 return -EINVAL; 1522 1523 return i2c_smbus_write_byte_data(client, REG_CONFIG3, config3); 1524 } 1525 1526 return 0; 1527 } 1528 1529 static int load_config4(const struct i2c_client *client, const char *propname) 1530 { 1531 const char *function; 1532 u8 config4; 1533 int ret; 1534 1535 ret = device_property_read_string(&client->dev, propname, &function); 1536 if (!ret) { 1537 ret = adt7475_read(REG_CONFIG4); 1538 if (ret < 0) 1539 return ret; 1540 1541 config4 = ret & ~CONFIG4_PINFUNC; 1542 1543 if (!strcmp("tach4", function)) 1544 ; 1545 else if (!strcmp("therm#", function)) 1546 config4 |= CONFIG4_THERM; 1547 else if (!strcmp("smbalert#", function)) 1548 config4 |= CONFIG4_SMBALERT; 1549 else if (!strcmp("gpio", function)) 1550 config4 |= CONFIG4_PINFUNC; 1551 else 1552 return -EINVAL; 1553 1554 return i2c_smbus_write_byte_data(client, REG_CONFIG4, config4); 1555 } 1556 1557 return 0; 1558 } 1559 1560 static int load_config(const struct i2c_client *client, enum chips chip) 1561 { 1562 int err; 1563 const char *prop1, *prop2; 1564 1565 switch (chip) { 1566 case adt7473: 1567 case adt7475: 1568 prop1 = "adi,pin5-function"; 1569 prop2 = "adi,pin9-function"; 1570 break; 1571 case adt7476: 1572 case adt7490: 1573 prop1 = "adi,pin10-function"; 1574 prop2 = "adi,pin14-function"; 1575 break; 1576 } 1577 1578 err = load_config3(client, prop1); 1579 if (err) { 1580 dev_err(&client->dev, "failed to configure %s\n", prop1); 1581 return err; 1582 } 1583 1584 err = load_config4(client, prop2); 1585 if (err) { 1586 dev_err(&client->dev, "failed to configure %s\n", prop2); 1587 return err; 1588 } 1589 1590 return 0; 1591 } 1592 1593 static int set_property_bit(const struct i2c_client *client, char *property, 1594 u8 *config, u8 bit_index) 1595 { 1596 u32 prop_value = 0; 1597 int ret = device_property_read_u32(&client->dev, property, 1598 &prop_value); 1599 1600 if (!ret) { 1601 if (prop_value) 1602 *config |= (1 << bit_index); 1603 else 1604 *config &= ~(1 << bit_index); 1605 } 1606 1607 return ret; 1608 } 1609 1610 static int load_attenuators(const struct i2c_client *client, enum chips chip, 1611 struct adt7475_data *data) 1612 { 1613 switch (chip) { 1614 case adt7476: 1615 case adt7490: 1616 set_property_bit(client, "adi,bypass-attenuator-in0", 1617 &data->config4, 4); 1618 set_property_bit(client, "adi,bypass-attenuator-in1", 1619 &data->config4, 5); 1620 set_property_bit(client, "adi,bypass-attenuator-in3", 1621 &data->config4, 6); 1622 set_property_bit(client, "adi,bypass-attenuator-in4", 1623 &data->config4, 7); 1624 1625 return i2c_smbus_write_byte_data(client, REG_CONFIG4, 1626 data->config4); 1627 case adt7473: 1628 case adt7475: 1629 set_property_bit(client, "adi,bypass-attenuator-in1", 1630 &data->config2, 5); 1631 1632 return i2c_smbus_write_byte_data(client, REG_CONFIG2, 1633 data->config2); 1634 } 1635 1636 return 0; 1637 } 1638 1639 static int adt7475_set_pwm_polarity(struct i2c_client *client) 1640 { 1641 u32 states[ADT7475_PWM_COUNT]; 1642 int ret, i; 1643 u8 val; 1644 1645 ret = device_property_read_u32_array(&client->dev, 1646 "adi,pwm-active-state", states, 1647 ARRAY_SIZE(states)); 1648 if (ret) 1649 return ret; 1650 1651 for (i = 0; i < ADT7475_PWM_COUNT; i++) { 1652 ret = adt7475_read(PWM_CONFIG_REG(i)); 1653 if (ret < 0) 1654 return ret; 1655 val = ret; 1656 if (states[i]) 1657 val &= ~BIT(4); 1658 else 1659 val |= BIT(4); 1660 1661 ret = i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(i), val); 1662 if (ret) 1663 return ret; 1664 } 1665 1666 return 0; 1667 } 1668 1669 struct adt7475_pwm_config { 1670 int index; 1671 int freq; 1672 int flags; 1673 int duty; 1674 }; 1675 1676 static int _adt7475_pwm_properties_parse_args(u32 args[4], struct adt7475_pwm_config *cfg) 1677 { 1678 int freq_hz; 1679 int duty; 1680 1681 if (args[1] == 0) 1682 return -EINVAL; 1683 1684 freq_hz = 1000000000UL / args[1]; 1685 if (args[3] >= args[1]) 1686 duty = 255; 1687 else 1688 duty = div_u64(255ULL * args[3], args[1]); 1689 1690 cfg->index = args[0]; 1691 cfg->freq = find_closest(freq_hz, pwmfreq_table, ARRAY_SIZE(pwmfreq_table)); 1692 cfg->flags = args[2]; 1693 cfg->duty = duty; 1694 1695 return 0; 1696 } 1697 1698 static int adt7475_pwm_properties_parse_reference_args(struct fwnode_handle *fwnode, 1699 struct adt7475_pwm_config *cfg) 1700 { 1701 int ret, i; 1702 struct fwnode_reference_args rargs = {}; 1703 u32 args[4] = {}; 1704 1705 ret = fwnode_property_get_reference_args(fwnode, "pwms", "#pwm-cells", 0, 0, &rargs); 1706 if (ret) 1707 return ret; 1708 1709 if (rargs.nargs != 3 && rargs.nargs != 4) { 1710 fwnode_handle_put(rargs.fwnode); 1711 return -EINVAL; 1712 } 1713 1714 /* Let duty_cycle default to period */ 1715 args[3] = rargs.args[1]; 1716 1717 for (i = 0; i < rargs.nargs; i++) 1718 args[i] = rargs.args[i]; 1719 1720 ret = _adt7475_pwm_properties_parse_args(args, cfg); 1721 1722 fwnode_handle_put(rargs.fwnode); 1723 1724 return ret; 1725 } 1726 1727 static int adt7475_pwm_properties_parse_args(struct fwnode_handle *fwnode, 1728 struct adt7475_pwm_config *cfg) 1729 { 1730 int ret; 1731 u32 args[4] = {}; 1732 size_t n_vals = fwnode_property_count_u32(fwnode, "pwms"); 1733 1734 if (n_vals != 3 && n_vals != 4) 1735 return -EOVERFLOW; 1736 1737 ret = fwnode_property_read_u32_array(fwnode, "pwms", args, n_vals); 1738 if (ret) 1739 return ret; 1740 1741 /* 1742 * If there are no item to define the duty_cycle, default it to the 1743 * period. 1744 */ 1745 if (n_vals == 3) 1746 args[3] = args[1]; 1747 1748 return _adt7475_pwm_properties_parse_args(args, cfg); 1749 } 1750 1751 static int adt7475_fan_pwm_config(struct i2c_client *client) 1752 { 1753 struct adt7475_data *data = i2c_get_clientdata(client); 1754 struct adt7475_pwm_config cfg = {}; 1755 int ret; 1756 1757 device_for_each_child_node_scoped(&client->dev, child) { 1758 if (!fwnode_property_present(child, "pwms")) 1759 continue; 1760 1761 if (is_of_node(child)) 1762 ret = adt7475_pwm_properties_parse_reference_args(child, &cfg); 1763 else 1764 ret = adt7475_pwm_properties_parse_args(child, &cfg); 1765 1766 if (cfg.index >= ADT7475_PWM_COUNT) 1767 return -EINVAL; 1768 1769 ret = adt7475_read(PWM_CONFIG_REG(cfg.index)); 1770 if (ret < 0) 1771 return ret; 1772 data->pwm[CONTROL][cfg.index] = ret; 1773 if (cfg.flags & PWM_POLARITY_INVERTED) 1774 data->pwm[CONTROL][cfg.index] |= BIT(4); 1775 else 1776 data->pwm[CONTROL][cfg.index] &= ~BIT(4); 1777 1778 /* Force to manual mode so PWM values take effect */ 1779 data->pwm[CONTROL][cfg.index] &= ~0xE0; 1780 data->pwm[CONTROL][cfg.index] |= 0x07 << 5; 1781 1782 ret = i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(cfg.index), 1783 data->pwm[CONTROL][cfg.index]); 1784 if (ret) 1785 return ret; 1786 1787 data->pwm[INPUT][cfg.index] = cfg.duty; 1788 ret = i2c_smbus_write_byte_data(client, PWM_REG(cfg.index), 1789 data->pwm[INPUT][cfg.index]); 1790 if (ret) 1791 return ret; 1792 1793 data->range[cfg.index] = adt7475_read(TEMP_TRANGE_REG(cfg.index)); 1794 data->range[cfg.index] &= ~0xf; 1795 data->range[cfg.index] |= cfg.freq; 1796 1797 ret = i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(cfg.index), 1798 data->range[cfg.index]); 1799 if (ret) 1800 return ret; 1801 } 1802 1803 return 0; 1804 } 1805 1806 static int adt7475_probe(struct i2c_client *client) 1807 { 1808 enum chips chip; 1809 static const char * const names[] = { 1810 [adt7473] = "ADT7473", 1811 [adt7475] = "ADT7475", 1812 [adt7476] = "ADT7476", 1813 [adt7490] = "ADT7490", 1814 }; 1815 1816 struct adt7475_data *data; 1817 struct device *hwmon_dev; 1818 int i, ret = 0, revision, group_num = 0; 1819 u8 config3; 1820 1821 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 1822 if (data == NULL) 1823 return -ENOMEM; 1824 1825 mutex_init(&data->lock); 1826 data->client = client; 1827 i2c_set_clientdata(client, data); 1828 1829 chip = (uintptr_t)i2c_get_match_data(client); 1830 1831 /* Initialize device-specific values */ 1832 switch (chip) { 1833 case adt7476: 1834 data->has_voltage = 0x0e; /* in1 to in3 */ 1835 revision = adt7475_read(REG_DEVID2) & 0x07; 1836 break; 1837 case adt7490: 1838 data->has_voltage = 0x7e; /* in1 to in6 */ 1839 revision = adt7475_read(REG_DEVID2) & 0x03; 1840 if (revision == 0x03) 1841 revision += adt7475_read(REG_DEVREV2); 1842 break; 1843 default: 1844 data->has_voltage = 0x06; /* in1, in2 */ 1845 revision = adt7475_read(REG_DEVID2) & 0x07; 1846 } 1847 1848 ret = load_config(client, chip); 1849 if (ret) 1850 return ret; 1851 1852 config3 = adt7475_read(REG_CONFIG3); 1853 /* Pin PWM2 may alternatively be used for ALERT output */ 1854 if (!(config3 & CONFIG3_SMBALERT)) 1855 data->has_pwm2 = 1; 1856 /* Meaning of this bit is inverted for the ADT7473-1 */ 1857 if (chip == adt7473 && revision >= 1) 1858 data->has_pwm2 = !data->has_pwm2; 1859 1860 data->config4 = adt7475_read(REG_CONFIG4); 1861 /* Pin TACH4 may alternatively be used for THERM */ 1862 if ((data->config4 & CONFIG4_PINFUNC) == 0x0) 1863 data->has_fan4 = 1; 1864 1865 /* 1866 * THERM configuration is more complex on the ADT7476 and ADT7490, 1867 * because 2 different pins (TACH4 and +2.5 Vin) can be used for 1868 * this function 1869 */ 1870 if (chip == adt7490) { 1871 if ((data->config4 & CONFIG4_PINFUNC) == 0x1 && 1872 !(config3 & CONFIG3_THERM)) 1873 data->has_fan4 = 1; 1874 } 1875 if (chip == adt7476 || chip == adt7490) { 1876 if (!(config3 & CONFIG3_THERM) || 1877 (data->config4 & CONFIG4_PINFUNC) == 0x1) 1878 data->has_voltage |= (1 << 0); /* in0 */ 1879 } 1880 1881 /* 1882 * On the ADT7476, the +12V input pin may instead be used as VID5, 1883 * and VID pins may alternatively be used as GPIO 1884 */ 1885 if (chip == adt7476) { 1886 u8 vid = adt7475_read(REG_VID); 1887 if (!(vid & VID_VIDSEL)) 1888 data->has_voltage |= (1 << 4); /* in4 */ 1889 1890 data->has_vid = !(adt7475_read(REG_CONFIG5) & CONFIG5_VIDGPIO); 1891 } 1892 1893 /* Voltage attenuators can be bypassed, globally or individually */ 1894 data->config2 = adt7475_read(REG_CONFIG2); 1895 ret = load_attenuators(client, chip, data); 1896 if (ret) 1897 dev_warn(&client->dev, "Error configuring attenuator bypass\n"); 1898 1899 if (data->config2 & CONFIG2_ATTN) { 1900 data->bypass_attn = (0x3 << 3) | 0x3; 1901 } else { 1902 data->bypass_attn = ((data->config4 & CONFIG4_ATTN_IN10) >> 4) | 1903 ((data->config4 & CONFIG4_ATTN_IN43) >> 3); 1904 } 1905 data->bypass_attn &= data->has_voltage; 1906 1907 /* 1908 * Call adt7475_read_pwm for all pwm's as this will reprogram any 1909 * pwm's which are disabled to manual mode with 0% duty cycle 1910 */ 1911 for (i = 0; i < ADT7475_PWM_COUNT; i++) 1912 adt7475_read_pwm(client, i); 1913 1914 ret = adt7475_set_pwm_polarity(client); 1915 if (ret && ret != -EINVAL) 1916 dev_warn(&client->dev, "Error configuring pwm polarity\n"); 1917 1918 ret = adt7475_fan_pwm_config(client); 1919 if (ret) 1920 dev_warn(&client->dev, "Error %d configuring fan/pwm\n", ret); 1921 1922 /* Start monitoring */ 1923 switch (chip) { 1924 case adt7475: 1925 case adt7476: 1926 i2c_smbus_write_byte_data(client, REG_CONFIG1, 1927 adt7475_read(REG_CONFIG1) | 0x01); 1928 break; 1929 default: 1930 break; 1931 } 1932 1933 data->groups[group_num++] = &adt7475_attr_group; 1934 1935 /* Features that can be disabled individually */ 1936 if (data->has_fan4) { 1937 data->groups[group_num++] = &fan4_attr_group; 1938 } 1939 if (data->has_pwm2) { 1940 data->groups[group_num++] = &pwm2_attr_group; 1941 } 1942 if (data->has_voltage & (1 << 0)) { 1943 data->groups[group_num++] = &in0_attr_group; 1944 } 1945 if (data->has_voltage & (1 << 3)) { 1946 data->groups[group_num++] = &in3_attr_group; 1947 } 1948 if (data->has_voltage & (1 << 4)) { 1949 data->groups[group_num++] = &in4_attr_group; 1950 } 1951 if (data->has_voltage & (1 << 5)) { 1952 data->groups[group_num++] = &in5_attr_group; 1953 } 1954 if (data->has_voltage & (1 << 6)) { 1955 data->groups[group_num++] = &in6_attr_group; 1956 } 1957 if (data->has_vid) { 1958 data->vrm = vid_which_vrm(); 1959 data->groups[group_num] = &vid_attr_group; 1960 } 1961 1962 /* register device with all the acquired attributes */ 1963 hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev, 1964 client->name, data, 1965 data->groups); 1966 1967 if (IS_ERR(hwmon_dev)) { 1968 ret = PTR_ERR(hwmon_dev); 1969 return ret; 1970 } 1971 1972 dev_info(&client->dev, "%s device, revision %d\n", 1973 names[chip], revision); 1974 if ((data->has_voltage & 0x11) || data->has_fan4 || data->has_pwm2) 1975 dev_info(&client->dev, "Optional features:%s%s%s%s%s\n", 1976 (data->has_voltage & (1 << 0)) ? " in0" : "", 1977 (data->has_voltage & (1 << 4)) ? " in4" : "", 1978 data->has_fan4 ? " fan4" : "", 1979 data->has_pwm2 ? " pwm2" : "", 1980 data->has_vid ? " vid" : ""); 1981 if (data->bypass_attn) 1982 dev_info(&client->dev, "Bypassing attenuators on:%s%s%s%s\n", 1983 (data->bypass_attn & (1 << 0)) ? " in0" : "", 1984 (data->bypass_attn & (1 << 1)) ? " in1" : "", 1985 (data->bypass_attn & (1 << 3)) ? " in3" : "", 1986 (data->bypass_attn & (1 << 4)) ? " in4" : ""); 1987 1988 /* Limits and settings, should never change update more than once */ 1989 ret = adt7475_update_limits(client); 1990 if (ret) 1991 return ret; 1992 1993 return 0; 1994 } 1995 1996 static struct i2c_driver adt7475_driver = { 1997 .class = I2C_CLASS_HWMON, 1998 .driver = { 1999 .name = "adt7475", 2000 .of_match_table = adt7475_of_match, 2001 }, 2002 .probe = adt7475_probe, 2003 .id_table = adt7475_id, 2004 .detect = adt7475_detect, 2005 .address_list = normal_i2c, 2006 }; 2007 2008 static void adt7475_read_hystersis(struct i2c_client *client) 2009 { 2010 struct adt7475_data *data = i2c_get_clientdata(client); 2011 2012 data->temp[HYSTERSIS][0] = (u16) adt7475_read(REG_REMOTE1_HYSTERSIS); 2013 data->temp[HYSTERSIS][1] = data->temp[HYSTERSIS][0]; 2014 data->temp[HYSTERSIS][2] = (u16) adt7475_read(REG_REMOTE2_HYSTERSIS); 2015 } 2016 2017 static void adt7475_read_pwm(struct i2c_client *client, int index) 2018 { 2019 struct adt7475_data *data = i2c_get_clientdata(client); 2020 unsigned int v; 2021 2022 data->pwm[CONTROL][index] = adt7475_read(PWM_CONFIG_REG(index)); 2023 2024 /* 2025 * Figure out the internal value for pwmctrl and pwmchan 2026 * based on the current settings 2027 */ 2028 v = (data->pwm[CONTROL][index] >> 5) & 7; 2029 2030 if (v == 3) 2031 data->pwmctl[index] = 0; 2032 else if (v == 7) 2033 data->pwmctl[index] = 1; 2034 else if (v == 4) { 2035 /* 2036 * The fan is disabled - we don't want to 2037 * support that, so change to manual mode and 2038 * set the duty cycle to 0 instead 2039 */ 2040 data->pwm[INPUT][index] = 0; 2041 data->pwm[CONTROL][index] &= ~0xE0; 2042 data->pwm[CONTROL][index] |= (7 << 5); 2043 2044 i2c_smbus_write_byte_data(client, PWM_REG(index), 2045 data->pwm[INPUT][index]); 2046 2047 i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index), 2048 data->pwm[CONTROL][index]); 2049 2050 data->pwmctl[index] = 1; 2051 } else { 2052 data->pwmctl[index] = 2; 2053 2054 switch (v) { 2055 case 0: 2056 data->pwmchan[index] = 1; 2057 break; 2058 case 1: 2059 data->pwmchan[index] = 2; 2060 break; 2061 case 2: 2062 data->pwmchan[index] = 4; 2063 break; 2064 case 5: 2065 data->pwmchan[index] = 6; 2066 break; 2067 case 6: 2068 data->pwmchan[index] = 7; 2069 break; 2070 } 2071 } 2072 } 2073 2074 static int adt7475_update_measure(struct device *dev) 2075 { 2076 struct adt7475_data *data = dev_get_drvdata(dev); 2077 struct i2c_client *client = data->client; 2078 u16 ext; 2079 int i; 2080 int ret; 2081 2082 ret = adt7475_read(REG_STATUS2); 2083 if (ret < 0) 2084 return ret; 2085 data->alarms = ret << 8; 2086 2087 ret = adt7475_read(REG_STATUS1); 2088 if (ret < 0) 2089 return ret; 2090 data->alarms |= ret; 2091 2092 ret = adt7475_read(REG_EXTEND2); 2093 if (ret < 0) 2094 return ret; 2095 2096 ext = (ret << 8); 2097 2098 ret = adt7475_read(REG_EXTEND1); 2099 if (ret < 0) 2100 return ret; 2101 2102 ext |= ret; 2103 2104 for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) { 2105 if (!(data->has_voltage & (1 << i))) 2106 continue; 2107 ret = adt7475_read(VOLTAGE_REG(i)); 2108 if (ret < 0) 2109 return ret; 2110 data->voltage[INPUT][i] = 2111 (ret << 2) | 2112 ((ext >> (i * 2)) & 3); 2113 } 2114 2115 for (i = 0; i < ADT7475_TEMP_COUNT; i++) { 2116 ret = adt7475_read(TEMP_REG(i)); 2117 if (ret < 0) 2118 return ret; 2119 data->temp[INPUT][i] = 2120 (ret << 2) | 2121 ((ext >> ((i + 5) * 2)) & 3); 2122 } 2123 2124 if (data->has_voltage & (1 << 5)) { 2125 ret = adt7475_read(REG_STATUS4); 2126 if (ret < 0) 2127 return ret; 2128 data->alarms |= ret << 24; 2129 2130 ret = adt7475_read(REG_EXTEND3); 2131 if (ret < 0) 2132 return ret; 2133 ext = ret; 2134 2135 ret = adt7475_read(REG_VTT); 2136 if (ret < 0) 2137 return ret; 2138 data->voltage[INPUT][5] = ret << 2 | 2139 ((ext >> 4) & 3); 2140 } 2141 2142 if (data->has_voltage & (1 << 6)) { 2143 ret = adt7475_read(REG_STATUS4); 2144 if (ret < 0) 2145 return ret; 2146 data->alarms |= ret << 24; 2147 2148 ret = adt7475_read(REG_EXTEND3); 2149 if (ret < 0) 2150 return ret; 2151 ext = ret; 2152 2153 ret = adt7475_read(REG_IMON); 2154 if (ret < 0) 2155 return ret; 2156 data->voltage[INPUT][6] = ret << 2 | 2157 ((ext >> 6) & 3); 2158 } 2159 2160 for (i = 0; i < ADT7475_TACH_COUNT; i++) { 2161 if (i == 3 && !data->has_fan4) 2162 continue; 2163 ret = adt7475_read_word(client, TACH_REG(i)); 2164 if (ret < 0) 2165 return ret; 2166 data->tach[INPUT][i] = ret; 2167 } 2168 2169 /* Updated by hw when in auto mode */ 2170 for (i = 0; i < ADT7475_PWM_COUNT; i++) { 2171 if (i == 1 && !data->has_pwm2) 2172 continue; 2173 ret = adt7475_read(PWM_REG(i)); 2174 if (ret < 0) 2175 return ret; 2176 data->pwm[INPUT][i] = ret; 2177 } 2178 2179 if (data->has_vid) { 2180 ret = adt7475_read(REG_VID); 2181 if (ret < 0) 2182 return ret; 2183 data->vid = ret & 0x3f; 2184 } 2185 2186 return 0; 2187 } 2188 2189 static struct adt7475_data *adt7475_update_device(struct device *dev) 2190 { 2191 struct adt7475_data *data = dev_get_drvdata(dev); 2192 int ret; 2193 2194 mutex_lock(&data->lock); 2195 2196 /* Measurement values update every 2 seconds */ 2197 if (time_after(jiffies, data->measure_updated + HZ * 2) || 2198 !data->valid) { 2199 ret = adt7475_update_measure(dev); 2200 if (ret) { 2201 data->valid = false; 2202 mutex_unlock(&data->lock); 2203 return ERR_PTR(ret); 2204 } 2205 data->measure_updated = jiffies; 2206 data->valid = true; 2207 } 2208 2209 mutex_unlock(&data->lock); 2210 2211 return data; 2212 } 2213 2214 module_i2c_driver(adt7475_driver); 2215 2216 MODULE_AUTHOR("Advanced Micro Devices, Inc"); 2217 MODULE_DESCRIPTION("adt7475 driver"); 2218 MODULE_LICENSE("GPL"); 2219