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