1 /* 2 w83627ehf - Driver for the hardware monitoring functionality of 3 the Winbond W83627EHF Super-I/O chip 4 Copyright (C) 2005 Jean Delvare <khali@linux-fr.org> 5 6 Shamelessly ripped from the w83627hf driver 7 Copyright (C) 2003 Mark Studebaker 8 9 Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help 10 in testing and debugging this driver. 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 2 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 25 26 27 Supports the following chips: 28 29 Chip #vin #fan #pwm #temp chip_id man_id 30 w83627ehf - 5 - 3 0x88 0x5ca3 31 32 This is a preliminary version of the driver, only supporting the 33 fan and temperature inputs. The chip does much more than that. 34 */ 35 36 #include <linux/module.h> 37 #include <linux/init.h> 38 #include <linux/slab.h> 39 #include <linux/i2c.h> 40 #include <linux/i2c-sensor.h> 41 #include <asm/io.h> 42 #include "lm75.h" 43 44 /* Addresses to scan 45 The actual ISA address is read from Super-I/O configuration space */ 46 static unsigned short normal_i2c[] = { I2C_CLIENT_END }; 47 static unsigned int normal_isa[] = { 0, I2C_CLIENT_ISA_END }; 48 49 /* Insmod parameters */ 50 SENSORS_INSMOD_1(w83627ehf); 51 52 /* 53 * Super-I/O constants and functions 54 */ 55 56 static int REG; /* The register to read/write */ 57 static int VAL; /* The value to read/write */ 58 59 #define W83627EHF_LD_HWM 0x0b 60 61 #define SIO_REG_LDSEL 0x07 /* Logical device select */ 62 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */ 63 #define SIO_REG_ENABLE 0x30 /* Logical device enable */ 64 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */ 65 66 #define SIO_W83627EHF_ID 0x8840 67 #define SIO_ID_MASK 0xFFC0 68 69 static inline void 70 superio_outb(int reg, int val) 71 { 72 outb(reg, REG); 73 outb(val, VAL); 74 } 75 76 static inline int 77 superio_inb(int reg) 78 { 79 outb(reg, REG); 80 return inb(VAL); 81 } 82 83 static inline void 84 superio_select(int ld) 85 { 86 outb(SIO_REG_LDSEL, REG); 87 outb(ld, VAL); 88 } 89 90 static inline void 91 superio_enter(void) 92 { 93 outb(0x87, REG); 94 outb(0x87, REG); 95 } 96 97 static inline void 98 superio_exit(void) 99 { 100 outb(0x02, REG); 101 outb(0x02, VAL); 102 } 103 104 /* 105 * ISA constants 106 */ 107 108 #define REGION_LENGTH 8 109 #define ADDR_REG_OFFSET 5 110 #define DATA_REG_OFFSET 6 111 112 #define W83627EHF_REG_BANK 0x4E 113 #define W83627EHF_REG_CONFIG 0x40 114 #define W83627EHF_REG_CHIP_ID 0x49 115 #define W83627EHF_REG_MAN_ID 0x4F 116 117 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 }; 118 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c }; 119 120 #define W83627EHF_REG_TEMP1 0x27 121 #define W83627EHF_REG_TEMP1_HYST 0x3a 122 #define W83627EHF_REG_TEMP1_OVER 0x39 123 static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 }; 124 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 }; 125 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 }; 126 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 }; 127 128 /* Fan clock dividers are spread over the following five registers */ 129 #define W83627EHF_REG_FANDIV1 0x47 130 #define W83627EHF_REG_FANDIV2 0x4B 131 #define W83627EHF_REG_VBAT 0x5D 132 #define W83627EHF_REG_DIODE 0x59 133 #define W83627EHF_REG_SMI_OVT 0x4C 134 135 /* 136 * Conversions 137 */ 138 139 static inline unsigned int 140 fan_from_reg(u8 reg, unsigned int div) 141 { 142 if (reg == 0 || reg == 255) 143 return 0; 144 return 1350000U / (reg * div); 145 } 146 147 static inline unsigned int 148 div_from_reg(u8 reg) 149 { 150 return 1 << reg; 151 } 152 153 static inline int 154 temp1_from_reg(s8 reg) 155 { 156 return reg * 1000; 157 } 158 159 static inline s8 160 temp1_to_reg(int temp) 161 { 162 if (temp <= -128000) 163 return -128; 164 if (temp >= 127000) 165 return 127; 166 if (temp < 0) 167 return (temp - 500) / 1000; 168 return (temp + 500) / 1000; 169 } 170 171 /* 172 * Data structures and manipulation thereof 173 */ 174 175 struct w83627ehf_data { 176 struct i2c_client client; 177 struct semaphore lock; 178 179 struct semaphore update_lock; 180 char valid; /* !=0 if following fields are valid */ 181 unsigned long last_updated; /* In jiffies */ 182 183 /* Register values */ 184 u8 fan[5]; 185 u8 fan_min[5]; 186 u8 fan_div[5]; 187 u8 has_fan; /* some fan inputs can be disabled */ 188 s8 temp1; 189 s8 temp1_max; 190 s8 temp1_max_hyst; 191 s16 temp[2]; 192 s16 temp_max[2]; 193 s16 temp_max_hyst[2]; 194 }; 195 196 static inline int is_word_sized(u16 reg) 197 { 198 return (((reg & 0xff00) == 0x100 199 || (reg & 0xff00) == 0x200) 200 && ((reg & 0x00ff) == 0x50 201 || (reg & 0x00ff) == 0x53 202 || (reg & 0x00ff) == 0x55)); 203 } 204 205 /* We assume that the default bank is 0, thus the following two functions do 206 nothing for registers which live in bank 0. For others, they respectively 207 set the bank register to the correct value (before the register is 208 accessed), and back to 0 (afterwards). */ 209 static inline void w83627ehf_set_bank(struct i2c_client *client, u16 reg) 210 { 211 if (reg & 0xff00) { 212 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET); 213 outb_p(reg >> 8, client->addr + DATA_REG_OFFSET); 214 } 215 } 216 217 static inline void w83627ehf_reset_bank(struct i2c_client *client, u16 reg) 218 { 219 if (reg & 0xff00) { 220 outb_p(W83627EHF_REG_BANK, client->addr + ADDR_REG_OFFSET); 221 outb_p(0, client->addr + DATA_REG_OFFSET); 222 } 223 } 224 225 static u16 w83627ehf_read_value(struct i2c_client *client, u16 reg) 226 { 227 struct w83627ehf_data *data = i2c_get_clientdata(client); 228 int res, word_sized = is_word_sized(reg); 229 230 down(&data->lock); 231 232 w83627ehf_set_bank(client, reg); 233 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET); 234 res = inb_p(client->addr + DATA_REG_OFFSET); 235 if (word_sized) { 236 outb_p((reg & 0xff) + 1, 237 client->addr + ADDR_REG_OFFSET); 238 res = (res << 8) + inb_p(client->addr + DATA_REG_OFFSET); 239 } 240 w83627ehf_reset_bank(client, reg); 241 242 up(&data->lock); 243 244 return res; 245 } 246 247 static int w83627ehf_write_value(struct i2c_client *client, u16 reg, u16 value) 248 { 249 struct w83627ehf_data *data = i2c_get_clientdata(client); 250 int word_sized = is_word_sized(reg); 251 252 down(&data->lock); 253 254 w83627ehf_set_bank(client, reg); 255 outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET); 256 if (word_sized) { 257 outb_p(value >> 8, client->addr + DATA_REG_OFFSET); 258 outb_p((reg & 0xff) + 1, 259 client->addr + ADDR_REG_OFFSET); 260 } 261 outb_p(value & 0xff, client->addr + DATA_REG_OFFSET); 262 w83627ehf_reset_bank(client, reg); 263 264 up(&data->lock); 265 return 0; 266 } 267 268 /* This function assumes that the caller holds data->update_lock */ 269 static void w83627ehf_write_fan_div(struct i2c_client *client, int nr) 270 { 271 struct w83627ehf_data *data = i2c_get_clientdata(client); 272 u8 reg; 273 274 switch (nr) { 275 case 0: 276 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0xcf) 277 | ((data->fan_div[0] & 0x03) << 4); 278 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg); 279 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xdf) 280 | ((data->fan_div[0] & 0x04) << 3); 281 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg); 282 break; 283 case 1: 284 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV1) & 0x3f) 285 | ((data->fan_div[1] & 0x03) << 6); 286 w83627ehf_write_value(client, W83627EHF_REG_FANDIV1, reg); 287 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0xbf) 288 | ((data->fan_div[1] & 0x04) << 4); 289 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg); 290 break; 291 case 2: 292 reg = (w83627ehf_read_value(client, W83627EHF_REG_FANDIV2) & 0x3f) 293 | ((data->fan_div[2] & 0x03) << 6); 294 w83627ehf_write_value(client, W83627EHF_REG_FANDIV2, reg); 295 reg = (w83627ehf_read_value(client, W83627EHF_REG_VBAT) & 0x7f) 296 | ((data->fan_div[2] & 0x04) << 5); 297 w83627ehf_write_value(client, W83627EHF_REG_VBAT, reg); 298 break; 299 case 3: 300 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0xfc) 301 | (data->fan_div[3] & 0x03); 302 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg); 303 reg = (w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT) & 0x7f) 304 | ((data->fan_div[3] & 0x04) << 5); 305 w83627ehf_write_value(client, W83627EHF_REG_SMI_OVT, reg); 306 break; 307 case 4: 308 reg = (w83627ehf_read_value(client, W83627EHF_REG_DIODE) & 0x73) 309 | ((data->fan_div[4] & 0x03) << 3) 310 | ((data->fan_div[4] & 0x04) << 5); 311 w83627ehf_write_value(client, W83627EHF_REG_DIODE, reg); 312 break; 313 } 314 } 315 316 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev) 317 { 318 struct i2c_client *client = to_i2c_client(dev); 319 struct w83627ehf_data *data = i2c_get_clientdata(client); 320 int i; 321 322 down(&data->update_lock); 323 324 if (time_after(jiffies, data->last_updated + HZ) 325 || !data->valid) { 326 /* Fan clock dividers */ 327 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1); 328 data->fan_div[0] = (i >> 4) & 0x03; 329 data->fan_div[1] = (i >> 6) & 0x03; 330 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV2); 331 data->fan_div[2] = (i >> 6) & 0x03; 332 i = w83627ehf_read_value(client, W83627EHF_REG_VBAT); 333 data->fan_div[0] |= (i >> 3) & 0x04; 334 data->fan_div[1] |= (i >> 4) & 0x04; 335 data->fan_div[2] |= (i >> 5) & 0x04; 336 if (data->has_fan & ((1 << 3) | (1 << 4))) { 337 i = w83627ehf_read_value(client, W83627EHF_REG_DIODE); 338 data->fan_div[3] = i & 0x03; 339 data->fan_div[4] = ((i >> 2) & 0x03) 340 | ((i >> 5) & 0x04); 341 } 342 if (data->has_fan & (1 << 3)) { 343 i = w83627ehf_read_value(client, W83627EHF_REG_SMI_OVT); 344 data->fan_div[3] |= (i >> 5) & 0x04; 345 } 346 347 /* Measured fan speeds and limits */ 348 for (i = 0; i < 5; i++) { 349 if (!(data->has_fan & (1 << i))) 350 continue; 351 352 data->fan[i] = w83627ehf_read_value(client, 353 W83627EHF_REG_FAN[i]); 354 data->fan_min[i] = w83627ehf_read_value(client, 355 W83627EHF_REG_FAN_MIN[i]); 356 357 /* If we failed to measure the fan speed and clock 358 divider can be increased, let's try that for next 359 time */ 360 if (data->fan[i] == 0xff 361 && data->fan_div[i] < 0x07) { 362 dev_dbg(&client->dev, "Increasing fan %d " 363 "clock divider from %u to %u\n", 364 i, div_from_reg(data->fan_div[i]), 365 div_from_reg(data->fan_div[i] + 1)); 366 data->fan_div[i]++; 367 w83627ehf_write_fan_div(client, i); 368 /* Preserve min limit if possible */ 369 if (data->fan_min[i] >= 2 370 && data->fan_min[i] != 255) 371 w83627ehf_write_value(client, 372 W83627EHF_REG_FAN_MIN[i], 373 (data->fan_min[i] /= 2)); 374 } 375 } 376 377 /* Measured temperatures and limits */ 378 data->temp1 = w83627ehf_read_value(client, 379 W83627EHF_REG_TEMP1); 380 data->temp1_max = w83627ehf_read_value(client, 381 W83627EHF_REG_TEMP1_OVER); 382 data->temp1_max_hyst = w83627ehf_read_value(client, 383 W83627EHF_REG_TEMP1_HYST); 384 for (i = 0; i < 2; i++) { 385 data->temp[i] = w83627ehf_read_value(client, 386 W83627EHF_REG_TEMP[i]); 387 data->temp_max[i] = w83627ehf_read_value(client, 388 W83627EHF_REG_TEMP_OVER[i]); 389 data->temp_max_hyst[i] = w83627ehf_read_value(client, 390 W83627EHF_REG_TEMP_HYST[i]); 391 } 392 393 data->last_updated = jiffies; 394 data->valid = 1; 395 } 396 397 up(&data->update_lock); 398 return data; 399 } 400 401 /* 402 * Sysfs callback functions 403 */ 404 405 #define show_fan_reg(reg) \ 406 static ssize_t \ 407 show_##reg(struct device *dev, char *buf, int nr) \ 408 { \ 409 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 410 return sprintf(buf, "%d\n", \ 411 fan_from_reg(data->reg[nr], \ 412 div_from_reg(data->fan_div[nr]))); \ 413 } 414 show_fan_reg(fan); 415 show_fan_reg(fan_min); 416 417 static ssize_t 418 show_fan_div(struct device *dev, char *buf, int nr) 419 { 420 struct w83627ehf_data *data = w83627ehf_update_device(dev); 421 return sprintf(buf, "%u\n", 422 div_from_reg(data->fan_div[nr])); 423 } 424 425 static ssize_t 426 store_fan_min(struct device *dev, const char *buf, size_t count, int nr) 427 { 428 struct i2c_client *client = to_i2c_client(dev); 429 struct w83627ehf_data *data = i2c_get_clientdata(client); 430 unsigned int val = simple_strtoul(buf, NULL, 10); 431 unsigned int reg; 432 u8 new_div; 433 434 down(&data->update_lock); 435 if (!val) { 436 /* No min limit, alarm disabled */ 437 data->fan_min[nr] = 255; 438 new_div = data->fan_div[nr]; /* No change */ 439 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1); 440 } else if ((reg = 1350000U / val) >= 128 * 255) { 441 /* Speed below this value cannot possibly be represented, 442 even with the highest divider (128) */ 443 data->fan_min[nr] = 254; 444 new_div = 7; /* 128 == (1 << 7) */ 445 dev_warn(dev, "fan%u low limit %u below minimum %u, set to " 446 "minimum\n", nr + 1, val, fan_from_reg(254, 128)); 447 } else if (!reg) { 448 /* Speed above this value cannot possibly be represented, 449 even with the lowest divider (1) */ 450 data->fan_min[nr] = 1; 451 new_div = 0; /* 1 == (1 << 0) */ 452 dev_warn(dev, "fan%u low limit %u above maximum %u, set to " 453 "maximum\n", nr + 1, val, fan_from_reg(1, 1)); 454 } else { 455 /* Automatically pick the best divider, i.e. the one such 456 that the min limit will correspond to a register value 457 in the 96..192 range */ 458 new_div = 0; 459 while (reg > 192 && new_div < 7) { 460 reg >>= 1; 461 new_div++; 462 } 463 data->fan_min[nr] = reg; 464 } 465 466 /* Write both the fan clock divider (if it changed) and the new 467 fan min (unconditionally) */ 468 if (new_div != data->fan_div[nr]) { 469 if (new_div > data->fan_div[nr]) 470 data->fan[nr] >>= (data->fan_div[nr] - new_div); 471 else 472 data->fan[nr] <<= (new_div - data->fan_div[nr]); 473 474 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n", 475 nr + 1, div_from_reg(data->fan_div[nr]), 476 div_from_reg(new_div)); 477 data->fan_div[nr] = new_div; 478 w83627ehf_write_fan_div(client, nr); 479 } 480 w83627ehf_write_value(client, W83627EHF_REG_FAN_MIN[nr], 481 data->fan_min[nr]); 482 up(&data->update_lock); 483 484 return count; 485 } 486 487 #define sysfs_fan_offset(offset) \ 488 static ssize_t \ 489 show_reg_fan_##offset(struct device *dev, struct device_attribute *attr, \ 490 char *buf) \ 491 { \ 492 return show_fan(dev, buf, offset-1); \ 493 } \ 494 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 495 show_reg_fan_##offset, NULL); 496 497 #define sysfs_fan_min_offset(offset) \ 498 static ssize_t \ 499 show_reg_fan##offset##_min(struct device *dev, struct device_attribute *attr, \ 500 char *buf) \ 501 { \ 502 return show_fan_min(dev, buf, offset-1); \ 503 } \ 504 static ssize_t \ 505 store_reg_fan##offset##_min(struct device *dev, struct device_attribute *attr, \ 506 const char *buf, size_t count) \ 507 { \ 508 return store_fan_min(dev, buf, count, offset-1); \ 509 } \ 510 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 511 show_reg_fan##offset##_min, \ 512 store_reg_fan##offset##_min); 513 514 #define sysfs_fan_div_offset(offset) \ 515 static ssize_t \ 516 show_reg_fan##offset##_div(struct device *dev, struct device_attribute *attr, \ 517 char *buf) \ 518 { \ 519 return show_fan_div(dev, buf, offset - 1); \ 520 } \ 521 static DEVICE_ATTR(fan##offset##_div, S_IRUGO, \ 522 show_reg_fan##offset##_div, NULL); 523 524 sysfs_fan_offset(1); 525 sysfs_fan_min_offset(1); 526 sysfs_fan_div_offset(1); 527 sysfs_fan_offset(2); 528 sysfs_fan_min_offset(2); 529 sysfs_fan_div_offset(2); 530 sysfs_fan_offset(3); 531 sysfs_fan_min_offset(3); 532 sysfs_fan_div_offset(3); 533 sysfs_fan_offset(4); 534 sysfs_fan_min_offset(4); 535 sysfs_fan_div_offset(4); 536 sysfs_fan_offset(5); 537 sysfs_fan_min_offset(5); 538 sysfs_fan_div_offset(5); 539 540 #define show_temp1_reg(reg) \ 541 static ssize_t \ 542 show_##reg(struct device *dev, struct device_attribute *attr, \ 543 char *buf) \ 544 { \ 545 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 546 return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \ 547 } 548 show_temp1_reg(temp1); 549 show_temp1_reg(temp1_max); 550 show_temp1_reg(temp1_max_hyst); 551 552 #define store_temp1_reg(REG, reg) \ 553 static ssize_t \ 554 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \ 555 const char *buf, size_t count) \ 556 { \ 557 struct i2c_client *client = to_i2c_client(dev); \ 558 struct w83627ehf_data *data = i2c_get_clientdata(client); \ 559 u32 val = simple_strtoul(buf, NULL, 10); \ 560 \ 561 down(&data->update_lock); \ 562 data->temp1_##reg = temp1_to_reg(val); \ 563 w83627ehf_write_value(client, W83627EHF_REG_TEMP1_##REG, \ 564 data->temp1_##reg); \ 565 up(&data->update_lock); \ 566 return count; \ 567 } 568 store_temp1_reg(OVER, max); 569 store_temp1_reg(HYST, max_hyst); 570 571 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp1, NULL); 572 static DEVICE_ATTR(temp1_max, S_IRUGO| S_IWUSR, 573 show_temp1_max, store_temp1_max); 574 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO| S_IWUSR, 575 show_temp1_max_hyst, store_temp1_max_hyst); 576 577 #define show_temp_reg(reg) \ 578 static ssize_t \ 579 show_##reg (struct device *dev, char *buf, int nr) \ 580 { \ 581 struct w83627ehf_data *data = w83627ehf_update_device(dev); \ 582 return sprintf(buf, "%d\n", \ 583 LM75_TEMP_FROM_REG(data->reg[nr])); \ 584 } 585 show_temp_reg(temp); 586 show_temp_reg(temp_max); 587 show_temp_reg(temp_max_hyst); 588 589 #define store_temp_reg(REG, reg) \ 590 static ssize_t \ 591 store_##reg (struct device *dev, const char *buf, size_t count, int nr) \ 592 { \ 593 struct i2c_client *client = to_i2c_client(dev); \ 594 struct w83627ehf_data *data = i2c_get_clientdata(client); \ 595 u32 val = simple_strtoul(buf, NULL, 10); \ 596 \ 597 down(&data->update_lock); \ 598 data->reg[nr] = LM75_TEMP_TO_REG(val); \ 599 w83627ehf_write_value(client, W83627EHF_REG_TEMP_##REG[nr], \ 600 data->reg[nr]); \ 601 up(&data->update_lock); \ 602 return count; \ 603 } 604 store_temp_reg(OVER, temp_max); 605 store_temp_reg(HYST, temp_max_hyst); 606 607 #define sysfs_temp_offset(offset) \ 608 static ssize_t \ 609 show_reg_temp##offset (struct device *dev, struct device_attribute *attr, \ 610 char *buf) \ 611 { \ 612 return show_temp(dev, buf, offset - 2); \ 613 } \ 614 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ 615 show_reg_temp##offset, NULL); 616 617 #define sysfs_temp_reg_offset(reg, offset) \ 618 static ssize_t \ 619 show_reg_temp##offset##_##reg(struct device *dev, struct device_attribute *attr, \ 620 char *buf) \ 621 { \ 622 return show_temp_##reg(dev, buf, offset - 2); \ 623 } \ 624 static ssize_t \ 625 store_reg_temp##offset##_##reg(struct device *dev, struct device_attribute *attr, \ 626 const char *buf, size_t count) \ 627 { \ 628 return store_temp_##reg(dev, buf, count, offset - 2); \ 629 } \ 630 static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, \ 631 show_reg_temp##offset##_##reg, \ 632 store_reg_temp##offset##_##reg); 633 634 sysfs_temp_offset(2); 635 sysfs_temp_reg_offset(max, 2); 636 sysfs_temp_reg_offset(max_hyst, 2); 637 sysfs_temp_offset(3); 638 sysfs_temp_reg_offset(max, 3); 639 sysfs_temp_reg_offset(max_hyst, 3); 640 641 /* 642 * Driver and client management 643 */ 644 645 static struct i2c_driver w83627ehf_driver; 646 647 static void w83627ehf_init_client(struct i2c_client *client) 648 { 649 int i; 650 u8 tmp; 651 652 /* Start monitoring is needed */ 653 tmp = w83627ehf_read_value(client, W83627EHF_REG_CONFIG); 654 if (!(tmp & 0x01)) 655 w83627ehf_write_value(client, W83627EHF_REG_CONFIG, 656 tmp | 0x01); 657 658 /* Enable temp2 and temp3 if needed */ 659 for (i = 0; i < 2; i++) { 660 tmp = w83627ehf_read_value(client, 661 W83627EHF_REG_TEMP_CONFIG[i]); 662 if (tmp & 0x01) 663 w83627ehf_write_value(client, 664 W83627EHF_REG_TEMP_CONFIG[i], 665 tmp & 0xfe); 666 } 667 } 668 669 static int w83627ehf_detect(struct i2c_adapter *adapter, int address, int kind) 670 { 671 struct i2c_client *client; 672 struct w83627ehf_data *data; 673 int i, err = 0; 674 675 if (!i2c_is_isa_adapter(adapter)) 676 return 0; 677 678 if (!request_region(address, REGION_LENGTH, w83627ehf_driver.name)) { 679 err = -EBUSY; 680 goto exit; 681 } 682 683 if (!(data = kmalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) { 684 err = -ENOMEM; 685 goto exit_release; 686 } 687 memset(data, 0, sizeof(struct w83627ehf_data)); 688 689 client = &data->client; 690 i2c_set_clientdata(client, data); 691 client->addr = address; 692 init_MUTEX(&data->lock); 693 client->adapter = adapter; 694 client->driver = &w83627ehf_driver; 695 client->flags = 0; 696 697 strlcpy(client->name, "w83627ehf", I2C_NAME_SIZE); 698 data->valid = 0; 699 init_MUTEX(&data->update_lock); 700 701 /* Tell the i2c layer a new client has arrived */ 702 if ((err = i2c_attach_client(client))) 703 goto exit_free; 704 705 /* Initialize the chip */ 706 w83627ehf_init_client(client); 707 708 /* A few vars need to be filled upon startup */ 709 for (i = 0; i < 5; i++) 710 data->fan_min[i] = w83627ehf_read_value(client, 711 W83627EHF_REG_FAN_MIN[i]); 712 713 /* It looks like fan4 and fan5 pins can be alternatively used 714 as fan on/off switches */ 715 data->has_fan = 0x07; /* fan1, fan2 and fan3 */ 716 i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1); 717 if (i & (1 << 2)) 718 data->has_fan |= (1 << 3); 719 if (i & (1 << 0)) 720 data->has_fan |= (1 << 4); 721 722 /* Register sysfs hooks */ 723 device_create_file(&client->dev, &dev_attr_fan1_input); 724 device_create_file(&client->dev, &dev_attr_fan1_min); 725 device_create_file(&client->dev, &dev_attr_fan1_div); 726 device_create_file(&client->dev, &dev_attr_fan2_input); 727 device_create_file(&client->dev, &dev_attr_fan2_min); 728 device_create_file(&client->dev, &dev_attr_fan2_div); 729 device_create_file(&client->dev, &dev_attr_fan3_input); 730 device_create_file(&client->dev, &dev_attr_fan3_min); 731 device_create_file(&client->dev, &dev_attr_fan3_div); 732 733 if (data->has_fan & (1 << 3)) { 734 device_create_file(&client->dev, &dev_attr_fan4_input); 735 device_create_file(&client->dev, &dev_attr_fan4_min); 736 device_create_file(&client->dev, &dev_attr_fan4_div); 737 } 738 if (data->has_fan & (1 << 4)) { 739 device_create_file(&client->dev, &dev_attr_fan5_input); 740 device_create_file(&client->dev, &dev_attr_fan5_min); 741 device_create_file(&client->dev, &dev_attr_fan5_div); 742 } 743 744 device_create_file(&client->dev, &dev_attr_temp1_input); 745 device_create_file(&client->dev, &dev_attr_temp1_max); 746 device_create_file(&client->dev, &dev_attr_temp1_max_hyst); 747 device_create_file(&client->dev, &dev_attr_temp2_input); 748 device_create_file(&client->dev, &dev_attr_temp2_max); 749 device_create_file(&client->dev, &dev_attr_temp2_max_hyst); 750 device_create_file(&client->dev, &dev_attr_temp3_input); 751 device_create_file(&client->dev, &dev_attr_temp3_max); 752 device_create_file(&client->dev, &dev_attr_temp3_max_hyst); 753 754 return 0; 755 756 exit_free: 757 kfree(data); 758 exit_release: 759 release_region(address, REGION_LENGTH); 760 exit: 761 return err; 762 } 763 764 static int w83627ehf_attach_adapter(struct i2c_adapter *adapter) 765 { 766 if (!(adapter->class & I2C_CLASS_HWMON)) 767 return 0; 768 return i2c_detect(adapter, &addr_data, w83627ehf_detect); 769 } 770 771 static int w83627ehf_detach_client(struct i2c_client *client) 772 { 773 int err; 774 775 if ((err = i2c_detach_client(client))) { 776 dev_err(&client->dev, "Client deregistration failed, " 777 "client not detached.\n"); 778 return err; 779 } 780 release_region(client->addr, REGION_LENGTH); 781 kfree(i2c_get_clientdata(client)); 782 783 return 0; 784 } 785 786 static struct i2c_driver w83627ehf_driver = { 787 .owner = THIS_MODULE, 788 .name = "w83627ehf", 789 .flags = I2C_DF_NOTIFY, 790 .attach_adapter = w83627ehf_attach_adapter, 791 .detach_client = w83627ehf_detach_client, 792 }; 793 794 static int __init w83627ehf_find(int sioaddr, int *address) 795 { 796 u16 val; 797 798 REG = sioaddr; 799 VAL = sioaddr + 1; 800 superio_enter(); 801 802 val = (superio_inb(SIO_REG_DEVID) << 8) 803 | superio_inb(SIO_REG_DEVID + 1); 804 if ((val & SIO_ID_MASK) != SIO_W83627EHF_ID) { 805 superio_exit(); 806 return -ENODEV; 807 } 808 809 superio_select(W83627EHF_LD_HWM); 810 val = (superio_inb(SIO_REG_ADDR) << 8) 811 | superio_inb(SIO_REG_ADDR + 1); 812 *address = val & ~(REGION_LENGTH - 1); 813 if (*address == 0) { 814 superio_exit(); 815 return -ENODEV; 816 } 817 818 /* Activate logical device if needed */ 819 val = superio_inb(SIO_REG_ENABLE); 820 if (!(val & 0x01)) 821 superio_outb(SIO_REG_ENABLE, val | 0x01); 822 823 superio_exit(); 824 return 0; 825 } 826 827 static int __init sensors_w83627ehf_init(void) 828 { 829 if (w83627ehf_find(0x2e, &normal_isa[0]) 830 && w83627ehf_find(0x4e, &normal_isa[0])) 831 return -ENODEV; 832 833 return i2c_add_driver(&w83627ehf_driver); 834 } 835 836 static void __exit sensors_w83627ehf_exit(void) 837 { 838 i2c_del_driver(&w83627ehf_driver); 839 } 840 841 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>"); 842 MODULE_DESCRIPTION("W83627EHF driver"); 843 MODULE_LICENSE("GPL"); 844 845 module_init(sensors_w83627ehf_init); 846 module_exit(sensors_w83627ehf_exit); 847