1 /* 2 * A hwmon driver for the Analog Devices ADT7462 3 * Copyright (C) 2008 IBM 4 * 5 * Author: Darrick J. Wong <djwong@us.ibm.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 device *hwmon_dev; 206 struct attribute_group attrs; 207 struct mutex lock; 208 char sensors_valid; 209 char limits_valid; 210 unsigned long sensors_last_updated; /* In jiffies */ 211 unsigned long limits_last_updated; /* In jiffies */ 212 213 u8 temp[ADT7462_TEMP_COUNT]; 214 /* bits 6-7 are quarter pieces of temp */ 215 u8 temp_frac[ADT7462_TEMP_COUNT]; 216 u8 temp_min[ADT7462_TEMP_COUNT]; 217 u8 temp_max[ADT7462_TEMP_COUNT]; 218 u16 fan[ADT7462_FAN_COUNT]; 219 u8 fan_enabled; 220 u8 fan_min[ADT7462_FAN_COUNT]; 221 u8 cfg2; 222 u8 pwm[ADT7462_PWM_COUNT]; 223 u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT]; 224 u8 voltages[ADT7462_VOLT_COUNT]; 225 u8 volt_max[ADT7462_VOLT_COUNT]; 226 u8 volt_min[ADT7462_VOLT_COUNT]; 227 u8 pwm_min[ADT7462_PWM_COUNT]; 228 u8 pwm_tmin[ADT7462_PWM_COUNT]; 229 u8 pwm_trange[ADT7462_PWM_COUNT]; 230 u8 pwm_max; /* only one per chip */ 231 u8 pwm_cfg[ADT7462_PWM_COUNT]; 232 u8 alarms[ADT7462_ALARM_REG_COUNT]; 233 }; 234 235 static int adt7462_probe(struct i2c_client *client, 236 const struct i2c_device_id *id); 237 static int adt7462_detect(struct i2c_client *client, 238 struct i2c_board_info *info); 239 static int adt7462_remove(struct i2c_client *client); 240 241 static const struct i2c_device_id adt7462_id[] = { 242 { "adt7462", 0 }, 243 { } 244 }; 245 MODULE_DEVICE_TABLE(i2c, adt7462_id); 246 247 static struct i2c_driver adt7462_driver = { 248 .class = I2C_CLASS_HWMON, 249 .driver = { 250 .name = "adt7462", 251 }, 252 .probe = adt7462_probe, 253 .remove = adt7462_remove, 254 .id_table = adt7462_id, 255 .detect = adt7462_detect, 256 .address_list = normal_i2c, 257 }; 258 259 /* 260 * 16-bit registers on the ADT7462 are low-byte first. The data sheet says 261 * that the low byte must be read before the high byte. 262 */ 263 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg) 264 { 265 u16 foo; 266 foo = i2c_smbus_read_byte_data(client, reg); 267 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8); 268 return foo; 269 } 270 271 /* For some reason these registers are not contiguous. */ 272 static int ADT7462_REG_FAN(int fan) 273 { 274 if (fan < 4) 275 return ADT7462_REG_FAN_BASE_ADDR + (2 * fan); 276 return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4)); 277 } 278 279 /* Voltage registers are scattered everywhere */ 280 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which) 281 { 282 switch (which) { 283 case 0: 284 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 285 return 0x7C; 286 break; 287 case 1: 288 return 0x69; 289 case 2: 290 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 291 return 0x7F; 292 break; 293 case 3: 294 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 295 return 0x7E; 296 break; 297 case 4: 298 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) 299 return 0x4B; 300 break; 301 case 5: 302 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) 303 return 0x49; 304 break; 305 case 6: 306 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 307 return 0x68; 308 break; 309 case 7: 310 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 311 return 0x7D; 312 break; 313 case 8: 314 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT)) 315 return 0x6C; 316 break; 317 case 9: 318 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT)) 319 return 0x6B; 320 break; 321 case 10: 322 return 0x6A; 323 case 11: 324 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 325 ADT7462_PIN28_VOLT && 326 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 327 return 0x50; 328 break; 329 case 12: 330 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 331 ADT7462_PIN28_VOLT && 332 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 333 return 0x4C; 334 break; 335 } 336 return -ENODEV; 337 } 338 339 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which) 340 { 341 switch (which) { 342 case 0: 343 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 344 return 0x6D; 345 break; 346 case 1: 347 return 0x72; 348 case 2: 349 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 350 return 0x6F; 351 break; 352 case 3: 353 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 354 return 0x71; 355 break; 356 case 4: 357 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) 358 return 0x47; 359 break; 360 case 5: 361 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) 362 return 0x45; 363 break; 364 case 6: 365 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 366 return 0x70; 367 break; 368 case 7: 369 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 370 return 0x6E; 371 break; 372 case 8: 373 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT)) 374 return 0x75; 375 break; 376 case 9: 377 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT)) 378 return 0x74; 379 break; 380 case 10: 381 return 0x73; 382 case 11: 383 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 384 ADT7462_PIN28_VOLT && 385 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 386 return 0x76; 387 break; 388 case 12: 389 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 390 ADT7462_PIN28_VOLT && 391 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 392 return 0x77; 393 break; 394 } 395 return -ENODEV; 396 } 397 398 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which) 399 { 400 switch (which) { 401 case 0: 402 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 403 return 0xA3; 404 break; 405 case 1: 406 return 0x90; 407 case 2: 408 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 409 return 0xA9; 410 break; 411 case 3: 412 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 413 return 0xA7; 414 break; 415 case 4: 416 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) 417 return 0x8F; 418 break; 419 case 5: 420 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) 421 return 0x8B; 422 break; 423 case 6: 424 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 425 return 0x96; 426 break; 427 case 7: 428 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 429 return 0xA5; 430 break; 431 case 8: 432 if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT)) 433 return 0x93; 434 break; 435 case 9: 436 if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT)) 437 return 0x92; 438 break; 439 case 10: 440 return 0x91; 441 case 11: 442 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 443 ADT7462_PIN28_VOLT && 444 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 445 return 0x94; 446 break; 447 case 12: 448 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 449 ADT7462_PIN28_VOLT && 450 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 451 return 0x95; 452 break; 453 } 454 return -ENODEV; 455 } 456 457 /* Provide labels for sysfs */ 458 static const char *voltage_label(struct adt7462_data *data, int which) 459 { 460 switch (which) { 461 case 0: 462 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 463 return "+12V1"; 464 break; 465 case 1: 466 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) { 467 case 0: 468 return "Vccp1"; 469 case 1: 470 return "+2.5V"; 471 case 2: 472 return "+1.8V"; 473 case 3: 474 return "+1.5V"; 475 } 476 case 2: 477 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 478 return "+12V3"; 479 break; 480 case 3: 481 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 482 return "+5V"; 483 break; 484 case 4: 485 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) { 486 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT) 487 return "+0.9V"; 488 return "+1.25V"; 489 } 490 break; 491 case 5: 492 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) { 493 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT) 494 return "+1.8V"; 495 return "+2.5V"; 496 } 497 break; 498 case 6: 499 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 500 return "+3.3V"; 501 break; 502 case 7: 503 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 504 return "+12V2"; 505 break; 506 case 8: 507 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) { 508 case 0: 509 return "Vbatt"; 510 case 1: 511 return "FSB_Vtt"; 512 } 513 break; 514 case 9: 515 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) { 516 case 0: 517 return "+3.3V"; 518 case 1: 519 return "+1.2V1"; 520 } 521 break; 522 case 10: 523 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) { 524 case 0: 525 return "Vccp2"; 526 case 1: 527 return "+2.5V"; 528 case 2: 529 return "+1.8V"; 530 case 3: 531 return "+1.5"; 532 } 533 case 11: 534 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 535 ADT7462_PIN28_VOLT && 536 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 537 return "+1.5V ICH"; 538 break; 539 case 12: 540 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 541 ADT7462_PIN28_VOLT && 542 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 543 return "+1.5V 3GPIO"; 544 break; 545 } 546 return "N/A"; 547 } 548 549 /* Multipliers are actually in uV, not mV. */ 550 static int voltage_multiplier(struct adt7462_data *data, int which) 551 { 552 switch (which) { 553 case 0: 554 if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT)) 555 return 62500; 556 break; 557 case 1: 558 switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) { 559 case 0: 560 if (data->pin_cfg[0] & ADT7462_VID_INPUT) 561 return 12500; 562 return 6250; 563 case 1: 564 return 13000; 565 case 2: 566 return 9400; 567 case 3: 568 return 7800; 569 } 570 case 2: 571 if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT)) 572 return 62500; 573 break; 574 case 3: 575 if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT)) 576 return 26000; 577 break; 578 case 4: 579 if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) { 580 if (data->pin_cfg[1] & ADT7462_PIN19_INPUT) 581 return 4690; 582 return 6500; 583 } 584 break; 585 case 5: 586 if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) { 587 if (data->pin_cfg[1] & ADT7462_PIN15_INPUT) 588 return 9400; 589 return 13000; 590 } 591 break; 592 case 6: 593 if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT)) 594 return 17200; 595 break; 596 case 7: 597 if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT)) 598 return 62500; 599 break; 600 case 8: 601 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) { 602 case 0: 603 return 15600; 604 case 1: 605 return 6250; 606 } 607 break; 608 case 9: 609 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) { 610 case 0: 611 return 17200; 612 case 1: 613 return 6250; 614 } 615 break; 616 case 10: 617 switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) { 618 case 0: 619 return 6250; 620 case 1: 621 return 13000; 622 case 2: 623 return 9400; 624 case 3: 625 return 7800; 626 } 627 case 11: 628 case 12: 629 if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT == 630 ADT7462_PIN28_VOLT && 631 !(data->pin_cfg[0] & ADT7462_VID_INPUT)) 632 return 7800; 633 } 634 return 0; 635 } 636 637 static int temp_enabled(struct adt7462_data *data, int which) 638 { 639 switch (which) { 640 case 0: 641 case 2: 642 return 1; 643 case 1: 644 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT) 645 return 1; 646 break; 647 case 3: 648 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT) 649 return 1; 650 break; 651 } 652 return 0; 653 } 654 655 static const char *temp_label(struct adt7462_data *data, int which) 656 { 657 switch (which) { 658 case 0: 659 return "local"; 660 case 1: 661 if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT) 662 return "remote1"; 663 break; 664 case 2: 665 return "remote2"; 666 case 3: 667 if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT) 668 return "remote3"; 669 break; 670 } 671 return "N/A"; 672 } 673 674 /* Map Trange register values to mC */ 675 #define NUM_TRANGE_VALUES 16 676 static const int trange_values[NUM_TRANGE_VALUES] = { 677 2000, 678 2500, 679 3300, 680 4000, 681 5000, 682 6700, 683 8000, 684 10000, 685 13300, 686 16000, 687 20000, 688 26700, 689 32000, 690 40000, 691 53300, 692 80000 693 }; 694 695 static int find_trange_value(int trange) 696 { 697 int i; 698 699 for (i = 0; i < NUM_TRANGE_VALUES; i++) 700 if (trange_values[i] == trange) 701 return i; 702 703 return -ENODEV; 704 } 705 706 static struct adt7462_data *adt7462_update_device(struct device *dev) 707 { 708 struct i2c_client *client = to_i2c_client(dev); 709 struct adt7462_data *data = i2c_get_clientdata(client); 710 unsigned long local_jiffies = jiffies; 711 int i; 712 713 mutex_lock(&data->lock); 714 if (time_before(local_jiffies, data->sensors_last_updated + 715 SENSOR_REFRESH_INTERVAL) 716 && data->sensors_valid) 717 goto no_sensor_update; 718 719 for (i = 0; i < ADT7462_TEMP_COUNT; i++) { 720 /* 721 * Reading the fractional register locks the integral 722 * register until both have been read. 723 */ 724 data->temp_frac[i] = i2c_smbus_read_byte_data(client, 725 ADT7462_TEMP_REG(i)); 726 data->temp[i] = i2c_smbus_read_byte_data(client, 727 ADT7462_TEMP_REG(i) + 1); 728 } 729 730 for (i = 0; i < ADT7462_FAN_COUNT; i++) 731 data->fan[i] = adt7462_read_word_data(client, 732 ADT7462_REG_FAN(i)); 733 734 data->fan_enabled = i2c_smbus_read_byte_data(client, 735 ADT7462_REG_FAN_ENABLE); 736 737 for (i = 0; i < ADT7462_PWM_COUNT; i++) 738 data->pwm[i] = i2c_smbus_read_byte_data(client, 739 ADT7462_REG_PWM(i)); 740 741 for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++) 742 data->pin_cfg[i] = i2c_smbus_read_byte_data(client, 743 ADT7462_REG_PIN_CFG(i)); 744 745 for (i = 0; i < ADT7462_VOLT_COUNT; i++) { 746 int reg = ADT7462_REG_VOLT(data, i); 747 if (!reg) 748 data->voltages[i] = 0; 749 else 750 data->voltages[i] = i2c_smbus_read_byte_data(client, 751 reg); 752 } 753 754 data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1); 755 data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2); 756 data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3); 757 data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4); 758 759 data->sensors_last_updated = local_jiffies; 760 data->sensors_valid = 1; 761 762 no_sensor_update: 763 if (time_before(local_jiffies, data->limits_last_updated + 764 LIMIT_REFRESH_INTERVAL) 765 && data->limits_valid) 766 goto out; 767 768 for (i = 0; i < ADT7462_TEMP_COUNT; i++) { 769 data->temp_min[i] = i2c_smbus_read_byte_data(client, 770 ADT7462_TEMP_MIN_REG(i)); 771 data->temp_max[i] = i2c_smbus_read_byte_data(client, 772 ADT7462_TEMP_MAX_REG(i)); 773 } 774 775 for (i = 0; i < ADT7462_FAN_COUNT; i++) 776 data->fan_min[i] = i2c_smbus_read_byte_data(client, 777 ADT7462_REG_FAN_MIN(i)); 778 779 for (i = 0; i < ADT7462_VOLT_COUNT; i++) { 780 int reg = ADT7462_REG_VOLT_MAX(data, i); 781 data->volt_max[i] = 782 (reg ? i2c_smbus_read_byte_data(client, reg) : 0); 783 784 reg = ADT7462_REG_VOLT_MIN(data, i); 785 data->volt_min[i] = 786 (reg ? i2c_smbus_read_byte_data(client, reg) : 0); 787 } 788 789 for (i = 0; i < ADT7462_PWM_COUNT; i++) { 790 data->pwm_min[i] = i2c_smbus_read_byte_data(client, 791 ADT7462_REG_PWM_MIN(i)); 792 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client, 793 ADT7462_REG_PWM_TMIN(i)); 794 data->pwm_trange[i] = i2c_smbus_read_byte_data(client, 795 ADT7462_REG_PWM_TRANGE(i)); 796 data->pwm_cfg[i] = i2c_smbus_read_byte_data(client, 797 ADT7462_REG_PWM_CFG(i)); 798 } 799 800 data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX); 801 802 data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2); 803 804 data->limits_last_updated = local_jiffies; 805 data->limits_valid = 1; 806 807 out: 808 mutex_unlock(&data->lock); 809 return data; 810 } 811 812 static ssize_t show_temp_min(struct device *dev, 813 struct device_attribute *devattr, 814 char *buf) 815 { 816 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 817 struct adt7462_data *data = adt7462_update_device(dev); 818 819 if (!temp_enabled(data, attr->index)) 820 return sprintf(buf, "0\n"); 821 822 return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64)); 823 } 824 825 static ssize_t set_temp_min(struct device *dev, 826 struct device_attribute *devattr, 827 const char *buf, 828 size_t count) 829 { 830 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 831 struct i2c_client *client = to_i2c_client(dev); 832 struct adt7462_data *data = i2c_get_clientdata(client); 833 long temp; 834 835 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index)) 836 return -EINVAL; 837 838 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64; 839 temp = SENSORS_LIMIT(temp, 0, 255); 840 841 mutex_lock(&data->lock); 842 data->temp_min[attr->index] = temp; 843 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index), 844 temp); 845 mutex_unlock(&data->lock); 846 847 return count; 848 } 849 850 static ssize_t show_temp_max(struct device *dev, 851 struct device_attribute *devattr, 852 char *buf) 853 { 854 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 855 struct adt7462_data *data = adt7462_update_device(dev); 856 857 if (!temp_enabled(data, attr->index)) 858 return sprintf(buf, "0\n"); 859 860 return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64)); 861 } 862 863 static ssize_t set_temp_max(struct device *dev, 864 struct device_attribute *devattr, 865 const char *buf, 866 size_t count) 867 { 868 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 869 struct i2c_client *client = to_i2c_client(dev); 870 struct adt7462_data *data = i2c_get_clientdata(client); 871 long temp; 872 873 if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index)) 874 return -EINVAL; 875 876 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64; 877 temp = SENSORS_LIMIT(temp, 0, 255); 878 879 mutex_lock(&data->lock); 880 data->temp_max[attr->index] = temp; 881 i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index), 882 temp); 883 mutex_unlock(&data->lock); 884 885 return count; 886 } 887 888 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr, 889 char *buf) 890 { 891 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 892 struct adt7462_data *data = adt7462_update_device(dev); 893 u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET; 894 895 if (!temp_enabled(data, attr->index)) 896 return sprintf(buf, "0\n"); 897 898 return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) + 899 250 * frac); 900 } 901 902 static ssize_t show_temp_label(struct device *dev, 903 struct device_attribute *devattr, 904 char *buf) 905 { 906 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 907 struct adt7462_data *data = adt7462_update_device(dev); 908 909 return sprintf(buf, "%s\n", temp_label(data, attr->index)); 910 } 911 912 static ssize_t show_volt_max(struct device *dev, 913 struct device_attribute *devattr, 914 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_max[attr->index]; 921 x /= 1000; /* convert from uV to mV */ 922 923 return sprintf(buf, "%d\n", x); 924 } 925 926 static ssize_t set_volt_max(struct device *dev, 927 struct device_attribute *devattr, 928 const char *buf, 929 size_t count) 930 { 931 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 932 struct i2c_client *client = to_i2c_client(dev); 933 struct adt7462_data *data = i2c_get_clientdata(client); 934 int x = voltage_multiplier(data, attr->index); 935 long temp; 936 937 if (kstrtol(buf, 10, &temp) || !x) 938 return -EINVAL; 939 940 temp *= 1000; /* convert mV to uV */ 941 temp = DIV_ROUND_CLOSEST(temp, x); 942 temp = SENSORS_LIMIT(temp, 0, 255); 943 944 mutex_lock(&data->lock); 945 data->volt_max[attr->index] = temp; 946 i2c_smbus_write_byte_data(client, 947 ADT7462_REG_VOLT_MAX(data, attr->index), 948 temp); 949 mutex_unlock(&data->lock); 950 951 return count; 952 } 953 954 static ssize_t show_volt_min(struct device *dev, 955 struct device_attribute *devattr, 956 char *buf) 957 { 958 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 959 struct adt7462_data *data = adt7462_update_device(dev); 960 int x = voltage_multiplier(data, attr->index); 961 962 x *= data->volt_min[attr->index]; 963 x /= 1000; /* convert from uV to mV */ 964 965 return sprintf(buf, "%d\n", x); 966 } 967 968 static ssize_t set_volt_min(struct device *dev, 969 struct device_attribute *devattr, 970 const char *buf, 971 size_t count) 972 { 973 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 974 struct i2c_client *client = to_i2c_client(dev); 975 struct adt7462_data *data = i2c_get_clientdata(client); 976 int x = voltage_multiplier(data, attr->index); 977 long temp; 978 979 if (kstrtol(buf, 10, &temp) || !x) 980 return -EINVAL; 981 982 temp *= 1000; /* convert mV to uV */ 983 temp = DIV_ROUND_CLOSEST(temp, x); 984 temp = SENSORS_LIMIT(temp, 0, 255); 985 986 mutex_lock(&data->lock); 987 data->volt_min[attr->index] = temp; 988 i2c_smbus_write_byte_data(client, 989 ADT7462_REG_VOLT_MIN(data, attr->index), 990 temp); 991 mutex_unlock(&data->lock); 992 993 return count; 994 } 995 996 static ssize_t show_voltage(struct device *dev, 997 struct device_attribute *devattr, 998 char *buf) 999 { 1000 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1001 struct adt7462_data *data = adt7462_update_device(dev); 1002 int x = voltage_multiplier(data, attr->index); 1003 1004 x *= data->voltages[attr->index]; 1005 x /= 1000; /* convert from uV to mV */ 1006 1007 return sprintf(buf, "%d\n", x); 1008 } 1009 1010 static ssize_t show_voltage_label(struct device *dev, 1011 struct device_attribute *devattr, 1012 char *buf) 1013 { 1014 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1015 struct adt7462_data *data = adt7462_update_device(dev); 1016 1017 return sprintf(buf, "%s\n", voltage_label(data, attr->index)); 1018 } 1019 1020 static ssize_t show_alarm(struct device *dev, 1021 struct device_attribute *devattr, 1022 char *buf) 1023 { 1024 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1025 struct adt7462_data *data = adt7462_update_device(dev); 1026 int reg = attr->index >> ADT7462_ALARM_REG_SHIFT; 1027 int mask = attr->index & ADT7462_ALARM_FLAG_MASK; 1028 1029 if (data->alarms[reg] & mask) 1030 return sprintf(buf, "1\n"); 1031 else 1032 return sprintf(buf, "0\n"); 1033 } 1034 1035 static int fan_enabled(struct adt7462_data *data, int fan) 1036 { 1037 return data->fan_enabled & (1 << fan); 1038 } 1039 1040 static ssize_t show_fan_min(struct device *dev, 1041 struct device_attribute *devattr, 1042 char *buf) 1043 { 1044 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1045 struct adt7462_data *data = adt7462_update_device(dev); 1046 u16 temp; 1047 1048 /* Only the MSB of the min fan period is stored... */ 1049 temp = data->fan_min[attr->index]; 1050 temp <<= 8; 1051 1052 if (!fan_enabled(data, attr->index) || 1053 !FAN_DATA_VALID(temp)) 1054 return sprintf(buf, "0\n"); 1055 1056 return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp)); 1057 } 1058 1059 static ssize_t set_fan_min(struct device *dev, 1060 struct device_attribute *devattr, 1061 const char *buf, size_t count) 1062 { 1063 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1064 struct i2c_client *client = to_i2c_client(dev); 1065 struct adt7462_data *data = i2c_get_clientdata(client); 1066 long temp; 1067 1068 if (kstrtol(buf, 10, &temp) || !temp || 1069 !fan_enabled(data, attr->index)) 1070 return -EINVAL; 1071 1072 temp = FAN_RPM_TO_PERIOD(temp); 1073 temp >>= 8; 1074 temp = SENSORS_LIMIT(temp, 1, 255); 1075 1076 mutex_lock(&data->lock); 1077 data->fan_min[attr->index] = temp; 1078 i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index), 1079 temp); 1080 mutex_unlock(&data->lock); 1081 1082 return count; 1083 } 1084 1085 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr, 1086 char *buf) 1087 { 1088 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1089 struct adt7462_data *data = adt7462_update_device(dev); 1090 1091 if (!fan_enabled(data, attr->index) || 1092 !FAN_DATA_VALID(data->fan[attr->index])) 1093 return sprintf(buf, "0\n"); 1094 1095 return sprintf(buf, "%d\n", 1096 FAN_PERIOD_TO_RPM(data->fan[attr->index])); 1097 } 1098 1099 static ssize_t show_force_pwm_max(struct device *dev, 1100 struct device_attribute *devattr, 1101 char *buf) 1102 { 1103 struct adt7462_data *data = adt7462_update_device(dev); 1104 return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0)); 1105 } 1106 1107 static ssize_t set_force_pwm_max(struct device *dev, 1108 struct device_attribute *devattr, 1109 const char *buf, 1110 size_t count) 1111 { 1112 struct i2c_client *client = to_i2c_client(dev); 1113 struct adt7462_data *data = i2c_get_clientdata(client); 1114 long temp; 1115 u8 reg; 1116 1117 if (kstrtol(buf, 10, &temp)) 1118 return -EINVAL; 1119 1120 mutex_lock(&data->lock); 1121 reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2); 1122 if (temp) 1123 reg |= ADT7462_FSPD_MASK; 1124 else 1125 reg &= ~ADT7462_FSPD_MASK; 1126 data->cfg2 = reg; 1127 i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg); 1128 mutex_unlock(&data->lock); 1129 1130 return count; 1131 } 1132 1133 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr, 1134 char *buf) 1135 { 1136 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1137 struct adt7462_data *data = adt7462_update_device(dev); 1138 return sprintf(buf, "%d\n", data->pwm[attr->index]); 1139 } 1140 1141 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, 1142 const char *buf, size_t count) 1143 { 1144 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1145 struct i2c_client *client = to_i2c_client(dev); 1146 struct adt7462_data *data = i2c_get_clientdata(client); 1147 long temp; 1148 1149 if (kstrtol(buf, 10, &temp)) 1150 return -EINVAL; 1151 1152 temp = SENSORS_LIMIT(temp, 0, 255); 1153 1154 mutex_lock(&data->lock); 1155 data->pwm[attr->index] = temp; 1156 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp); 1157 mutex_unlock(&data->lock); 1158 1159 return count; 1160 } 1161 1162 static ssize_t show_pwm_max(struct device *dev, 1163 struct device_attribute *devattr, 1164 char *buf) 1165 { 1166 struct adt7462_data *data = adt7462_update_device(dev); 1167 return sprintf(buf, "%d\n", data->pwm_max); 1168 } 1169 1170 static ssize_t set_pwm_max(struct device *dev, 1171 struct device_attribute *devattr, 1172 const char *buf, 1173 size_t count) 1174 { 1175 struct i2c_client *client = to_i2c_client(dev); 1176 struct adt7462_data *data = i2c_get_clientdata(client); 1177 long temp; 1178 1179 if (kstrtol(buf, 10, &temp)) 1180 return -EINVAL; 1181 1182 temp = SENSORS_LIMIT(temp, 0, 255); 1183 1184 mutex_lock(&data->lock); 1185 data->pwm_max = temp; 1186 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp); 1187 mutex_unlock(&data->lock); 1188 1189 return count; 1190 } 1191 1192 static ssize_t show_pwm_min(struct device *dev, 1193 struct device_attribute *devattr, 1194 char *buf) 1195 { 1196 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1197 struct adt7462_data *data = adt7462_update_device(dev); 1198 return sprintf(buf, "%d\n", data->pwm_min[attr->index]); 1199 } 1200 1201 static ssize_t set_pwm_min(struct device *dev, 1202 struct device_attribute *devattr, 1203 const char *buf, 1204 size_t count) 1205 { 1206 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1207 struct i2c_client *client = to_i2c_client(dev); 1208 struct adt7462_data *data = i2c_get_clientdata(client); 1209 long temp; 1210 1211 if (kstrtol(buf, 10, &temp)) 1212 return -EINVAL; 1213 1214 temp = SENSORS_LIMIT(temp, 0, 255); 1215 1216 mutex_lock(&data->lock); 1217 data->pwm_min[attr->index] = temp; 1218 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index), 1219 temp); 1220 mutex_unlock(&data->lock); 1221 1222 return count; 1223 } 1224 1225 static ssize_t show_pwm_hyst(struct device *dev, 1226 struct device_attribute *devattr, 1227 char *buf) 1228 { 1229 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1230 struct adt7462_data *data = adt7462_update_device(dev); 1231 return sprintf(buf, "%d\n", 1000 * 1232 (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK)); 1233 } 1234 1235 static ssize_t set_pwm_hyst(struct device *dev, 1236 struct device_attribute *devattr, 1237 const char *buf, 1238 size_t count) 1239 { 1240 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1241 struct i2c_client *client = to_i2c_client(dev); 1242 struct adt7462_data *data = i2c_get_clientdata(client); 1243 long temp; 1244 1245 if (kstrtol(buf, 10, &temp)) 1246 return -EINVAL; 1247 1248 temp = DIV_ROUND_CLOSEST(temp, 1000); 1249 temp = SENSORS_LIMIT(temp, 0, 15); 1250 1251 /* package things up */ 1252 temp &= ADT7462_PWM_HYST_MASK; 1253 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_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 show_pwm_tmax(struct device *dev, 1265 struct device_attribute *devattr, 1266 char *buf) 1267 { 1268 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1269 struct adt7462_data *data = adt7462_update_device(dev); 1270 1271 /* tmax = tmin + trange */ 1272 int trange = trange_values[data->pwm_trange[attr->index] >> 1273 ADT7462_PWM_RANGE_SHIFT]; 1274 int tmin = (data->pwm_tmin[attr->index] - 64) * 1000; 1275 1276 return sprintf(buf, "%d\n", tmin + trange); 1277 } 1278 1279 static ssize_t set_pwm_tmax(struct device *dev, 1280 struct device_attribute *devattr, 1281 const char *buf, 1282 size_t count) 1283 { 1284 int temp; 1285 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1286 struct i2c_client *client = to_i2c_client(dev); 1287 struct adt7462_data *data = i2c_get_clientdata(client); 1288 int tmin, trange_value; 1289 long trange; 1290 1291 if (kstrtol(buf, 10, &trange)) 1292 return -EINVAL; 1293 1294 /* trange = tmax - tmin */ 1295 tmin = (data->pwm_tmin[attr->index] - 64) * 1000; 1296 trange_value = find_trange_value(trange - tmin); 1297 1298 if (trange_value < 0) 1299 return -EINVAL; 1300 1301 temp = trange_value << ADT7462_PWM_RANGE_SHIFT; 1302 temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK; 1303 1304 mutex_lock(&data->lock); 1305 data->pwm_trange[attr->index] = temp; 1306 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index), 1307 temp); 1308 mutex_unlock(&data->lock); 1309 1310 return count; 1311 } 1312 1313 static ssize_t show_pwm_tmin(struct device *dev, 1314 struct device_attribute *devattr, 1315 char *buf) 1316 { 1317 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1318 struct adt7462_data *data = adt7462_update_device(dev); 1319 return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64)); 1320 } 1321 1322 static ssize_t set_pwm_tmin(struct device *dev, 1323 struct device_attribute *devattr, 1324 const char *buf, 1325 size_t count) 1326 { 1327 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1328 struct i2c_client *client = to_i2c_client(dev); 1329 struct adt7462_data *data = i2c_get_clientdata(client); 1330 long temp; 1331 1332 if (kstrtol(buf, 10, &temp)) 1333 return -EINVAL; 1334 1335 temp = DIV_ROUND_CLOSEST(temp, 1000) + 64; 1336 temp = SENSORS_LIMIT(temp, 0, 255); 1337 1338 mutex_lock(&data->lock); 1339 data->pwm_tmin[attr->index] = temp; 1340 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index), 1341 temp); 1342 mutex_unlock(&data->lock); 1343 1344 return count; 1345 } 1346 1347 static ssize_t show_pwm_auto(struct device *dev, 1348 struct device_attribute *devattr, 1349 char *buf) 1350 { 1351 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1352 struct adt7462_data *data = adt7462_update_device(dev); 1353 int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT; 1354 1355 switch (cfg) { 1356 case 4: /* off */ 1357 return sprintf(buf, "0\n"); 1358 case 7: /* manual */ 1359 return sprintf(buf, "1\n"); 1360 default: /* automatic */ 1361 return sprintf(buf, "2\n"); 1362 } 1363 } 1364 1365 static void set_pwm_channel(struct i2c_client *client, 1366 struct adt7462_data *data, 1367 int which, 1368 int value) 1369 { 1370 int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK; 1371 temp |= value << ADT7462_PWM_CHANNEL_SHIFT; 1372 1373 mutex_lock(&data->lock); 1374 data->pwm_cfg[which] = temp; 1375 i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp); 1376 mutex_unlock(&data->lock); 1377 } 1378 1379 static ssize_t set_pwm_auto(struct device *dev, 1380 struct device_attribute *devattr, 1381 const char *buf, 1382 size_t count) 1383 { 1384 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1385 struct i2c_client *client = to_i2c_client(dev); 1386 struct adt7462_data *data = i2c_get_clientdata(client); 1387 long temp; 1388 1389 if (kstrtol(buf, 10, &temp)) 1390 return -EINVAL; 1391 1392 switch (temp) { 1393 case 0: /* off */ 1394 set_pwm_channel(client, data, attr->index, 4); 1395 return count; 1396 case 1: /* manual */ 1397 set_pwm_channel(client, data, attr->index, 7); 1398 return count; 1399 default: 1400 return -EINVAL; 1401 } 1402 } 1403 1404 static ssize_t show_pwm_auto_temp(struct device *dev, 1405 struct device_attribute *devattr, 1406 char *buf) 1407 { 1408 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1409 struct adt7462_data *data = adt7462_update_device(dev); 1410 int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT; 1411 1412 switch (channel) { 1413 case 0: /* temp[1234] only */ 1414 case 1: 1415 case 2: 1416 case 3: 1417 return sprintf(buf, "%d\n", (1 << channel)); 1418 case 5: /* temp1 & temp4 */ 1419 return sprintf(buf, "9\n"); 1420 case 6: 1421 return sprintf(buf, "15\n"); 1422 default: 1423 return sprintf(buf, "0\n"); 1424 } 1425 } 1426 1427 static int cvt_auto_temp(int input) 1428 { 1429 if (input == 0xF) 1430 return 6; 1431 if (input == 0x9) 1432 return 5; 1433 if (input < 1 || !is_power_of_2(input)) 1434 return -EINVAL; 1435 return ilog2(input); 1436 } 1437 1438 static ssize_t set_pwm_auto_temp(struct device *dev, 1439 struct device_attribute *devattr, 1440 const char *buf, 1441 size_t count) 1442 { 1443 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 1444 struct i2c_client *client = to_i2c_client(dev); 1445 struct adt7462_data *data = i2c_get_clientdata(client); 1446 long temp; 1447 1448 if (kstrtol(buf, 10, &temp)) 1449 return -EINVAL; 1450 1451 temp = cvt_auto_temp(temp); 1452 if (temp < 0) 1453 return temp; 1454 1455 set_pwm_channel(client, data, attr->index, temp); 1456 1457 return count; 1458 } 1459 1460 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, 1461 set_temp_max, 0); 1462 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max, 1463 set_temp_max, 1); 1464 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max, 1465 set_temp_max, 2); 1466 static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max, 1467 set_temp_max, 3); 1468 1469 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min, 1470 set_temp_min, 0); 1471 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min, 1472 set_temp_min, 1); 1473 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min, 1474 set_temp_min, 2); 1475 static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min, 1476 set_temp_min, 3); 1477 1478 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 1479 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 1480 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2); 1481 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3); 1482 1483 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0); 1484 static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1); 1485 static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2); 1486 static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3); 1487 1488 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 1489 ADT7462_ALARM1 | ADT7462_LT_ALARM); 1490 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 1491 ADT7462_ALARM1 | ADT7462_R1T_ALARM); 1492 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 1493 ADT7462_ALARM1 | ADT7462_R2T_ALARM); 1494 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL, 1495 ADT7462_ALARM1 | ADT7462_R3T_ALARM); 1496 1497 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max, 1498 set_volt_max, 0); 1499 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max, 1500 set_volt_max, 1); 1501 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, show_volt_max, 1502 set_volt_max, 2); 1503 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, show_volt_max, 1504 set_volt_max, 3); 1505 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, show_volt_max, 1506 set_volt_max, 4); 1507 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, show_volt_max, 1508 set_volt_max, 5); 1509 static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, show_volt_max, 1510 set_volt_max, 6); 1511 static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, show_volt_max, 1512 set_volt_max, 7); 1513 static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, show_volt_max, 1514 set_volt_max, 8); 1515 static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, show_volt_max, 1516 set_volt_max, 9); 1517 static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, show_volt_max, 1518 set_volt_max, 10); 1519 static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, show_volt_max, 1520 set_volt_max, 11); 1521 static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, show_volt_max, 1522 set_volt_max, 12); 1523 1524 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min, 1525 set_volt_min, 0); 1526 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min, 1527 set_volt_min, 1); 1528 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, show_volt_min, 1529 set_volt_min, 2); 1530 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, show_volt_min, 1531 set_volt_min, 3); 1532 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, show_volt_min, 1533 set_volt_min, 4); 1534 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, show_volt_min, 1535 set_volt_min, 5); 1536 static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, show_volt_min, 1537 set_volt_min, 6); 1538 static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, show_volt_min, 1539 set_volt_min, 7); 1540 static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, show_volt_min, 1541 set_volt_min, 8); 1542 static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, show_volt_min, 1543 set_volt_min, 9); 1544 static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, show_volt_min, 1545 set_volt_min, 10); 1546 static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, show_volt_min, 1547 set_volt_min, 11); 1548 static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, show_volt_min, 1549 set_volt_min, 12); 1550 1551 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_voltage, NULL, 0); 1552 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_voltage, NULL, 1); 1553 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_voltage, NULL, 2); 1554 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_voltage, NULL, 3); 1555 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_voltage, NULL, 4); 1556 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_voltage, NULL, 5); 1557 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_voltage, NULL, 6); 1558 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_voltage, NULL, 7); 1559 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_voltage, NULL, 8); 1560 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_voltage, NULL, 9); 1561 static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_voltage, NULL, 10); 1562 static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_voltage, NULL, 11); 1563 static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_voltage, NULL, 12); 1564 1565 static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, show_voltage_label, NULL, 0); 1566 static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, show_voltage_label, NULL, 1); 1567 static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_voltage_label, NULL, 2); 1568 static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, show_voltage_label, NULL, 3); 1569 static SENSOR_DEVICE_ATTR(in5_label, S_IRUGO, show_voltage_label, NULL, 4); 1570 static SENSOR_DEVICE_ATTR(in6_label, S_IRUGO, show_voltage_label, NULL, 5); 1571 static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_voltage_label, NULL, 6); 1572 static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_voltage_label, NULL, 7); 1573 static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_voltage_label, NULL, 8); 1574 static SENSOR_DEVICE_ATTR(in10_label, S_IRUGO, show_voltage_label, NULL, 9); 1575 static SENSOR_DEVICE_ATTR(in11_label, S_IRUGO, show_voltage_label, NULL, 10); 1576 static SENSOR_DEVICE_ATTR(in12_label, S_IRUGO, show_voltage_label, NULL, 11); 1577 static SENSOR_DEVICE_ATTR(in13_label, S_IRUGO, show_voltage_label, NULL, 12); 1578 1579 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1580 ADT7462_ALARM2 | ADT7462_V0_ALARM); 1581 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 1582 ADT7462_ALARM2 | ADT7462_V7_ALARM); 1583 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 1584 ADT7462_ALARM2 | ADT7462_V2_ALARM); 1585 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 1586 ADT7462_ALARM2 | ADT7462_V6_ALARM); 1587 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 1588 ADT7462_ALARM2 | ADT7462_V5_ALARM); 1589 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 1590 ADT7462_ALARM2 | ADT7462_V4_ALARM); 1591 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 1592 ADT7462_ALARM2 | ADT7462_V3_ALARM); 1593 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 1594 ADT7462_ALARM2 | ADT7462_V1_ALARM); 1595 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 1596 ADT7462_ALARM3 | ADT7462_V10_ALARM); 1597 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 1598 ADT7462_ALARM3 | ADT7462_V9_ALARM); 1599 static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL, 1600 ADT7462_ALARM3 | ADT7462_V8_ALARM); 1601 static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL, 1602 ADT7462_ALARM3 | ADT7462_V11_ALARM); 1603 static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL, 1604 ADT7462_ALARM3 | ADT7462_V12_ALARM); 1605 1606 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min, 1607 set_fan_min, 0); 1608 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min, 1609 set_fan_min, 1); 1610 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min, 1611 set_fan_min, 2); 1612 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min, 1613 set_fan_min, 3); 1614 static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min, 1615 set_fan_min, 4); 1616 static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min, 1617 set_fan_min, 5); 1618 static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min, 1619 set_fan_min, 6); 1620 static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, show_fan_min, 1621 set_fan_min, 7); 1622 1623 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0); 1624 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1); 1625 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2); 1626 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3); 1627 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4); 1628 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 5); 1629 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 6); 1630 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan, NULL, 7); 1631 1632 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 1633 ADT7462_ALARM4 | ADT7462_F0_ALARM); 1634 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1635 ADT7462_ALARM4 | ADT7462_F1_ALARM); 1636 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 1637 ADT7462_ALARM4 | ADT7462_F2_ALARM); 1638 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 1639 ADT7462_ALARM4 | ADT7462_F3_ALARM); 1640 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 1641 ADT7462_ALARM4 | ADT7462_F4_ALARM); 1642 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL, 1643 ADT7462_ALARM4 | ADT7462_F5_ALARM); 1644 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL, 1645 ADT7462_ALARM4 | ADT7462_F6_ALARM); 1646 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL, 1647 ADT7462_ALARM4 | ADT7462_F7_ALARM); 1648 1649 static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO, 1650 show_force_pwm_max, set_force_pwm_max, 0); 1651 1652 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0); 1653 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1); 1654 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2); 1655 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3); 1656 1657 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO, 1658 show_pwm_min, set_pwm_min, 0); 1659 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO, 1660 show_pwm_min, set_pwm_min, 1); 1661 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO, 1662 show_pwm_min, set_pwm_min, 2); 1663 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO, 1664 show_pwm_min, set_pwm_min, 3); 1665 1666 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO, 1667 show_pwm_max, set_pwm_max, 0); 1668 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO, 1669 show_pwm_max, set_pwm_max, 1); 1670 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO, 1671 show_pwm_max, set_pwm_max, 2); 1672 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO, 1673 show_pwm_max, set_pwm_max, 3); 1674 1675 static SENSOR_DEVICE_ATTR(temp1_auto_point1_hyst, S_IWUSR | S_IRUGO, 1676 show_pwm_hyst, set_pwm_hyst, 0); 1677 static SENSOR_DEVICE_ATTR(temp2_auto_point1_hyst, S_IWUSR | S_IRUGO, 1678 show_pwm_hyst, set_pwm_hyst, 1); 1679 static SENSOR_DEVICE_ATTR(temp3_auto_point1_hyst, S_IWUSR | S_IRUGO, 1680 show_pwm_hyst, set_pwm_hyst, 2); 1681 static SENSOR_DEVICE_ATTR(temp4_auto_point1_hyst, S_IWUSR | S_IRUGO, 1682 show_pwm_hyst, set_pwm_hyst, 3); 1683 1684 static SENSOR_DEVICE_ATTR(temp1_auto_point2_hyst, S_IWUSR | S_IRUGO, 1685 show_pwm_hyst, set_pwm_hyst, 0); 1686 static SENSOR_DEVICE_ATTR(temp2_auto_point2_hyst, S_IWUSR | S_IRUGO, 1687 show_pwm_hyst, set_pwm_hyst, 1); 1688 static SENSOR_DEVICE_ATTR(temp3_auto_point2_hyst, S_IWUSR | S_IRUGO, 1689 show_pwm_hyst, set_pwm_hyst, 2); 1690 static SENSOR_DEVICE_ATTR(temp4_auto_point2_hyst, S_IWUSR | S_IRUGO, 1691 show_pwm_hyst, set_pwm_hyst, 3); 1692 1693 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO, 1694 show_pwm_tmin, set_pwm_tmin, 0); 1695 static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO, 1696 show_pwm_tmin, set_pwm_tmin, 1); 1697 static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO, 1698 show_pwm_tmin, set_pwm_tmin, 2); 1699 static SENSOR_DEVICE_ATTR(temp4_auto_point1_temp, S_IWUSR | S_IRUGO, 1700 show_pwm_tmin, set_pwm_tmin, 3); 1701 1702 static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO, 1703 show_pwm_tmax, set_pwm_tmax, 0); 1704 static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO, 1705 show_pwm_tmax, set_pwm_tmax, 1); 1706 static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO, 1707 show_pwm_tmax, set_pwm_tmax, 2); 1708 static SENSOR_DEVICE_ATTR(temp4_auto_point2_temp, S_IWUSR | S_IRUGO, 1709 show_pwm_tmax, set_pwm_tmax, 3); 1710 1711 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1712 set_pwm_auto, 0); 1713 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1714 set_pwm_auto, 1); 1715 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1716 set_pwm_auto, 2); 1717 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto, 1718 set_pwm_auto, 3); 1719 1720 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO, 1721 show_pwm_auto_temp, set_pwm_auto_temp, 0); 1722 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO, 1723 show_pwm_auto_temp, set_pwm_auto_temp, 1); 1724 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO, 1725 show_pwm_auto_temp, set_pwm_auto_temp, 2); 1726 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO, 1727 show_pwm_auto_temp, set_pwm_auto_temp, 3); 1728 1729 static struct attribute *adt7462_attr[] = { 1730 &sensor_dev_attr_temp1_max.dev_attr.attr, 1731 &sensor_dev_attr_temp2_max.dev_attr.attr, 1732 &sensor_dev_attr_temp3_max.dev_attr.attr, 1733 &sensor_dev_attr_temp4_max.dev_attr.attr, 1734 1735 &sensor_dev_attr_temp1_min.dev_attr.attr, 1736 &sensor_dev_attr_temp2_min.dev_attr.attr, 1737 &sensor_dev_attr_temp3_min.dev_attr.attr, 1738 &sensor_dev_attr_temp4_min.dev_attr.attr, 1739 1740 &sensor_dev_attr_temp1_input.dev_attr.attr, 1741 &sensor_dev_attr_temp2_input.dev_attr.attr, 1742 &sensor_dev_attr_temp3_input.dev_attr.attr, 1743 &sensor_dev_attr_temp4_input.dev_attr.attr, 1744 1745 &sensor_dev_attr_temp1_label.dev_attr.attr, 1746 &sensor_dev_attr_temp2_label.dev_attr.attr, 1747 &sensor_dev_attr_temp3_label.dev_attr.attr, 1748 &sensor_dev_attr_temp4_label.dev_attr.attr, 1749 1750 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1751 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1752 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1753 &sensor_dev_attr_temp4_alarm.dev_attr.attr, 1754 1755 &sensor_dev_attr_in1_max.dev_attr.attr, 1756 &sensor_dev_attr_in2_max.dev_attr.attr, 1757 &sensor_dev_attr_in3_max.dev_attr.attr, 1758 &sensor_dev_attr_in4_max.dev_attr.attr, 1759 &sensor_dev_attr_in5_max.dev_attr.attr, 1760 &sensor_dev_attr_in6_max.dev_attr.attr, 1761 &sensor_dev_attr_in7_max.dev_attr.attr, 1762 &sensor_dev_attr_in8_max.dev_attr.attr, 1763 &sensor_dev_attr_in9_max.dev_attr.attr, 1764 &sensor_dev_attr_in10_max.dev_attr.attr, 1765 &sensor_dev_attr_in11_max.dev_attr.attr, 1766 &sensor_dev_attr_in12_max.dev_attr.attr, 1767 &sensor_dev_attr_in13_max.dev_attr.attr, 1768 1769 &sensor_dev_attr_in1_min.dev_attr.attr, 1770 &sensor_dev_attr_in2_min.dev_attr.attr, 1771 &sensor_dev_attr_in3_min.dev_attr.attr, 1772 &sensor_dev_attr_in4_min.dev_attr.attr, 1773 &sensor_dev_attr_in5_min.dev_attr.attr, 1774 &sensor_dev_attr_in6_min.dev_attr.attr, 1775 &sensor_dev_attr_in7_min.dev_attr.attr, 1776 &sensor_dev_attr_in8_min.dev_attr.attr, 1777 &sensor_dev_attr_in9_min.dev_attr.attr, 1778 &sensor_dev_attr_in10_min.dev_attr.attr, 1779 &sensor_dev_attr_in11_min.dev_attr.attr, 1780 &sensor_dev_attr_in12_min.dev_attr.attr, 1781 &sensor_dev_attr_in13_min.dev_attr.attr, 1782 1783 &sensor_dev_attr_in1_input.dev_attr.attr, 1784 &sensor_dev_attr_in2_input.dev_attr.attr, 1785 &sensor_dev_attr_in3_input.dev_attr.attr, 1786 &sensor_dev_attr_in4_input.dev_attr.attr, 1787 &sensor_dev_attr_in5_input.dev_attr.attr, 1788 &sensor_dev_attr_in6_input.dev_attr.attr, 1789 &sensor_dev_attr_in7_input.dev_attr.attr, 1790 &sensor_dev_attr_in8_input.dev_attr.attr, 1791 &sensor_dev_attr_in9_input.dev_attr.attr, 1792 &sensor_dev_attr_in10_input.dev_attr.attr, 1793 &sensor_dev_attr_in11_input.dev_attr.attr, 1794 &sensor_dev_attr_in12_input.dev_attr.attr, 1795 &sensor_dev_attr_in13_input.dev_attr.attr, 1796 1797 &sensor_dev_attr_in1_label.dev_attr.attr, 1798 &sensor_dev_attr_in2_label.dev_attr.attr, 1799 &sensor_dev_attr_in3_label.dev_attr.attr, 1800 &sensor_dev_attr_in4_label.dev_attr.attr, 1801 &sensor_dev_attr_in5_label.dev_attr.attr, 1802 &sensor_dev_attr_in6_label.dev_attr.attr, 1803 &sensor_dev_attr_in7_label.dev_attr.attr, 1804 &sensor_dev_attr_in8_label.dev_attr.attr, 1805 &sensor_dev_attr_in9_label.dev_attr.attr, 1806 &sensor_dev_attr_in10_label.dev_attr.attr, 1807 &sensor_dev_attr_in11_label.dev_attr.attr, 1808 &sensor_dev_attr_in12_label.dev_attr.attr, 1809 &sensor_dev_attr_in13_label.dev_attr.attr, 1810 1811 &sensor_dev_attr_in1_alarm.dev_attr.attr, 1812 &sensor_dev_attr_in2_alarm.dev_attr.attr, 1813 &sensor_dev_attr_in3_alarm.dev_attr.attr, 1814 &sensor_dev_attr_in4_alarm.dev_attr.attr, 1815 &sensor_dev_attr_in5_alarm.dev_attr.attr, 1816 &sensor_dev_attr_in6_alarm.dev_attr.attr, 1817 &sensor_dev_attr_in7_alarm.dev_attr.attr, 1818 &sensor_dev_attr_in8_alarm.dev_attr.attr, 1819 &sensor_dev_attr_in9_alarm.dev_attr.attr, 1820 &sensor_dev_attr_in10_alarm.dev_attr.attr, 1821 &sensor_dev_attr_in11_alarm.dev_attr.attr, 1822 &sensor_dev_attr_in12_alarm.dev_attr.attr, 1823 &sensor_dev_attr_in13_alarm.dev_attr.attr, 1824 1825 &sensor_dev_attr_fan1_min.dev_attr.attr, 1826 &sensor_dev_attr_fan2_min.dev_attr.attr, 1827 &sensor_dev_attr_fan3_min.dev_attr.attr, 1828 &sensor_dev_attr_fan4_min.dev_attr.attr, 1829 &sensor_dev_attr_fan5_min.dev_attr.attr, 1830 &sensor_dev_attr_fan6_min.dev_attr.attr, 1831 &sensor_dev_attr_fan7_min.dev_attr.attr, 1832 &sensor_dev_attr_fan8_min.dev_attr.attr, 1833 1834 &sensor_dev_attr_fan1_input.dev_attr.attr, 1835 &sensor_dev_attr_fan2_input.dev_attr.attr, 1836 &sensor_dev_attr_fan3_input.dev_attr.attr, 1837 &sensor_dev_attr_fan4_input.dev_attr.attr, 1838 &sensor_dev_attr_fan5_input.dev_attr.attr, 1839 &sensor_dev_attr_fan6_input.dev_attr.attr, 1840 &sensor_dev_attr_fan7_input.dev_attr.attr, 1841 &sensor_dev_attr_fan8_input.dev_attr.attr, 1842 1843 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1844 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1845 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1846 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 1847 &sensor_dev_attr_fan5_alarm.dev_attr.attr, 1848 &sensor_dev_attr_fan6_alarm.dev_attr.attr, 1849 &sensor_dev_attr_fan7_alarm.dev_attr.attr, 1850 &sensor_dev_attr_fan8_alarm.dev_attr.attr, 1851 1852 &sensor_dev_attr_force_pwm_max.dev_attr.attr, 1853 &sensor_dev_attr_pwm1.dev_attr.attr, 1854 &sensor_dev_attr_pwm2.dev_attr.attr, 1855 &sensor_dev_attr_pwm3.dev_attr.attr, 1856 &sensor_dev_attr_pwm4.dev_attr.attr, 1857 1858 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 1859 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 1860 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 1861 &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr, 1862 1863 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 1864 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 1865 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 1866 &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr, 1867 1868 &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr, 1869 &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr, 1870 &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr, 1871 &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr, 1872 1873 &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr, 1874 &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr, 1875 &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr, 1876 &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr, 1877 1878 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr, 1879 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr, 1880 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr, 1881 &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr, 1882 1883 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr, 1884 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr, 1885 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr, 1886 &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr, 1887 1888 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1889 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1890 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1891 &sensor_dev_attr_pwm4_enable.dev_attr.attr, 1892 1893 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr, 1894 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr, 1895 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr, 1896 &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr, 1897 NULL 1898 }; 1899 1900 /* Return 0 if detection is successful, -ENODEV otherwise */ 1901 static int adt7462_detect(struct i2c_client *client, 1902 struct i2c_board_info *info) 1903 { 1904 struct i2c_adapter *adapter = client->adapter; 1905 int vendor, device, revision; 1906 1907 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1908 return -ENODEV; 1909 1910 vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR); 1911 if (vendor != ADT7462_VENDOR) 1912 return -ENODEV; 1913 1914 device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE); 1915 if (device != ADT7462_DEVICE) 1916 return -ENODEV; 1917 1918 revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION); 1919 if (revision != ADT7462_REVISION) 1920 return -ENODEV; 1921 1922 strlcpy(info->type, "adt7462", I2C_NAME_SIZE); 1923 1924 return 0; 1925 } 1926 1927 static int adt7462_probe(struct i2c_client *client, 1928 const struct i2c_device_id *id) 1929 { 1930 struct adt7462_data *data; 1931 int err; 1932 1933 data = devm_kzalloc(&client->dev, sizeof(struct adt7462_data), 1934 GFP_KERNEL); 1935 if (!data) 1936 return -ENOMEM; 1937 1938 i2c_set_clientdata(client, data); 1939 mutex_init(&data->lock); 1940 1941 dev_info(&client->dev, "%s chip found\n", client->name); 1942 1943 /* Register sysfs hooks */ 1944 data->attrs.attrs = adt7462_attr; 1945 err = sysfs_create_group(&client->dev.kobj, &data->attrs); 1946 if (err) 1947 return err; 1948 1949 data->hwmon_dev = hwmon_device_register(&client->dev); 1950 if (IS_ERR(data->hwmon_dev)) { 1951 err = PTR_ERR(data->hwmon_dev); 1952 goto exit_remove; 1953 } 1954 1955 return 0; 1956 1957 exit_remove: 1958 sysfs_remove_group(&client->dev.kobj, &data->attrs); 1959 return err; 1960 } 1961 1962 static int adt7462_remove(struct i2c_client *client) 1963 { 1964 struct adt7462_data *data = i2c_get_clientdata(client); 1965 1966 hwmon_device_unregister(data->hwmon_dev); 1967 sysfs_remove_group(&client->dev.kobj, &data->attrs); 1968 return 0; 1969 } 1970 1971 module_i2c_driver(adt7462_driver); 1972 1973 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>"); 1974 MODULE_DESCRIPTION("ADT7462 driver"); 1975 MODULE_LICENSE("GPL"); 1976