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