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