drivers/hwmon/w83627ehf.c

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