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