1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * A hwmon driver for the Analog Devices ADT7462 4 * Copyright (C) 2008 IBM 5 * 6 * Author: Darrick J. Wong <darrick.wong@oracle.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/jiffies.h> 11 #include <linux/i2c.h> 12 #include <linux/hwmon.h> 13 #include <linux/hwmon-sysfs.h> 14 #include <linux/err.h> 15 #include <linux/mod_devicetable.h> 16 #include <linux/mutex.h> 17 #include <linux/log2.h> 18 #include <linux/slab.h> 19 20 /* Addresses to scan */ 21 static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END }; 22 23 /* ADT7462 registers */ 24 #define ADT7462_REG_DEVICE 0x3D 25 #define ADT7462_REG_VENDOR 0x3E 26 #define ADT7462_REG_REVISION 0x3F 27 28 #define ADT7462_REG_MIN_TEMP_BASE_ADDR 0x44 29 #define ADT7462_REG_MIN_TEMP_MAX_ADDR 0x47 30 #define ADT7462_REG_MAX_TEMP_BASE_ADDR 0x48 31 #define ADT7462_REG_MAX_TEMP_MAX_ADDR 0x4B 32 #define ADT7462_REG_TEMP_BASE_ADDR 0x88 33 #define ADT7462_REG_TEMP_MAX_ADDR 0x8F 34 35 #define ADT7462_REG_FAN_BASE_ADDR 0x98 36 #define ADT7462_REG_FAN_MAX_ADDR 0x9F 37 #define ADT7462_REG_FAN2_BASE_ADDR 0xA2 38 #define ADT7462_REG_FAN2_MAX_ADDR 0xA9 39 #define ADT7462_REG_FAN_ENABLE 0x07 40 #define ADT7462_REG_FAN_MIN_BASE_ADDR 0x78 41 #define ADT7462_REG_FAN_MIN_MAX_ADDR 0x7F 42 43 #define ADT7462_REG_CFG2 0x02 44 #define ADT7462_FSPD_MASK 0x20 45 46 #define ADT7462_REG_PWM_BASE_ADDR 0xAA 47 #define ADT7462_REG_PWM_MAX_ADDR 0xAD 48 #define ADT7462_REG_PWM_MIN_BASE_ADDR 0x28 49 #define ADT7462_REG_PWM_MIN_MAX_ADDR 0x2B 50 #define ADT7462_REG_PWM_MAX 0x2C 51 #define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR 0x5C 52 #define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR 0x5F 53 #define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR 0x60 54 #define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63 55 #define ADT7462_PWM_HYST_MASK 0x0F 56 #define ADT7462_PWM_RANGE_MASK 0xF0 57 #define ADT7462_PWM_RANGE_SHIFT 4 58 #define ADT7462_REG_PWM_CFG_BASE_ADDR 0x21 59 #define ADT7462_REG_PWM_CFG_MAX_ADDR 0x24 60 #define ADT7462_PWM_CHANNEL_MASK 0xE0 61 #define ADT7462_PWM_CHANNEL_SHIFT 5 62 63 #define ADT7462_REG_PIN_CFG_BASE_ADDR 0x10 64 #define ADT7462_REG_PIN_CFG_MAX_ADDR 0x13 65 #define ADT7462_PIN7_INPUT 0x01 /* cfg0 */ 66 #define ADT7462_DIODE3_INPUT 0x20 67 #define ADT7462_DIODE1_INPUT 0x40 68 #define ADT7462_VID_INPUT 0x80 69 #define ADT7462_PIN22_INPUT 0x04 /* cfg1 */ 70 #define ADT7462_PIN21_INPUT 0x08 71 #define ADT7462_PIN19_INPUT 0x10 72 #define ADT7462_PIN15_INPUT 0x20 73 #define ADT7462_PIN13_INPUT 0x40 74 #define ADT7462_PIN8_INPUT 0x80 75 #define ADT7462_PIN23_MASK 0x03 76 #define ADT7462_PIN23_SHIFT 0 77 #define ADT7462_PIN26_MASK 0x0C /* cfg2 */ 78 #define ADT7462_PIN26_SHIFT 2 79 #define ADT7462_PIN25_MASK 0x30 80 #define ADT7462_PIN25_SHIFT 4 81 #define ADT7462_PIN24_MASK 0xC0 82 #define ADT7462_PIN24_SHIFT 6 83 #define ADT7462_PIN26_VOLT_INPUT 0x08 84 #define ADT7462_PIN25_VOLT_INPUT 0x20 85 #define ADT7462_PIN28_SHIFT 4 /* cfg3 */ 86 #define ADT7462_PIN28_VOLT 0x5 87 88 #define ADT7462_REG_ALARM1 0xB8 89 #define ADT7462_LT_ALARM 0x02 90 #define ADT7462_R1T_ALARM 0x04 91 #define ADT7462_R2T_ALARM 0x08 92 #define ADT7462_R3T_ALARM 0x10 93 #define ADT7462_REG_ALARM2 0xBB 94 #define ADT7462_V0_ALARM 0x01 95 #define ADT7462_V1_ALARM 0x02 96 #define ADT7462_V2_ALARM 0x04 97 #define ADT7462_V3_ALARM 0x08 98 #define ADT7462_V4_ALARM 0x10 99 #define ADT7462_V5_ALARM 0x20 100 #define ADT7462_V6_ALARM 0x40 101 #define ADT7462_V7_ALARM 0x80 102 #define ADT7462_REG_ALARM3 0xBC 103 #define ADT7462_V8_ALARM 0x08 104 #define ADT7462_V9_ALARM 0x10 105 #define ADT7462_V10_ALARM 0x20 106 #define ADT7462_V11_ALARM 0x40 107 #define ADT7462_V12_ALARM 0x80 108 #define ADT7462_REG_ALARM4 0xBD 109 #define ADT7462_F0_ALARM 0x01 110 #define ADT7462_F1_ALARM 0x02 111 #define ADT7462_F2_ALARM 0x04 112 #define ADT7462_F3_ALARM 0x08 113 #define ADT7462_F4_ALARM 0x10 114 #define ADT7462_F5_ALARM 0x20 115 #define ADT7462_F6_ALARM 0x40 116 #define ADT7462_F7_ALARM 0x80 117 #define ADT7462_ALARM1 0x0000 118 #define ADT7462_ALARM2 0x0100 119 #define ADT7462_ALARM3 0x0200 120 #define ADT7462_ALARM4 0x0300 121 #define ADT7462_ALARM_REG_SHIFT 8 122 #define ADT7462_ALARM_FLAG_MASK 0x0F 123 124 #define ADT7462_TEMP_COUNT 4 125 #define ADT7462_TEMP_REG(x) (ADT7462_REG_TEMP_BASE_ADDR + ((x) * 2)) 126 #define ADT7462_TEMP_MIN_REG(x) (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x)) 127 #define ADT7462_TEMP_MAX_REG(x) (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x)) 128 #define TEMP_FRAC_OFFSET 6 129 130 #define ADT7462_FAN_COUNT 8 131 #define ADT7462_REG_FAN_MIN(x) (ADT7462_REG_FAN_MIN_BASE_ADDR + (x)) 132 133 #define ADT7462_PWM_COUNT 4 134 #define ADT7462_REG_PWM(x) (ADT7462_REG_PWM_BASE_ADDR + (x)) 135 #define ADT7462_REG_PWM_MIN(x) (ADT7462_REG_PWM_MIN_BASE_ADDR + (x)) 136 #define ADT7462_REG_PWM_TMIN(x) \ 137 (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x)) 138 #define ADT7462_REG_PWM_TRANGE(x) \ 139 (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x)) 140 141 #define ADT7462_PIN_CFG_REG_COUNT 4 142 #define ADT7462_REG_PIN_CFG(x) (ADT7462_REG_PIN_CFG_BASE_ADDR + (x)) 143 #define ADT7462_REG_PWM_CFG(x) (ADT7462_REG_PWM_CFG_BASE_ADDR + (x)) 144 145 #define ADT7462_ALARM_REG_COUNT 4 146 147 /* 148 * The chip can measure 13 different voltage sources: 149 * 150 * 1. +12V1 (pin 7) 151 * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23) 152 * 3. +12V3 (pin 22) 153 * 4. +5V (pin 21) 154 * 5. +1.25V/+0.9V (pin 19) 155 * 6. +2.5V/+1.8V (pin 15) 156 * 7. +3.3v (pin 13) 157 * 8. +12V2 (pin 8) 158 * 9. Vbatt/FSB_Vtt (pin 26) 159 * A. +3.3V/+1.2V1 (pin 25) 160 * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24) 161 * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V) 162 * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V) 163 * 164 * Each of these 13 has a factor to convert raw to voltage. Even better, 165 * the pins can be connected to other sensors (tach/gpio/hot/etc), which 166 * makes the bookkeeping tricky. 167 * 168 * Some, but not all, of these voltages have low/high limits. 169 */ 170 #define ADT7462_VOLT_COUNT 13 171 172 #define ADT7462_VENDOR 0x41 173 #define ADT7462_DEVICE 0x62 174 /* datasheet only mentions a revision 4 */ 175 #define ADT7462_REVISION 0x04 176 177 /* How often do we reread sensors values? (In jiffies) */ 178 #define SENSOR_REFRESH_INTERVAL (2 * HZ) 179 180 /* How often do we reread sensor limit values? (In jiffies) */ 181 #define LIMIT_REFRESH_INTERVAL (60 * HZ) 182 183 /* datasheet says to divide this number by the fan reading to get fan rpm */ 184 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x)) 185 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM 186 #define FAN_PERIOD_INVALID 65535 187 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID) 188 189 #define MASK_AND_SHIFT(value, prefix) \ 190 (((value) & prefix##_MASK) >> prefix##_SHIFT) 191 192 struct adt7462_data { 193 struct i2c_client *client; 194 struct mutex lock; 195 char sensors_valid; 196 char limits_valid; 197 unsigned long sensors_last_updated; /* In jiffies */ 198 unsigned long limits_last_updated; /* In jiffies */ 199 200 u8 temp[ADT7462_TEMP_COUNT]; 201 /* bits 6-7 are quarter pieces of temp */ 202 u8 temp_frac[ADT7462_TEMP_COUNT]; 203 u8 temp_min[ADT7462_TEMP_COUNT]; 204 u8 temp_max[ADT7462_TEMP_COUNT]; 205 u16 fan[ADT7462_FAN_COUNT]; 206 u8 fan_enabled; 207 u8 fan_min[ADT7462_FAN_COUNT]; 208 u8 cfg2; 209 u8 pwm[ADT7462_PWM_COUNT]; 210 u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT]; 211 u8 voltages[ADT7462_VOLT_COUNT]; 212 u8 volt_max[ADT7462_VOLT_COUNT]; 213 u8 volt_min[ADT7462_VOLT_COUNT]; 214 u8 pwm_min[ADT7462_PWM_COUNT]; 215 u8 pwm_tmin[ADT7462_PWM_COUNT]; 216 u8 pwm_trange[ADT7462_PWM_COUNT]; 217 u8 pwm_max; /* only one per chip */ 218 u8 pwm_cfg[ADT7462_PWM_COUNT]; 219 u8 alarms[ADT7462_ALARM_REG_COUNT]; 220 }; 221 222 /* 223 * 16-bit registers on the ADT7462 are low-byte first. The data sheet says 224 * that the low byte must be read before the high byte. 225 */ 226 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg) 227 { 228 u16 foo; 229 foo = i2c_smbus_read_byte_data(client, reg); 230 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8); 231 return foo; 232 } 233 234 /* For some reason these registers are not contiguous. */ 235 static int ADT7462_REG_FAN(int fan) 236 { 237 if (fan < 4) 238 return ADT7462_REG_FAN_BASE_ADDR + (2 * fan); 239 return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4)); 240 } 241 242 /* Voltage registers are scattered everywhere */ 243 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which) 244 { 245 switch (which) { 246 case 0: 247 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 248 return 0x7C; 249 break; 250 case 1: 251 return 0x69; 252 case 2: 253 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 254 return 0x7F; 255 break; 256 case 3: 257 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 258 return 0x7E; 259 break; 260 case 4: 261 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) 262 return 0x4B; 263 break; 264 case 5: 265 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) 266 return 0x49; 267 break; 268 case 6: 269 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 270 return 0x68; 271 break; 272 case 7: 273 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 274 return 0x7D; 275 break; 276 case 8: 277 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT)) 278 return 0x6C; 279 break; 280 case 9: 281 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT)) 282 return 0x6B; 283 break; 284 case 10: 285 return 0x6A; 286 case 11: 287 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 288 ADT7462_PIN28_VOLT && 289 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 290 return 0x50; 291 break; 292 case 12: 293 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 294 ADT7462_PIN28_VOLT && 295 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 296 return 0x4C; 297 break; 298 } 299 return 0; 300 } 301 302 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which) 303 { 304 switch (which) { 305 case 0: 306 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 307 return 0x6D; 308 break; 309 case 1: 310 return 0x72; 311 case 2: 312 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 313 return 0x6F; 314 break; 315 case 3: 316 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 317 return 0x71; 318 break; 319 case 4: 320 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) 321 return 0x47; 322 break; 323 case 5: 324 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) 325 return 0x45; 326 break; 327 case 6: 328 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 329 return 0x70; 330 break; 331 case 7: 332 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 333 return 0x6E; 334 break; 335 case 8: 336 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT)) 337 return 0x75; 338 break; 339 case 9: 340 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT)) 341 return 0x74; 342 break; 343 case 10: 344 return 0x73; 345 case 11: 346 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 347 ADT7462_PIN28_VOLT && 348 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 349 return 0x76; 350 break; 351 case 12: 352 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 353 ADT7462_PIN28_VOLT && 354 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 355 return 0x77; 356 break; 357 } 358 return 0; 359 } 360 361 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which) 362 { 363 switch (which) { 364 case 0: 365 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 366 return 0xA3; 367 break; 368 case 1: 369 return 0x90; 370 case 2: 371 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 372 return 0xA9; 373 break; 374 case 3: 375 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 376 return 0xA7; 377 break; 378 case 4: 379 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) 380 return 0x8F; 381 break; 382 case 5: 383 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) 384 return 0x8B; 385 break; 386 case 6: 387 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 388 return 0x96; 389 break; 390 case 7: 391 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 392 return 0xA5; 393 break; 394 case 8: 395 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT)) 396 return 0x93; 397 break; 398 case 9: 399 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT)) 400 return 0x92; 401 break; 402 case 10: 403 return 0x91; 404 case 11: 405 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 406 ADT7462_PIN28_VOLT && 407 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 408 return 0x94; 409 break; 410 case 12: 411 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 412 ADT7462_PIN28_VOLT && 413 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 414 return 0x95; 415 break; 416 } 417 return 0; 418 } 419 420 /* Provide labels for sysfs */ 421 static const char *voltage_label(struct adt7462_data *data, int which) 422 { 423 switch (which) { 424 case 0: 425 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 426 return "+12V1"; 427 break; 428 case 1: 429 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) { 430 case 0: 431 return "Vccp1"; 432 case 1: 433 return "+2.5V"; 434 case 2: 435 return "+1.8V"; 436 case 3: 437 return "+1.5V"; 438 } 439 fallthrough; 440 case 2: 441 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 442 return "+12V3"; 443 break; 444 case 3: 445 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 446 return "+5V"; 447 break; 448 case 4: 449 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) { 450 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT) 451 return "+0.9V"; 452 return "+1.25V"; 453 } 454 break; 455 case 5: 456 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) { 457 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT) 458 return "+1.8V"; 459 return "+2.5V"; 460 } 461 break; 462 case 6: 463 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 464 return "+3.3V"; 465 break; 466 case 7: 467 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 468 return "+12V2"; 469 break; 470 case 8: 471 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) { 472 case 0: 473 return "Vbatt"; 474 case 1: 475 return "FSB_Vtt"; 476 } 477 break; 478 case 9: 479 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) { 480 case 0: 481 return "+3.3V"; 482 case 1: 483 return "+1.2V1"; 484 } 485 break; 486 case 10: 487 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) { 488 case 0: 489 return "Vccp2"; 490 case 1: 491 return "+2.5V"; 492 case 2: 493 return "+1.8V"; 494 case 3: 495 return "+1.5"; 496 } 497 fallthrough; 498 case 11: 499 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 500 ADT7462_PIN28_VOLT && 501 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 502 return "+1.5V ICH"; 503 break; 504 case 12: 505 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 506 ADT7462_PIN28_VOLT && 507 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 508 return "+1.5V 3GPIO"; 509 break; 510 } 511 return "N/A"; 512 } 513 514 /* Multipliers are actually in uV, not mV. */ 515 static int voltage_multiplier(struct adt7462_data *data, int which) 516 { 517 switch (which) { 518 case 0: 519 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 520 return 62500; 521 break; 522 case 1: 523 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) { 524 case 0: 525 if (data->pin_cfg[0] & ADT7462_VID_INPUT) 526 return 12500; 527 return 6250; 528 case 1: 529 return 13000; 530 case 2: 531 return 9400; 532 case 3: 533 return 7800; 534 } 535 fallthrough; 536 case 2: 537 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 538 return 62500; 539 break; 540 case 3: 541 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 542 return 26000; 543 break; 544 case 4: 545 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) { 546 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT) 547 return 4690; 548 return 6500; 549 } 550 break; 551 case 5: 552 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) { 553 if (data->pin_cfg[1] & ADT7462_PIN15_INPUT) 554 return 9400; 555 return 13000; 556 } 557 break; 558 case 6: 559 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 560 return 17200; 561 break; 562 case 7: 563 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 564 return 62500; 565 break; 566 case 8: 567 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) { 568 case 0: 569 return 15600; 570 case 1: 571 return 6250; 572 } 573 break; 574 case 9: 575 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) { 576 case 0: 577 return 17200; 578 case 1: 579 return 6250; 580 } 581 break; 582 case 10: 583 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) { 584 case 0: 585 return 6250; 586 case 1: 587 return 13000; 588 case 2: 589 return 9400; 590 case 3: 591 return 7800; 592 } 593 fallthrough; 594 case 11: 595 case 12: 596 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 597 ADT7462_PIN28_VOLT && 598 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 599 return 7800; 600 } 601 return 0; 602 } 603 604 static int temp_enabled(struct adt7462_data *data, int which) 605 { 606 switch (which) { 607 case 0: 608 case 2: 609 return 1; 610 case 1: 611 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT) 612 return 1; 613 break; 614 case 3: 615 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT) 616 return 1; 617 break; 618 } 619 return 0; 620 } 621 622 static const char *temp_label(struct adt7462_data *data, int which) 623 { 624 switch (which) { 625 case 0: 626 return "local"; 627 case 1: 628 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT) 629 return "remote1"; 630 break; 631 case 2: 632 return "remote2"; 633 case 3: 634 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT) 635 return "remote3"; 636 break; 637 } 638 return "N/A"; 639 } 640 641 /* Map Trange register values to mC */ 642 #define NUM_TRANGE_VALUES 16 643 static const int trange_values[NUM_TRANGE_VALUES] = { 644 2000, 645 2500, 646 3300, 647 4000, 648 5000, 649 6700, 650 8000, 651 10000, 652 13300, 653 16000, 654 20000, 655 26700, 656 32000, 657 40000, 658 53300, 659 80000 660 }; 661 662 static int find_trange_value(int trange) 663 { 664 int i; 665 666 for (i = 0; i < NUM_TRANGE_VALUES; i++) 667 if (trange_values[i] == trange) 668 return i; 669 670 return -EINVAL; 671 } 672 673 static struct adt7462_data *adt7462_update_device(struct device *dev) 674 { 675 struct adt7462_data *data = dev_get_drvdata(dev); 676 struct i2c_client *client = data->client; 677 unsigned long local_jiffies = jiffies; 678 int i; 679 680 mutex_lock(&data->lock); 681 if (time_before(local_jiffies, data->sensors_last_updated + 682 SENSOR_REFRESH_INTERVAL) 683 && data->sensors_valid) 684 goto no_sensor_update; 685 686 for (i = 0; i < ADT7462_TEMP_COUNT; i++) { 687 /* 688 * Reading the fractional register locks the integral 689 * register until both have been read. 690 */ 691 data->temp_frac[i] = i2c_smbus_read_byte_data(client, 692 ADT7462_TEMP_REG(i)); 693 data->temp[i] = i2c_smbus_read_byte_data(client, 694 ADT7462_TEMP_REG(i) + 1); 695 } 696 697 for (i = 0; i < ADT7462_FAN_COUNT; i++) 698 data->fan[i] = adt7462_read_word_data(client, 699 ADT7462_REG_FAN(i)); 700 701 data->fan_enabled = i2c_smbus_read_byte_data(client, 702 ADT7462_REG_FAN_ENABLE); 703 704 for (i = 0; i < ADT7462_PWM_COUNT; i++) 705 data->pwm[i] = i2c_smbus_read_byte_data(client, 706 ADT7462_REG_PWM(i)); 707 708 for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++) 709 data->pin_cfg[i] = i2c_smbus_read_byte_data(client, 710 ADT7462_REG_PIN_CFG(i)); 711 712 for (i = 0; i < ADT7462_VOLT_COUNT; i++) { 713 int reg = ADT7462_REG_VOLT(data, i); 714 if (!reg) 715 data->voltages[i] = 0; 716 else 717 data->voltages[i] = i2c_smbus_read_byte_data(client, 718 reg); 719 } 720 721 data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1); 722 data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2); 723 data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3); 724 data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4); 725 726 data->sensors_last_updated = local_jiffies; 727 data->sensors_valid = 1; 728 729 no_sensor_update: 730 if (time_before(local_jiffies, data->limits_last_updated + 731 LIMIT_REFRESH_INTERVAL) 732 && data->limits_valid) 733 goto out; 734 735 for (i = 0; i < ADT7462_TEMP_COUNT; i++) { 736 data->temp_min[i] = i2c_smbus_read_byte_data(client, 737 ADT7462_TEMP_MIN_REG(i)); 738 data->temp_max[i] = i2c_smbus_read_byte_data(client, 739 ADT7462_TEMP_MAX_REG(i)); 740 } 741 742 for (i = 0; i < ADT7462_FAN_COUNT; i++) 743 data->fan_min[i] = i2c_smbus_read_byte_data(client, 744 ADT7462_REG_FAN_MIN(i)); 745 746 for (i = 0; i < ADT7462_VOLT_COUNT; i++) { 747 int reg = ADT7462_REG_VOLT_MAX(data, i); 748 data->volt_max[i] = 749 (reg ? i2c_smbus_read_byte_data(client, reg) : 0); 750 751 reg = ADT7462_REG_VOLT_MIN(data, i); 752 data->volt_min[i] = 753 (reg ? i2c_smbus_read_byte_data(client, reg) : 0); 754 } 755 756 for (i = 0; i < ADT7462_PWM_COUNT; i++) { 757 data->pwm_min[i] = i2c_smbus_read_byte_data(client, 758 ADT7462_REG_PWM_MIN(i)); 759 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client, 760 ADT7462_REG_PWM_TMIN(i)); 761 data->pwm_trange[i] = i2c_smbus_read_byte_data(client, 762 ADT7462_REG_PWM_TRANGE(i)); 763 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client, 764 ADT7462_REG_PWM_CFG(i)); 765 } 766 767 data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX); 768 769 data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2); 770 771 data->limits_last_updated = local_jiffies; 772 data->limits_valid = 1; 773 774 out: 775 mutex_unlock(&data->lock); 776 return data; 777 } 778 779 static ssize_t temp_min_show(struct device *dev, 780 struct device_attribute *devattr, char *buf) 781 { 782 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 783 struct adt7462_data *data = adt7462_update_device(dev); 784 785 if (!temp_enabled(data, attr->index)) 786 return sprintf(buf, "0\n"); 787 788 return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64)); 789 } 790 791 static ssize_t temp_min_store(struct device *dev, 792 struct device_attribute *devattr, 793 const char *buf, size_t count) 794 { 795 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 796 struct adt7462_data *data = dev_get_drvdata(dev); 797 struct i2c_client *client = data->client; 798 long temp; 799 800 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index)) 801 return -EINVAL; 802 803 temp = clamp_val(temp, -64000, 191000); 804 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64; 805 806 mutex_lock(&data->lock); 807 data->temp_min[attr->index] = temp; 808 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index), 809 temp); 810 mutex_unlock(&data->lock); 811 812 return count; 813 } 814 815 static ssize_t temp_max_show(struct device *dev, 816 struct device_attribute *devattr, char *buf) 817 { 818 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 819 struct adt7462_data *data = adt7462_update_device(dev); 820 821 if (!temp_enabled(data, attr->index)) 822 return sprintf(buf, "0\n"); 823 824 return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64)); 825 } 826 827 static ssize_t temp_max_store(struct device *dev, 828 struct device_attribute *devattr, 829 const char *buf, size_t count) 830 { 831 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 832 struct adt7462_data *data = dev_get_drvdata(dev); 833 struct i2c_client *client = data->client; 834 long temp; 835 836 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index)) 837 return -EINVAL; 838 839 temp = clamp_val(temp, -64000, 191000); 840 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64; 841 842 mutex_lock(&data->lock); 843 data->temp_max[attr->index] = temp; 844 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index), 845 temp); 846 mutex_unlock(&data->lock); 847 848 return count; 849 } 850 851 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr, 852 char *buf) 853 { 854 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 855 struct adt7462_data *data = adt7462_update_device(dev); 856 u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET; 857 858 if (!temp_enabled(data, attr->index)) 859 return sprintf(buf, "0\n"); 860 861 return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) + 862 250 * frac); 863 } 864 865 static ssize_t temp_label_show(struct device *dev, 866 struct device_attribute *devattr, char *buf) 867 { 868 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 869 struct adt7462_data *data = adt7462_update_device(dev); 870 871 return sprintf(buf, "%s\n", temp_label(data, attr->index)); 872 } 873 874 static ssize_t volt_max_show(struct device *dev, 875 struct device_attribute *devattr, char *buf) 876 { 877 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 878 struct adt7462_data *data = adt7462_update_device(dev); 879 int x = voltage_multiplier(data, attr->index); 880 881 x *= data->volt_max[attr->index]; 882 x /= 1000; /* convert from uV to mV */ 883 884 return sprintf(buf, "%d\n", x); 885 } 886 887 static ssize_t volt_max_store(struct device *dev, 888 struct device_attribute *devattr, 889 const char *buf, size_t count) 890 { 891 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 892 struct adt7462_data *data = dev_get_drvdata(dev); 893 struct i2c_client *client = data->client; 894 int x = voltage_multiplier(data, attr->index); 895 long temp; 896 897 if (kstrtol(buf, 10, &temp) || !x) 898 return -EINVAL; 899 900 temp = clamp_val(temp, 0, 255 * x / 1000); 901 temp *= 1000; /* convert mV to uV */ 902 temp = DIV_ROUND_CLOSEST(temp, x); 903 904 mutex_lock(&data->lock); 905 data->volt_max[attr->index] = temp; 906 i2c_smbus_write_byte_data(client, 907 ADT7462_REG_VOLT_MAX(data, attr->index), 908 temp); 909 mutex_unlock(&data->lock); 910 911 return count; 912 } 913 914 static ssize_t volt_min_show(struct device *dev, 915 struct device_attribute *devattr, char *buf) 916 { 917 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 918 struct adt7462_data *data = adt7462_update_device(dev); 919 int x = voltage_multiplier(data, attr->index); 920 921 x *= data->volt_min[attr->index]; 922 x /= 1000; /* convert from uV to mV */ 923 924 return sprintf(buf, "%d\n", x); 925 } 926 927 static ssize_t volt_min_store(struct device *dev, 928 struct device_attribute *devattr, 929 const char *buf, size_t count) 930 { 931 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 932 struct adt7462_data *data = dev_get_drvdata(dev); 933 struct i2c_client *client = data->client; 934 int x = voltage_multiplier(data, attr->index); 935 long temp; 936 937 if (kstrtol(buf, 10, &temp) || !x) 938 return -EINVAL; 939 940 temp = clamp_val(temp, 0, 255 * x / 1000); 941 temp *= 1000; /* convert mV to uV */ 942 temp = DIV_ROUND_CLOSEST(temp, x); 943 944 mutex_lock(&data->lock); 945 data->volt_min[attr->index] = temp; 946 i2c_smbus_write_byte_data(client, 947 ADT7462_REG_VOLT_MIN(data, attr->index), 948 temp); 949 mutex_unlock(&data->lock); 950 951 return count; 952 } 953 954 static ssize_t voltage_show(struct device *dev, 955 struct device_attribute *devattr, char *buf) 956 { 957 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 958 struct adt7462_data *data = adt7462_update_device(dev); 959 int x = voltage_multiplier(data, attr->index); 960 961 x *= data->voltages[attr->index]; 962 x /= 1000; /* convert from uV to mV */ 963 964 return sprintf(buf, "%d\n", x); 965 } 966 967 static ssize_t voltage_label_show(struct device *dev, 968 struct device_attribute *devattr, char *buf) 969 { 970 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 971 struct adt7462_data *data = adt7462_update_device(dev); 972 973 return sprintf(buf, "%s\n", voltage_label(data, attr->index)); 974 } 975 976 static ssize_t alarm_show(struct device *dev, 977 struct device_attribute *devattr, char *buf) 978 { 979 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 980 struct adt7462_data *data = adt7462_update_device(dev); 981 int reg = attr->index >> ADT7462_ALARM_REG_SHIFT; 982 int mask = attr->index & ADT7462_ALARM_FLAG_MASK; 983 984 if (data->alarms[reg] & mask) 985 return sprintf(buf, "1\n"); 986 else 987 return sprintf(buf, "0\n"); 988 } 989 990 static int fan_enabled(struct adt7462_data *data, int fan) 991 { 992 return data->fan_enabled & (1 << fan); 993 } 994 995 static ssize_t fan_min_show(struct device *dev, 996 struct device_attribute *devattr, char *buf) 997 { 998 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 999 struct adt7462_data *data = adt7462_update_device(dev); 1000 u16 temp; 1001 1002 /* Only the MSB of the min fan period is stored... */ 1003 temp = data->fan_min[attr->index]; 1004 temp <<= 8; 1005 1006 if (!fan_enabled(data, attr->index) || 1007 !FAN_DATA_VALID(temp)) 1008 return sprintf(buf, "0\n"); 1009 1010 return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp)); 1011 } 1012 1013 static ssize_t fan_min_store(struct device *dev, 1014 struct device_attribute *devattr, 1015 const char *buf, size_t count) 1016 { 1017 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1018 struct adt7462_data *data = dev_get_drvdata(dev); 1019 struct i2c_client *client = data->client; 1020 long temp; 1021 1022 if (kstrtol(buf, 10, &temp) || !temp || 1023 !fan_enabled(data, attr->index)) 1024 return -EINVAL; 1025 1026 temp = FAN_RPM_TO_PERIOD(temp); 1027 temp >>= 8; 1028 temp = clamp_val(temp, 1, 255); 1029 1030 mutex_lock(&data->lock); 1031 data->fan_min[attr->index] = temp; 1032 i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index), 1033 temp); 1034 mutex_unlock(&data->lock); 1035 1036 return count; 1037 } 1038 1039 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr, 1040 char *buf) 1041 { 1042 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1043 struct adt7462_data *data = adt7462_update_device(dev); 1044 1045 if (!fan_enabled(data, attr->index) || 1046 !FAN_DATA_VALID(data->fan[attr->index])) 1047 return sprintf(buf, "0\n"); 1048 1049 return sprintf(buf, "%d\n", 1050 FAN_PERIOD_TO_RPM(data->fan[attr->index])); 1051 } 1052 1053 static ssize_t force_pwm_max_show(struct device *dev, 1054 struct device_attribute *devattr, char *buf) 1055 { 1056 struct adt7462_data *data = adt7462_update_device(dev); 1057 return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0)); 1058 } 1059 1060 static ssize_t force_pwm_max_store(struct device *dev, 1061 struct device_attribute *devattr, 1062 const char *buf, size_t count) 1063 { 1064 struct adt7462_data *data = dev_get_drvdata(dev); 1065 struct i2c_client *client = data->client; 1066 long temp; 1067 u8 reg; 1068 1069 if (kstrtol(buf, 10, &temp)) 1070 return -EINVAL; 1071 1072 mutex_lock(&data->lock); 1073 reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2); 1074 if (temp) 1075 reg |= ADT7462_FSPD_MASK; 1076 else 1077 reg &= ~ADT7462_FSPD_MASK; 1078 data->cfg2 = reg; 1079 i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg); 1080 mutex_unlock(&data->lock); 1081 1082 return count; 1083 } 1084 1085 static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr, 1086 char *buf) 1087 { 1088 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1089 struct adt7462_data *data = adt7462_update_device(dev); 1090 return sprintf(buf, "%d\n", data->pwm[attr->index]); 1091 } 1092 1093 static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr, 1094 const char *buf, size_t count) 1095 { 1096 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1097 struct adt7462_data *data = dev_get_drvdata(dev); 1098 struct i2c_client *client = data->client; 1099 long temp; 1100 1101 if (kstrtol(buf, 10, &temp)) 1102 return -EINVAL; 1103 1104 temp = clamp_val(temp, 0, 255); 1105 1106 mutex_lock(&data->lock); 1107 data->pwm[attr->index] = temp; 1108 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp); 1109 mutex_unlock(&data->lock); 1110 1111 return count; 1112 } 1113 1114 static ssize_t pwm_max_show(struct device *dev, 1115 struct device_attribute *devattr, char *buf) 1116 { 1117 struct adt7462_data *data = adt7462_update_device(dev); 1118 return sprintf(buf, "%d\n", data->pwm_max); 1119 } 1120 1121 static ssize_t pwm_max_store(struct device *dev, 1122 struct device_attribute *devattr, 1123 const char *buf, size_t count) 1124 { 1125 struct adt7462_data *data = dev_get_drvdata(dev); 1126 struct i2c_client *client = data->client; 1127 long temp; 1128 1129 if (kstrtol(buf, 10, &temp)) 1130 return -EINVAL; 1131 1132 temp = clamp_val(temp, 0, 255); 1133 1134 mutex_lock(&data->lock); 1135 data->pwm_max = temp; 1136 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp); 1137 mutex_unlock(&data->lock); 1138 1139 return count; 1140 } 1141 1142 static ssize_t pwm_min_show(struct device *dev, 1143 struct device_attribute *devattr, char *buf) 1144 { 1145 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1146 struct adt7462_data *data = adt7462_update_device(dev); 1147 return sprintf(buf, "%d\n", data->pwm_min[attr->index]); 1148 } 1149 1150 static ssize_t pwm_min_store(struct device *dev, 1151 struct device_attribute *devattr, 1152 const char *buf, size_t count) 1153 { 1154 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1155 struct adt7462_data *data = dev_get_drvdata(dev); 1156 struct i2c_client *client = data->client; 1157 long temp; 1158 1159 if (kstrtol(buf, 10, &temp)) 1160 return -EINVAL; 1161 1162 temp = clamp_val(temp, 0, 255); 1163 1164 mutex_lock(&data->lock); 1165 data->pwm_min[attr->index] = temp; 1166 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index), 1167 temp); 1168 mutex_unlock(&data->lock); 1169 1170 return count; 1171 } 1172 1173 static ssize_t pwm_hyst_show(struct device *dev, 1174 struct device_attribute *devattr, char *buf) 1175 { 1176 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1177 struct adt7462_data *data = adt7462_update_device(dev); 1178 return sprintf(buf, "%d\n", 1000 * 1179 (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK)); 1180 } 1181 1182 static ssize_t pwm_hyst_store(struct device *dev, 1183 struct device_attribute *devattr, 1184 const char *buf, size_t count) 1185 { 1186 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1187 struct adt7462_data *data = dev_get_drvdata(dev); 1188 struct i2c_client *client = data->client; 1189 long temp; 1190 1191 if (kstrtol(buf, 10, &temp)) 1192 return -EINVAL; 1193 1194 temp = clamp_val(temp, 0, 15000); 1195 temp = DIV_ROUND_CLOSEST(temp, 1000); 1196 1197 /* package things up */ 1198 temp &= ADT7462_PWM_HYST_MASK; 1199 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK; 1200 1201 mutex_lock(&data->lock); 1202 data->pwm_trange[attr->index] = temp; 1203 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index), 1204 temp); 1205 mutex_unlock(&data->lock); 1206 1207 return count; 1208 } 1209 1210 static ssize_t pwm_tmax_show(struct device *dev, 1211 struct device_attribute *devattr, char *buf) 1212 { 1213 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1214 struct adt7462_data *data = adt7462_update_device(dev); 1215 1216 /* tmax = tmin + trange */ 1217 int trange = trange_values[data->pwm_trange[attr->index] >> 1218 ADT7462_PWM_RANGE_SHIFT]; 1219 int tmin = (data->pwm_tmin[attr->index] - 64) * 1000; 1220 1221 return sprintf(buf, "%d\n", tmin + trange); 1222 } 1223 1224 static ssize_t pwm_tmax_store(struct device *dev, 1225 struct device_attribute *devattr, 1226 const char *buf, size_t count) 1227 { 1228 int temp; 1229 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1230 struct adt7462_data *data = dev_get_drvdata(dev); 1231 struct i2c_client *client = data->client; 1232 int tmin, trange_value; 1233 long trange; 1234 1235 if (kstrtol(buf, 10, &trange)) 1236 return -EINVAL; 1237 1238 /* trange = tmax - tmin */ 1239 tmin = (data->pwm_tmin[attr->index] - 64) * 1000; 1240 trange_value = find_trange_value(trange - tmin); 1241 if (trange_value < 0) 1242 return trange_value; 1243 1244 temp = trange_value << ADT7462_PWM_RANGE_SHIFT; 1245 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK; 1246 1247 mutex_lock(&data->lock); 1248 data->pwm_trange[attr->index] = temp; 1249 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index), 1250 temp); 1251 mutex_unlock(&data->lock); 1252 1253 return count; 1254 } 1255 1256 static ssize_t pwm_tmin_show(struct device *dev, 1257 struct device_attribute *devattr, char *buf) 1258 { 1259 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1260 struct adt7462_data *data = adt7462_update_device(dev); 1261 return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64)); 1262 } 1263 1264 static ssize_t pwm_tmin_store(struct device *dev, 1265 struct device_attribute *devattr, 1266 const char *buf, size_t count) 1267 { 1268 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1269 struct adt7462_data *data = dev_get_drvdata(dev); 1270 struct i2c_client *client = data->client; 1271 long temp; 1272 1273 if (kstrtol(buf, 10, &temp)) 1274 return -EINVAL; 1275 1276 temp = clamp_val(temp, -64000, 191000); 1277 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64; 1278 1279 mutex_lock(&data->lock); 1280 data->pwm_tmin[attr->index] = temp; 1281 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index), 1282 temp); 1283 mutex_unlock(&data->lock); 1284 1285 return count; 1286 } 1287 1288 static ssize_t pwm_auto_show(struct device *dev, 1289 struct device_attribute *devattr, char *buf) 1290 { 1291 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1292 struct adt7462_data *data = adt7462_update_device(dev); 1293 int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT; 1294 1295 switch (cfg) { 1296 case 4: /* off */ 1297 return sprintf(buf, "0\n"); 1298 case 7: /* manual */ 1299 return sprintf(buf, "1\n"); 1300 default: /* automatic */ 1301 return sprintf(buf, "2\n"); 1302 } 1303 } 1304 1305 static void set_pwm_channel(struct i2c_client *client, 1306 struct adt7462_data *data, 1307 int which, 1308 int value) 1309 { 1310 int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK; 1311 temp |= value << ADT7462_PWM_CHANNEL_SHIFT; 1312 1313 mutex_lock(&data->lock); 1314 data->pwm_cfg[which] = temp; 1315 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp); 1316 mutex_unlock(&data->lock); 1317 } 1318 1319 static ssize_t pwm_auto_store(struct device *dev, 1320 struct device_attribute *devattr, 1321 const char *buf, size_t count) 1322 { 1323 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1324 struct adt7462_data *data = dev_get_drvdata(dev); 1325 struct i2c_client *client = data->client; 1326 long temp; 1327 1328 if (kstrtol(buf, 10, &temp)) 1329 return -EINVAL; 1330 1331 switch (temp) { 1332 case 0: /* off */ 1333 set_pwm_channel(client, data, attr->index, 4); 1334 return count; 1335 case 1: /* manual */ 1336 set_pwm_channel(client, data, attr->index, 7); 1337 return count; 1338 default: 1339 return -EINVAL; 1340 } 1341 } 1342 1343 static ssize_t pwm_auto_temp_show(struct device *dev, 1344 struct device_attribute *devattr, char *buf) 1345 { 1346 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1347 struct adt7462_data *data = adt7462_update_device(dev); 1348 int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT; 1349 1350 switch (channel) { 1351 case 0: /* temp[1234] only */ 1352 case 1: 1353 case 2: 1354 case 3: 1355 return sprintf(buf, "%d\n", (1 << channel)); 1356 case 5: /* temp1 & temp4 */ 1357 return sprintf(buf, "9\n"); 1358 case 6: 1359 return sprintf(buf, "15\n"); 1360 default: 1361 return sprintf(buf, "0\n"); 1362 } 1363 } 1364 1365 static int cvt_auto_temp(int input) 1366 { 1367 if (input == 0xF) 1368 return 6; 1369 if (input == 0x9) 1370 return 5; 1371 if (input < 1 || !is_power_of_2(input)) 1372 return -EINVAL; 1373 return ilog2(input); 1374 } 1375 1376 static ssize_t pwm_auto_temp_store(struct device *dev, 1377 struct device_attribute *devattr, 1378 const char *buf, size_t count) 1379 { 1380 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1381 struct adt7462_data *data = dev_get_drvdata(dev); 1382 struct i2c_client *client = data->client; 1383 long temp; 1384 1385 if (kstrtol(buf, 10, &temp)) 1386 return -EINVAL; 1387 1388 temp = cvt_auto_temp(temp); 1389 if (temp < 0) 1390 return temp; 1391 1392 set_pwm_channel(client, data, attr->index, temp); 1393 1394 return count; 1395 } 1396 1397 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0); 1398 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1); 1399 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2); 1400 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3); 1401 1402 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0); 1403 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1); 1404 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2); 1405 static SENSOR_DEVICE_ATTR_RW(temp4_min, temp_min, 3); 1406 1407 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0); 1408 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1); 1409 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2); 1410 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3); 1411 1412 static SENSOR_DEVICE_ATTR_RO(temp1_label, temp_label, 0); 1413 static SENSOR_DEVICE_ATTR_RO(temp2_label, temp_label, 1); 1414 static SENSOR_DEVICE_ATTR_RO(temp3_label, temp_label, 2); 1415 static SENSOR_DEVICE_ATTR_RO(temp4_label, temp_label, 3); 1416 1417 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 1418 ADT7462_ALARM1 | ADT7462_LT_ALARM); 1419 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 1420 ADT7462_ALARM1 | ADT7462_R1T_ALARM); 1421 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1422 ADT7462_ALARM1 | ADT7462_R2T_ALARM); 1423 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm, 1424 ADT7462_ALARM1 | ADT7462_R3T_ALARM); 1425 1426 static SENSOR_DEVICE_ATTR_RW(in1_max, volt_max, 0); 1427 static SENSOR_DEVICE_ATTR_RW(in2_max, volt_max, 1); 1428 static SENSOR_DEVICE_ATTR_RW(in3_max, volt_max, 2); 1429 static SENSOR_DEVICE_ATTR_RW(in4_max, volt_max, 3); 1430 static SENSOR_DEVICE_ATTR_RW(in5_max, volt_max, 4); 1431 static SENSOR_DEVICE_ATTR_RW(in6_max, volt_max, 5); 1432 static SENSOR_DEVICE_ATTR_RW(in7_max, volt_max, 6); 1433 static SENSOR_DEVICE_ATTR_RW(in8_max, volt_max, 7); 1434 static SENSOR_DEVICE_ATTR_RW(in9_max, volt_max, 8); 1435 static SENSOR_DEVICE_ATTR_RW(in10_max, volt_max, 9); 1436 static SENSOR_DEVICE_ATTR_RW(in11_max, volt_max, 10); 1437 static SENSOR_DEVICE_ATTR_RW(in12_max, volt_max, 11); 1438 static SENSOR_DEVICE_ATTR_RW(in13_max, volt_max, 12); 1439 1440 static SENSOR_DEVICE_ATTR_RW(in1_min, volt_min, 0); 1441 static SENSOR_DEVICE_ATTR_RW(in2_min, volt_min, 1); 1442 static SENSOR_DEVICE_ATTR_RW(in3_min, volt_min, 2); 1443 static SENSOR_DEVICE_ATTR_RW(in4_min, volt_min, 3); 1444 static SENSOR_DEVICE_ATTR_RW(in5_min, volt_min, 4); 1445 static SENSOR_DEVICE_ATTR_RW(in6_min, volt_min, 5); 1446 static SENSOR_DEVICE_ATTR_RW(in7_min, volt_min, 6); 1447 static SENSOR_DEVICE_ATTR_RW(in8_min, volt_min, 7); 1448 static SENSOR_DEVICE_ATTR_RW(in9_min, volt_min, 8); 1449 static SENSOR_DEVICE_ATTR_RW(in10_min, volt_min, 9); 1450 static SENSOR_DEVICE_ATTR_RW(in11_min, volt_min, 10); 1451 static SENSOR_DEVICE_ATTR_RW(in12_min, volt_min, 11); 1452 static SENSOR_DEVICE_ATTR_RW(in13_min, volt_min, 12); 1453 1454 static SENSOR_DEVICE_ATTR_RO(in1_input, voltage, 0); 1455 static SENSOR_DEVICE_ATTR_RO(in2_input, voltage, 1); 1456 static SENSOR_DEVICE_ATTR_RO(in3_input, voltage, 2); 1457 static SENSOR_DEVICE_ATTR_RO(in4_input, voltage, 3); 1458 static SENSOR_DEVICE_ATTR_RO(in5_input, voltage, 4); 1459 static SENSOR_DEVICE_ATTR_RO(in6_input, voltage, 5); 1460 static SENSOR_DEVICE_ATTR_RO(in7_input, voltage, 6); 1461 static SENSOR_DEVICE_ATTR_RO(in8_input, voltage, 7); 1462 static SENSOR_DEVICE_ATTR_RO(in9_input, voltage, 8); 1463 static SENSOR_DEVICE_ATTR_RO(in10_input, voltage, 9); 1464 static SENSOR_DEVICE_ATTR_RO(in11_input, voltage, 10); 1465 static SENSOR_DEVICE_ATTR_RO(in12_input, voltage, 11); 1466 static SENSOR_DEVICE_ATTR_RO(in13_input, voltage, 12); 1467 1468 static SENSOR_DEVICE_ATTR_RO(in1_label, voltage_label, 0); 1469 static SENSOR_DEVICE_ATTR_RO(in2_label, voltage_label, 1); 1470 static SENSOR_DEVICE_ATTR_RO(in3_label, voltage_label, 2); 1471 static SENSOR_DEVICE_ATTR_RO(in4_label, voltage_label, 3); 1472 static SENSOR_DEVICE_ATTR_RO(in5_label, voltage_label, 4); 1473 static SENSOR_DEVICE_ATTR_RO(in6_label, voltage_label, 5); 1474 static SENSOR_DEVICE_ATTR_RO(in7_label, voltage_label, 6); 1475 static SENSOR_DEVICE_ATTR_RO(in8_label, voltage_label, 7); 1476 static SENSOR_DEVICE_ATTR_RO(in9_label, voltage_label, 8); 1477 static SENSOR_DEVICE_ATTR_RO(in10_label, voltage_label, 9); 1478 static SENSOR_DEVICE_ATTR_RO(in11_label, voltage_label, 10); 1479 static SENSOR_DEVICE_ATTR_RO(in12_label, voltage_label, 11); 1480 static SENSOR_DEVICE_ATTR_RO(in13_label, voltage_label, 12); 1481 1482 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1483 ADT7462_ALARM2 | ADT7462_V0_ALARM); 1484 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 1485 ADT7462_ALARM2 | ADT7462_V7_ALARM); 1486 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 1487 ADT7462_ALARM2 | ADT7462_V2_ALARM); 1488 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 1489 ADT7462_ALARM2 | ADT7462_V6_ALARM); 1490 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 1491 ADT7462_ALARM2 | ADT7462_V5_ALARM); 1492 static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 1493 ADT7462_ALARM2 | ADT7462_V4_ALARM); 1494 static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 1495 ADT7462_ALARM2 | ADT7462_V3_ALARM); 1496 static SENSOR_DEVICE_ATTR_RO(in8_alarm, alarm, 1497 ADT7462_ALARM2 | ADT7462_V1_ALARM); 1498 static SENSOR_DEVICE_ATTR_RO(in9_alarm, alarm, 1499 ADT7462_ALARM3 | ADT7462_V10_ALARM); 1500 static SENSOR_DEVICE_ATTR_RO(in10_alarm, alarm, 1501 ADT7462_ALARM3 | ADT7462_V9_ALARM); 1502 static SENSOR_DEVICE_ATTR_RO(in11_alarm, alarm, 1503 ADT7462_ALARM3 | ADT7462_V8_ALARM); 1504 static SENSOR_DEVICE_ATTR_RO(in12_alarm, alarm, 1505 ADT7462_ALARM3 | ADT7462_V11_ALARM); 1506 static SENSOR_DEVICE_ATTR_RO(in13_alarm, alarm, 1507 ADT7462_ALARM3 | ADT7462_V12_ALARM); 1508 1509 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0); 1510 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1); 1511 static SENSOR_DEVICE_ATTR_RW(fan3_min, fan_min, 2); 1512 static SENSOR_DEVICE_ATTR_RW(fan4_min, fan_min, 3); 1513 static SENSOR_DEVICE_ATTR_RW(fan5_min, fan_min, 4); 1514 static SENSOR_DEVICE_ATTR_RW(fan6_min, fan_min, 5); 1515 static SENSOR_DEVICE_ATTR_RW(fan7_min, fan_min, 6); 1516 static SENSOR_DEVICE_ATTR_RW(fan8_min, fan_min, 7); 1517 1518 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0); 1519 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1); 1520 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan, 2); 1521 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan, 3); 1522 static SENSOR_DEVICE_ATTR_RO(fan5_input, fan, 4); 1523 static SENSOR_DEVICE_ATTR_RO(fan6_input, fan, 5); 1524 static SENSOR_DEVICE_ATTR_RO(fan7_input, fan, 6); 1525 static SENSOR_DEVICE_ATTR_RO(fan8_input, fan, 7); 1526 1527 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 1528 ADT7462_ALARM4 | ADT7462_F0_ALARM); 1529 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 1530 ADT7462_ALARM4 | ADT7462_F1_ALARM); 1531 static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm, 1532 ADT7462_ALARM4 | ADT7462_F2_ALARM); 1533 static SENSOR_DEVICE_ATTR_RO(fan4_alarm, alarm, 1534 ADT7462_ALARM4 | ADT7462_F3_ALARM); 1535 static SENSOR_DEVICE_ATTR_RO(fan5_alarm, alarm, 1536 ADT7462_ALARM4 | ADT7462_F4_ALARM); 1537 static SENSOR_DEVICE_ATTR_RO(fan6_alarm, alarm, 1538 ADT7462_ALARM4 | ADT7462_F5_ALARM); 1539 static SENSOR_DEVICE_ATTR_RO(fan7_alarm, alarm, 1540 ADT7462_ALARM4 | ADT7462_F6_ALARM); 1541 static SENSOR_DEVICE_ATTR_RO(fan8_alarm, alarm, 1542 ADT7462_ALARM4 | ADT7462_F7_ALARM); 1543 1544 static SENSOR_DEVICE_ATTR_RW(force_pwm_max, force_pwm_max, 0); 1545 1546 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0); 1547 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1); 1548 static SENSOR_DEVICE_ATTR_RW(pwm3, pwm, 2); 1549 static SENSOR_DEVICE_ATTR_RW(pwm4, pwm, 3); 1550 1551 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_pwm, pwm_min, 0); 1552 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point1_pwm, pwm_min, 1); 1553 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point1_pwm, pwm_min, 2); 1554 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point1_pwm, pwm_min, 3); 1555 1556 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm_max, 0); 1557 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_point2_pwm, pwm_max, 1); 1558 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_point2_pwm, pwm_max, 2); 1559 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_point2_pwm, pwm_max, 3); 1560 1561 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_hyst, pwm_hyst, 0); 1562 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_hyst, pwm_hyst, 1); 1563 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_hyst, pwm_hyst, 2); 1564 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_hyst, pwm_hyst, 3); 1565 1566 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_hyst, pwm_hyst, 0); 1567 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_hyst, pwm_hyst, 1); 1568 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_hyst, pwm_hyst, 2); 1569 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_hyst, pwm_hyst, 3); 1570 1571 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point1_temp, pwm_tmin, 0); 1572 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point1_temp, pwm_tmin, 1); 1573 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point1_temp, pwm_tmin, 2); 1574 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point1_temp, pwm_tmin, 3); 1575 1576 static SENSOR_DEVICE_ATTR_RW(temp1_auto_point2_temp, pwm_tmax, 0); 1577 static SENSOR_DEVICE_ATTR_RW(temp2_auto_point2_temp, pwm_tmax, 1); 1578 static SENSOR_DEVICE_ATTR_RW(temp3_auto_point2_temp, pwm_tmax, 2); 1579 static SENSOR_DEVICE_ATTR_RW(temp4_auto_point2_temp, pwm_tmax, 3); 1580 1581 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm_auto, 0); 1582 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, pwm_auto, 1); 1583 static SENSOR_DEVICE_ATTR_RW(pwm3_enable, pwm_auto, 2); 1584 static SENSOR_DEVICE_ATTR_RW(pwm4_enable, pwm_auto, 3); 1585 1586 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_channels_temp, pwm_auto_temp, 0); 1587 static SENSOR_DEVICE_ATTR_RW(pwm2_auto_channels_temp, pwm_auto_temp, 1); 1588 static SENSOR_DEVICE_ATTR_RW(pwm3_auto_channels_temp, pwm_auto_temp, 2); 1589 static SENSOR_DEVICE_ATTR_RW(pwm4_auto_channels_temp, pwm_auto_temp, 3); 1590 1591 static struct attribute *adt7462_attrs[] = { 1592 &sensor_dev_attr_temp1_max.dev_attr.attr, 1593 &sensor_dev_attr_temp2_max.dev_attr.attr, 1594 &sensor_dev_attr_temp3_max.dev_attr.attr, 1595 &sensor_dev_attr_temp4_max.dev_attr.attr, 1596 1597 &sensor_dev_attr_temp1_min.dev_attr.attr, 1598 &sensor_dev_attr_temp2_min.dev_attr.attr, 1599 &sensor_dev_attr_temp3_min.dev_attr.attr, 1600 &sensor_dev_attr_temp4_min.dev_attr.attr, 1601 1602 &sensor_dev_attr_temp1_input.dev_attr.attr, 1603 &sensor_dev_attr_temp2_input.dev_attr.attr, 1604 &sensor_dev_attr_temp3_input.dev_attr.attr, 1605 &sensor_dev_attr_temp4_input.dev_attr.attr, 1606 1607 &sensor_dev_attr_temp1_label.dev_attr.attr, 1608 &sensor_dev_attr_temp2_label.dev_attr.attr, 1609 &sensor_dev_attr_temp3_label.dev_attr.attr, 1610 &sensor_dev_attr_temp4_label.dev_attr.attr, 1611 1612 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1613 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1614 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1615 &sensor_dev_attr_temp4_alarm.dev_attr.attr, 1616 1617 &sensor_dev_attr_in1_max.dev_attr.attr, 1618 &sensor_dev_attr_in2_max.dev_attr.attr, 1619 &sensor_dev_attr_in3_max.dev_attr.attr, 1620 &sensor_dev_attr_in4_max.dev_attr.attr, 1621 &sensor_dev_attr_in5_max.dev_attr.attr, 1622 &sensor_dev_attr_in6_max.dev_attr.attr, 1623 &sensor_dev_attr_in7_max.dev_attr.attr, 1624 &sensor_dev_attr_in8_max.dev_attr.attr, 1625 &sensor_dev_attr_in9_max.dev_attr.attr, 1626 &sensor_dev_attr_in10_max.dev_attr.attr, 1627 &sensor_dev_attr_in11_max.dev_attr.attr, 1628 &sensor_dev_attr_in12_max.dev_attr.attr, 1629 &sensor_dev_attr_in13_max.dev_attr.attr, 1630 1631 &sensor_dev_attr_in1_min.dev_attr.attr, 1632 &sensor_dev_attr_in2_min.dev_attr.attr, 1633 &sensor_dev_attr_in3_min.dev_attr.attr, 1634 &sensor_dev_attr_in4_min.dev_attr.attr, 1635 &sensor_dev_attr_in5_min.dev_attr.attr, 1636 &sensor_dev_attr_in6_min.dev_attr.attr, 1637 &sensor_dev_attr_in7_min.dev_attr.attr, 1638 &sensor_dev_attr_in8_min.dev_attr.attr, 1639 &sensor_dev_attr_in9_min.dev_attr.attr, 1640 &sensor_dev_attr_in10_min.dev_attr.attr, 1641 &sensor_dev_attr_in11_min.dev_attr.attr, 1642 &sensor_dev_attr_in12_min.dev_attr.attr, 1643 &sensor_dev_attr_in13_min.dev_attr.attr, 1644 1645 &sensor_dev_attr_in1_input.dev_attr.attr, 1646 &sensor_dev_attr_in2_input.dev_attr.attr, 1647 &sensor_dev_attr_in3_input.dev_attr.attr, 1648 &sensor_dev_attr_in4_input.dev_attr.attr, 1649 &sensor_dev_attr_in5_input.dev_attr.attr, 1650 &sensor_dev_attr_in6_input.dev_attr.attr, 1651 &sensor_dev_attr_in7_input.dev_attr.attr, 1652 &sensor_dev_attr_in8_input.dev_attr.attr, 1653 &sensor_dev_attr_in9_input.dev_attr.attr, 1654 &sensor_dev_attr_in10_input.dev_attr.attr, 1655 &sensor_dev_attr_in11_input.dev_attr.attr, 1656 &sensor_dev_attr_in12_input.dev_attr.attr, 1657 &sensor_dev_attr_in13_input.dev_attr.attr, 1658 1659 &sensor_dev_attr_in1_label.dev_attr.attr, 1660 &sensor_dev_attr_in2_label.dev_attr.attr, 1661 &sensor_dev_attr_in3_label.dev_attr.attr, 1662 &sensor_dev_attr_in4_label.dev_attr.attr, 1663 &sensor_dev_attr_in5_label.dev_attr.attr, 1664 &sensor_dev_attr_in6_label.dev_attr.attr, 1665 &sensor_dev_attr_in7_label.dev_attr.attr, 1666 &sensor_dev_attr_in8_label.dev_attr.attr, 1667 &sensor_dev_attr_in9_label.dev_attr.attr, 1668 &sensor_dev_attr_in10_label.dev_attr.attr, 1669 &sensor_dev_attr_in11_label.dev_attr.attr, 1670 &sensor_dev_attr_in12_label.dev_attr.attr, 1671 &sensor_dev_attr_in13_label.dev_attr.attr, 1672 1673 &sensor_dev_attr_in1_alarm.dev_attr.attr, 1674 &sensor_dev_attr_in2_alarm.dev_attr.attr, 1675 &sensor_dev_attr_in3_alarm.dev_attr.attr, 1676 &sensor_dev_attr_in4_alarm.dev_attr.attr, 1677 &sensor_dev_attr_in5_alarm.dev_attr.attr, 1678 &sensor_dev_attr_in6_alarm.dev_attr.attr, 1679 &sensor_dev_attr_in7_alarm.dev_attr.attr, 1680 &sensor_dev_attr_in8_alarm.dev_attr.attr, 1681 &sensor_dev_attr_in9_alarm.dev_attr.attr, 1682 &sensor_dev_attr_in10_alarm.dev_attr.attr, 1683 &sensor_dev_attr_in11_alarm.dev_attr.attr, 1684 &sensor_dev_attr_in12_alarm.dev_attr.attr, 1685 &sensor_dev_attr_in13_alarm.dev_attr.attr, 1686 1687 &sensor_dev_attr_fan1_min.dev_attr.attr, 1688 &sensor_dev_attr_fan2_min.dev_attr.attr, 1689 &sensor_dev_attr_fan3_min.dev_attr.attr, 1690 &sensor_dev_attr_fan4_min.dev_attr.attr, 1691 &sensor_dev_attr_fan5_min.dev_attr.attr, 1692 &sensor_dev_attr_fan6_min.dev_attr.attr, 1693 &sensor_dev_attr_fan7_min.dev_attr.attr, 1694 &sensor_dev_attr_fan8_min.dev_attr.attr, 1695 1696 &sensor_dev_attr_fan1_input.dev_attr.attr, 1697 &sensor_dev_attr_fan2_input.dev_attr.attr, 1698 &sensor_dev_attr_fan3_input.dev_attr.attr, 1699 &sensor_dev_attr_fan4_input.dev_attr.attr, 1700 &sensor_dev_attr_fan5_input.dev_attr.attr, 1701 &sensor_dev_attr_fan6_input.dev_attr.attr, 1702 &sensor_dev_attr_fan7_input.dev_attr.attr, 1703 &sensor_dev_attr_fan8_input.dev_attr.attr, 1704 1705 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1706 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1707 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1708 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 1709 &sensor_dev_attr_fan5_alarm.dev_attr.attr, 1710 &sensor_dev_attr_fan6_alarm.dev_attr.attr, 1711 &sensor_dev_attr_fan7_alarm.dev_attr.attr, 1712 &sensor_dev_attr_fan8_alarm.dev_attr.attr, 1713 1714 &sensor_dev_attr_force_pwm_max.dev_attr.attr, 1715 &sensor_dev_attr_pwm1.dev_attr.attr, 1716 &sensor_dev_attr_pwm2.dev_attr.attr, 1717 &sensor_dev_attr_pwm3.dev_attr.attr, 1718 &sensor_dev_attr_pwm4.dev_attr.attr, 1719 1720 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 1721 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 1722 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 1723 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr, 1724 1725 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 1726 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 1727 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 1728 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr, 1729 1730 &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr, 1731 &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr, 1732 &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr, 1733 &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr, 1734 1735 &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr, 1736 &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr, 1737 &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr, 1738 &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr, 1739 1740 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr, 1741 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr, 1742 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr, 1743 &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr, 1744 1745 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr, 1746 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr, 1747 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr, 1748 &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr, 1749 1750 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1751 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1752 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1753 &sensor_dev_attr_pwm4_enable.dev_attr.attr, 1754 1755 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr, 1756 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr, 1757 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr, 1758 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr, 1759 NULL 1760 }; 1761 1762 ATTRIBUTE_GROUPS(adt7462); 1763 1764 /* Return 0 if detection is successful, -ENODEV otherwise */ 1765 static int adt7462_detect(struct i2c_client *client, 1766 struct i2c_board_info *info) 1767 { 1768 struct i2c_adapter *adapter = client->adapter; 1769 int vendor, device, revision; 1770 1771 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1772 return -ENODEV; 1773 1774 vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR); 1775 if (vendor != ADT7462_VENDOR) 1776 return -ENODEV; 1777 1778 device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE); 1779 if (device != ADT7462_DEVICE) 1780 return -ENODEV; 1781 1782 revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION); 1783 if (revision != ADT7462_REVISION) 1784 return -ENODEV; 1785 1786 strscpy(info->type, "adt7462", I2C_NAME_SIZE); 1787 1788 return 0; 1789 } 1790 1791 static int adt7462_probe(struct i2c_client *client) 1792 { 1793 struct device *dev = &client->dev; 1794 struct adt7462_data *data; 1795 struct device *hwmon_dev; 1796 1797 data = devm_kzalloc(dev, sizeof(struct adt7462_data), GFP_KERNEL); 1798 if (!data) 1799 return -ENOMEM; 1800 1801 data->client = client; 1802 mutex_init(&data->lock); 1803 1804 dev_info(&client->dev, "%s chip found\n", client->name); 1805 1806 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 1807 data, 1808 adt7462_groups); 1809 return PTR_ERR_OR_ZERO(hwmon_dev); 1810 } 1811 1812 static const struct i2c_device_id adt7462_id[] = { 1813 { .name = "adt7462" }, 1814 { } 1815 }; 1816 MODULE_DEVICE_TABLE(i2c, adt7462_id); 1817 1818 static const struct of_device_id adt7462_of_match[] = { 1819 { .compatible = "onnn,adt7462" }, 1820 { }, 1821 }; 1822 MODULE_DEVICE_TABLE(of, adt7462_of_match); 1823 1824 static struct i2c_driver adt7462_driver = { 1825 .class = I2C_CLASS_HWMON, 1826 .driver = { 1827 .name = "adt7462", 1828 .of_match_table = adt7462_of_match, 1829 }, 1830 .probe = adt7462_probe, 1831 .id_table = adt7462_id, 1832 .detect = adt7462_detect, 1833 .address_list = normal_i2c, 1834 }; 1835 1836 module_i2c_driver(adt7462_driver); 1837 1838 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>"); 1839 MODULE_DESCRIPTION("ADT7462 driver"); 1840 MODULE_LICENSE("GPL"); 1841