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