1 /* 2 * lm85.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 5 * Copyright (c) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com> 6 * Copyright (c) 2003 Margit Schubert-While <margitsw@t-online.de> 7 * Copyright (c) 2004 Justin Thiessen <jthiessen@penguincomputing.com> 8 * Copyright (C) 2007--2014 Jean Delvare <jdelvare@suse.de> 9 * 10 * Chip details at <http://www.national.com/ds/LM/LM85.pdf> 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 25 */ 26 27 #include <linux/module.h> 28 #include <linux/init.h> 29 #include <linux/slab.h> 30 #include <linux/jiffies.h> 31 #include <linux/i2c.h> 32 #include <linux/hwmon.h> 33 #include <linux/hwmon-vid.h> 34 #include <linux/hwmon-sysfs.h> 35 #include <linux/err.h> 36 #include <linux/mutex.h> 37 38 /* Addresses to scan */ 39 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 40 41 enum chips { 42 lm85, 43 adm1027, adt7463, adt7468, 44 emc6d100, emc6d102, emc6d103, emc6d103s 45 }; 46 47 /* The LM85 registers */ 48 49 #define LM85_REG_IN(nr) (0x20 + (nr)) 50 #define LM85_REG_IN_MIN(nr) (0x44 + (nr) * 2) 51 #define LM85_REG_IN_MAX(nr) (0x45 + (nr) * 2) 52 53 #define LM85_REG_TEMP(nr) (0x25 + (nr)) 54 #define LM85_REG_TEMP_MIN(nr) (0x4e + (nr) * 2) 55 #define LM85_REG_TEMP_MAX(nr) (0x4f + (nr) * 2) 56 57 /* Fan speeds are LSB, MSB (2 bytes) */ 58 #define LM85_REG_FAN(nr) (0x28 + (nr) * 2) 59 #define LM85_REG_FAN_MIN(nr) (0x54 + (nr) * 2) 60 61 #define LM85_REG_PWM(nr) (0x30 + (nr)) 62 63 #define LM85_REG_COMPANY 0x3e 64 #define LM85_REG_VERSTEP 0x3f 65 66 #define ADT7468_REG_CFG5 0x7c 67 #define ADT7468_OFF64 (1 << 0) 68 #define ADT7468_HFPWM (1 << 1) 69 #define IS_ADT7468_OFF64(data) \ 70 ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_OFF64)) 71 #define IS_ADT7468_HFPWM(data) \ 72 ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_HFPWM)) 73 74 /* These are the recognized values for the above regs */ 75 #define LM85_COMPANY_NATIONAL 0x01 76 #define LM85_COMPANY_ANALOG_DEV 0x41 77 #define LM85_COMPANY_SMSC 0x5c 78 #define LM85_VERSTEP_LM85C 0x60 79 #define LM85_VERSTEP_LM85B 0x62 80 #define LM85_VERSTEP_LM96000_1 0x68 81 #define LM85_VERSTEP_LM96000_2 0x69 82 #define LM85_VERSTEP_ADM1027 0x60 83 #define LM85_VERSTEP_ADT7463 0x62 84 #define LM85_VERSTEP_ADT7463C 0x6A 85 #define LM85_VERSTEP_ADT7468_1 0x71 86 #define LM85_VERSTEP_ADT7468_2 0x72 87 #define LM85_VERSTEP_EMC6D100_A0 0x60 88 #define LM85_VERSTEP_EMC6D100_A1 0x61 89 #define LM85_VERSTEP_EMC6D102 0x65 90 #define LM85_VERSTEP_EMC6D103_A0 0x68 91 #define LM85_VERSTEP_EMC6D103_A1 0x69 92 #define LM85_VERSTEP_EMC6D103S 0x6A /* Also known as EMC6D103:A2 */ 93 94 #define LM85_REG_CONFIG 0x40 95 96 #define LM85_REG_ALARM1 0x41 97 #define LM85_REG_ALARM2 0x42 98 99 #define LM85_REG_VID 0x43 100 101 /* Automated FAN control */ 102 #define LM85_REG_AFAN_CONFIG(nr) (0x5c + (nr)) 103 #define LM85_REG_AFAN_RANGE(nr) (0x5f + (nr)) 104 #define LM85_REG_AFAN_SPIKE1 0x62 105 #define LM85_REG_AFAN_MINPWM(nr) (0x64 + (nr)) 106 #define LM85_REG_AFAN_LIMIT(nr) (0x67 + (nr)) 107 #define LM85_REG_AFAN_CRITICAL(nr) (0x6a + (nr)) 108 #define LM85_REG_AFAN_HYST1 0x6d 109 #define LM85_REG_AFAN_HYST2 0x6e 110 111 #define ADM1027_REG_EXTEND_ADC1 0x76 112 #define ADM1027_REG_EXTEND_ADC2 0x77 113 114 #define EMC6D100_REG_ALARM3 0x7d 115 /* IN5, IN6 and IN7 */ 116 #define EMC6D100_REG_IN(nr) (0x70 + ((nr) - 5)) 117 #define EMC6D100_REG_IN_MIN(nr) (0x73 + ((nr) - 5) * 2) 118 #define EMC6D100_REG_IN_MAX(nr) (0x74 + ((nr) - 5) * 2) 119 #define EMC6D102_REG_EXTEND_ADC1 0x85 120 #define EMC6D102_REG_EXTEND_ADC2 0x86 121 #define EMC6D102_REG_EXTEND_ADC3 0x87 122 #define EMC6D102_REG_EXTEND_ADC4 0x88 123 124 125 /* 126 * Conversions. Rounding and limit checking is only done on the TO_REG 127 * variants. Note that you should be a bit careful with which arguments 128 * these macros are called: arguments may be evaluated more than once. 129 */ 130 131 /* IN are scaled according to built-in resistors */ 132 static const int lm85_scaling[] = { /* .001 Volts */ 133 2500, 2250, 3300, 5000, 12000, 134 3300, 1500, 1800 /*EMC6D100*/ 135 }; 136 #define SCALE(val, from, to) (((val) * (to) + ((from) / 2)) / (from)) 137 138 #define INS_TO_REG(n, val) \ 139 clamp_val(SCALE(val, lm85_scaling[n], 192), 0, 255) 140 141 #define INSEXT_FROM_REG(n, val, ext) \ 142 SCALE(((val) << 4) + (ext), 192 << 4, lm85_scaling[n]) 143 144 #define INS_FROM_REG(n, val) SCALE((val), 192, lm85_scaling[n]) 145 146 /* FAN speed is measured using 90kHz clock */ 147 static inline u16 FAN_TO_REG(unsigned long val) 148 { 149 if (!val) 150 return 0xffff; 151 return clamp_val(5400000 / val, 1, 0xfffe); 152 } 153 #define FAN_FROM_REG(val) ((val) == 0 ? -1 : (val) == 0xffff ? 0 : \ 154 5400000 / (val)) 155 156 /* Temperature is reported in .001 degC increments */ 157 #define TEMP_TO_REG(val) \ 158 clamp_val(SCALE(val, 1000, 1), -127, 127) 159 #define TEMPEXT_FROM_REG(val, ext) \ 160 SCALE(((val) << 4) + (ext), 16, 1000) 161 #define TEMP_FROM_REG(val) ((val) * 1000) 162 163 #define PWM_TO_REG(val) clamp_val(val, 0, 255) 164 #define PWM_FROM_REG(val) (val) 165 166 167 /* 168 * ZONEs have the following parameters: 169 * Limit (low) temp, 1. degC 170 * Hysteresis (below limit), 1. degC (0-15) 171 * Range of speed control, .1 degC (2-80) 172 * Critical (high) temp, 1. degC 173 * 174 * FAN PWMs have the following parameters: 175 * Reference Zone, 1, 2, 3, etc. 176 * Spinup time, .05 sec 177 * PWM value at limit/low temp, 1 count 178 * PWM Frequency, 1. Hz 179 * PWM is Min or OFF below limit, flag 180 * Invert PWM output, flag 181 * 182 * Some chips filter the temp, others the fan. 183 * Filter constant (or disabled) .1 seconds 184 */ 185 186 /* These are the zone temperature range encodings in .001 degree C */ 187 static const int lm85_range_map[] = { 188 2000, 2500, 3300, 4000, 5000, 6600, 8000, 10000, 189 13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000 190 }; 191 192 static int RANGE_TO_REG(int range) 193 { 194 int i; 195 196 /* Find the closest match */ 197 for (i = 0; i < 15; ++i) { 198 if (range <= (lm85_range_map[i] + lm85_range_map[i + 1]) / 2) 199 break; 200 } 201 202 return i; 203 } 204 #define RANGE_FROM_REG(val) lm85_range_map[(val) & 0x0f] 205 206 /* These are the PWM frequency encodings */ 207 static const int lm85_freq_map[8] = { /* 1 Hz */ 208 10, 15, 23, 30, 38, 47, 61, 94 209 }; 210 static const int adm1027_freq_map[8] = { /* 1 Hz */ 211 11, 15, 22, 29, 35, 44, 59, 88 212 }; 213 214 static int FREQ_TO_REG(const int *map, int freq) 215 { 216 int i; 217 218 /* Find the closest match */ 219 for (i = 0; i < 7; ++i) 220 if (freq <= (map[i] + map[i + 1]) / 2) 221 break; 222 return i; 223 } 224 225 static int FREQ_FROM_REG(const int *map, u8 reg) 226 { 227 return map[reg & 0x07]; 228 } 229 230 /* 231 * Since we can't use strings, I'm abusing these numbers 232 * to stand in for the following meanings: 233 * 1 -- PWM responds to Zone 1 234 * 2 -- PWM responds to Zone 2 235 * 3 -- PWM responds to Zone 3 236 * 23 -- PWM responds to the higher temp of Zone 2 or 3 237 * 123 -- PWM responds to highest of Zone 1, 2, or 3 238 * 0 -- PWM is always at 0% (ie, off) 239 * -1 -- PWM is always at 100% 240 * -2 -- PWM responds to manual control 241 */ 242 243 static const int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 }; 244 #define ZONE_FROM_REG(val) lm85_zone_map[(val) >> 5] 245 246 static int ZONE_TO_REG(int zone) 247 { 248 int i; 249 250 for (i = 0; i <= 7; ++i) 251 if (zone == lm85_zone_map[i]) 252 break; 253 if (i > 7) /* Not found. */ 254 i = 3; /* Always 100% */ 255 return i << 5; 256 } 257 258 #define HYST_TO_REG(val) clamp_val(((val) + 500) / 1000, 0, 15) 259 #define HYST_FROM_REG(val) ((val) * 1000) 260 261 /* 262 * Chip sampling rates 263 * 264 * Some sensors are not updated more frequently than once per second 265 * so it doesn't make sense to read them more often than that. 266 * We cache the results and return the saved data if the driver 267 * is called again before a second has elapsed. 268 * 269 * Also, there is significant configuration data for this chip 270 * given the automatic PWM fan control that is possible. There 271 * are about 47 bytes of config data to only 22 bytes of actual 272 * readings. So, we keep the config data up to date in the cache 273 * when it is written and only sample it once every 1 *minute* 274 */ 275 #define LM85_DATA_INTERVAL (HZ + HZ / 2) 276 #define LM85_CONFIG_INTERVAL (1 * 60 * HZ) 277 278 /* 279 * LM85 can automatically adjust fan speeds based on temperature 280 * This structure encapsulates an entire Zone config. There are 281 * three zones (one for each temperature input) on the lm85 282 */ 283 struct lm85_zone { 284 s8 limit; /* Low temp limit */ 285 u8 hyst; /* Low limit hysteresis. (0-15) */ 286 u8 range; /* Temp range, encoded */ 287 s8 critical; /* "All fans ON" temp limit */ 288 u8 max_desired; /* 289 * Actual "max" temperature specified. Preserved 290 * to prevent "drift" as other autofan control 291 * values change. 292 */ 293 }; 294 295 struct lm85_autofan { 296 u8 config; /* Register value */ 297 u8 min_pwm; /* Minimum PWM value, encoded */ 298 u8 min_off; /* Min PWM or OFF below "limit", flag */ 299 }; 300 301 /* 302 * For each registered chip, we need to keep some data in memory. 303 * The structure is dynamically allocated. 304 */ 305 struct lm85_data { 306 struct device *hwmon_dev; 307 const int *freq_map; 308 enum chips type; 309 310 bool has_vid5; /* true if VID5 is configured for ADT7463 or ADT7468 */ 311 312 struct mutex update_lock; 313 int valid; /* !=0 if following fields are valid */ 314 unsigned long last_reading; /* In jiffies */ 315 unsigned long last_config; /* In jiffies */ 316 317 u8 in[8]; /* Register value */ 318 u8 in_max[8]; /* Register value */ 319 u8 in_min[8]; /* Register value */ 320 s8 temp[3]; /* Register value */ 321 s8 temp_min[3]; /* Register value */ 322 s8 temp_max[3]; /* Register value */ 323 u16 fan[4]; /* Register value */ 324 u16 fan_min[4]; /* Register value */ 325 u8 pwm[3]; /* Register value */ 326 u8 pwm_freq[3]; /* Register encoding */ 327 u8 temp_ext[3]; /* Decoded values */ 328 u8 in_ext[8]; /* Decoded values */ 329 u8 vid; /* Register value */ 330 u8 vrm; /* VRM version */ 331 u32 alarms; /* Register encoding, combined */ 332 u8 cfg5; /* Config Register 5 on ADT7468 */ 333 struct lm85_autofan autofan[3]; 334 struct lm85_zone zone[3]; 335 }; 336 337 static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info); 338 static int lm85_probe(struct i2c_client *client, 339 const struct i2c_device_id *id); 340 static int lm85_remove(struct i2c_client *client); 341 342 static int lm85_read_value(struct i2c_client *client, u8 reg); 343 static void lm85_write_value(struct i2c_client *client, u8 reg, int value); 344 static struct lm85_data *lm85_update_device(struct device *dev); 345 346 347 static const struct i2c_device_id lm85_id[] = { 348 { "adm1027", adm1027 }, 349 { "adt7463", adt7463 }, 350 { "adt7468", adt7468 }, 351 { "lm85", lm85 }, 352 { "lm85b", lm85 }, 353 { "lm85c", lm85 }, 354 { "emc6d100", emc6d100 }, 355 { "emc6d101", emc6d100 }, 356 { "emc6d102", emc6d102 }, 357 { "emc6d103", emc6d103 }, 358 { "emc6d103s", emc6d103s }, 359 { } 360 }; 361 MODULE_DEVICE_TABLE(i2c, lm85_id); 362 363 static struct i2c_driver lm85_driver = { 364 .class = I2C_CLASS_HWMON, 365 .driver = { 366 .name = "lm85", 367 }, 368 .probe = lm85_probe, 369 .remove = lm85_remove, 370 .id_table = lm85_id, 371 .detect = lm85_detect, 372 .address_list = normal_i2c, 373 }; 374 375 376 /* 4 Fans */ 377 static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 378 char *buf) 379 { 380 int nr = to_sensor_dev_attr(attr)->index; 381 struct lm85_data *data = lm85_update_device(dev); 382 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr])); 383 } 384 385 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr, 386 char *buf) 387 { 388 int nr = to_sensor_dev_attr(attr)->index; 389 struct lm85_data *data = lm85_update_device(dev); 390 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr])); 391 } 392 393 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 394 const char *buf, size_t count) 395 { 396 int nr = to_sensor_dev_attr(attr)->index; 397 struct i2c_client *client = to_i2c_client(dev); 398 struct lm85_data *data = i2c_get_clientdata(client); 399 unsigned long val; 400 int err; 401 402 err = kstrtoul(buf, 10, &val); 403 if (err) 404 return err; 405 406 mutex_lock(&data->update_lock); 407 data->fan_min[nr] = FAN_TO_REG(val); 408 lm85_write_value(client, LM85_REG_FAN_MIN(nr), data->fan_min[nr]); 409 mutex_unlock(&data->update_lock); 410 return count; 411 } 412 413 #define show_fan_offset(offset) \ 414 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 415 show_fan, NULL, offset - 1); \ 416 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 417 show_fan_min, set_fan_min, offset - 1) 418 419 show_fan_offset(1); 420 show_fan_offset(2); 421 show_fan_offset(3); 422 show_fan_offset(4); 423 424 /* vid, vrm, alarms */ 425 426 static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, 427 char *buf) 428 { 429 struct lm85_data *data = lm85_update_device(dev); 430 int vid; 431 432 if (data->has_vid5) { 433 /* 6-pin VID (VRM 10) */ 434 vid = vid_from_reg(data->vid & 0x3f, data->vrm); 435 } else { 436 /* 5-pin VID (VRM 9) */ 437 vid = vid_from_reg(data->vid & 0x1f, data->vrm); 438 } 439 440 return sprintf(buf, "%d\n", vid); 441 } 442 443 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); 444 445 static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr, 446 char *buf) 447 { 448 struct lm85_data *data = dev_get_drvdata(dev); 449 return sprintf(buf, "%ld\n", (long) data->vrm); 450 } 451 452 static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr, 453 const char *buf, size_t count) 454 { 455 struct lm85_data *data = dev_get_drvdata(dev); 456 unsigned long val; 457 int err; 458 459 err = kstrtoul(buf, 10, &val); 460 if (err) 461 return err; 462 463 data->vrm = val; 464 return count; 465 } 466 467 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); 468 469 static ssize_t show_alarms_reg(struct device *dev, struct device_attribute 470 *attr, char *buf) 471 { 472 struct lm85_data *data = lm85_update_device(dev); 473 return sprintf(buf, "%u\n", data->alarms); 474 } 475 476 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL); 477 478 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 479 char *buf) 480 { 481 int nr = to_sensor_dev_attr(attr)->index; 482 struct lm85_data *data = lm85_update_device(dev); 483 return sprintf(buf, "%u\n", (data->alarms >> nr) & 1); 484 } 485 486 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0); 487 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1); 488 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2); 489 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3); 490 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8); 491 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 18); 492 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 16); 493 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 17); 494 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4); 495 static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_alarm, NULL, 14); 496 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5); 497 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 6); 498 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 15); 499 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10); 500 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11); 501 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 12); 502 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 13); 503 504 /* pwm */ 505 506 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, 507 char *buf) 508 { 509 int nr = to_sensor_dev_attr(attr)->index; 510 struct lm85_data *data = lm85_update_device(dev); 511 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr])); 512 } 513 514 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 515 const char *buf, size_t count) 516 { 517 int nr = to_sensor_dev_attr(attr)->index; 518 struct i2c_client *client = to_i2c_client(dev); 519 struct lm85_data *data = i2c_get_clientdata(client); 520 unsigned long val; 521 int err; 522 523 err = kstrtoul(buf, 10, &val); 524 if (err) 525 return err; 526 527 mutex_lock(&data->update_lock); 528 data->pwm[nr] = PWM_TO_REG(val); 529 lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]); 530 mutex_unlock(&data->update_lock); 531 return count; 532 } 533 534 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute 535 *attr, char *buf) 536 { 537 int nr = to_sensor_dev_attr(attr)->index; 538 struct lm85_data *data = lm85_update_device(dev); 539 int pwm_zone, enable; 540 541 pwm_zone = ZONE_FROM_REG(data->autofan[nr].config); 542 switch (pwm_zone) { 543 case -1: /* PWM is always at 100% */ 544 enable = 0; 545 break; 546 case 0: /* PWM is always at 0% */ 547 case -2: /* PWM responds to manual control */ 548 enable = 1; 549 break; 550 default: /* PWM in automatic mode */ 551 enable = 2; 552 } 553 return sprintf(buf, "%d\n", enable); 554 } 555 556 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute 557 *attr, const char *buf, size_t count) 558 { 559 int nr = to_sensor_dev_attr(attr)->index; 560 struct i2c_client *client = to_i2c_client(dev); 561 struct lm85_data *data = i2c_get_clientdata(client); 562 u8 config; 563 unsigned long val; 564 int err; 565 566 err = kstrtoul(buf, 10, &val); 567 if (err) 568 return err; 569 570 switch (val) { 571 case 0: 572 config = 3; 573 break; 574 case 1: 575 config = 7; 576 break; 577 case 2: 578 /* 579 * Here we have to choose arbitrarily one of the 5 possible 580 * configurations; I go for the safest 581 */ 582 config = 6; 583 break; 584 default: 585 return -EINVAL; 586 } 587 588 mutex_lock(&data->update_lock); 589 data->autofan[nr].config = lm85_read_value(client, 590 LM85_REG_AFAN_CONFIG(nr)); 591 data->autofan[nr].config = (data->autofan[nr].config & ~0xe0) 592 | (config << 5); 593 lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr), 594 data->autofan[nr].config); 595 mutex_unlock(&data->update_lock); 596 return count; 597 } 598 599 static ssize_t show_pwm_freq(struct device *dev, 600 struct device_attribute *attr, char *buf) 601 { 602 int nr = to_sensor_dev_attr(attr)->index; 603 struct lm85_data *data = lm85_update_device(dev); 604 int freq; 605 606 if (IS_ADT7468_HFPWM(data)) 607 freq = 22500; 608 else 609 freq = FREQ_FROM_REG(data->freq_map, data->pwm_freq[nr]); 610 611 return sprintf(buf, "%d\n", freq); 612 } 613 614 static ssize_t set_pwm_freq(struct device *dev, 615 struct device_attribute *attr, const char *buf, size_t count) 616 { 617 int nr = to_sensor_dev_attr(attr)->index; 618 struct i2c_client *client = to_i2c_client(dev); 619 struct lm85_data *data = i2c_get_clientdata(client); 620 unsigned long val; 621 int err; 622 623 err = kstrtoul(buf, 10, &val); 624 if (err) 625 return err; 626 627 mutex_lock(&data->update_lock); 628 /* 629 * The ADT7468 has a special high-frequency PWM output mode, 630 * where all PWM outputs are driven by a 22.5 kHz clock. 631 * This might confuse the user, but there's not much we can do. 632 */ 633 if (data->type == adt7468 && val >= 11300) { /* High freq. mode */ 634 data->cfg5 &= ~ADT7468_HFPWM; 635 lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5); 636 } else { /* Low freq. mode */ 637 data->pwm_freq[nr] = FREQ_TO_REG(data->freq_map, val); 638 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr), 639 (data->zone[nr].range << 4) 640 | data->pwm_freq[nr]); 641 if (data->type == adt7468) { 642 data->cfg5 |= ADT7468_HFPWM; 643 lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5); 644 } 645 } 646 mutex_unlock(&data->update_lock); 647 return count; 648 } 649 650 #define show_pwm_reg(offset) \ 651 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \ 652 show_pwm, set_pwm, offset - 1); \ 653 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \ 654 show_pwm_enable, set_pwm_enable, offset - 1); \ 655 static SENSOR_DEVICE_ATTR(pwm##offset##_freq, S_IRUGO | S_IWUSR, \ 656 show_pwm_freq, set_pwm_freq, offset - 1) 657 658 show_pwm_reg(1); 659 show_pwm_reg(2); 660 show_pwm_reg(3); 661 662 /* Voltages */ 663 664 static ssize_t show_in(struct device *dev, struct device_attribute *attr, 665 char *buf) 666 { 667 int nr = to_sensor_dev_attr(attr)->index; 668 struct lm85_data *data = lm85_update_device(dev); 669 return sprintf(buf, "%d\n", INSEXT_FROM_REG(nr, data->in[nr], 670 data->in_ext[nr])); 671 } 672 673 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr, 674 char *buf) 675 { 676 int nr = to_sensor_dev_attr(attr)->index; 677 struct lm85_data *data = lm85_update_device(dev); 678 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr])); 679 } 680 681 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr, 682 const char *buf, size_t count) 683 { 684 int nr = to_sensor_dev_attr(attr)->index; 685 struct i2c_client *client = to_i2c_client(dev); 686 struct lm85_data *data = i2c_get_clientdata(client); 687 long val; 688 int err; 689 690 err = kstrtol(buf, 10, &val); 691 if (err) 692 return err; 693 694 mutex_lock(&data->update_lock); 695 data->in_min[nr] = INS_TO_REG(nr, val); 696 lm85_write_value(client, LM85_REG_IN_MIN(nr), data->in_min[nr]); 697 mutex_unlock(&data->update_lock); 698 return count; 699 } 700 701 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr, 702 char *buf) 703 { 704 int nr = to_sensor_dev_attr(attr)->index; 705 struct lm85_data *data = lm85_update_device(dev); 706 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr])); 707 } 708 709 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr, 710 const char *buf, size_t count) 711 { 712 int nr = to_sensor_dev_attr(attr)->index; 713 struct i2c_client *client = to_i2c_client(dev); 714 struct lm85_data *data = i2c_get_clientdata(client); 715 long val; 716 int err; 717 718 err = kstrtol(buf, 10, &val); 719 if (err) 720 return err; 721 722 mutex_lock(&data->update_lock); 723 data->in_max[nr] = INS_TO_REG(nr, val); 724 lm85_write_value(client, LM85_REG_IN_MAX(nr), data->in_max[nr]); 725 mutex_unlock(&data->update_lock); 726 return count; 727 } 728 729 #define show_in_reg(offset) \ 730 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \ 731 show_in, NULL, offset); \ 732 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 733 show_in_min, set_in_min, offset); \ 734 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 735 show_in_max, set_in_max, offset) 736 737 show_in_reg(0); 738 show_in_reg(1); 739 show_in_reg(2); 740 show_in_reg(3); 741 show_in_reg(4); 742 show_in_reg(5); 743 show_in_reg(6); 744 show_in_reg(7); 745 746 /* Temps */ 747 748 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 749 char *buf) 750 { 751 int nr = to_sensor_dev_attr(attr)->index; 752 struct lm85_data *data = lm85_update_device(dev); 753 return sprintf(buf, "%d\n", TEMPEXT_FROM_REG(data->temp[nr], 754 data->temp_ext[nr])); 755 } 756 757 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr, 758 char *buf) 759 { 760 int nr = to_sensor_dev_attr(attr)->index; 761 struct lm85_data *data = lm85_update_device(dev); 762 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr])); 763 } 764 765 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, 766 const char *buf, size_t count) 767 { 768 int nr = to_sensor_dev_attr(attr)->index; 769 struct i2c_client *client = to_i2c_client(dev); 770 struct lm85_data *data = i2c_get_clientdata(client); 771 long val; 772 int err; 773 774 err = kstrtol(buf, 10, &val); 775 if (err) 776 return err; 777 778 if (IS_ADT7468_OFF64(data)) 779 val += 64; 780 781 mutex_lock(&data->update_lock); 782 data->temp_min[nr] = TEMP_TO_REG(val); 783 lm85_write_value(client, LM85_REG_TEMP_MIN(nr), data->temp_min[nr]); 784 mutex_unlock(&data->update_lock); 785 return count; 786 } 787 788 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr, 789 char *buf) 790 { 791 int nr = to_sensor_dev_attr(attr)->index; 792 struct lm85_data *data = lm85_update_device(dev); 793 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr])); 794 } 795 796 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 797 const char *buf, size_t count) 798 { 799 int nr = to_sensor_dev_attr(attr)->index; 800 struct i2c_client *client = to_i2c_client(dev); 801 struct lm85_data *data = i2c_get_clientdata(client); 802 long val; 803 int err; 804 805 err = kstrtol(buf, 10, &val); 806 if (err) 807 return err; 808 809 if (IS_ADT7468_OFF64(data)) 810 val += 64; 811 812 mutex_lock(&data->update_lock); 813 data->temp_max[nr] = TEMP_TO_REG(val); 814 lm85_write_value(client, LM85_REG_TEMP_MAX(nr), data->temp_max[nr]); 815 mutex_unlock(&data->update_lock); 816 return count; 817 } 818 819 #define show_temp_reg(offset) \ 820 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ 821 show_temp, NULL, offset - 1); \ 822 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ 823 show_temp_min, set_temp_min, offset - 1); \ 824 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 825 show_temp_max, set_temp_max, offset - 1); 826 827 show_temp_reg(1); 828 show_temp_reg(2); 829 show_temp_reg(3); 830 831 832 /* Automatic PWM control */ 833 834 static ssize_t show_pwm_auto_channels(struct device *dev, 835 struct device_attribute *attr, char *buf) 836 { 837 int nr = to_sensor_dev_attr(attr)->index; 838 struct lm85_data *data = lm85_update_device(dev); 839 return sprintf(buf, "%d\n", ZONE_FROM_REG(data->autofan[nr].config)); 840 } 841 842 static ssize_t set_pwm_auto_channels(struct device *dev, 843 struct device_attribute *attr, const char *buf, size_t count) 844 { 845 int nr = to_sensor_dev_attr(attr)->index; 846 struct i2c_client *client = to_i2c_client(dev); 847 struct lm85_data *data = i2c_get_clientdata(client); 848 long val; 849 int err; 850 851 err = kstrtol(buf, 10, &val); 852 if (err) 853 return err; 854 855 mutex_lock(&data->update_lock); 856 data->autofan[nr].config = (data->autofan[nr].config & (~0xe0)) 857 | ZONE_TO_REG(val); 858 lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr), 859 data->autofan[nr].config); 860 mutex_unlock(&data->update_lock); 861 return count; 862 } 863 864 static ssize_t show_pwm_auto_pwm_min(struct device *dev, 865 struct device_attribute *attr, char *buf) 866 { 867 int nr = to_sensor_dev_attr(attr)->index; 868 struct lm85_data *data = lm85_update_device(dev); 869 return sprintf(buf, "%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm)); 870 } 871 872 static ssize_t set_pwm_auto_pwm_min(struct device *dev, 873 struct device_attribute *attr, const char *buf, size_t count) 874 { 875 int nr = to_sensor_dev_attr(attr)->index; 876 struct i2c_client *client = to_i2c_client(dev); 877 struct lm85_data *data = i2c_get_clientdata(client); 878 unsigned long val; 879 int err; 880 881 err = kstrtoul(buf, 10, &val); 882 if (err) 883 return err; 884 885 mutex_lock(&data->update_lock); 886 data->autofan[nr].min_pwm = PWM_TO_REG(val); 887 lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr), 888 data->autofan[nr].min_pwm); 889 mutex_unlock(&data->update_lock); 890 return count; 891 } 892 893 static ssize_t show_pwm_auto_pwm_minctl(struct device *dev, 894 struct device_attribute *attr, char *buf) 895 { 896 int nr = to_sensor_dev_attr(attr)->index; 897 struct lm85_data *data = lm85_update_device(dev); 898 return sprintf(buf, "%d\n", data->autofan[nr].min_off); 899 } 900 901 static ssize_t set_pwm_auto_pwm_minctl(struct device *dev, 902 struct device_attribute *attr, const char *buf, size_t count) 903 { 904 int nr = to_sensor_dev_attr(attr)->index; 905 struct i2c_client *client = to_i2c_client(dev); 906 struct lm85_data *data = i2c_get_clientdata(client); 907 u8 tmp; 908 long val; 909 int err; 910 911 err = kstrtol(buf, 10, &val); 912 if (err) 913 return err; 914 915 mutex_lock(&data->update_lock); 916 data->autofan[nr].min_off = val; 917 tmp = lm85_read_value(client, LM85_REG_AFAN_SPIKE1); 918 tmp &= ~(0x20 << nr); 919 if (data->autofan[nr].min_off) 920 tmp |= 0x20 << nr; 921 lm85_write_value(client, LM85_REG_AFAN_SPIKE1, tmp); 922 mutex_unlock(&data->update_lock); 923 return count; 924 } 925 926 #define pwm_auto(offset) \ 927 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_channels, \ 928 S_IRUGO | S_IWUSR, show_pwm_auto_channels, \ 929 set_pwm_auto_channels, offset - 1); \ 930 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_min, \ 931 S_IRUGO | S_IWUSR, show_pwm_auto_pwm_min, \ 932 set_pwm_auto_pwm_min, offset - 1); \ 933 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_minctl, \ 934 S_IRUGO | S_IWUSR, show_pwm_auto_pwm_minctl, \ 935 set_pwm_auto_pwm_minctl, offset - 1) 936 937 pwm_auto(1); 938 pwm_auto(2); 939 pwm_auto(3); 940 941 /* Temperature settings for automatic PWM control */ 942 943 static ssize_t show_temp_auto_temp_off(struct device *dev, 944 struct device_attribute *attr, char *buf) 945 { 946 int nr = to_sensor_dev_attr(attr)->index; 947 struct lm85_data *data = lm85_update_device(dev); 948 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) - 949 HYST_FROM_REG(data->zone[nr].hyst)); 950 } 951 952 static ssize_t set_temp_auto_temp_off(struct device *dev, 953 struct device_attribute *attr, const char *buf, size_t count) 954 { 955 int nr = to_sensor_dev_attr(attr)->index; 956 struct i2c_client *client = to_i2c_client(dev); 957 struct lm85_data *data = i2c_get_clientdata(client); 958 int min; 959 long val; 960 int err; 961 962 err = kstrtol(buf, 10, &val); 963 if (err) 964 return err; 965 966 mutex_lock(&data->update_lock); 967 min = TEMP_FROM_REG(data->zone[nr].limit); 968 data->zone[nr].hyst = HYST_TO_REG(min - val); 969 if (nr == 0 || nr == 1) { 970 lm85_write_value(client, LM85_REG_AFAN_HYST1, 971 (data->zone[0].hyst << 4) 972 | data->zone[1].hyst); 973 } else { 974 lm85_write_value(client, LM85_REG_AFAN_HYST2, 975 (data->zone[2].hyst << 4)); 976 } 977 mutex_unlock(&data->update_lock); 978 return count; 979 } 980 981 static ssize_t show_temp_auto_temp_min(struct device *dev, 982 struct device_attribute *attr, char *buf) 983 { 984 int nr = to_sensor_dev_attr(attr)->index; 985 struct lm85_data *data = lm85_update_device(dev); 986 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit)); 987 } 988 989 static ssize_t set_temp_auto_temp_min(struct device *dev, 990 struct device_attribute *attr, const char *buf, size_t count) 991 { 992 int nr = to_sensor_dev_attr(attr)->index; 993 struct i2c_client *client = to_i2c_client(dev); 994 struct lm85_data *data = i2c_get_clientdata(client); 995 long val; 996 int err; 997 998 err = kstrtol(buf, 10, &val); 999 if (err) 1000 return err; 1001 1002 mutex_lock(&data->update_lock); 1003 data->zone[nr].limit = TEMP_TO_REG(val); 1004 lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr), 1005 data->zone[nr].limit); 1006 1007 /* Update temp_auto_max and temp_auto_range */ 1008 data->zone[nr].range = RANGE_TO_REG( 1009 TEMP_FROM_REG(data->zone[nr].max_desired) - 1010 TEMP_FROM_REG(data->zone[nr].limit)); 1011 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr), 1012 ((data->zone[nr].range & 0x0f) << 4) 1013 | (data->pwm_freq[nr] & 0x07)); 1014 1015 mutex_unlock(&data->update_lock); 1016 return count; 1017 } 1018 1019 static ssize_t show_temp_auto_temp_max(struct device *dev, 1020 struct device_attribute *attr, char *buf) 1021 { 1022 int nr = to_sensor_dev_attr(attr)->index; 1023 struct lm85_data *data = lm85_update_device(dev); 1024 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) + 1025 RANGE_FROM_REG(data->zone[nr].range)); 1026 } 1027 1028 static ssize_t set_temp_auto_temp_max(struct device *dev, 1029 struct device_attribute *attr, const char *buf, size_t count) 1030 { 1031 int nr = to_sensor_dev_attr(attr)->index; 1032 struct i2c_client *client = to_i2c_client(dev); 1033 struct lm85_data *data = i2c_get_clientdata(client); 1034 int min; 1035 long val; 1036 int err; 1037 1038 err = kstrtol(buf, 10, &val); 1039 if (err) 1040 return err; 1041 1042 mutex_lock(&data->update_lock); 1043 min = TEMP_FROM_REG(data->zone[nr].limit); 1044 data->zone[nr].max_desired = TEMP_TO_REG(val); 1045 data->zone[nr].range = RANGE_TO_REG( 1046 val - min); 1047 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr), 1048 ((data->zone[nr].range & 0x0f) << 4) 1049 | (data->pwm_freq[nr] & 0x07)); 1050 mutex_unlock(&data->update_lock); 1051 return count; 1052 } 1053 1054 static ssize_t show_temp_auto_temp_crit(struct device *dev, 1055 struct device_attribute *attr, char *buf) 1056 { 1057 int nr = to_sensor_dev_attr(attr)->index; 1058 struct lm85_data *data = lm85_update_device(dev); 1059 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].critical)); 1060 } 1061 1062 static ssize_t set_temp_auto_temp_crit(struct device *dev, 1063 struct device_attribute *attr, const char *buf, size_t count) 1064 { 1065 int nr = to_sensor_dev_attr(attr)->index; 1066 struct i2c_client *client = to_i2c_client(dev); 1067 struct lm85_data *data = i2c_get_clientdata(client); 1068 long val; 1069 int err; 1070 1071 err = kstrtol(buf, 10, &val); 1072 if (err) 1073 return err; 1074 1075 mutex_lock(&data->update_lock); 1076 data->zone[nr].critical = TEMP_TO_REG(val); 1077 lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr), 1078 data->zone[nr].critical); 1079 mutex_unlock(&data->update_lock); 1080 return count; 1081 } 1082 1083 #define temp_auto(offset) \ 1084 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_off, \ 1085 S_IRUGO | S_IWUSR, show_temp_auto_temp_off, \ 1086 set_temp_auto_temp_off, offset - 1); \ 1087 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_min, \ 1088 S_IRUGO | S_IWUSR, show_temp_auto_temp_min, \ 1089 set_temp_auto_temp_min, offset - 1); \ 1090 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_max, \ 1091 S_IRUGO | S_IWUSR, show_temp_auto_temp_max, \ 1092 set_temp_auto_temp_max, offset - 1); \ 1093 static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_crit, \ 1094 S_IRUGO | S_IWUSR, show_temp_auto_temp_crit, \ 1095 set_temp_auto_temp_crit, offset - 1); 1096 1097 temp_auto(1); 1098 temp_auto(2); 1099 temp_auto(3); 1100 1101 static struct attribute *lm85_attributes[] = { 1102 &sensor_dev_attr_fan1_input.dev_attr.attr, 1103 &sensor_dev_attr_fan2_input.dev_attr.attr, 1104 &sensor_dev_attr_fan3_input.dev_attr.attr, 1105 &sensor_dev_attr_fan4_input.dev_attr.attr, 1106 &sensor_dev_attr_fan1_min.dev_attr.attr, 1107 &sensor_dev_attr_fan2_min.dev_attr.attr, 1108 &sensor_dev_attr_fan3_min.dev_attr.attr, 1109 &sensor_dev_attr_fan4_min.dev_attr.attr, 1110 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1111 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1112 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1113 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 1114 1115 &sensor_dev_attr_pwm1.dev_attr.attr, 1116 &sensor_dev_attr_pwm2.dev_attr.attr, 1117 &sensor_dev_attr_pwm3.dev_attr.attr, 1118 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1119 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1120 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1121 &sensor_dev_attr_pwm1_freq.dev_attr.attr, 1122 &sensor_dev_attr_pwm2_freq.dev_attr.attr, 1123 &sensor_dev_attr_pwm3_freq.dev_attr.attr, 1124 1125 &sensor_dev_attr_in0_input.dev_attr.attr, 1126 &sensor_dev_attr_in1_input.dev_attr.attr, 1127 &sensor_dev_attr_in2_input.dev_attr.attr, 1128 &sensor_dev_attr_in3_input.dev_attr.attr, 1129 &sensor_dev_attr_in0_min.dev_attr.attr, 1130 &sensor_dev_attr_in1_min.dev_attr.attr, 1131 &sensor_dev_attr_in2_min.dev_attr.attr, 1132 &sensor_dev_attr_in3_min.dev_attr.attr, 1133 &sensor_dev_attr_in0_max.dev_attr.attr, 1134 &sensor_dev_attr_in1_max.dev_attr.attr, 1135 &sensor_dev_attr_in2_max.dev_attr.attr, 1136 &sensor_dev_attr_in3_max.dev_attr.attr, 1137 &sensor_dev_attr_in0_alarm.dev_attr.attr, 1138 &sensor_dev_attr_in1_alarm.dev_attr.attr, 1139 &sensor_dev_attr_in2_alarm.dev_attr.attr, 1140 &sensor_dev_attr_in3_alarm.dev_attr.attr, 1141 1142 &sensor_dev_attr_temp1_input.dev_attr.attr, 1143 &sensor_dev_attr_temp2_input.dev_attr.attr, 1144 &sensor_dev_attr_temp3_input.dev_attr.attr, 1145 &sensor_dev_attr_temp1_min.dev_attr.attr, 1146 &sensor_dev_attr_temp2_min.dev_attr.attr, 1147 &sensor_dev_attr_temp3_min.dev_attr.attr, 1148 &sensor_dev_attr_temp1_max.dev_attr.attr, 1149 &sensor_dev_attr_temp2_max.dev_attr.attr, 1150 &sensor_dev_attr_temp3_max.dev_attr.attr, 1151 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1152 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1153 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1154 &sensor_dev_attr_temp1_fault.dev_attr.attr, 1155 &sensor_dev_attr_temp3_fault.dev_attr.attr, 1156 1157 &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr, 1158 &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr, 1159 &sensor_dev_attr_pwm3_auto_channels.dev_attr.attr, 1160 &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr, 1161 &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr, 1162 &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr, 1163 1164 &sensor_dev_attr_temp1_auto_temp_min.dev_attr.attr, 1165 &sensor_dev_attr_temp2_auto_temp_min.dev_attr.attr, 1166 &sensor_dev_attr_temp3_auto_temp_min.dev_attr.attr, 1167 &sensor_dev_attr_temp1_auto_temp_max.dev_attr.attr, 1168 &sensor_dev_attr_temp2_auto_temp_max.dev_attr.attr, 1169 &sensor_dev_attr_temp3_auto_temp_max.dev_attr.attr, 1170 &sensor_dev_attr_temp1_auto_temp_crit.dev_attr.attr, 1171 &sensor_dev_attr_temp2_auto_temp_crit.dev_attr.attr, 1172 &sensor_dev_attr_temp3_auto_temp_crit.dev_attr.attr, 1173 1174 &dev_attr_vrm.attr, 1175 &dev_attr_cpu0_vid.attr, 1176 &dev_attr_alarms.attr, 1177 NULL 1178 }; 1179 1180 static const struct attribute_group lm85_group = { 1181 .attrs = lm85_attributes, 1182 }; 1183 1184 static struct attribute *lm85_attributes_minctl[] = { 1185 &sensor_dev_attr_pwm1_auto_pwm_minctl.dev_attr.attr, 1186 &sensor_dev_attr_pwm2_auto_pwm_minctl.dev_attr.attr, 1187 &sensor_dev_attr_pwm3_auto_pwm_minctl.dev_attr.attr, 1188 NULL 1189 }; 1190 1191 static const struct attribute_group lm85_group_minctl = { 1192 .attrs = lm85_attributes_minctl, 1193 }; 1194 1195 static struct attribute *lm85_attributes_temp_off[] = { 1196 &sensor_dev_attr_temp1_auto_temp_off.dev_attr.attr, 1197 &sensor_dev_attr_temp2_auto_temp_off.dev_attr.attr, 1198 &sensor_dev_attr_temp3_auto_temp_off.dev_attr.attr, 1199 NULL 1200 }; 1201 1202 static const struct attribute_group lm85_group_temp_off = { 1203 .attrs = lm85_attributes_temp_off, 1204 }; 1205 1206 static struct attribute *lm85_attributes_in4[] = { 1207 &sensor_dev_attr_in4_input.dev_attr.attr, 1208 &sensor_dev_attr_in4_min.dev_attr.attr, 1209 &sensor_dev_attr_in4_max.dev_attr.attr, 1210 &sensor_dev_attr_in4_alarm.dev_attr.attr, 1211 NULL 1212 }; 1213 1214 static const struct attribute_group lm85_group_in4 = { 1215 .attrs = lm85_attributes_in4, 1216 }; 1217 1218 static struct attribute *lm85_attributes_in567[] = { 1219 &sensor_dev_attr_in5_input.dev_attr.attr, 1220 &sensor_dev_attr_in6_input.dev_attr.attr, 1221 &sensor_dev_attr_in7_input.dev_attr.attr, 1222 &sensor_dev_attr_in5_min.dev_attr.attr, 1223 &sensor_dev_attr_in6_min.dev_attr.attr, 1224 &sensor_dev_attr_in7_min.dev_attr.attr, 1225 &sensor_dev_attr_in5_max.dev_attr.attr, 1226 &sensor_dev_attr_in6_max.dev_attr.attr, 1227 &sensor_dev_attr_in7_max.dev_attr.attr, 1228 &sensor_dev_attr_in5_alarm.dev_attr.attr, 1229 &sensor_dev_attr_in6_alarm.dev_attr.attr, 1230 &sensor_dev_attr_in7_alarm.dev_attr.attr, 1231 NULL 1232 }; 1233 1234 static const struct attribute_group lm85_group_in567 = { 1235 .attrs = lm85_attributes_in567, 1236 }; 1237 1238 static void lm85_init_client(struct i2c_client *client) 1239 { 1240 int value; 1241 1242 /* Start monitoring if needed */ 1243 value = lm85_read_value(client, LM85_REG_CONFIG); 1244 if (!(value & 0x01)) { 1245 dev_info(&client->dev, "Starting monitoring\n"); 1246 lm85_write_value(client, LM85_REG_CONFIG, value | 0x01); 1247 } 1248 1249 /* Warn about unusual configuration bits */ 1250 if (value & 0x02) 1251 dev_warn(&client->dev, "Device configuration is locked\n"); 1252 if (!(value & 0x04)) 1253 dev_warn(&client->dev, "Device is not ready\n"); 1254 } 1255 1256 static int lm85_is_fake(struct i2c_client *client) 1257 { 1258 /* 1259 * Differenciate between real LM96000 and Winbond WPCD377I. The latter 1260 * emulate the former except that it has no hardware monitoring function 1261 * so the readings are always 0. 1262 */ 1263 int i; 1264 u8 in_temp, fan; 1265 1266 for (i = 0; i < 8; i++) { 1267 in_temp = i2c_smbus_read_byte_data(client, 0x20 + i); 1268 fan = i2c_smbus_read_byte_data(client, 0x28 + i); 1269 if (in_temp != 0x00 || fan != 0xff) 1270 return 0; 1271 } 1272 1273 return 1; 1274 } 1275 1276 /* Return 0 if detection is successful, -ENODEV otherwise */ 1277 static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info) 1278 { 1279 struct i2c_adapter *adapter = client->adapter; 1280 int address = client->addr; 1281 const char *type_name = NULL; 1282 int company, verstep; 1283 1284 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 1285 /* We need to be able to do byte I/O */ 1286 return -ENODEV; 1287 } 1288 1289 /* Determine the chip type */ 1290 company = lm85_read_value(client, LM85_REG_COMPANY); 1291 verstep = lm85_read_value(client, LM85_REG_VERSTEP); 1292 1293 dev_dbg(&adapter->dev, 1294 "Detecting device at 0x%02x with COMPANY: 0x%02x and VERSTEP: 0x%02x\n", 1295 address, company, verstep); 1296 1297 if (company == LM85_COMPANY_NATIONAL) { 1298 switch (verstep) { 1299 case LM85_VERSTEP_LM85C: 1300 type_name = "lm85c"; 1301 break; 1302 case LM85_VERSTEP_LM85B: 1303 type_name = "lm85b"; 1304 break; 1305 case LM85_VERSTEP_LM96000_1: 1306 case LM85_VERSTEP_LM96000_2: 1307 /* Check for Winbond WPCD377I */ 1308 if (lm85_is_fake(client)) { 1309 dev_dbg(&adapter->dev, 1310 "Found Winbond WPCD377I, ignoring\n"); 1311 return -ENODEV; 1312 } 1313 type_name = "lm85"; 1314 break; 1315 } 1316 } else if (company == LM85_COMPANY_ANALOG_DEV) { 1317 switch (verstep) { 1318 case LM85_VERSTEP_ADM1027: 1319 type_name = "adm1027"; 1320 break; 1321 case LM85_VERSTEP_ADT7463: 1322 case LM85_VERSTEP_ADT7463C: 1323 type_name = "adt7463"; 1324 break; 1325 case LM85_VERSTEP_ADT7468_1: 1326 case LM85_VERSTEP_ADT7468_2: 1327 type_name = "adt7468"; 1328 break; 1329 } 1330 } else if (company == LM85_COMPANY_SMSC) { 1331 switch (verstep) { 1332 case LM85_VERSTEP_EMC6D100_A0: 1333 case LM85_VERSTEP_EMC6D100_A1: 1334 /* Note: we can't tell a '100 from a '101 */ 1335 type_name = "emc6d100"; 1336 break; 1337 case LM85_VERSTEP_EMC6D102: 1338 type_name = "emc6d102"; 1339 break; 1340 case LM85_VERSTEP_EMC6D103_A0: 1341 case LM85_VERSTEP_EMC6D103_A1: 1342 type_name = "emc6d103"; 1343 break; 1344 case LM85_VERSTEP_EMC6D103S: 1345 type_name = "emc6d103s"; 1346 break; 1347 } 1348 } 1349 1350 if (!type_name) 1351 return -ENODEV; 1352 1353 strlcpy(info->type, type_name, I2C_NAME_SIZE); 1354 1355 return 0; 1356 } 1357 1358 static void lm85_remove_files(struct i2c_client *client, struct lm85_data *data) 1359 { 1360 sysfs_remove_group(&client->dev.kobj, &lm85_group); 1361 if (data->type != emc6d103s) { 1362 sysfs_remove_group(&client->dev.kobj, &lm85_group_minctl); 1363 sysfs_remove_group(&client->dev.kobj, &lm85_group_temp_off); 1364 } 1365 if (!data->has_vid5) 1366 sysfs_remove_group(&client->dev.kobj, &lm85_group_in4); 1367 if (data->type == emc6d100) 1368 sysfs_remove_group(&client->dev.kobj, &lm85_group_in567); 1369 } 1370 1371 static int lm85_probe(struct i2c_client *client, 1372 const struct i2c_device_id *id) 1373 { 1374 struct lm85_data *data; 1375 int err; 1376 1377 data = devm_kzalloc(&client->dev, sizeof(struct lm85_data), GFP_KERNEL); 1378 if (!data) 1379 return -ENOMEM; 1380 1381 i2c_set_clientdata(client, data); 1382 data->type = id->driver_data; 1383 mutex_init(&data->update_lock); 1384 1385 /* Fill in the chip specific driver values */ 1386 switch (data->type) { 1387 case adm1027: 1388 case adt7463: 1389 case adt7468: 1390 case emc6d100: 1391 case emc6d102: 1392 case emc6d103: 1393 case emc6d103s: 1394 data->freq_map = adm1027_freq_map; 1395 break; 1396 default: 1397 data->freq_map = lm85_freq_map; 1398 } 1399 1400 /* Set the VRM version */ 1401 data->vrm = vid_which_vrm(); 1402 1403 /* Initialize the LM85 chip */ 1404 lm85_init_client(client); 1405 1406 /* Register sysfs hooks */ 1407 err = sysfs_create_group(&client->dev.kobj, &lm85_group); 1408 if (err) 1409 return err; 1410 1411 /* minctl and temp_off exist on all chips except emc6d103s */ 1412 if (data->type != emc6d103s) { 1413 err = sysfs_create_group(&client->dev.kobj, &lm85_group_minctl); 1414 if (err) 1415 goto err_remove_files; 1416 err = sysfs_create_group(&client->dev.kobj, 1417 &lm85_group_temp_off); 1418 if (err) 1419 goto err_remove_files; 1420 } 1421 1422 /* 1423 * The ADT7463/68 have an optional VRM 10 mode where pin 21 is used 1424 * as a sixth digital VID input rather than an analog input. 1425 */ 1426 if (data->type == adt7463 || data->type == adt7468) { 1427 u8 vid = lm85_read_value(client, LM85_REG_VID); 1428 if (vid & 0x80) 1429 data->has_vid5 = true; 1430 } 1431 1432 if (!data->has_vid5) { 1433 err = sysfs_create_group(&client->dev.kobj, &lm85_group_in4); 1434 if (err) 1435 goto err_remove_files; 1436 } 1437 1438 /* The EMC6D100 has 3 additional voltage inputs */ 1439 if (data->type == emc6d100) { 1440 err = sysfs_create_group(&client->dev.kobj, &lm85_group_in567); 1441 if (err) 1442 goto err_remove_files; 1443 } 1444 1445 data->hwmon_dev = hwmon_device_register(&client->dev); 1446 if (IS_ERR(data->hwmon_dev)) { 1447 err = PTR_ERR(data->hwmon_dev); 1448 goto err_remove_files; 1449 } 1450 1451 return 0; 1452 1453 /* Error out and cleanup code */ 1454 err_remove_files: 1455 lm85_remove_files(client, data); 1456 return err; 1457 } 1458 1459 static int lm85_remove(struct i2c_client *client) 1460 { 1461 struct lm85_data *data = i2c_get_clientdata(client); 1462 hwmon_device_unregister(data->hwmon_dev); 1463 lm85_remove_files(client, data); 1464 return 0; 1465 } 1466 1467 1468 static int lm85_read_value(struct i2c_client *client, u8 reg) 1469 { 1470 int res; 1471 1472 /* What size location is it? */ 1473 switch (reg) { 1474 case LM85_REG_FAN(0): /* Read WORD data */ 1475 case LM85_REG_FAN(1): 1476 case LM85_REG_FAN(2): 1477 case LM85_REG_FAN(3): 1478 case LM85_REG_FAN_MIN(0): 1479 case LM85_REG_FAN_MIN(1): 1480 case LM85_REG_FAN_MIN(2): 1481 case LM85_REG_FAN_MIN(3): 1482 case LM85_REG_ALARM1: /* Read both bytes at once */ 1483 res = i2c_smbus_read_byte_data(client, reg) & 0xff; 1484 res |= i2c_smbus_read_byte_data(client, reg + 1) << 8; 1485 break; 1486 default: /* Read BYTE data */ 1487 res = i2c_smbus_read_byte_data(client, reg); 1488 break; 1489 } 1490 1491 return res; 1492 } 1493 1494 static void lm85_write_value(struct i2c_client *client, u8 reg, int value) 1495 { 1496 switch (reg) { 1497 case LM85_REG_FAN(0): /* Write WORD data */ 1498 case LM85_REG_FAN(1): 1499 case LM85_REG_FAN(2): 1500 case LM85_REG_FAN(3): 1501 case LM85_REG_FAN_MIN(0): 1502 case LM85_REG_FAN_MIN(1): 1503 case LM85_REG_FAN_MIN(2): 1504 case LM85_REG_FAN_MIN(3): 1505 /* NOTE: ALARM is read only, so not included here */ 1506 i2c_smbus_write_byte_data(client, reg, value & 0xff); 1507 i2c_smbus_write_byte_data(client, reg + 1, value >> 8); 1508 break; 1509 default: /* Write BYTE data */ 1510 i2c_smbus_write_byte_data(client, reg, value); 1511 break; 1512 } 1513 } 1514 1515 static struct lm85_data *lm85_update_device(struct device *dev) 1516 { 1517 struct i2c_client *client = to_i2c_client(dev); 1518 struct lm85_data *data = i2c_get_clientdata(client); 1519 int i; 1520 1521 mutex_lock(&data->update_lock); 1522 1523 if (!data->valid || 1524 time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) { 1525 /* Things that change quickly */ 1526 dev_dbg(&client->dev, "Reading sensor values\n"); 1527 1528 /* 1529 * Have to read extended bits first to "freeze" the 1530 * more significant bits that are read later. 1531 * There are 2 additional resolution bits per channel and we 1532 * have room for 4, so we shift them to the left. 1533 */ 1534 if (data->type == adm1027 || data->type == adt7463 || 1535 data->type == adt7468) { 1536 int ext1 = lm85_read_value(client, 1537 ADM1027_REG_EXTEND_ADC1); 1538 int ext2 = lm85_read_value(client, 1539 ADM1027_REG_EXTEND_ADC2); 1540 int val = (ext1 << 8) + ext2; 1541 1542 for (i = 0; i <= 4; i++) 1543 data->in_ext[i] = 1544 ((val >> (i * 2)) & 0x03) << 2; 1545 1546 for (i = 0; i <= 2; i++) 1547 data->temp_ext[i] = 1548 (val >> ((i + 4) * 2)) & 0x0c; 1549 } 1550 1551 data->vid = lm85_read_value(client, LM85_REG_VID); 1552 1553 for (i = 0; i <= 3; ++i) { 1554 data->in[i] = 1555 lm85_read_value(client, LM85_REG_IN(i)); 1556 data->fan[i] = 1557 lm85_read_value(client, LM85_REG_FAN(i)); 1558 } 1559 1560 if (!data->has_vid5) 1561 data->in[4] = lm85_read_value(client, LM85_REG_IN(4)); 1562 1563 if (data->type == adt7468) 1564 data->cfg5 = lm85_read_value(client, ADT7468_REG_CFG5); 1565 1566 for (i = 0; i <= 2; ++i) { 1567 data->temp[i] = 1568 lm85_read_value(client, LM85_REG_TEMP(i)); 1569 data->pwm[i] = 1570 lm85_read_value(client, LM85_REG_PWM(i)); 1571 1572 if (IS_ADT7468_OFF64(data)) 1573 data->temp[i] -= 64; 1574 } 1575 1576 data->alarms = lm85_read_value(client, LM85_REG_ALARM1); 1577 1578 if (data->type == emc6d100) { 1579 /* Three more voltage sensors */ 1580 for (i = 5; i <= 7; ++i) { 1581 data->in[i] = lm85_read_value(client, 1582 EMC6D100_REG_IN(i)); 1583 } 1584 /* More alarm bits */ 1585 data->alarms |= lm85_read_value(client, 1586 EMC6D100_REG_ALARM3) << 16; 1587 } else if (data->type == emc6d102 || data->type == emc6d103 || 1588 data->type == emc6d103s) { 1589 /* 1590 * Have to read LSB bits after the MSB ones because 1591 * the reading of the MSB bits has frozen the 1592 * LSBs (backward from the ADM1027). 1593 */ 1594 int ext1 = lm85_read_value(client, 1595 EMC6D102_REG_EXTEND_ADC1); 1596 int ext2 = lm85_read_value(client, 1597 EMC6D102_REG_EXTEND_ADC2); 1598 int ext3 = lm85_read_value(client, 1599 EMC6D102_REG_EXTEND_ADC3); 1600 int ext4 = lm85_read_value(client, 1601 EMC6D102_REG_EXTEND_ADC4); 1602 data->in_ext[0] = ext3 & 0x0f; 1603 data->in_ext[1] = ext4 & 0x0f; 1604 data->in_ext[2] = ext4 >> 4; 1605 data->in_ext[3] = ext3 >> 4; 1606 data->in_ext[4] = ext2 >> 4; 1607 1608 data->temp_ext[0] = ext1 & 0x0f; 1609 data->temp_ext[1] = ext2 & 0x0f; 1610 data->temp_ext[2] = ext1 >> 4; 1611 } 1612 1613 data->last_reading = jiffies; 1614 } /* last_reading */ 1615 1616 if (!data->valid || 1617 time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) { 1618 /* Things that don't change often */ 1619 dev_dbg(&client->dev, "Reading config values\n"); 1620 1621 for (i = 0; i <= 3; ++i) { 1622 data->in_min[i] = 1623 lm85_read_value(client, LM85_REG_IN_MIN(i)); 1624 data->in_max[i] = 1625 lm85_read_value(client, LM85_REG_IN_MAX(i)); 1626 data->fan_min[i] = 1627 lm85_read_value(client, LM85_REG_FAN_MIN(i)); 1628 } 1629 1630 if (!data->has_vid5) { 1631 data->in_min[4] = lm85_read_value(client, 1632 LM85_REG_IN_MIN(4)); 1633 data->in_max[4] = lm85_read_value(client, 1634 LM85_REG_IN_MAX(4)); 1635 } 1636 1637 if (data->type == emc6d100) { 1638 for (i = 5; i <= 7; ++i) { 1639 data->in_min[i] = lm85_read_value(client, 1640 EMC6D100_REG_IN_MIN(i)); 1641 data->in_max[i] = lm85_read_value(client, 1642 EMC6D100_REG_IN_MAX(i)); 1643 } 1644 } 1645 1646 for (i = 0; i <= 2; ++i) { 1647 int val; 1648 1649 data->temp_min[i] = 1650 lm85_read_value(client, LM85_REG_TEMP_MIN(i)); 1651 data->temp_max[i] = 1652 lm85_read_value(client, LM85_REG_TEMP_MAX(i)); 1653 1654 data->autofan[i].config = 1655 lm85_read_value(client, LM85_REG_AFAN_CONFIG(i)); 1656 val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i)); 1657 data->pwm_freq[i] = val & 0x07; 1658 data->zone[i].range = val >> 4; 1659 data->autofan[i].min_pwm = 1660 lm85_read_value(client, LM85_REG_AFAN_MINPWM(i)); 1661 data->zone[i].limit = 1662 lm85_read_value(client, LM85_REG_AFAN_LIMIT(i)); 1663 data->zone[i].critical = 1664 lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i)); 1665 1666 if (IS_ADT7468_OFF64(data)) { 1667 data->temp_min[i] -= 64; 1668 data->temp_max[i] -= 64; 1669 data->zone[i].limit -= 64; 1670 data->zone[i].critical -= 64; 1671 } 1672 } 1673 1674 if (data->type != emc6d103s) { 1675 i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1); 1676 data->autofan[0].min_off = (i & 0x20) != 0; 1677 data->autofan[1].min_off = (i & 0x40) != 0; 1678 data->autofan[2].min_off = (i & 0x80) != 0; 1679 1680 i = lm85_read_value(client, LM85_REG_AFAN_HYST1); 1681 data->zone[0].hyst = i >> 4; 1682 data->zone[1].hyst = i & 0x0f; 1683 1684 i = lm85_read_value(client, LM85_REG_AFAN_HYST2); 1685 data->zone[2].hyst = i >> 4; 1686 } 1687 1688 data->last_config = jiffies; 1689 } /* last_config */ 1690 1691 data->valid = 1; 1692 1693 mutex_unlock(&data->update_lock); 1694 1695 return data; 1696 } 1697 1698 module_i2c_driver(lm85_driver); 1699 1700 MODULE_LICENSE("GPL"); 1701 MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, " 1702 "Margit Schubert-While <margitsw@t-online.de>, " 1703 "Justin Thiessen <jthiessen@penguincomputing.com>"); 1704 MODULE_DESCRIPTION("LM85-B, LM85-C driver"); 1705