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