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