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