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