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