git.oblomov.eu Git - linux-2.6/blob - drivers/hwmon/w83627ehf.c

   1 /*
   2     w83627ehf - Driver for the hardware monitoring functionality of
   3                 the Winbond W83627EHF Super-I/O chip
   4     Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
   5     Copyright (C) 2006  Yuan Mu (Winbond),
   6                         Rudolf Marek <r.marek@assembler.cz>
   7                         David Hubbard <david.c.hubbard@gmail.com>
   8
   9     Shamelessly ripped from the w83627hf driver
  10     Copyright (C) 2003  Mark Studebaker
  11
  12     Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
  13     in testing and debugging this driver.
  14
  15     This driver also supports the W83627EHG, which is the lead-free
  16     version of the W83627EHF.
  17
  18     This program is free software; you can redistribute it and/or modify
  19     it under the terms of the GNU General Public License as published by
  20     the Free Software Foundation; either version 2 of the License, or
  21     (at your option) any later version.
  22
  23     This program is distributed in the hope that it will be useful,
  24     but WITHOUT ANY WARRANTY; without even the implied warranty of
  25     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26     GNU General Public License for more details.
  27
  28     You should have received a copy of the GNU General Public License
  29     along with this program; if not, write to the Free Software
  30     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31
  32
  33     Supports the following chips:
  34
  35     Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
  36     w83627ehf   10      5       4       3      0x8850 0x88    0x5ca3
  37                                                0x8860 0xa1
  38     w83627dhg    9      5       4       3      0xa020 0xc1    0x5ca3
  39     w83667hg     9      5       3       3      0xa510 0xc1    0x5ca3
  40 */
  41
  42 #include <linux/module.h>
  43 #include <linux/init.h>
  44 #include <linux/slab.h>
  45 #include <linux/jiffies.h>
  46 #include <linux/platform_device.h>
  47 #include <linux/hwmon.h>
  48 #include <linux/hwmon-sysfs.h>
  49 #include <linux/hwmon-vid.h>
  50 #include <linux/err.h>
  51 #include <linux/mutex.h>
  52 #include <linux/acpi.h>
  53 #include <asm/io.h>
  54 #include "lm75.h"
  55
  56 enum kinds { w83627ehf, w83627dhg, w83667hg };
  57
  58 /* used to set data->name = w83627ehf_device_names[data->sio_kind] */
  59 static const char * w83627ehf_device_names[] = {
  60         "w83627ehf",
  61         "w83627dhg",
  62         "w83667hg",
  63 };
  64
  65 static unsigned short force_id;
  66 module_param(force_id, ushort, 0);
  67 MODULE_PARM_DESC(force_id, "Override the detected device ID");
  68
  69 #define DRVNAME "w83627ehf"
  70
  71 /*
  72  * Super-I/O constants and functions
  73  */
  74
  75 #define W83627EHF_LD_HWM        0x0b
  76 #define W83667HG_LD_VID         0x0d
  77
  78 #define SIO_REG_LDSEL           0x07    /* Logical device select */
  79 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
  80 #define SIO_REG_EN_VRM10        0x2C    /* GPIO3, GPIO4 selection */
  81 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
  82 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
  83 #define SIO_REG_VID_CTRL        0xF0    /* VID control */
  84 #define SIO_REG_VID_DATA        0xF1    /* VID data */
  85
  86 #define SIO_W83627EHF_ID        0x8850
  87 #define SIO_W83627EHG_ID        0x8860
  88 #define SIO_W83627DHG_ID        0xa020
  89 #define SIO_W83667HG_ID         0xa510
  90 #define SIO_ID_MASK             0xFFF0
  91
  92 static inline void
  93 superio_outb(int ioreg, int reg, int val)
  94 {
  95         outb(reg, ioreg);
  96         outb(val, ioreg + 1);
  97 }
  98
  99 static inline int
 100 superio_inb(int ioreg, int reg)
 101 {
 102         outb(reg, ioreg);
 103         return inb(ioreg + 1);
 104 }
 105
 106 static inline void
 107 superio_select(int ioreg, int ld)
 108 {
 109         outb(SIO_REG_LDSEL, ioreg);
 110         outb(ld, ioreg + 1);
 111 }
 112
 113 static inline void
 114 superio_enter(int ioreg)
 115 {
 116         outb(0x87, ioreg);
 117         outb(0x87, ioreg);
 118 }
 119
 120 static inline void
 121 superio_exit(int ioreg)
 122 {
 123         outb(0x02, ioreg);
 124         outb(0x02, ioreg + 1);
 125 }
 126
 127 /*
 128  * ISA constants
 129  */
 130
 131 #define IOREGION_ALIGNMENT      ~7
 132 #define IOREGION_OFFSET         5
 133 #define IOREGION_LENGTH         2
 134 #define ADDR_REG_OFFSET         0
 135 #define DATA_REG_OFFSET         1
 136
 137 #define W83627EHF_REG_BANK              0x4E
 138 #define W83627EHF_REG_CONFIG            0x40
 139
 140 /* Not currently used:
 141  * REG_MAN_ID has the value 0x5ca3 for all supported chips.
 142  * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
 143  * REG_MAN_ID is at port 0x4f
 144  * REG_CHIP_ID is at port 0x58 */
 145
 146 static const u16 W83627EHF_REG_FAN[] = { 0x28, 0x29, 0x2a, 0x3f, 0x553 };
 147 static const u16 W83627EHF_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d, 0x3e, 0x55c };
 148
 149 /* The W83627EHF registers for nr=7,8,9 are in bank 5 */
 150 #define W83627EHF_REG_IN_MAX(nr)        ((nr < 7) ? (0x2b + (nr) * 2) : \
 151                                          (0x554 + (((nr) - 7) * 2)))
 152 #define W83627EHF_REG_IN_MIN(nr)        ((nr < 7) ? (0x2c + (nr) * 2) : \
 153                                          (0x555 + (((nr) - 7) * 2)))
 154 #define W83627EHF_REG_IN(nr)            ((nr < 7) ? (0x20 + (nr)) : \
 155                                          (0x550 + (nr) - 7))
 156
 157 #define W83627EHF_REG_TEMP1             0x27
 158 #define W83627EHF_REG_TEMP1_HYST        0x3a
 159 #define W83627EHF_REG_TEMP1_OVER        0x39
 160 static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
 161 static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
 162 static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
 163 static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
 164
 165 /* Fan clock dividers are spread over the following five registers */
 166 #define W83627EHF_REG_FANDIV1           0x47
 167 #define W83627EHF_REG_FANDIV2           0x4B
 168 #define W83627EHF_REG_VBAT              0x5D
 169 #define W83627EHF_REG_DIODE             0x59
 170 #define W83627EHF_REG_SMI_OVT           0x4C
 171
 172 #define W83627EHF_REG_ALARM1            0x459
 173 #define W83627EHF_REG_ALARM2            0x45A
 174 #define W83627EHF_REG_ALARM3            0x45B
 175
 176 /* SmartFan registers */
 177 /* DC or PWM output fan configuration */
 178 static const u8 W83627EHF_REG_PWM_ENABLE[] = {
 179         0x04,                   /* SYS FAN0 output mode and PWM mode */
 180         0x04,                   /* CPU FAN0 output mode and PWM mode */
 181         0x12,                   /* AUX FAN mode */
 182         0x62,                   /* CPU fan1 mode */
 183 };
 184
 185 static const u8 W83627EHF_PWM_MODE_SHIFT[] = { 0, 1, 0, 6 };
 186 static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
 187
 188 /* FAN Duty Cycle, be used to control */
 189 static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
 190 static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
 191 static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
 192
 193
 194 /* Advanced Fan control, some values are common for all fans */
 195 static const u8 W83627EHF_REG_FAN_MIN_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
 196 static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0C, 0x0D, 0x17, 0x66 };
 197
 198 /*
 199  * Conversions
 200  */
 201
 202 /* 1 is PWM mode, output in ms */
 203 static inline unsigned int step_time_from_reg(u8 reg, u8 mode)
 204 {
 205         return mode ? 100 * reg : 400 * reg;
 206 }
 207
 208 static inline u8 step_time_to_reg(unsigned int msec, u8 mode)
 209 {
 210         return SENSORS_LIMIT((mode ? (msec + 50) / 100 :
 211                                                 (msec + 200) / 400), 1, 255);
 212 }
 213
 214 static inline unsigned int
 215 fan_from_reg(u8 reg, unsigned int div)
 216 {
 217         if (reg == 0 || reg == 255)
 218                 return 0;
 219         return 1350000U / (reg * div);
 220 }
 221
 222 static inline unsigned int
 223 div_from_reg(u8 reg)
 224 {
 225         return 1 << reg;
 226 }
 227
 228 static inline int
 229 temp1_from_reg(s8 reg)
 230 {
 231         return reg * 1000;
 232 }
 233
 234 static inline s8
 235 temp1_to_reg(long temp, int min, int max)
 236 {
 237         if (temp <= min)
 238                 return min / 1000;
 239         if (temp >= max)
 240                 return max / 1000;
 241         if (temp < 0)
 242                 return (temp - 500) / 1000;
 243         return (temp + 500) / 1000;
 244 }
 245
 246 /* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
 247
 248 static u8 scale_in[10] = { 8, 8, 16, 16, 8, 8, 8, 16, 16, 8 };
 249
 250 static inline long in_from_reg(u8 reg, u8 nr)
 251 {
 252         return reg * scale_in[nr];
 253 }
 254
 255 static inline u8 in_to_reg(u32 val, u8 nr)
 256 {
 257         return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
 258 }
 259
 260 /*
 261  * Data structures and manipulation thereof
 262  */
 263
 264 struct w83627ehf_data {
 265         int addr;       /* IO base of hw monitor block */
 266         const char *name;
 267
 268         struct device *hwmon_dev;
 269         struct mutex lock;
 270
 271         struct mutex update_lock;
 272         char valid;             /* !=0 if following fields are valid */
 273         unsigned long last_updated;     /* In jiffies */
 274
 275         /* Register values */
 276         u8 in_num;              /* number of in inputs we have */
 277         u8 in[10];              /* Register value */
 278         u8 in_max[10];          /* Register value */
 279         u8 in_min[10];          /* Register value */
 280         u8 fan[5];
 281         u8 fan_min[5];
 282         u8 fan_div[5];
 283         u8 has_fan;             /* some fan inputs can be disabled */
 284         u8 temp_type[3];
 285         s8 temp1;
 286         s8 temp1_max;
 287         s8 temp1_max_hyst;
 288         s16 temp[2];
 289         s16 temp_max[2];
 290         s16 temp_max_hyst[2];
 291         u32 alarms;
 292
 293         u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
 294         u8 pwm_enable[4]; /* 1->manual
 295                              2->thermal cruise (also called SmartFan I) */
 296         u8 pwm_num;             /* number of pwm */
 297         u8 pwm[4];
 298         u8 target_temp[4];
 299         u8 tolerance[4];
 300
 301         u8 fan_min_output[4]; /* minimum fan speed */
 302         u8 fan_stop_time[4];
 303
 304         u8 vid;
 305         u8 vrm;
 306
 307         u8 temp3_disable;
 308         u8 in6_skip;
 309 };
 310
 311 struct w83627ehf_sio_data {
 312         int sioreg;
 313         enum kinds kind;
 314 };
 315
 316 static inline int is_word_sized(u16 reg)
 317 {
 318         return (((reg & 0xff00) == 0x100
 319               || (reg & 0xff00) == 0x200)
 320              && ((reg & 0x00ff) == 0x50
 321               || (reg & 0x00ff) == 0x53
 322               || (reg & 0x00ff) == 0x55));
 323 }
 324
 325 /* Registers 0x50-0x5f are banked */
 326 static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
 327 {
 328         if ((reg & 0x00f0) == 0x50) {
 329                 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
 330                 outb_p(reg >> 8, data->addr + DATA_REG_OFFSET);
 331         }
 332 }
 333
 334 /* Not strictly necessary, but play it safe for now */
 335 static inline void w83627ehf_reset_bank(struct w83627ehf_data *data, u16 reg)
 336 {
 337         if (reg & 0xff00) {
 338                 outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
 339                 outb_p(0, data->addr + DATA_REG_OFFSET);
 340         }
 341 }
 342
 343 static u16 w83627ehf_read_value(struct w83627ehf_data *data, u16 reg)
 344 {
 345         int res, word_sized = is_word_sized(reg);
 346
 347         mutex_lock(&data->lock);
 348
 349         w83627ehf_set_bank(data, reg);
 350         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 351         res = inb_p(data->addr + DATA_REG_OFFSET);
 352         if (word_sized) {
 353                 outb_p((reg & 0xff) + 1,
 354                        data->addr + ADDR_REG_OFFSET);
 355                 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
 356         }
 357         w83627ehf_reset_bank(data, reg);
 358
 359         mutex_unlock(&data->lock);
 360
 361         return res;
 362 }
 363
 364 static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg, u16 value)
 365 {
 366         int word_sized = is_word_sized(reg);
 367
 368         mutex_lock(&data->lock);
 369
 370         w83627ehf_set_bank(data, reg);
 371         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
 372         if (word_sized) {
 373                 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
 374                 outb_p((reg & 0xff) + 1,
 375                        data->addr + ADDR_REG_OFFSET);
 376         }
 377         outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
 378         w83627ehf_reset_bank(data, reg);
 379
 380         mutex_unlock(&data->lock);
 381         return 0;
 382 }
 383
 384 /* This function assumes that the caller holds data->update_lock */
 385 static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
 386 {
 387         u8 reg;
 388
 389         switch (nr) {
 390         case 0:
 391                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0xcf)
 392                     | ((data->fan_div[0] & 0x03) << 4);
 393                 /* fan5 input control bit is write only, compute the value */
 394                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
 395                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
 396                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xdf)
 397                     | ((data->fan_div[0] & 0x04) << 3);
 398                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
 399                 break;
 400         case 1:
 401                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV1) & 0x3f)
 402                     | ((data->fan_div[1] & 0x03) << 6);
 403                 /* fan5 input control bit is write only, compute the value */
 404                 reg |= (data->has_fan & (1 << 4)) ? 1 : 0;
 405                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV1, reg);
 406                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0xbf)
 407                     | ((data->fan_div[1] & 0x04) << 4);
 408                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
 409                 break;
 410         case 2:
 411                 reg = (w83627ehf_read_value(data, W83627EHF_REG_FANDIV2) & 0x3f)
 412                     | ((data->fan_div[2] & 0x03) << 6);
 413                 w83627ehf_write_value(data, W83627EHF_REG_FANDIV2, reg);
 414                 reg = (w83627ehf_read_value(data, W83627EHF_REG_VBAT) & 0x7f)
 415                     | ((data->fan_div[2] & 0x04) << 5);
 416                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, reg);
 417                 break;
 418         case 3:
 419                 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0xfc)
 420                     | (data->fan_div[3] & 0x03);
 421                 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
 422                 reg = (w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT) & 0x7f)
 423                     | ((data->fan_div[3] & 0x04) << 5);
 424                 w83627ehf_write_value(data, W83627EHF_REG_SMI_OVT, reg);
 425                 break;
 426         case 4:
 427                 reg = (w83627ehf_read_value(data, W83627EHF_REG_DIODE) & 0x73)
 428                     | ((data->fan_div[4] & 0x03) << 2)
 429                     | ((data->fan_div[4] & 0x04) << 5);
 430                 w83627ehf_write_value(data, W83627EHF_REG_DIODE, reg);
 431                 break;
 432         }
 433 }
 434
 435 static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
 436 {
 437         int i;
 438
 439         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
 440         data->fan_div[0] = (i >> 4) & 0x03;
 441         data->fan_div[1] = (i >> 6) & 0x03;
 442         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV2);
 443         data->fan_div[2] = (i >> 6) & 0x03;
 444         i = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
 445         data->fan_div[0] |= (i >> 3) & 0x04;
 446         data->fan_div[1] |= (i >> 4) & 0x04;
 447         data->fan_div[2] |= (i >> 5) & 0x04;
 448         if (data->has_fan & ((1 << 3) | (1 << 4))) {
 449                 i = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
 450                 data->fan_div[3] = i & 0x03;
 451                 data->fan_div[4] = ((i >> 2) & 0x03)
 452                                  | ((i >> 5) & 0x04);
 453         }
 454         if (data->has_fan & (1 << 3)) {
 455                 i = w83627ehf_read_value(data, W83627EHF_REG_SMI_OVT);
 456                 data->fan_div[3] |= (i >> 5) & 0x04;
 457         }
 458 }
 459
 460 static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
 461 {
 462         struct w83627ehf_data *data = dev_get_drvdata(dev);
 463         int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
 464         int i;
 465
 466         mutex_lock(&data->update_lock);
 467
 468         if (time_after(jiffies, data->last_updated + HZ + HZ/2)
 469          || !data->valid) {
 470                 /* Fan clock dividers */
 471                 w83627ehf_update_fan_div(data);
 472
 473                 /* Measured voltages and limits */
 474                 for (i = 0; i < data->in_num; i++) {
 475                         data->in[i] = w83627ehf_read_value(data,
 476                                       W83627EHF_REG_IN(i));
 477                         data->in_min[i] = w83627ehf_read_value(data,
 478                                           W83627EHF_REG_IN_MIN(i));
 479                         data->in_max[i] = w83627ehf_read_value(data,
 480                                           W83627EHF_REG_IN_MAX(i));
 481                 }
 482
 483                 /* Measured fan speeds and limits */
 484                 for (i = 0; i < 5; i++) {
 485                         if (!(data->has_fan & (1 << i)))
 486                                 continue;
 487
 488                         data->fan[i] = w83627ehf_read_value(data,
 489                                        W83627EHF_REG_FAN[i]);
 490                         data->fan_min[i] = w83627ehf_read_value(data,
 491                                            W83627EHF_REG_FAN_MIN[i]);
 492
 493                         /* If we failed to measure the fan speed and clock
 494                            divider can be increased, let's try that for next
 495                            time */
 496                         if (data->fan[i] == 0xff
 497                          && data->fan_div[i] < 0x07) {
 498                                 dev_dbg(dev, "Increasing fan%d "
 499                                         "clock divider from %u to %u\n",
 500                                         i + 1, div_from_reg(data->fan_div[i]),
 501                                         div_from_reg(data->fan_div[i] + 1));
 502                                 data->fan_div[i]++;
 503                                 w83627ehf_write_fan_div(data, i);
 504                                 /* Preserve min limit if possible */
 505                                 if (data->fan_min[i] >= 2
 506                                  && data->fan_min[i] != 255)
 507                                         w83627ehf_write_value(data,
 508                                                 W83627EHF_REG_FAN_MIN[i],
 509                                                 (data->fan_min[i] /= 2));
 510                         }
 511                 }
 512
 513                 for (i = 0; i < 4; i++) {
 514                         /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
 515                         if (i != 1) {
 516                                 pwmcfg = w83627ehf_read_value(data,
 517                                                 W83627EHF_REG_PWM_ENABLE[i]);
 518                                 tolerance = w83627ehf_read_value(data,
 519                                                 W83627EHF_REG_TOLERANCE[i]);
 520                         }
 521                         data->pwm_mode[i] =
 522                                 ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1)
 523                                 ? 0 : 1;
 524                         data->pwm_enable[i] =
 525                                         ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
 526                                                 & 3) + 1;
 527                         data->pwm[i] = w83627ehf_read_value(data,
 528                                                 W83627EHF_REG_PWM[i]);
 529                         data->fan_min_output[i] = w83627ehf_read_value(data,
 530                                                 W83627EHF_REG_FAN_MIN_OUTPUT[i]);
 531                         data->fan_stop_time[i] = w83627ehf_read_value(data,
 532                                                 W83627EHF_REG_FAN_STOP_TIME[i]);
 533                         data->target_temp[i] =
 534                                 w83627ehf_read_value(data,
 535                                         W83627EHF_REG_TARGET[i]) &
 536                                         (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
 537                         data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
 538                                                                         & 0x0f;
 539                 }
 540
 541                 /* Measured temperatures and limits */
 542                 data->temp1 = w83627ehf_read_value(data,
 543                               W83627EHF_REG_TEMP1);
 544                 data->temp1_max = w83627ehf_read_value(data,
 545                                   W83627EHF_REG_TEMP1_OVER);
 546                 data->temp1_max_hyst = w83627ehf_read_value(data,
 547                                        W83627EHF_REG_TEMP1_HYST);
 548                 for (i = 0; i < 2; i++) {
 549                         data->temp[i] = w83627ehf_read_value(data,
 550                                         W83627EHF_REG_TEMP[i]);
 551                         data->temp_max[i] = w83627ehf_read_value(data,
 552                                             W83627EHF_REG_TEMP_OVER[i]);
 553                         data->temp_max_hyst[i] = w83627ehf_read_value(data,
 554                                                  W83627EHF_REG_TEMP_HYST[i]);
 555                 }
 556
 557                 data->alarms = w83627ehf_read_value(data,
 558                                         W83627EHF_REG_ALARM1) |
 559                                (w83627ehf_read_value(data,
 560                                         W83627EHF_REG_ALARM2) << 8) |
 561                                (w83627ehf_read_value(data,
 562                                         W83627EHF_REG_ALARM3) << 16);
 563
 564                 data->last_updated = jiffies;
 565                 data->valid = 1;
 566         }
 567
 568         mutex_unlock(&data->update_lock);
 569         return data;
 570 }
 571
 572 /*
 573  * Sysfs callback functions
 574  */
 575 #define show_in_reg(reg) \
 576 static ssize_t \
 577 show_##reg(struct device *dev, struct device_attribute *attr, \
 578            char *buf) \
 579 { \
 580         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 581         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 582         int nr = sensor_attr->index; \
 583         return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
 584 }
 585 show_in_reg(in)
 586 show_in_reg(in_min)
 587 show_in_reg(in_max)
 588
 589 #define store_in_reg(REG, reg) \
 590 static ssize_t \
 591 store_in_##reg (struct device *dev, struct device_attribute *attr, \
 592                         const char *buf, size_t count) \
 593 { \
 594         struct w83627ehf_data *data = dev_get_drvdata(dev); \
 595         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 596         int nr = sensor_attr->index; \
 597         u32 val = simple_strtoul(buf, NULL, 10); \
 598  \
 599         mutex_lock(&data->update_lock); \
 600         data->in_##reg[nr] = in_to_reg(val, nr); \
 601         w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
 602                               data->in_##reg[nr]); \
 603         mutex_unlock(&data->update_lock); \
 604         return count; \
 605 }
 606
 607 store_in_reg(MIN, min)
 608 store_in_reg(MAX, max)
 609
 610 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
 611 {
 612         struct w83627ehf_data *data = w83627ehf_update_device(dev);
 613         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 614         int nr = sensor_attr->index;
 615         return sprintf(buf, "%u\n", (data->alarms >> nr) & 0x01);
 616 }
 617
 618 static struct sensor_device_attribute sda_in_input[] = {
 619         SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
 620         SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
 621         SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
 622         SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
 623         SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
 624         SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
 625         SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
 626         SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
 627         SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
 628         SENSOR_ATTR(in9_input, S_IRUGO, show_in, NULL, 9),
 629 };
 630
 631 static struct sensor_device_attribute sda_in_alarm[] = {
 632         SENSOR_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0),
 633         SENSOR_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1),
 634         SENSOR_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2),
 635         SENSOR_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3),
 636         SENSOR_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8),
 637         SENSOR_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 21),
 638         SENSOR_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 20),
 639         SENSOR_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 16),
 640         SENSOR_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 17),
 641         SENSOR_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 19),
 642 };
 643
 644 static struct sensor_device_attribute sda_in_min[] = {
 645        SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
 646        SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
 647        SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
 648        SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
 649        SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
 650        SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
 651        SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
 652        SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
 653        SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
 654        SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
 655 };
 656
 657 static struct sensor_device_attribute sda_in_max[] = {
 658        SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
 659        SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
 660        SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
 661        SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
 662        SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
 663        SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
 664        SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
 665        SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
 666        SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
 667        SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
 668 };
 669
 670 #define show_fan_reg(reg) \
 671 static ssize_t \
 672 show_##reg(struct device *dev, struct device_attribute *attr, \
 673            char *buf) \
 674 { \
 675         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 676         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 677         int nr = sensor_attr->index; \
 678         return sprintf(buf, "%d\n", \
 679                        fan_from_reg(data->reg[nr], \
 680                                     div_from_reg(data->fan_div[nr]))); \
 681 }
 682 show_fan_reg(fan);
 683 show_fan_reg(fan_min);
 684
 685 static ssize_t
 686 show_fan_div(struct device *dev, struct device_attribute *attr,
 687              char *buf)
 688 {
 689         struct w83627ehf_data *data = w83627ehf_update_device(dev);
 690         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 691         int nr = sensor_attr->index;
 692         return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
 693 }
 694
 695 static ssize_t
 696 store_fan_min(struct device *dev, struct device_attribute *attr,
 697               const char *buf, size_t count)
 698 {
 699         struct w83627ehf_data *data = dev_get_drvdata(dev);
 700         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 701         int nr = sensor_attr->index;
 702         unsigned int val = simple_strtoul(buf, NULL, 10);
 703         unsigned int reg;
 704         u8 new_div;
 705
 706         mutex_lock(&data->update_lock);
 707         if (!val) {
 708                 /* No min limit, alarm disabled */
 709                 data->fan_min[nr] = 255;
 710                 new_div = data->fan_div[nr]; /* No change */
 711                 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
 712         } else if ((reg = 1350000U / val) >= 128 * 255) {
 713                 /* Speed below this value cannot possibly be represented,
 714                    even with the highest divider (128) */
 715                 data->fan_min[nr] = 254;
 716                 new_div = 7; /* 128 == (1 << 7) */
 717                 dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
 718                          "minimum\n", nr + 1, val, fan_from_reg(254, 128));
 719         } else if (!reg) {
 720                 /* Speed above this value cannot possibly be represented,
 721                    even with the lowest divider (1) */
 722                 data->fan_min[nr] = 1;
 723                 new_div = 0; /* 1 == (1 << 0) */
 724                 dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
 725                          "maximum\n", nr + 1, val, fan_from_reg(1, 1));
 726         } else {
 727                 /* Automatically pick the best divider, i.e. the one such
 728                    that the min limit will correspond to a register value
 729                    in the 96..192 range */
 730                 new_div = 0;
 731                 while (reg > 192 && new_div < 7) {
 732                         reg >>= 1;
 733                         new_div++;
 734                 }
 735                 data->fan_min[nr] = reg;
 736         }
 737
 738         /* Write both the fan clock divider (if it changed) and the new
 739            fan min (unconditionally) */
 740         if (new_div != data->fan_div[nr]) {
 741                 /* Preserve the fan speed reading */
 742                 if (data->fan[nr] != 0xff) {
 743                         if (new_div > data->fan_div[nr])
 744                                 data->fan[nr] >>= new_div - data->fan_div[nr];
 745                         else if (data->fan[nr] & 0x80)
 746                                 data->fan[nr] = 0xff;
 747                         else
 748                                 data->fan[nr] <<= data->fan_div[nr] - new_div;
 749                 }
 750
 751                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
 752                         nr + 1, div_from_reg(data->fan_div[nr]),
 753                         div_from_reg(new_div));
 754                 data->fan_div[nr] = new_div;
 755                 w83627ehf_write_fan_div(data, nr);
 756                 /* Give the chip time to sample a new speed value */
 757                 data->last_updated = jiffies;
 758         }
 759         w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[nr],
 760                               data->fan_min[nr]);
 761         mutex_unlock(&data->update_lock);
 762
 763         return count;
 764 }
 765
 766 static struct sensor_device_attribute sda_fan_input[] = {
 767         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
 768         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
 769         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
 770         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
 771         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
 772 };
 773
 774 static struct sensor_device_attribute sda_fan_alarm[] = {
 775         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
 776         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
 777         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
 778         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
 779         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
 780 };
 781
 782 static struct sensor_device_attribute sda_fan_min[] = {
 783         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
 784                     store_fan_min, 0),
 785         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
 786                     store_fan_min, 1),
 787         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
 788                     store_fan_min, 2),
 789         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
 790                     store_fan_min, 3),
 791         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
 792                     store_fan_min, 4),
 793 };
 794
 795 static struct sensor_device_attribute sda_fan_div[] = {
 796         SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
 797         SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
 798         SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
 799         SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
 800         SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
 801 };
 802
 803 #define show_temp1_reg(reg) \
 804 static ssize_t \
 805 show_##reg(struct device *dev, struct device_attribute *attr, \
 806            char *buf) \
 807 { \
 808         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 809         return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
 810 }
 811 show_temp1_reg(temp1);
 812 show_temp1_reg(temp1_max);
 813 show_temp1_reg(temp1_max_hyst);
 814
 815 #define store_temp1_reg(REG, reg) \
 816 static ssize_t \
 817 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
 818                   const char *buf, size_t count) \
 819 { \
 820         struct w83627ehf_data *data = dev_get_drvdata(dev); \
 821         long val = simple_strtol(buf, NULL, 10); \
 822  \
 823         mutex_lock(&data->update_lock); \
 824         data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
 825         w83627ehf_write_value(data, W83627EHF_REG_TEMP1_##REG, \
 826                               data->temp1_##reg); \
 827         mutex_unlock(&data->update_lock); \
 828         return count; \
 829 }
 830 store_temp1_reg(OVER, max);
 831 store_temp1_reg(HYST, max_hyst);
 832
 833 #define show_temp_reg(reg) \
 834 static ssize_t \
 835 show_##reg(struct device *dev, struct device_attribute *attr, \
 836            char *buf) \
 837 { \
 838         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 839         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 840         int nr = sensor_attr->index; \
 841         return sprintf(buf, "%d\n", \
 842                        LM75_TEMP_FROM_REG(data->reg[nr])); \
 843 }
 844 show_temp_reg(temp);
 845 show_temp_reg(temp_max);
 846 show_temp_reg(temp_max_hyst);
 847
 848 #define store_temp_reg(REG, reg) \
 849 static ssize_t \
 850 store_##reg(struct device *dev, struct device_attribute *attr, \
 851             const char *buf, size_t count) \
 852 { \
 853         struct w83627ehf_data *data = dev_get_drvdata(dev); \
 854         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 855         int nr = sensor_attr->index; \
 856         long val = simple_strtol(buf, NULL, 10); \
 857  \
 858         mutex_lock(&data->update_lock); \
 859         data->reg[nr] = LM75_TEMP_TO_REG(val); \
 860         w83627ehf_write_value(data, W83627EHF_REG_TEMP_##REG[nr], \
 861                               data->reg[nr]); \
 862         mutex_unlock(&data->update_lock); \
 863         return count; \
 864 }
 865 store_temp_reg(OVER, temp_max);
 866 store_temp_reg(HYST, temp_max_hyst);
 867
 868 static ssize_t
 869 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
 870 {
 871         struct w83627ehf_data *data = w83627ehf_update_device(dev);
 872         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 873         int nr = sensor_attr->index;
 874         return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
 875 }
 876
 877 static struct sensor_device_attribute sda_temp_input[] = {
 878         SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
 879         SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
 880         SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
 881 };
 882
 883 static struct sensor_device_attribute sda_temp_max[] = {
 884         SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
 885                     store_temp1_max, 0),
 886         SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
 887                     store_temp_max, 0),
 888         SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
 889                     store_temp_max, 1),
 890 };
 891
 892 static struct sensor_device_attribute sda_temp_max_hyst[] = {
 893         SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
 894                     store_temp1_max_hyst, 0),
 895         SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 896                     store_temp_max_hyst, 0),
 897         SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 898                     store_temp_max_hyst, 1),
 899 };
 900
 901 static struct sensor_device_attribute sda_temp_alarm[] = {
 902         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
 903         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
 904         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
 905 };
 906
 907 static struct sensor_device_attribute sda_temp_type[] = {
 908         SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
 909         SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
 910         SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
 911 };
 912
 913 #define show_pwm_reg(reg) \
 914 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
 915                                 char *buf) \
 916 { \
 917         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 918         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 919         int nr = sensor_attr->index; \
 920         return sprintf(buf, "%d\n", data->reg[nr]); \
 921 }
 922
 923 show_pwm_reg(pwm_mode)
 924 show_pwm_reg(pwm_enable)
 925 show_pwm_reg(pwm)
 926
 927 static ssize_t
 928 store_pwm_mode(struct device *dev, struct device_attribute *attr,
 929                         const char *buf, size_t count)
 930 {
 931         struct w83627ehf_data *data = dev_get_drvdata(dev);
 932         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 933         int nr = sensor_attr->index;
 934         u32 val = simple_strtoul(buf, NULL, 10);
 935         u16 reg;
 936
 937         if (val > 1)
 938                 return -EINVAL;
 939         mutex_lock(&data->update_lock);
 940         reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
 941         data->pwm_mode[nr] = val;
 942         reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
 943         if (!val)
 944                 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
 945         w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
 946         mutex_unlock(&data->update_lock);
 947         return count;
 948 }
 949
 950 static ssize_t
 951 store_pwm(struct device *dev, struct device_attribute *attr,
 952                         const char *buf, size_t count)
 953 {
 954         struct w83627ehf_data *data = dev_get_drvdata(dev);
 955         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 956         int nr = sensor_attr->index;
 957         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
 958
 959         mutex_lock(&data->update_lock);
 960         data->pwm[nr] = val;
 961         w83627ehf_write_value(data, W83627EHF_REG_PWM[nr], val);
 962         mutex_unlock(&data->update_lock);
 963         return count;
 964 }
 965
 966 static ssize_t
 967 store_pwm_enable(struct device *dev, struct device_attribute *attr,
 968                         const char *buf, size_t count)
 969 {
 970         struct w83627ehf_data *data = dev_get_drvdata(dev);
 971         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 972         int nr = sensor_attr->index;
 973         u32 val = simple_strtoul(buf, NULL, 10);
 974         u16 reg;
 975
 976         if (!val || (val > 2))  /* only modes 1 and 2 are supported */
 977                 return -EINVAL;
 978         mutex_lock(&data->update_lock);
 979         reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
 980         data->pwm_enable[nr] = val;
 981         reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
 982         reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
 983         w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
 984         mutex_unlock(&data->update_lock);
 985         return count;
 986 }
 987
 988
 989 #define show_tol_temp(reg) \
 990 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 991                                 char *buf) \
 992 { \
 993         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 994         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 995         int nr = sensor_attr->index; \
 996         return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
 997 }
 998
 999 show_tol_temp(tolerance)
