1 /* 2 adm1031.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Based on lm75.c and lm85.c 5 Supports adm1030 / adm1031 6 Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org> 7 Reworked by Jean Delvare <khali@linux-fr.org> 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/jiffies.h> 28 #include <linux/i2c.h> 29 #include <linux/hwmon.h> 30 #include <linux/hwmon-sysfs.h> 31 #include <linux/err.h> 32 #include <linux/mutex.h> 33 34 /* Following macros takes channel parameter starting from 0 to 2 */ 35 #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr)) 36 #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr)) 37 #define ADM1031_REG_PWM (0x22) 38 #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr)) 39 #define ADM1031_REG_FAN_FILTER (0x23) 40 41 #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr)) 42 #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr)) 43 #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr)) 44 #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr)) 45 46 #define ADM1031_REG_TEMP(nr) (0x0a + (nr)) 47 #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr)) 48 49 #define ADM1031_REG_STATUS(nr) (0x2 + (nr)) 50 51 #define ADM1031_REG_CONF1 0x00 52 #define ADM1031_REG_CONF2 0x01 53 #define ADM1031_REG_EXT_TEMP 0x06 54 55 #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */ 56 #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */ 57 #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */ 58 59 #define ADM1031_CONF2_PWM1_ENABLE 0x01 60 #define ADM1031_CONF2_PWM2_ENABLE 0x02 61 #define ADM1031_CONF2_TACH1_ENABLE 0x04 62 #define ADM1031_CONF2_TACH2_ENABLE 0x08 63 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan)) 64 65 #define ADM1031_UPDATE_RATE_MASK 0x1c 66 #define ADM1031_UPDATE_RATE_SHIFT 2 67 68 /* Addresses to scan */ 69 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 70 71 enum chips { adm1030, adm1031 }; 72 73 typedef u8 auto_chan_table_t[8][2]; 74 75 /* Each client has this additional data */ 76 struct adm1031_data { 77 struct device *hwmon_dev; 78 struct mutex update_lock; 79 int chip_type; 80 char valid; /* !=0 if following fields are valid */ 81 unsigned long last_updated; /* In jiffies */ 82 unsigned int update_interval; /* In milliseconds */ 83 /* The chan_select_table contains the possible configurations for 84 * auto fan control. 85 */ 86 const auto_chan_table_t *chan_select_table; 87 u16 alarm; 88 u8 conf1; 89 u8 conf2; 90 u8 fan[2]; 91 u8 fan_div[2]; 92 u8 fan_min[2]; 93 u8 pwm[2]; 94 u8 old_pwm[2]; 95 s8 temp[3]; 96 u8 ext_temp[3]; 97 u8 auto_temp[3]; 98 u8 auto_temp_min[3]; 99 u8 auto_temp_off[3]; 100 u8 auto_temp_max[3]; 101 s8 temp_offset[3]; 102 s8 temp_min[3]; 103 s8 temp_max[3]; 104 s8 temp_crit[3]; 105 }; 106 107 static int adm1031_probe(struct i2c_client *client, 108 const struct i2c_device_id *id); 109 static int adm1031_detect(struct i2c_client *client, 110 struct i2c_board_info *info); 111 static void adm1031_init_client(struct i2c_client *client); 112 static int adm1031_remove(struct i2c_client *client); 113 static struct adm1031_data *adm1031_update_device(struct device *dev); 114 115 static const struct i2c_device_id adm1031_id[] = { 116 { "adm1030", adm1030 }, 117 { "adm1031", adm1031 }, 118 { } 119 }; 120 MODULE_DEVICE_TABLE(i2c, adm1031_id); 121 122 /* This is the driver that will be inserted */ 123 static struct i2c_driver adm1031_driver = { 124 .class = I2C_CLASS_HWMON, 125 .driver = { 126 .name = "adm1031", 127 }, 128 .probe = adm1031_probe, 129 .remove = adm1031_remove, 130 .id_table = adm1031_id, 131 .detect = adm1031_detect, 132 .address_list = normal_i2c, 133 }; 134 135 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg) 136 { 137 return i2c_smbus_read_byte_data(client, reg); 138 } 139 140 static inline int 141 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value) 142 { 143 return i2c_smbus_write_byte_data(client, reg, value); 144 } 145 146 147 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \ 148 ((val + 500) / 1000))) 149 150 #define TEMP_FROM_REG(val) ((val) * 1000) 151 152 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125) 153 154 #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f) 155 #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \ 156 (val) | 0x70 : (val)) 157 158 #define FAN_FROM_REG(reg, div) ((reg) ? (11250 * 60) / ((reg) * (div)) : 0) 159 160 static int FAN_TO_REG(int reg, int div) 161 { 162 int tmp; 163 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div); 164 return tmp > 255 ? 255 : tmp; 165 } 166 167 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6)) 168 169 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4) 170 #define PWM_FROM_REG(val) ((val) << 4) 171 172 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7) 173 #define FAN_CHAN_TO_REG(val, reg) \ 174 (((reg) & 0x1F) | (((val) << 5) & 0xe0)) 175 176 #define AUTO_TEMP_MIN_TO_REG(val, reg) \ 177 ((((val)/500) & 0xf8)|((reg) & 0x7)) 178 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1<< ((reg)&0x7))) 179 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2)) 180 181 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2) 182 183 #define AUTO_TEMP_OFF_FROM_REG(reg) \ 184 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000) 185 186 #define AUTO_TEMP_MAX_FROM_REG(reg) \ 187 (AUTO_TEMP_RANGE_FROM_REG(reg) + \ 188 AUTO_TEMP_MIN_FROM_REG(reg)) 189 190 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm) 191 { 192 int ret; 193 int range = val - AUTO_TEMP_MIN_FROM_REG(reg); 194 195 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm); 196 ret = ((reg & 0xf8) | 197 (range < 10000 ? 0 : 198 range < 20000 ? 1 : 199 range < 40000 ? 2 : range < 80000 ? 3 : 4)); 200 return ret; 201 } 202 203 /* FAN auto control */ 204 #define GET_FAN_AUTO_BITFIELD(data, idx) \ 205 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx%2] 206 207 /* The tables below contains the possible values for the auto fan 208 * control bitfields. the index in the table is the register value. 209 * MSb is the auto fan control enable bit, so the four first entries 210 * in the table disables auto fan control when both bitfields are zero. 211 */ 212 static const auto_chan_table_t auto_channel_select_table_adm1031 = { 213 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, 214 { 2 /* 0b010 */ , 4 /* 0b100 */ }, 215 { 2 /* 0b010 */ , 2 /* 0b010 */ }, 216 { 4 /* 0b100 */ , 4 /* 0b100 */ }, 217 { 7 /* 0b111 */ , 7 /* 0b111 */ }, 218 }; 219 220 static const auto_chan_table_t auto_channel_select_table_adm1030 = { 221 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, 222 { 2 /* 0b10 */ , 0 }, 223 { 0xff /* invalid */ , 0 }, 224 { 0xff /* invalid */ , 0 }, 225 { 3 /* 0b11 */ , 0 }, 226 }; 227 228 /* That function checks if a bitfield is valid and returns the other bitfield 229 * nearest match if no exact match where found. 230 */ 231 static int 232 get_fan_auto_nearest(struct adm1031_data *data, 233 int chan, u8 val, u8 reg, u8 * new_reg) 234 { 235 int i; 236 int first_match = -1, exact_match = -1; 237 u8 other_reg_val = 238 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1]; 239 240 if (val == 0) { 241 *new_reg = 0; 242 return 0; 243 } 244 245 for (i = 0; i < 8; i++) { 246 if ((val == (*data->chan_select_table)[i][chan]) && 247 ((*data->chan_select_table)[i][chan ? 0 : 1] == 248 other_reg_val)) { 249 /* We found an exact match */ 250 exact_match = i; 251 break; 252 } else if (val == (*data->chan_select_table)[i][chan] && 253 first_match == -1) { 254 /* Save the first match in case of an exact match has 255 * not been found 256 */ 257 first_match = i; 258 } 259 } 260 261 if (exact_match >= 0) { 262 *new_reg = exact_match; 263 } else if (first_match >= 0) { 264 *new_reg = first_match; 265 } else { 266 return -EINVAL; 267 } 268 return 0; 269 } 270 271 static ssize_t show_fan_auto_channel(struct device *dev, 272 struct device_attribute *attr, char *buf) 273 { 274 int nr = to_sensor_dev_attr(attr)->index; 275 struct adm1031_data *data = adm1031_update_device(dev); 276 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr)); 277 } 278 279 static ssize_t 280 set_fan_auto_channel(struct device *dev, struct device_attribute *attr, 281 const char *buf, size_t count) 282 { 283 struct i2c_client *client = to_i2c_client(dev); 284 struct adm1031_data *data = i2c_get_clientdata(client); 285 int nr = to_sensor_dev_attr(attr)->index; 286 int val = simple_strtol(buf, NULL, 10); 287 u8 reg; 288 int ret; 289 u8 old_fan_mode; 290 291 old_fan_mode = data->conf1; 292 293 mutex_lock(&data->update_lock); 294 295 if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, ®))) { 296 mutex_unlock(&data->update_lock); 297 return ret; 298 } 299 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); 300 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^ 301 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) { 302 if (data->conf1 & ADM1031_CONF1_AUTO_MODE){ 303 /* Switch to Auto Fan Mode 304 * Save PWM registers 305 * Set PWM registers to 33% Both */ 306 data->old_pwm[0] = data->pwm[0]; 307 data->old_pwm[1] = data->pwm[1]; 308 adm1031_write_value(client, ADM1031_REG_PWM, 0x55); 309 } else { 310 /* Switch to Manual Mode */ 311 data->pwm[0] = data->old_pwm[0]; 312 data->pwm[1] = data->old_pwm[1]; 313 /* Restore PWM registers */ 314 adm1031_write_value(client, ADM1031_REG_PWM, 315 data->pwm[0] | (data->pwm[1] << 4)); 316 } 317 } 318 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); 319 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1); 320 mutex_unlock(&data->update_lock); 321 return count; 322 } 323 324 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR, 325 show_fan_auto_channel, set_fan_auto_channel, 0); 326 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR, 327 show_fan_auto_channel, set_fan_auto_channel, 1); 328 329 /* Auto Temps */ 330 static ssize_t show_auto_temp_off(struct device *dev, 331 struct device_attribute *attr, char *buf) 332 { 333 int nr = to_sensor_dev_attr(attr)->index; 334 struct adm1031_data *data = adm1031_update_device(dev); 335 return sprintf(buf, "%d\n", 336 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr])); 337 } 338 static ssize_t show_auto_temp_min(struct device *dev, 339 struct device_attribute *attr, char *buf) 340 { 341 int nr = to_sensor_dev_attr(attr)->index; 342 struct adm1031_data *data = adm1031_update_device(dev); 343 return sprintf(buf, "%d\n", 344 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr])); 345 } 346 static ssize_t 347 set_auto_temp_min(struct device *dev, struct device_attribute *attr, 348 const char *buf, size_t count) 349 { 350 struct i2c_client *client = to_i2c_client(dev); 351 struct adm1031_data *data = i2c_get_clientdata(client); 352 int nr = to_sensor_dev_attr(attr)->index; 353 int val = simple_strtol(buf, NULL, 10); 354 355 mutex_lock(&data->update_lock); 356 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]); 357 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), 358 data->auto_temp[nr]); 359 mutex_unlock(&data->update_lock); 360 return count; 361 } 362 static ssize_t show_auto_temp_max(struct device *dev, 363 struct device_attribute *attr, char *buf) 364 { 365 int nr = to_sensor_dev_attr(attr)->index; 366 struct adm1031_data *data = adm1031_update_device(dev); 367 return sprintf(buf, "%d\n", 368 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr])); 369 } 370 static ssize_t 371 set_auto_temp_max(struct device *dev, struct device_attribute *attr, 372 const char *buf, size_t count) 373 { 374 struct i2c_client *client = to_i2c_client(dev); 375 struct adm1031_data *data = i2c_get_clientdata(client); 376 int nr = to_sensor_dev_attr(attr)->index; 377 int val = simple_strtol(buf, NULL, 10); 378 379 mutex_lock(&data->update_lock); 380 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]); 381 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), 382 data->temp_max[nr]); 383 mutex_unlock(&data->update_lock); 384 return count; 385 } 386 387 #define auto_temp_reg(offset) \ 388 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \ 389 show_auto_temp_off, NULL, offset - 1); \ 390 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \ 391 show_auto_temp_min, set_auto_temp_min, offset - 1); \ 392 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \ 393 show_auto_temp_max, set_auto_temp_max, offset - 1) 394 395 auto_temp_reg(1); 396 auto_temp_reg(2); 397 auto_temp_reg(3); 398 399 /* pwm */ 400 static ssize_t show_pwm(struct device *dev, 401 struct device_attribute *attr, char *buf) 402 { 403 int nr = to_sensor_dev_attr(attr)->index; 404 struct adm1031_data *data = adm1031_update_device(dev); 405 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr])); 406 } 407 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 408 const char *buf, size_t count) 409 { 410 struct i2c_client *client = to_i2c_client(dev); 411 struct adm1031_data *data = i2c_get_clientdata(client); 412 int nr = to_sensor_dev_attr(attr)->index; 413 int val = simple_strtol(buf, NULL, 10); 414 int reg; 415 416 mutex_lock(&data->update_lock); 417 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) && 418 (((val>>4) & 0xf) != 5)) { 419 /* In automatic mode, the only PWM accepted is 33% */ 420 mutex_unlock(&data->update_lock); 421 return -EINVAL; 422 } 423 data->pwm[nr] = PWM_TO_REG(val); 424 reg = adm1031_read_value(client, ADM1031_REG_PWM); 425 adm1031_write_value(client, ADM1031_REG_PWM, 426 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf) 427 : (data->pwm[nr] & 0xf) | (reg & 0xf0)); 428 mutex_unlock(&data->update_lock); 429 return count; 430 } 431 432 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0); 433 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1); 434 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR, 435 show_pwm, set_pwm, 0); 436 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR, 437 show_pwm, set_pwm, 1); 438 439 /* Fans */ 440 441 /* 442 * That function checks the cases where the fan reading is not 443 * relevant. It is used to provide 0 as fan reading when the fan is 444 * not supposed to run 445 */ 446 static int trust_fan_readings(struct adm1031_data *data, int chan) 447 { 448 int res = 0; 449 450 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) { 451 switch (data->conf1 & 0x60) { 452 case 0x00: /* remote temp1 controls fan1 remote temp2 controls fan2 */ 453 res = data->temp[chan+1] >= 454 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]); 455 break; 456 case 0x20: /* remote temp1 controls both fans */ 457 res = 458 data->temp[1] >= 459 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]); 460 break; 461 case 0x40: /* remote temp2 controls both fans */ 462 res = 463 data->temp[2] >= 464 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]); 465 break; 466 case 0x60: /* max controls both fans */ 467 res = 468 data->temp[0] >= 469 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0]) 470 || data->temp[1] >= 471 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]) 472 || (data->chip_type == adm1031 473 && data->temp[2] >= 474 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2])); 475 break; 476 } 477 } else { 478 res = data->pwm[chan] > 0; 479 } 480 return res; 481 } 482 483 484 static ssize_t show_fan(struct device *dev, 485 struct device_attribute *attr, char *buf) 486 { 487 int nr = to_sensor_dev_attr(attr)->index; 488 struct adm1031_data *data = adm1031_update_device(dev); 489 int value; 490 491 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr], 492 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0; 493 return sprintf(buf, "%d\n", value); 494 } 495 496 static ssize_t show_fan_div(struct device *dev, 497 struct device_attribute *attr, char *buf) 498 { 499 int nr = to_sensor_dev_attr(attr)->index; 500 struct adm1031_data *data = adm1031_update_device(dev); 501 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr])); 502 } 503 static ssize_t show_fan_min(struct device *dev, 504 struct device_attribute *attr, char *buf) 505 { 506 int nr = to_sensor_dev_attr(attr)->index; 507 struct adm1031_data *data = adm1031_update_device(dev); 508 return sprintf(buf, "%d\n", 509 FAN_FROM_REG(data->fan_min[nr], 510 FAN_DIV_FROM_REG(data->fan_div[nr]))); 511 } 512 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 513 const char *buf, size_t count) 514 { 515 struct i2c_client *client = to_i2c_client(dev); 516 struct adm1031_data *data = i2c_get_clientdata(client); 517 int nr = to_sensor_dev_attr(attr)->index; 518 int val = simple_strtol(buf, NULL, 10); 519 520 mutex_lock(&data->update_lock); 521 if (val) { 522 data->fan_min[nr] = 523 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr])); 524 } else { 525 data->fan_min[nr] = 0xff; 526 } 527 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]); 528 mutex_unlock(&data->update_lock); 529 return count; 530 } 531 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 532 const char *buf, size_t count) 533 { 534 struct i2c_client *client = to_i2c_client(dev); 535 struct adm1031_data *data = i2c_get_clientdata(client); 536 int nr = to_sensor_dev_attr(attr)->index; 537 int val = simple_strtol(buf, NULL, 10); 538 u8 tmp; 539 int old_div; 540 int new_min; 541 542 tmp = val == 8 ? 0xc0 : 543 val == 4 ? 0x80 : 544 val == 2 ? 0x40 : 545 val == 1 ? 0x00 : 546 0xff; 547 if (tmp == 0xff) 548 return -EINVAL; 549 550 mutex_lock(&data->update_lock); 551 /* Get fresh readings */ 552 data->fan_div[nr] = adm1031_read_value(client, 553 ADM1031_REG_FAN_DIV(nr)); 554 data->fan_min[nr] = adm1031_read_value(client, 555 ADM1031_REG_FAN_MIN(nr)); 556 557 /* Write the new clock divider and fan min */ 558 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]); 559 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]); 560 new_min = data->fan_min[nr] * old_div / val; 561 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min; 562 563 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr), 564 data->fan_div[nr]); 565 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), 566 data->fan_min[nr]); 567 568 /* Invalidate the cache: fan speed is no longer valid */ 569 data->valid = 0; 570 mutex_unlock(&data->update_lock); 571 return count; 572 } 573 574 #define fan_offset(offset) \ 575 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 576 show_fan, NULL, offset - 1); \ 577 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 578 show_fan_min, set_fan_min, offset - 1); \ 579 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 580 show_fan_div, set_fan_div, offset - 1) 581 582 fan_offset(1); 583 fan_offset(2); 584 585 586 /* Temps */ 587 static ssize_t show_temp(struct device *dev, 588 struct device_attribute *attr, char *buf) 589 { 590 int nr = to_sensor_dev_attr(attr)->index; 591 struct adm1031_data *data = adm1031_update_device(dev); 592 int ext; 593 ext = nr == 0 ? 594 ((data->ext_temp[nr] >> 6) & 0x3) * 2 : 595 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7)); 596 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext)); 597 } 598 static ssize_t show_temp_offset(struct device *dev, 599 struct device_attribute *attr, char *buf) 600 { 601 int nr = to_sensor_dev_attr(attr)->index; 602 struct adm1031_data *data = adm1031_update_device(dev); 603 return sprintf(buf, "%d\n", 604 TEMP_OFFSET_FROM_REG(data->temp_offset[nr])); 605 } 606 static ssize_t show_temp_min(struct device *dev, 607 struct device_attribute *attr, char *buf) 608 { 609 int nr = to_sensor_dev_attr(attr)->index; 610 struct adm1031_data *data = adm1031_update_device(dev); 611 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr])); 612 } 613 static ssize_t show_temp_max(struct device *dev, 614 struct device_attribute *attr, char *buf) 615 { 616 int nr = to_sensor_dev_attr(attr)->index; 617 struct adm1031_data *data = adm1031_update_device(dev); 618 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr])); 619 } 620 static ssize_t show_temp_crit(struct device *dev, 621 struct device_attribute *attr, char *buf) 622 { 623 int nr = to_sensor_dev_attr(attr)->index; 624 struct adm1031_data *data = adm1031_update_device(dev); 625 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr])); 626 } 627 static ssize_t set_temp_offset(struct device *dev, 628 struct device_attribute *attr, const char *buf, 629 size_t count) 630 { 631 struct i2c_client *client = to_i2c_client(dev); 632 struct adm1031_data *data = i2c_get_clientdata(client); 633 int nr = to_sensor_dev_attr(attr)->index; 634 int val; 635 636 val = simple_strtol(buf, NULL, 10); 637 val = SENSORS_LIMIT(val, -15000, 15000); 638 mutex_lock(&data->update_lock); 639 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val); 640 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr), 641 data->temp_offset[nr]); 642 mutex_unlock(&data->update_lock); 643 return count; 644 } 645 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, 646 const char *buf, size_t count) 647 { 648 struct i2c_client *client = to_i2c_client(dev); 649 struct adm1031_data *data = i2c_get_clientdata(client); 650 int nr = to_sensor_dev_attr(attr)->index; 651 int val; 652 653 val = simple_strtol(buf, NULL, 10); 654 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 655 mutex_lock(&data->update_lock); 656 data->temp_min[nr] = TEMP_TO_REG(val); 657 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr), 658 data->temp_min[nr]); 659 mutex_unlock(&data->update_lock); 660 return count; 661 } 662 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 663 const char *buf, size_t count) 664 { 665 struct i2c_client *client = to_i2c_client(dev); 666 struct adm1031_data *data = i2c_get_clientdata(client); 667 int nr = to_sensor_dev_attr(attr)->index; 668 int val; 669 670 val = simple_strtol(buf, NULL, 10); 671 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 672 mutex_lock(&data->update_lock); 673 data->temp_max[nr] = TEMP_TO_REG(val); 674 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr), 675 data->temp_max[nr]); 676 mutex_unlock(&data->update_lock); 677 return count; 678 } 679 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr, 680 const char *buf, size_t count) 681 { 682 struct i2c_client *client = to_i2c_client(dev); 683 struct adm1031_data *data = i2c_get_clientdata(client); 684 int nr = to_sensor_dev_attr(attr)->index; 685 int val; 686 687 val = simple_strtol(buf, NULL, 10); 688 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 689 mutex_lock(&data->update_lock); 690 data->temp_crit[nr] = TEMP_TO_REG(val); 691 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr), 692 data->temp_crit[nr]); 693 mutex_unlock(&data->update_lock); 694 return count; 695 } 696 697 #define temp_reg(offset) \ 698 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ 699 show_temp, NULL, offset - 1); \ 700 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \ 701 show_temp_offset, set_temp_offset, offset - 1); \ 702 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ 703 show_temp_min, set_temp_min, offset - 1); \ 704 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 705 show_temp_max, set_temp_max, offset - 1); \ 706 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \ 707 show_temp_crit, set_temp_crit, offset - 1) 708 709 temp_reg(1); 710 temp_reg(2); 711 temp_reg(3); 712 713 /* Alarms */ 714 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 715 { 716 struct adm1031_data *data = adm1031_update_device(dev); 717 return sprintf(buf, "%d\n", data->alarm); 718 } 719 720 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 721 722 static ssize_t show_alarm(struct device *dev, 723 struct device_attribute *attr, char *buf) 724 { 725 int bitnr = to_sensor_dev_attr(attr)->index; 726 struct adm1031_data *data = adm1031_update_device(dev); 727 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1); 728 } 729 730 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0); 731 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1); 732 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2); 733 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); 734 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4); 735 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5); 736 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); 737 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7); 738 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8); 739 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9); 740 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10); 741 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11); 742 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12); 743 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13); 744 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14); 745 746 /* Update Interval */ 747 static const unsigned int update_intervals[] = { 748 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 749 }; 750 751 static ssize_t show_update_interval(struct device *dev, 752 struct device_attribute *attr, char *buf) 753 { 754 struct i2c_client *client = to_i2c_client(dev); 755 struct adm1031_data *data = i2c_get_clientdata(client); 756 757 return sprintf(buf, "%u\n", data->update_interval); 758 } 759 760 static ssize_t set_update_interval(struct device *dev, 761 struct device_attribute *attr, 762 const char *buf, size_t count) 763 { 764 struct i2c_client *client = to_i2c_client(dev); 765 struct adm1031_data *data = i2c_get_clientdata(client); 766 unsigned long val; 767 int i, err; 768 u8 reg; 769 770 err = strict_strtoul(buf, 10, &val); 771 if (err) 772 return err; 773 774 /* 775 * Find the nearest update interval from the table. 776 * Use it to determine the matching update rate. 777 */ 778 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) { 779 if (val >= update_intervals[i]) 780 break; 781 } 782 /* if not found, we point to the last entry (lowest update interval) */ 783 784 /* set the new update rate while preserving other settings */ 785 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); 786 reg &= ~ADM1031_UPDATE_RATE_MASK; 787 reg |= i << ADM1031_UPDATE_RATE_SHIFT; 788 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg); 789 790 mutex_lock(&data->update_lock); 791 data->update_interval = update_intervals[i]; 792 mutex_unlock(&data->update_lock); 793 794 return count; 795 } 796 797 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval, 798 set_update_interval); 799 800 static struct attribute *adm1031_attributes[] = { 801 &sensor_dev_attr_fan1_input.dev_attr.attr, 802 &sensor_dev_attr_fan1_div.dev_attr.attr, 803 &sensor_dev_attr_fan1_min.dev_attr.attr, 804 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 805 &sensor_dev_attr_fan1_fault.dev_attr.attr, 806 &sensor_dev_attr_pwm1.dev_attr.attr, 807 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr, 808 &sensor_dev_attr_temp1_input.dev_attr.attr, 809 &sensor_dev_attr_temp1_offset.dev_attr.attr, 810 &sensor_dev_attr_temp1_min.dev_attr.attr, 811 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 812 &sensor_dev_attr_temp1_max.dev_attr.attr, 813 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 814 &sensor_dev_attr_temp1_crit.dev_attr.attr, 815 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 816 &sensor_dev_attr_temp2_input.dev_attr.attr, 817 &sensor_dev_attr_temp2_offset.dev_attr.attr, 818 &sensor_dev_attr_temp2_min.dev_attr.attr, 819 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 820 &sensor_dev_attr_temp2_max.dev_attr.attr, 821 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 822 &sensor_dev_attr_temp2_crit.dev_attr.attr, 823 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 824 &sensor_dev_attr_temp2_fault.dev_attr.attr, 825 826 &sensor_dev_attr_auto_temp1_off.dev_attr.attr, 827 &sensor_dev_attr_auto_temp1_min.dev_attr.attr, 828 &sensor_dev_attr_auto_temp1_max.dev_attr.attr, 829 830 &sensor_dev_attr_auto_temp2_off.dev_attr.attr, 831 &sensor_dev_attr_auto_temp2_min.dev_attr.attr, 832 &sensor_dev_attr_auto_temp2_max.dev_attr.attr, 833 834 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr, 835 836 &dev_attr_update_interval.attr, 837 &dev_attr_alarms.attr, 838 839 NULL 840 }; 841 842 static const struct attribute_group adm1031_group = { 843 .attrs = adm1031_attributes, 844 }; 845 846 static struct attribute *adm1031_attributes_opt[] = { 847 &sensor_dev_attr_fan2_input.dev_attr.attr, 848 &sensor_dev_attr_fan2_div.dev_attr.attr, 849 &sensor_dev_attr_fan2_min.dev_attr.attr, 850 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 851 &sensor_dev_attr_fan2_fault.dev_attr.attr, 852 &sensor_dev_attr_pwm2.dev_attr.attr, 853 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr, 854 &sensor_dev_attr_temp3_input.dev_attr.attr, 855 &sensor_dev_attr_temp3_offset.dev_attr.attr, 856 &sensor_dev_attr_temp3_min.dev_attr.attr, 857 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 858 &sensor_dev_attr_temp3_max.dev_attr.attr, 859 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 860 &sensor_dev_attr_temp3_crit.dev_attr.attr, 861 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 862 &sensor_dev_attr_temp3_fault.dev_attr.attr, 863 &sensor_dev_attr_auto_temp3_off.dev_attr.attr, 864 &sensor_dev_attr_auto_temp3_min.dev_attr.attr, 865 &sensor_dev_attr_auto_temp3_max.dev_attr.attr, 866 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr, 867 NULL 868 }; 869 870 static const struct attribute_group adm1031_group_opt = { 871 .attrs = adm1031_attributes_opt, 872 }; 873 874 /* Return 0 if detection is successful, -ENODEV otherwise */ 875 static int adm1031_detect(struct i2c_client *client, 876 struct i2c_board_info *info) 877 { 878 struct i2c_adapter *adapter = client->adapter; 879 const char *name; 880 int id, co; 881 882 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 883 return -ENODEV; 884 885 id = i2c_smbus_read_byte_data(client, 0x3d); 886 co = i2c_smbus_read_byte_data(client, 0x3e); 887 888 if (!((id == 0x31 || id == 0x30) && co == 0x41)) 889 return -ENODEV; 890 name = (id == 0x30) ? "adm1030" : "adm1031"; 891 892 strlcpy(info->type, name, I2C_NAME_SIZE); 893 894 return 0; 895 } 896 897 static int adm1031_probe(struct i2c_client *client, 898 const struct i2c_device_id *id) 899 { 900 struct adm1031_data *data; 901 int err; 902 903 data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL); 904 if (!data) { 905 err = -ENOMEM; 906 goto exit; 907 } 908 909 i2c_set_clientdata(client, data); 910 data->chip_type = id->driver_data; 911 mutex_init(&data->update_lock); 912 913 if (data->chip_type == adm1030) 914 data->chan_select_table = &auto_channel_select_table_adm1030; 915 else 916 data->chan_select_table = &auto_channel_select_table_adm1031; 917 918 /* Initialize the ADM1031 chip */ 919 adm1031_init_client(client); 920 921 /* Register sysfs hooks */ 922 if ((err = sysfs_create_group(&client->dev.kobj, &adm1031_group))) 923 goto exit_free; 924 925 if (data->chip_type == adm1031) { 926 if ((err = sysfs_create_group(&client->dev.kobj, 927 &adm1031_group_opt))) 928 goto exit_remove; 929 } 930 931 data->hwmon_dev = hwmon_device_register(&client->dev); 932 if (IS_ERR(data->hwmon_dev)) { 933 err = PTR_ERR(data->hwmon_dev); 934 goto exit_remove; 935 } 936 937 return 0; 938 939 exit_remove: 940 sysfs_remove_group(&client->dev.kobj, &adm1031_group); 941 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); 942 exit_free: 943 kfree(data); 944 exit: 945 return err; 946 } 947 948 static int adm1031_remove(struct i2c_client *client) 949 { 950 struct adm1031_data *data = i2c_get_clientdata(client); 951 952 hwmon_device_unregister(data->hwmon_dev); 953 sysfs_remove_group(&client->dev.kobj, &adm1031_group); 954 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); 955 kfree(data); 956 return 0; 957 } 958 959 static void adm1031_init_client(struct i2c_client *client) 960 { 961 unsigned int read_val; 962 unsigned int mask; 963 int i; 964 struct adm1031_data *data = i2c_get_clientdata(client); 965 966 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE); 967 if (data->chip_type == adm1031) { 968 mask |= (ADM1031_CONF2_PWM2_ENABLE | 969 ADM1031_CONF2_TACH2_ENABLE); 970 } 971 /* Initialize the ADM1031 chip (enables fan speed reading ) */ 972 read_val = adm1031_read_value(client, ADM1031_REG_CONF2); 973 if ((read_val | mask) != read_val) { 974 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask); 975 } 976 977 read_val = adm1031_read_value(client, ADM1031_REG_CONF1); 978 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) { 979 adm1031_write_value(client, ADM1031_REG_CONF1, read_val | 980 ADM1031_CONF1_MONITOR_ENABLE); 981 } 982 983 /* Read the chip's update rate */ 984 mask = ADM1031_UPDATE_RATE_MASK; 985 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); 986 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT; 987 /* Save it as update interval */ 988 data->update_interval = update_intervals[i]; 989 } 990 991 static struct adm1031_data *adm1031_update_device(struct device *dev) 992 { 993 struct i2c_client *client = to_i2c_client(dev); 994 struct adm1031_data *data = i2c_get_clientdata(client); 995 unsigned long next_update; 996 int chan; 997 998 mutex_lock(&data->update_lock); 999 1000 next_update = data->last_updated 1001 + msecs_to_jiffies(data->update_interval); 1002 if (time_after(jiffies, next_update) || !data->valid) { 1003 1004 dev_dbg(&client->dev, "Starting adm1031 update\n"); 1005 for (chan = 0; 1006 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) { 1007 u8 oldh, newh; 1008 1009 oldh = 1010 adm1031_read_value(client, ADM1031_REG_TEMP(chan)); 1011 data->ext_temp[chan] = 1012 adm1031_read_value(client, ADM1031_REG_EXT_TEMP); 1013 newh = 1014 adm1031_read_value(client, ADM1031_REG_TEMP(chan)); 1015 if (newh != oldh) { 1016 data->ext_temp[chan] = 1017 adm1031_read_value(client, 1018 ADM1031_REG_EXT_TEMP); 1019 #ifdef DEBUG 1020 oldh = 1021 adm1031_read_value(client, 1022 ADM1031_REG_TEMP(chan)); 1023 1024 /* oldh is actually newer */ 1025 if (newh != oldh) 1026 dev_warn(&client->dev, 1027 "Remote temperature may be " 1028 "wrong.\n"); 1029 #endif 1030 } 1031 data->temp[chan] = newh; 1032 1033 data->temp_offset[chan] = 1034 adm1031_read_value(client, 1035 ADM1031_REG_TEMP_OFFSET(chan)); 1036 data->temp_min[chan] = 1037 adm1031_read_value(client, 1038 ADM1031_REG_TEMP_MIN(chan)); 1039 data->temp_max[chan] = 1040 adm1031_read_value(client, 1041 ADM1031_REG_TEMP_MAX(chan)); 1042 data->temp_crit[chan] = 1043 adm1031_read_value(client, 1044 ADM1031_REG_TEMP_CRIT(chan)); 1045 data->auto_temp[chan] = 1046 adm1031_read_value(client, 1047 ADM1031_REG_AUTO_TEMP(chan)); 1048 1049 } 1050 1051 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1); 1052 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2); 1053 1054 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0)) 1055 | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) 1056 << 8); 1057 if (data->chip_type == adm1030) { 1058 data->alarm &= 0xc0ff; 1059 } 1060 1061 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) { 1062 data->fan_div[chan] = 1063 adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan)); 1064 data->fan_min[chan] = 1065 adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan)); 1066 data->fan[chan] = 1067 adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan)); 1068 data->pwm[chan] = 1069 0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >> 1070 (4*chan)); 1071 } 1072 data->last_updated = jiffies; 1073 data->valid = 1; 1074 } 1075 1076 mutex_unlock(&data->update_lock); 1077 1078 return data; 1079 } 1080 1081 static int __init sensors_adm1031_init(void) 1082 { 1083 return i2c_add_driver(&adm1031_driver); 1084 } 1085 1086 static void __exit sensors_adm1031_exit(void) 1087 { 1088 i2c_del_driver(&adm1031_driver); 1089 } 1090 1091 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>"); 1092 MODULE_DESCRIPTION("ADM1031/ADM1030 driver"); 1093 MODULE_LICENSE("GPL"); 1094 1095 module_init(sensors_adm1031_init); 1096 module_exit(sensors_adm1031_exit); 1097