1000 show_tol_temp(target_temp)
1001
1002 static ssize_t
1003 store_target_temp(struct device *dev, struct device_attribute *attr,
1004                         const char *buf, size_t count)
1005 {
1006         struct w83627ehf_data *data = dev_get_drvdata(dev);
1007         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1008         int nr = sensor_attr->index;
1009         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
1010
1011         mutex_lock(&data->update_lock);
1012         data->target_temp[nr] = val;
1013         w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val);
1014         mutex_unlock(&data->update_lock);
1015         return count;
1016 }
1017
1018 static ssize_t
1019 store_tolerance(struct device *dev, struct device_attribute *attr,
1020                         const char *buf, size_t count)
1021 {
1022         struct w83627ehf_data *data = dev_get_drvdata(dev);
1023         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1024         int nr = sensor_attr->index;
1025         u16 reg;
1026         /* Limit the temp to 0C - 15C */
1027         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
1028
1029         mutex_lock(&data->update_lock);
1030         reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
1031         data->tolerance[nr] = val;
1032         if (nr == 1)
1033                 reg = (reg & 0x0f) | (val << 4);
1034         else
1035                 reg = (reg & 0xf0) | val;
1036         w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1037         mutex_unlock(&data->update_lock);
1038         return count;
1039 }
1040
1041 static struct sensor_device_attribute sda_pwm[] = {
1042         SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
1043         SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
1044         SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
1045         SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
1046 };
1047
1048 static struct sensor_device_attribute sda_pwm_mode[] = {
1049         SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1050                     store_pwm_mode, 0),
1051         SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1052                     store_pwm_mode, 1),
1053         SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1054                     store_pwm_mode, 2),
1055         SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1056                     store_pwm_mode, 3),
1057 };
1058
1059 static struct sensor_device_attribute sda_pwm_enable[] = {
1060         SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1061                     store_pwm_enable, 0),
1062         SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1063                     store_pwm_enable, 1),
1064         SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1065                     store_pwm_enable, 2),
1066         SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1067                     store_pwm_enable, 3),
1068 };
1069
1070 static struct sensor_device_attribute sda_target_temp[] = {
1071         SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1072                     store_target_temp, 0),
1073         SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1074                     store_target_temp, 1),
1075         SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1076                     store_target_temp, 2),
1077         SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1078                     store_target_temp, 3),
1079 };
1080
1081 static struct sensor_device_attribute sda_tolerance[] = {
1082         SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1083                     store_tolerance, 0),
1084         SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1085                     store_tolerance, 1),
1086         SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1087                     store_tolerance, 2),
1088         SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1089                     store_tolerance, 3),
1090 };
1091
1092 /* Smart Fan registers */
1093
1094 #define fan_functions(reg, REG) \
1095 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1096                        char *buf) \
1097 { \
1098         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1099         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1100         int nr = sensor_attr->index; \
1101         return sprintf(buf, "%d\n", data->reg[nr]); \
1102 }\
1103 static ssize_t \
1104 store_##reg(struct device *dev, struct device_attribute *attr, \
1105                             const char *buf, size_t count) \
1106 {\
1107         struct w83627ehf_data *data = dev_get_drvdata(dev); \
1108         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1109         int nr = sensor_attr->index; \
1110         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
1111         mutex_lock(&data->update_lock); \
1112         data->reg[nr] = val; \
1113         w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
1114         mutex_unlock(&data->update_lock); \
1115         return count; \
1116 }
1117
1118 fan_functions(fan_min_output, FAN_MIN_OUTPUT)
1119
1120 #define fan_time_functions(reg, REG) \
1121 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1122                                 char *buf) \
1123 { \
1124         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1125         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1126         int nr = sensor_attr->index; \
1127         return sprintf(buf, "%d\n", \
1128                         step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
1129 } \
1130 \
1131 static ssize_t \
1132 store_##reg(struct device *dev, struct device_attribute *attr, \
1133                         const char *buf, size_t count) \
1134 { \
1135         struct w83627ehf_data *data = dev_get_drvdata(dev); \
1136         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1137         int nr = sensor_attr->index; \
1138         u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
1139                                         data->pwm_mode[nr]); \
1140         mutex_lock(&data->update_lock); \
1141         data->reg[nr] = val; \
1142         w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
1143         mutex_unlock(&data->update_lock); \
1144         return count; \
1145 } \
1146
1147 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1148
1149 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
1150                          char *buf)
1151 {
1152         struct w83627ehf_data *data = dev_get_drvdata(dev);
1153
1154         return sprintf(buf, "%s\n", data->name);
1155 }
1156 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1157
1158 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1159         SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1160                     store_fan_stop_time, 3),
1161         SENSOR_ATTR(pwm4_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1162                     store_fan_min_output, 3),
1163 };
1164
1165 static struct sensor_device_attribute sda_sf3_arrays[] = {
1166         SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1167                     store_fan_stop_time, 0),
1168         SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1169                     store_fan_stop_time, 1),
1170         SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1171                     store_fan_stop_time, 2),
1172         SENSOR_ATTR(pwm1_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1173                     store_fan_min_output, 0),
1174         SENSOR_ATTR(pwm2_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1175                     store_fan_min_output, 1),
1176         SENSOR_ATTR(pwm3_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1177                     store_fan_min_output, 2),
1178 };
1179
1180 static ssize_t
1181 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
1182 {
1183         struct w83627ehf_data *data = dev_get_drvdata(dev);
1184         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1185 }
1186 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
1187
1188 /*
1189  * Driver and device management
1190  */
1191
1192 static void w83627ehf_device_remove_files(struct device *dev)
1193 {
1194         /* some entries in the following arrays may not have been used in
1195          * device_create_file(), but device_remove_file() will ignore them */
1196         int i;
1197         struct w83627ehf_data *data = dev_get_drvdata(dev);
1198
1199         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1200                 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1201         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1202                 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1203         for (i = 0; i < data->in_num; i++) {
1204                 if ((i == 6) && data->in6_skip)
1205                         continue;
1206                 device_remove_file(dev, &sda_in_input[i].dev_attr);
1207                 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1208                 device_remove_file(dev, &sda_in_min[i].dev_attr);
1209                 device_remove_file(dev, &sda_in_max[i].dev_attr);
1210         }
1211         for (i = 0; i < 5; i++) {
1212                 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1213                 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1214                 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1215                 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1216         }
1217         for (i = 0; i < data->pwm_num; i++) {
1218                 device_remove_file(dev, &sda_pwm[i].dev_attr);
1219                 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1220                 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1221                 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1222                 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1223         }
1224         for (i = 0; i < 3; i++) {
1225                 if ((i == 2) && data->temp3_disable)
1226                         continue;
1227                 device_remove_file(dev, &sda_temp_input[i].dev_attr);
1228                 device_remove_file(dev, &sda_temp_max[i].dev_attr);
1229                 device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
1230                 device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
1231                 device_remove_file(dev, &sda_temp_type[i].dev_attr);
1232         }
1233
1234         device_remove_file(dev, &dev_attr_name);
1235         device_remove_file(dev, &dev_attr_cpu0_vid);
1236 }
1237
1238 /* Get the monitoring functions started */
1239 static inline void __devinit w83627ehf_init_device(struct w83627ehf_data *data)
1240 {
1241         int i;
1242         u8 tmp, diode;
1243
1244         /* Start monitoring is needed */
1245         tmp = w83627ehf_read_value(data, W83627EHF_REG_CONFIG);
1246         if (!(tmp & 0x01))
1247                 w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
1248                                       tmp | 0x01);
1249
1250         /* Enable temp2 and temp3 if needed */
1251         for (i = 0; i < 2; i++) {
1252                 tmp = w83627ehf_read_value(data,
1253                                            W83627EHF_REG_TEMP_CONFIG[i]);
1254                 if ((i == 1) && data->temp3_disable)
1255                         continue;
1256                 if (tmp & 0x01)
1257                         w83627ehf_write_value(data,
1258                                               W83627EHF_REG_TEMP_CONFIG[i],
1259                                               tmp & 0xfe);
1260         }
1261
1262         /* Enable VBAT monitoring if needed */
1263         tmp = w83627ehf_read_value(data, W83627EHF_REG_VBAT);
1264         if (!(tmp & 0x01))
1265                 w83627ehf_write_value(data, W83627EHF_REG_VBAT, tmp | 0x01);
1266
1267         /* Get thermal sensor types */
1268         diode = w83627ehf_read_value(data, W83627EHF_REG_DIODE);
1269         for (i = 0; i < 3; i++) {
1270                 if ((tmp & (0x02 << i)))
1271                         data->temp_type[i] = (diode & (0x10 << i)) ? 1 : 2;
1272                 else
1273                         data->temp_type[i] = 4; /* thermistor */
1274         }
1275 }
1276
1277 static int __devinit w83627ehf_probe(struct platform_device *pdev)
1278 {
1279         struct device *dev = &pdev->dev;
1280         struct w83627ehf_sio_data *sio_data = dev->platform_data;
1281         struct w83627ehf_data *data;
1282         struct resource *res;
1283         u8 fan4pin, fan5pin, en_vrm10;
1284         int i, err = 0;
1285
1286         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1287         if (!request_region(res->start, IOREGION_LENGTH, DRVNAME)) {
1288                 err = -EBUSY;
1289                 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1290                         (unsigned long)res->start,
1291                         (unsigned long)res->start + IOREGION_LENGTH - 1);
1292                 goto exit;
1293         }
1294
1295         if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
1296                 err = -ENOMEM;
1297                 goto exit_release;
1298         }
1299
1300         data->addr = res->start;
1301         mutex_init(&data->lock);
1302         mutex_init(&data->update_lock);
1303         data->name = w83627ehf_device_names[sio_data->kind];
1304         platform_set_drvdata(pdev, data);
1305
1306         /* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
1307         data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
1308         /* 667HG has 3 pwms */
1309         data->pwm_num = (sio_data->kind == w83667hg) ? 3 : 4;
1310
1311         /* Check temp3 configuration bit for 667HG */
1312         if (sio_data->kind == w83667hg) {
1313                 data->temp3_disable = w83627ehf_read_value(data,
1314                                         W83627EHF_REG_TEMP_CONFIG[1]) & 0x01;
1315                 data->in6_skip = !data->temp3_disable;
1316         }
1317
1318         /* Initialize the chip */
1319         w83627ehf_init_device(data);
1320
1321         data->vrm = vid_which_vrm();
1322         superio_enter(sio_data->sioreg);
1323         /* Read VID value */
1324         if (sio_data->kind == w83667hg) {
1325                 /* W83667HG has different pins for VID input and output, so
1326                 we can get the VID input values directly at logical device D
1327                 0xe3. */
1328                 superio_select(sio_data->sioreg, W83667HG_LD_VID);
1329                 data->vid = superio_inb(sio_data->sioreg, 0xe3);
1330                 err = device_create_file(dev, &dev_attr_cpu0_vid);
1331                 if (err)
1332                         goto exit_release;
1333         } else {
1334                 superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
1335                 if (superio_inb(sio_data->sioreg, SIO_REG_VID_CTRL) & 0x80) {
1336                         /* Set VID input sensibility if needed. In theory the
1337                            BIOS should have set it, but in practice it's not
1338                            always the case. We only do it for the W83627EHF/EHG
1339                            because the W83627DHG is more complex in this
1340                            respect. */
1341                         if (sio_data->kind == w83627ehf) {
1342                                 en_vrm10 = superio_inb(sio_data->sioreg,
1343                                                        SIO_REG_EN_VRM10);
1344                                 if ((en_vrm10 & 0x08) && data->vrm == 90) {
1345                                         dev_warn(dev, "Setting VID input "
1346                                                  "voltage to TTL\n");
1347                                         superio_outb(sio_data->sioreg,
1348                                                      SIO_REG_EN_VRM10,
1349                                                      en_vrm10 & ~0x08);
1350                                 } else if (!(en_vrm10 & 0x08)
1351                                            && data->vrm == 100) {
1352                                         dev_warn(dev, "Setting VID input "
1353                                                  "voltage to VRM10\n");
1354                                         superio_outb(sio_data->sioreg,
1355                                                      SIO_REG_EN_VRM10,
1356                                                      en_vrm10 | 0x08);
1357                                 }
1358                         }
1359
1360                         data->vid = superio_inb(sio_data->sioreg,
1361                                                 SIO_REG_VID_DATA);
1362                         if (sio_data->kind == w83627ehf) /* 6 VID pins only */
1363                                 data->vid &= 0x3f;
1364
1365                         err = device_create_file(dev, &dev_attr_cpu0_vid);
1366                         if (err)
1367                                 goto exit_release;
1368                 } else {
1369                         dev_info(dev, "VID pins in output mode, CPU VID not "
1370                                  "available\n");
1371                 }
1372         }
1373
1374         /* fan4 and fan5 share some pins with the GPIO and serial flash */
1375         if (sio_data->kind == w83667hg) {
1376                 fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
1377                 fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
1378         } else {
1379                 fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02);
1380                 fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
1381         }
1382         superio_exit(sio_data->sioreg);
1383
1384         /* It looks like fan4 and fan5 pins can be alternatively used
1385            as fan on/off switches, but fan5 control is write only :/
1386            We assume that if the serial interface is disabled, designers
1387            connected fan5 as input unless they are emitting log 1, which
1388            is not the default. */
1389
1390         data->has_fan = 0x07; /* fan1, fan2 and fan3 */
1391         i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
1392         if ((i & (1 << 2)) && fan4pin)
1393                 data->has_fan |= (1 << 3);
1394         if (!(i & (1 << 1)) && fan5pin)
1395                 data->has_fan |= (1 << 4);
1396
1397         /* Read fan clock dividers immediately */
1398         w83627ehf_update_fan_div(data);
1399
1400         /* Register sysfs hooks */
1401         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1402                 if ((err = device_create_file(dev,
1403                         &sda_sf3_arrays[i].dev_attr)))
1404                         goto exit_remove;
1405
1406         /* if fan4 is enabled create the sf3 files for it */
1407         if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
1408                 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
1409                         if ((err = device_create_file(dev,
1410                                 &sda_sf3_arrays_fan4[i].dev_attr)))
1411                                 goto exit_remove;
1412                 }
1413
1414         for (i = 0; i < data->in_num; i++) {
1415                 if ((i == 6) && data->in6_skip)
1416                         continue;
1417                 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
1418                         || (err = device_create_file(dev,
1419                                 &sda_in_alarm[i].dev_attr))
1420                         || (err = device_create_file(dev,
1421                                 &sda_in_min[i].dev_attr))
1422                         || (err = device_create_file(dev,
1423                                 &sda_in_max[i].dev_attr)))
1424                         goto exit_remove;
1425         }
1426
1427         for (i = 0; i < 5; i++) {
1428                 if (data->has_fan & (1 << i)) {
1429                         if ((err = device_create_file(dev,
1430                                         &sda_fan_input[i].dev_attr))
1431                                 || (err = device_create_file(dev,
1432                                         &sda_fan_alarm[i].dev_attr))
1433                                 || (err = device_create_file(dev,
1434                                         &sda_fan_div[i].dev_attr))
1435                                 || (err = device_create_file(dev,
1436                                         &sda_fan_min[i].dev_attr)))
1437                                 goto exit_remove;
1438                         if (i < data->pwm_num &&
1439                                 ((err = device_create_file(dev,
1440                                         &sda_pwm[i].dev_attr))
1441                                 || (err = device_create_file(dev,
1442                                         &sda_pwm_mode[i].dev_attr))
1443                                 || (err = device_create_file(dev,
1444                                         &sda_pwm_enable[i].dev_attr))
1445                                 || (err = device_create_file(dev,
1446                                         &sda_target_temp[i].dev_attr))
1447                                 || (err = device_create_file(dev,
1448                                         &sda_tolerance[i].dev_attr))))
1449                                 goto exit_remove;
1450                 }
1451         }
1452
1453         for (i = 0; i < 3; i++) {
1454                 if ((i == 2) && data->temp3_disable)
1455                         continue;
1456                 if ((err = device_create_file(dev,
1457                                 &sda_temp_input[i].dev_attr))
1458                         || (err = device_create_file(dev,
1459                                 &sda_temp_max[i].dev_attr))
1460                         || (err = device_create_file(dev,
1461                                 &sda_temp_max_hyst[i].dev_attr))
1462                         || (err = device_create_file(dev,
1463                                 &sda_temp_alarm[i].dev_attr))
1464                         || (err = device_create_file(dev,
1465                                 &sda_temp_type[i].dev_attr)))
1466                         goto exit_remove;
1467         }
1468
1469         err = device_create_file(dev, &dev_attr_name);
1470         if (err)
1471                 goto exit_remove;
1472
1473         data->hwmon_dev = hwmon_device_register(dev);
1474         if (IS_ERR(data->hwmon_dev)) {
1475                 err = PTR_ERR(data->hwmon_dev);
1476                 goto exit_remove;
1477         }
1478
1479         return 0;
1480
1481 exit_remove:
1482         w83627ehf_device_remove_files(dev);
1483         kfree(data);
1484         platform_set_drvdata(pdev, NULL);
1485 exit_release:
1486         release_region(res->start, IOREGION_LENGTH);
1487 exit:
1488         return err;
1489 }
1490
1491 static int __devexit w83627ehf_remove(struct platform_device *pdev)
1492 {
1493         struct w83627ehf_data *data = platform_get_drvdata(pdev);
1494
1495         hwmon_device_unregister(data->hwmon_dev);
1496         w83627ehf_device_remove_files(&pdev->dev);
1497         release_region(data->addr, IOREGION_LENGTH);
1498         platform_set_drvdata(pdev, NULL);
1499         kfree(data);
1500
1501         return 0;
1502 }
1503
1504 static struct platform_driver w83627ehf_driver = {
1505         .driver = {
1506                 .owner  = THIS_MODULE,
1507                 .name   = DRVNAME,
1508         },
1509         .probe          = w83627ehf_probe,
1510         .remove         = __devexit_p(w83627ehf_remove),
1511 };
1512
1513 /* w83627ehf_find() looks for a '627 in the Super-I/O config space */
1514 static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
1515                                  struct w83627ehf_sio_data *sio_data)
1516 {
1517         static const char __initdata sio_name_W83627EHF[] = "W83627EHF";
1518         static const char __initdata sio_name_W83627EHG[] = "W83627EHG";
1519         static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
1520         static const char __initdata sio_name_W83667HG[] = "W83667HG";
1521
1522         u16 val;
1523         const char *sio_name;
1524
1525         superio_enter(sioaddr);
1526
1527         if (force_id)
1528                 val = force_id;
1529         else
1530                 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
1531                     | superio_inb(sioaddr, SIO_REG_DEVID + 1);
1532         switch (val & SIO_ID_MASK) {
1533         case SIO_W83627EHF_ID:
1534                 sio_data->kind = w83627ehf;
1535                 sio_name = sio_name_W83627EHF;
1536                 break;
1537         case SIO_W83627EHG_ID:
1538                 sio_data->kind = w83627ehf;
1539                 sio_name = sio_name_W83627EHG;
1540                 break;
1541         case SIO_W83627DHG_ID:
1542                 sio_data->kind = w83627dhg;
1543                 sio_name = sio_name_W83627DHG;
1544                 break;
1545         case SIO_W83667HG_ID:
1546                 sio_data->kind = w83667hg;
1547                 sio_name = sio_name_W83667HG;
1548                 break;
1549         default:
1550                 if (val != 0xffff)
1551                         pr_debug(DRVNAME ": unsupported chip ID: 0x%04x\n",
1552                                  val);
1553                 superio_exit(sioaddr);
1554                 return -ENODEV;
1555         }
1556
1557         /* We have a known chip, find the HWM I/O address */
1558         superio_select(sioaddr, W83627EHF_LD_HWM);
1559         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
1560             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
1561         *addr = val & IOREGION_ALIGNMENT;
1562         if (*addr == 0) {
1563                 printk(KERN_ERR DRVNAME ": Refusing to enable a Super-I/O "
1564                        "device with a base I/O port 0.\n");
1565                 superio_exit(sioaddr);
1566                 return -ENODEV;
1567         }
1568
1569         /* Activate logical device if needed */
1570         val = superio_inb(sioaddr, SIO_REG_ENABLE);
1571         if (!(val & 0x01)) {
1572                 printk(KERN_WARNING DRVNAME ": Forcibly enabling Super-I/O. "
1573                        "Sensor is probably unusable.\n");
1574                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
1575         }
1576
1577         superio_exit(sioaddr);
1578         pr_info(DRVNAME ": Found %s chip at %#x\n", sio_name, *addr);
1579         sio_data->sioreg = sioaddr;
1580
1581         return 0;
1582 }
1583
1584 /* when Super-I/O functions move to a separate file, the Super-I/O
1585  * bus will manage the lifetime of the device and this module will only keep
1586  * track of the w83627ehf driver. But since we platform_device_alloc(), we
1587  * must keep track of the device */
1588 static struct platform_device *pdev;
1589
1590 static int __init sensors_w83627ehf_init(void)
1591 {
1592         int err;
1593         unsigned short address;
1594         struct resource res;
1595         struct w83627ehf_sio_data sio_data;
1596
1597         /* initialize sio_data->kind and sio_data->sioreg.
1598          *
1599          * when Super-I/O functions move to a separate file, the Super-I/O
1600          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
1601          * w83627ehf hardware monitor, and call probe() */
1602         if (w83627ehf_find(0x2e, &address, &sio_data) &&
1603             w83627ehf_find(0x4e, &address, &sio_data))
1604                 return -ENODEV;
1605
1606         err = platform_driver_register(&w83627ehf_driver);
1607         if (err)
1608                 goto exit;
1609
1610         if (!(pdev = platform_device_alloc(DRVNAME, address))) {
1611                 err = -ENOMEM;
1612                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1613                 goto exit_unregister;
1614         }
1615
1616         err = platform_device_add_data(pdev, &sio_data,
1617                                        sizeof(struct w83627ehf_sio_data));
1618         if (err) {
1619                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1620                 goto exit_device_put;
1621         }
1622
1623         memset(&res, 0, sizeof(res));
1624         res.name = DRVNAME;
1625         res.start = address + IOREGION_OFFSET;
1626         res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
1627         res.flags = IORESOURCE_IO;
1628
1629         err = acpi_check_resource_conflict(&res);
1630         if (err)
1631                 goto exit_device_put;
1632
1633         err = platform_device_add_resources(pdev, &res, 1);
1634         if (err) {
1635                 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1636                        "(%d)\n", err);
1637                 goto exit_device_put;
1638         }
1639
1640         /* platform_device_add calls probe() */
1641         err = platform_device_add(pdev);
1642         if (err) {
1643                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1644                        err);
1645                 goto exit_device_put;
1646         }
1647
1648         return 0;
1649
1650 exit_device_put:
1651         platform_device_put(pdev);
1652 exit_unregister:
1653         platform_driver_unregister(&w83627ehf_driver);
1654 exit:
1655         return err;
1656 }
1657
1658 static void __exit sensors_w83627ehf_exit(void)
1659 {
1660         platform_device_unregister(pdev);
1661         platform_driver_unregister(&w83627ehf_driver);
1662 }
1663
1664 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1665 MODULE_DESCRIPTION("W83627EHF driver");
1666 MODULE_LICENSE("GPL");
1667
1668 module_init(sensors_w83627ehf_init);
1669 module_exit(sensors_w83627ehf_exit);