drivers/hwmon/w83627hf.c

   1 /*
   2     w83627hf.c - Part of lm_sensors, Linux kernel modules for hardware
   3                 monitoring
   4     Copyright (c) 1998 - 2003  Frodo Looijaard <frodol@dds.nl>,
   5     Philip Edelbrock <phil@netroedge.com>,
   6     and Mark Studebaker <mdsxyz123@yahoo.com>
   7     Ported to 2.6 by Bernhard C. Schrenk <clemy@clemy.org>
   8     Copyright (c) 2007  Jean Delvare <khali@linux-fr.org>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 /*
  26     Supports following chips:
  27
  28     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  29     w83627hf    9       3       2       3       0x20    0x5ca3  no      yes(LPC)
  30     w83627thf   7       3       3       3       0x90    0x5ca3  no      yes(LPC)
  31     w83637hf    7       3       3       3       0x80    0x5ca3  no      yes(LPC)
  32     w83687thf   7       3       3       3       0x90    0x5ca3  no      yes(LPC)
  33     w83697hf    8       2       2       2       0x60    0x5ca3  no      yes(LPC)
  34
  35     For other winbond chips, and for i2c support in the above chips,
  36     use w83781d.c.
  37
  38     Note: automatic ("cruise") fan control for 697, 637 & 627thf not
  39     supported yet.
  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-vid.h>
  49 #include <linux/err.h>
  50 #include <linux/mutex.h>
  51 #include <linux/ioport.h>
  52 #include <asm/io.h>
  53 #include "lm75.h"
  54
  55 static struct platform_device *pdev;
  56
  57 #define DRVNAME "w83627hf"
  58 enum chips { w83627hf, w83627thf, w83697hf, w83637hf, w83687thf };
  59
  60 static u16 force_addr;
  61 module_param(force_addr, ushort, 0);
  62 MODULE_PARM_DESC(force_addr,
  63                  "Initialize the base address of the sensors");
  64 static u8 force_i2c = 0x1f;
  65 module_param(force_i2c, byte, 0);
  66 MODULE_PARM_DESC(force_i2c,
  67                  "Initialize the i2c address of the sensors");
  68
  69 static int reset;
  70 module_param(reset, bool, 0);
  71 MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
  72
  73 static int init = 1;
  74 module_param(init, bool, 0);
  75 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
  76
  77 /* modified from kernel/include/traps.c */
  78 static int REG;         /* The register to read/write */
  79 #define DEV     0x07    /* Register: Logical device select */
  80 static int VAL;         /* The value to read/write */
  81
  82 /* logical device numbers for superio_select (below) */
  83 #define W83627HF_LD_FDC         0x00
  84 #define W83627HF_LD_PRT         0x01
  85 #define W83627HF_LD_UART1       0x02
  86 #define W83627HF_LD_UART2       0x03
  87 #define W83627HF_LD_KBC         0x05
  88 #define W83627HF_LD_CIR         0x06 /* w83627hf only */
  89 #define W83627HF_LD_GAME        0x07
  90 #define W83627HF_LD_MIDI        0x07
  91 #define W83627HF_LD_GPIO1       0x07
  92 #define W83627HF_LD_GPIO5       0x07 /* w83627thf only */
  93 #define W83627HF_LD_GPIO2       0x08
  94 #define W83627HF_LD_GPIO3       0x09
  95 #define W83627HF_LD_GPIO4       0x09 /* w83627thf only */
  96 #define W83627HF_LD_ACPI        0x0a
  97 #define W83627HF_LD_HWM         0x0b
  98
  99 #define DEVID   0x20    /* Register: Device ID */
 100
 101 #define W83627THF_GPIO5_EN      0x30 /* w83627thf only */
 102 #define W83627THF_GPIO5_IOSR    0xf3 /* w83627thf only */
 103 #define W83627THF_GPIO5_DR      0xf4 /* w83627thf only */
 104
 105 #define W83687THF_VID_EN        0x29 /* w83687thf only */
 106 #define W83687THF_VID_CFG       0xF0 /* w83687thf only */
 107 #define W83687THF_VID_DATA      0xF1 /* w83687thf only */
 108
 109 static inline void
 110 superio_outb(int reg, int val)
 111 {
 112         outb(reg, REG);
 113         outb(val, VAL);
 114 }
 115
 116 static inline int
 117 superio_inb(int reg)
 118 {
 119         outb(reg, REG);
 120         return inb(VAL);
 121 }
 122
 123 static inline void
 124 superio_select(int ld)
 125 {
 126         outb(DEV, REG);
 127         outb(ld, VAL);
 128 }
 129
 130 static inline void
 131 superio_enter(void)
 132 {
 133         outb(0x87, REG);
 134         outb(0x87, REG);
 135 }
 136
 137 static inline void
 138 superio_exit(void)
 139 {
 140         outb(0xAA, REG);
 141 }
 142
 143 #define W627_DEVID 0x52
 144 #define W627THF_DEVID 0x82
 145 #define W697_DEVID 0x60
 146 #define W637_DEVID 0x70
 147 #define W687THF_DEVID 0x85
 148 #define WINB_ACT_REG 0x30
 149 #define WINB_BASE_REG 0x60
 150 /* Constants specified below */
 151
 152 /* Alignment of the base address */
 153 #define WINB_ALIGNMENT          ~7
 154
 155 /* Offset & size of I/O region we are interested in */
 156 #define WINB_REGION_OFFSET      5
 157 #define WINB_REGION_SIZE        2
 158
 159 /* Where are the sensors address/data registers relative to the region offset */
 160 #define W83781D_ADDR_REG_OFFSET 0
 161 #define W83781D_DATA_REG_OFFSET 1
 162
 163 /* The W83781D registers */
 164 /* The W83782D registers for nr=7,8 are in bank 5 */
 165 #define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
 166                                            (0x554 + (((nr) - 7) * 2)))
 167 #define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
 168                                            (0x555 + (((nr) - 7) * 2)))
 169 #define W83781D_REG_IN(nr)     ((nr < 7) ? (0x20 + (nr)) : \
 170                                            (0x550 + (nr) - 7))
 171
 172 #define W83781D_REG_FAN_MIN(nr) (0x3a + (nr))
 173 #define W83781D_REG_FAN(nr) (0x27 + (nr))
 174
 175 #define W83781D_REG_TEMP2_CONFIG 0x152
 176 #define W83781D_REG_TEMP3_CONFIG 0x252
 177 #define W83781D_REG_TEMP(nr)            ((nr == 3) ? (0x0250) : \
 178                                         ((nr == 2) ? (0x0150) : \
 179                                                      (0x27)))
 180 #define W83781D_REG_TEMP_HYST(nr)       ((nr == 3) ? (0x253) : \
 181                                         ((nr == 2) ? (0x153) : \
 182                                                      (0x3A)))
 183 #define W83781D_REG_TEMP_OVER(nr)       ((nr == 3) ? (0x255) : \
 184                                         ((nr == 2) ? (0x155) : \
 185                                                      (0x39)))
 186
 187 #define W83781D_REG_BANK 0x4E
 188
 189 #define W83781D_REG_CONFIG 0x40
 190 #define W83781D_REG_ALARM1 0x459
 191 #define W83781D_REG_ALARM2 0x45A
 192 #define W83781D_REG_ALARM3 0x45B
 193
 194 #define W83781D_REG_BEEP_CONFIG 0x4D
 195 #define W83781D_REG_BEEP_INTS1 0x56
 196 #define W83781D_REG_BEEP_INTS2 0x57
 197 #define W83781D_REG_BEEP_INTS3 0x453
 198
 199 #define W83781D_REG_VID_FANDIV 0x47
 200
 201 #define W83781D_REG_CHIPID 0x49
 202 #define W83781D_REG_WCHIPID 0x58
 203 #define W83781D_REG_CHIPMAN 0x4F
 204 #define W83781D_REG_PIN 0x4B
 205
 206 #define W83781D_REG_VBAT 0x5D
 207
 208 #define W83627HF_REG_PWM1 0x5A
 209 #define W83627HF_REG_PWM2 0x5B
 210
 211 #define W83627THF_REG_PWM1              0x01    /* 697HF/637HF/687THF too */
 212 #define W83627THF_REG_PWM2              0x03    /* 697HF/637HF/687THF too */
 213 #define W83627THF_REG_PWM3              0x11    /* 637HF/687THF too */
 214
 215 #define W83627THF_REG_VRM_OVT_CFG       0x18    /* 637HF/687THF too */
 216
 217 static const u8 regpwm_627hf[] = { W83627HF_REG_PWM1, W83627HF_REG_PWM2 };
 218 static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
 219                              W83627THF_REG_PWM3 };
 220 #define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
 221                                      regpwm_627hf[(nr) - 1] : regpwm[(nr) - 1])
 222
 223 #define W83627HF_REG_PWM_FREQ           0x5C    /* Only for the 627HF */
 224
 225 #define W83637HF_REG_PWM_FREQ1          0x00    /* 697HF/687THF too */
 226 #define W83637HF_REG_PWM_FREQ2          0x02    /* 697HF/687THF too */
 227 #define W83637HF_REG_PWM_FREQ3          0x10    /* 687THF too */
 228
 229 static const u8 W83637HF_REG_PWM_FREQ[] = { W83637HF_REG_PWM_FREQ1,
 230                                         W83637HF_REG_PWM_FREQ2,
 231                                         W83637HF_REG_PWM_FREQ3 };
 232
 233 #define W83627HF_BASE_PWM_FREQ  46870
 234
 235 #define W83781D_REG_I2C_ADDR 0x48
 236 #define W83781D_REG_I2C_SUBADDR 0x4A
 237
 238 /* Sensor selection */
 239 #define W83781D_REG_SCFG1 0x5D
 240 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
 241 #define W83781D_REG_SCFG2 0x59
 242 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
 243 #define W83781D_DEFAULT_BETA 3435
 244
 245 /* Conversions. Limit checking is only done on the TO_REG
 246    variants. Note that you should be a bit careful with which arguments
 247    these macros are called: arguments may be evaluated more than once.
 248    Fixing this is just not worth it. */
 249 #define IN_TO_REG(val)  (SENSORS_LIMIT((((val) + 8)/16),0,255))
 250 #define IN_FROM_REG(val) ((val) * 16)
 251
 252 static inline u8 FAN_TO_REG(long rpm, int div)
 253 {
 254         if (rpm == 0)
 255                 return 255;
 256         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 257         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
 258                              254);
 259 }
 260
 261 #define TEMP_MIN (-128000)
 262 #define TEMP_MAX ( 127000)
 263
 264 /* TEMP: 0.001C/bit (-128C to +127C)
 265    REG: 1C/bit, two's complement */
 266 static u8 TEMP_TO_REG(int temp)
 267 {
 268         int ntemp = SENSORS_LIMIT(temp, TEMP_MIN, TEMP_MAX);
 269         ntemp += (ntemp<0 ? -500 : 500);
 270         return (u8)(ntemp / 1000);
 271 }
 272
 273 static int TEMP_FROM_REG(u8 reg)
 274 {
 275         return (s8)reg * 1000;
 276 }
 277
 278 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
 279
 280 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
 281
 282 static inline unsigned long pwm_freq_from_reg_627hf(u8 reg)
 283 {
 284         unsigned long freq;
 285         freq = W83627HF_BASE_PWM_FREQ >> reg;
 286         return freq;
 287 }
 288 static inline u8 pwm_freq_to_reg_627hf(unsigned long val)
 289 {
 290         u8 i;
 291         /* Only 5 dividers (1 2 4 8 16)
 292            Search for the nearest available frequency */
 293         for (i = 0; i < 4; i++) {
 294                 if (val > (((W83627HF_BASE_PWM_FREQ >> i) +
 295                             (W83627HF_BASE_PWM_FREQ >> (i+1))) / 2))
 296                         break;
 297         }
 298         return i;
 299 }
 300
 301 static inline unsigned long pwm_freq_from_reg(u8 reg)
 302 {
 303         /* Clock bit 8 -> 180 kHz or 24 MHz */
 304         unsigned long clock = (reg & 0x80) ? 180000UL : 24000000UL;
 305
 306         reg &= 0x7f;
 307         /* This should not happen but anyway... */
 308         if (reg == 0)
 309                 reg++;
 310         return (clock / (reg << 8));
 311 }
 312 static inline u8 pwm_freq_to_reg(unsigned long val)
 313 {
 314         /* Minimum divider value is 0x01 and maximum is 0x7F */
 315         if (val >= 93750)       /* The highest we can do */
 316                 return 0x01;
 317         if (val >= 720) /* Use 24 MHz clock */
 318                 return (24000000UL / (val << 8));
 319         if (val < 6)            /* The lowest we can do */
 320                 return 0xFF;
 321         else                    /* Use 180 kHz clock */
 322                 return (0x80 | (180000UL / (val << 8)));
 323 }
 324
 325 #define BEEP_MASK_FROM_REG(val)          (val)
 326 #define BEEP_MASK_TO_REG(val)           ((val) & 0xffffff)
 327 #define BEEP_ENABLE_TO_REG(val)         ((val)?1:0)
 328 #define BEEP_ENABLE_FROM_REG(val)       ((val)?1:0)
 329
 330 #define DIV_FROM_REG(val) (1 << (val))
 331
 332 static inline u8 DIV_TO_REG(long val)
 333 {
 334         int i;
 335         val = SENSORS_LIMIT(val, 1, 128) >> 1;
 336         for (i = 0; i < 7; i++) {
 337                 if (val == 0)
 338                         break;
 339                 val >>= 1;
 340         }
 341         return ((u8) i);
 342 }
 343
 344 /* For each registered chip, we need to keep some data in memory.
 345    The structure is dynamically allocated. */
 346 struct w83627hf_data {
 347         unsigned short addr;
 348         const char *name;
 349         struct class_device *class_dev;
 350         struct mutex lock;
 351         enum chips type;
 352
 353         struct mutex update_lock;
 354         char valid;             /* !=0 if following fields are valid */
 355         unsigned long last_updated;     /* In jiffies */
 356
 357         u8 in[9];               /* Register value */
 358         u8 in_max[9];           /* Register value */
 359         u8 in_min[9];           /* Register value */
 360         u8 fan[3];              /* Register value */
 361         u8 fan_min[3];          /* Register value */
 362         u8 temp;
 363         u8 temp_max;            /* Register value */
 364         u8 temp_max_hyst;       /* Register value */
 365         u16 temp_add[2];        /* Register value */
 366         u16 temp_max_add[2];    /* Register value */
 367         u16 temp_max_hyst_add[2]; /* Register value */
 368         u8 fan_div[3];          /* Register encoding, shifted right */
 369         u8 vid;                 /* Register encoding, combined */
 370         u32 alarms;             /* Register encoding, combined */
 371         u32 beep_mask;          /* Register encoding, combined */
 372         u8 beep_enable;         /* Boolean */
 373         u8 pwm[3];              /* Register value */
 374         u8 pwm_freq[3];         /* Register value */
 375         u16 sens[3];            /* 782D/783S only.
 376                                    1 = pentium diode; 2 = 3904 diode;
 377                                    3000-5000 = thermistor beta.
 378                                    Default = 3435.
 379                                    Other Betas unimplemented */
 380         u8 vrm;
 381         u8 vrm_ovt;             /* Register value, 627THF/637HF/687THF only */
 382 };
 383
 384 struct w83627hf_sio_data {
 385         enum chips type;
 386 };
 387
 388
 389 static int w83627hf_probe(struct platform_device *pdev);
 390 static int w83627hf_remove(struct platform_device *pdev);
 391
 392 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg);
 393 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value);
 394 static struct w83627hf_data *w83627hf_update_device(struct device *dev);
 395 static void w83627hf_init_device(struct platform_device *pdev);
 396
 397 static struct platform_driver w83627hf_driver = {
 398         .driver = {
 399                 .owner  = THIS_MODULE,
 400                 .name   = DRVNAME,
 401         },
 402         .probe          = w83627hf_probe,
 403         .remove         = __devexit_p(w83627hf_remove),
 404 };
 405
 406 /* following are the sysfs callback functions */
 407 #define show_in_reg(reg) \
 408 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 409 { \
 410         struct w83627hf_data *data = w83627hf_update_device(dev); \
 411         return sprintf(buf,"%ld\n", (long)IN_FROM_REG(data->reg[nr])); \
 412 }
 413 show_in_reg(in)
 414 show_in_reg(in_min)
 415 show_in_reg(in_max)
 416
 417 #define store_in_reg(REG, reg) \
 418 static ssize_t \
 419 store_in_##reg (struct device *dev, const char *buf, size_t count, int nr) \
 420 { \
 421         struct w83627hf_data *data = dev_get_drvdata(dev); \
 422         u32 val; \
 423          \
 424         val = simple_strtoul(buf, NULL, 10); \
 425          \
 426         mutex_lock(&data->update_lock); \
 427         data->in_##reg[nr] = IN_TO_REG(val); \
 428         w83627hf_write_value(data, W83781D_REG_IN_##REG(nr), \
 429                             data->in_##reg[nr]); \
 430          \
 431         mutex_unlock(&data->update_lock); \
 432         return count; \
 433 }
 434 store_in_reg(MIN, min)
 435 store_in_reg(MAX, max)
 436
 437 #define sysfs_in_offset(offset) \
 438 static ssize_t \
 439 show_regs_in_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 440 { \
 441         return show_in(dev, buf, offset); \
 442 } \
 443 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_regs_in_##offset, NULL);
 444
 445 #define sysfs_in_reg_offset(reg, offset) \
 446 static ssize_t show_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 447 { \
 448         return show_in_##reg (dev, buf, offset); \
 449 } \
 450 static ssize_t \
 451 store_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, \
 452                             const char *buf, size_t count) \
 453 { \
 454         return store_in_##reg (dev, buf, count, offset); \
 455 } \
 456 static DEVICE_ATTR(in##offset##_##reg, S_IRUGO| S_IWUSR, \
 457                   show_regs_in_##reg##offset, store_regs_in_##reg##offset);
 458
 459 #define sysfs_in_offsets(offset) \
 460 sysfs_in_offset(offset) \
 461 sysfs_in_reg_offset(min, offset) \
 462 sysfs_in_reg_offset(max, offset)
 463
 464 sysfs_in_offsets(1);
 465 sysfs_in_offsets(2);
 466 sysfs_in_offsets(3);
 467 sysfs_in_offsets(4);
 468 sysfs_in_offsets(5);
 469 sysfs_in_offsets(6);
 470 sysfs_in_offsets(7);
 471 sysfs_in_offsets(8);
 472
 473 /* use a different set of functions for in0 */
 474 static ssize_t show_in_0(struct w83627hf_data *data, char *buf, u8 reg)
 475 {
 476         long in0;
 477
 478         if ((data->vrm_ovt & 0x01) &&
 479                 (w83627thf == data->type || w83637hf == data->type
 480                  || w83687thf == data->type))
 481
 482                 /* use VRM9 calculation */
 483                 in0 = (long)((reg * 488 + 70000 + 50) / 100);
 484         else
 485                 /* use VRM8 (standard) calculation */
 486                 in0 = (long)IN_FROM_REG(reg);
 487
 488         return sprintf(buf,"%ld\n", in0);
 489 }
 490
 491 static ssize_t show_regs_in_0(struct device *dev, struct device_attribute *attr, char *buf)
 492 {
 493         struct w83627hf_data *data = w83627hf_update_device(dev);
 494         return show_in_0(data, buf, data->in[0]);
 495 }
 496
 497 static ssize_t show_regs_in_min0(struct device *dev, struct device_attribute *attr, char *buf)
 498 {
 499         struct w83627hf_data *data = w83627hf_update_device(dev);
 500         return show_in_0(data, buf, data->in_min[0]);
 501 }
 502
 503 static ssize_t show_regs_in_max0(struct device *dev, struct device_attribute *attr, char *buf)
 504 {
 505         struct w83627hf_data *data = w83627hf_update_device(dev);
 506         return show_in_0(data, buf, data->in_max[0]);
 507 }
 508
 509 static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *attr,
 510         const char *buf, size_t count)
 511 {
 512         struct w83627hf_data *data = dev_get_drvdata(dev);
 513         u32 val;
 514
 515         val = simple_strtoul(buf, NULL, 10);
 516
 517         mutex_lock(&data->update_lock);
 518
 519         if ((data->vrm_ovt & 0x01) &&
 520                 (w83627thf == data->type || w83637hf == data->type
 521                  || w83687thf == data->type))
 522
 523                 /* use VRM9 calculation */
 524                 data->in_min[0] =
 525                         SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
 526                                         255);
 527         else
 528                 /* use VRM8 (standard) calculation */
 529                 data->in_min[0] = IN_TO_REG(val);
 530
 531         w83627hf_write_value(data, W83781D_REG_IN_MIN(0), data->in_min[0]);
 532         mutex_unlock(&data->update_lock);
 533         return count;
 534 }
 535
 536 static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *attr,
 537         const char *buf, size_t count)
 538 {
 539         struct w83627hf_data *data = dev_get_drvdata(dev);
 540         u32 val;
 541
 542         val = simple_strtoul(buf, NULL, 10);
 543
 544         mutex_lock(&data->update_lock);
 545
 546         if ((data->vrm_ovt & 0x01) &&
 547                 (w83627thf == data->type || w83637hf == data->type
 548                  || w83687thf == data->type))
 549
 550                 /* use VRM9 calculation */
 551                 data->in_max[0] =
 552                         SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
 553                                         255);
 554         else
 555                 /* use VRM8 (standard) calculation */
 556                 data->in_max[0] = IN_TO_REG(val);
 557
 558         w83627hf_write_value(data, W83781D_REG_IN_MAX(0), data->in_max[0]);
 559         mutex_unlock(&data->update_lock);
 560         return count;
 561 }
 562
 563 static DEVICE_ATTR(in0_input, S_IRUGO, show_regs_in_0, NULL);
 564 static DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
 565         show_regs_in_min0, store_regs_in_min0);
 566 static DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
 567         show_regs_in_max0, store_regs_in_max0);
 568
 569 #define show_fan_reg(reg) \
 570 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 571 { \
 572         struct w83627hf_data *data = w83627hf_update_device(dev); \
 573         return sprintf(buf,"%ld\n", \
 574                 FAN_FROM_REG(data->reg[nr-1], \
 575                             (long)DIV_FROM_REG(data->fan_div[nr-1]))); \
 576 }
 577 show_fan_reg(fan);
 578 show_fan_reg(fan_min);
 579
 580 static ssize_t
 581 store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
 582 {
 583         struct w83627hf_data *data = dev_get_drvdata(dev);
 584         u32 val;
 585
 586         val = simple_strtoul(buf, NULL, 10);
 587
 588         mutex_lock(&data->update_lock);
 589         data->fan_min[nr - 1] =
 590             FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr - 1]));
 591         w83627hf_write_value(data, W83781D_REG_FAN_MIN(nr),
 592                             data->fan_min[nr - 1]);
 593
 594         mutex_unlock(&data->update_lock);
 595         return count;
 596 }
 597
 598 #define sysfs_fan_offset(offset) \
 599 static ssize_t show_regs_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 600 { \
 601         return show_fan(dev, buf, offset); \
 602 } \
 603 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_regs_fan_##offset, NULL);
 604
 605 #define sysfs_fan_min_offset(offset) \
 606 static ssize_t show_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 607 { \
 608         return show_fan_min(dev, buf, offset); \
 609 } \
 610 static ssize_t \
 611 store_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
 612 { \
 613         return store_fan_min(dev, buf, count, offset); \
 614 } \
 615 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 616                   show_regs_fan_min##offset, store_regs_fan_min##offset);
 617
 618 sysfs_fan_offset(1);
 619 sysfs_fan_min_offset(1);
 620 sysfs_fan_offset(2);
 621 sysfs_fan_min_offset(2);
 622 sysfs_fan_offset(3);
 623 sysfs_fan_min_offset(3);
 624
 625 #define show_temp_reg(reg) \
 626 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 627 { \
 628         struct w83627hf_data *data = w83627hf_update_device(dev); \
 629         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 630                 return sprintf(buf,"%ld\n", \
 631                         (long)LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
 632         } else {        /* TEMP1 */ \
 633                 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
 634         } \
 635 }
 636 show_temp_reg(temp);
 637 show_temp_reg(temp_max);
 638 show_temp_reg(temp_max_hyst);
 639
 640 #define store_temp_reg(REG, reg) \
 641 static ssize_t \
 642 store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
 643 { \
 644         struct w83627hf_data *data = dev_get_drvdata(dev); \
 645         u32 val; \
 646          \
 647         val = simple_strtoul(buf, NULL, 10); \
 648          \
 649         mutex_lock(&data->update_lock); \
 650          \
 651         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 652                 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
 653                 w83627hf_write_value(data, W83781D_REG_TEMP_##REG(nr), \
 654                                 data->temp_##reg##_add[nr-2]); \
 655         } else {        /* TEMP1 */ \
 656                 data->temp_##reg = TEMP_TO_REG(val); \
 657                 w83627hf_write_value(data, W83781D_REG_TEMP_##REG(nr), \
 658                         data->temp_##reg); \
 659         } \
 660          \
 661         mutex_unlock(&data->update_lock); \
 662         return count; \
 663 }
 664 store_temp_reg(OVER, max);
 665 store_temp_reg(HYST, max_hyst);
 666
 667 #define sysfs_temp_offset(offset) \
 668 static ssize_t \
 669 show_regs_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 670 { \
 671         return show_temp(dev, buf, offset); \
 672 } \
 673 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_regs_temp_##offset, NULL);
 674
 675 #define sysfs_temp_reg_offset(reg, offset) \
 676 static ssize_t show_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 677 { \
 678         return show_temp_##reg (dev, buf, offset); \
 679 } \
 680 static ssize_t \
 681 store_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, \
 682                               const char *buf, size_t count) \
 683 { \
 684         return store_temp_##reg (dev, buf, count, offset); \
 685 } \
 686 static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, \
 687                   show_regs_temp_##reg##offset, store_regs_temp_##reg##offset);
 688
 689 #define sysfs_temp_offsets(offset) \
 690 sysfs_temp_offset(offset) \
 691 sysfs_temp_reg_offset(max, offset) \
 692 sysfs_temp_reg_offset(max_hyst, offset)
 693
 694 sysfs_temp_offsets(1);
 695 sysfs_temp_offsets(2);
 696 sysfs_temp_offsets(3);
 697
 698 static ssize_t
 699 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
 700 {
 701         struct w83627hf_data *data = w83627hf_update_device(dev);
 702         return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
 703 }
 704 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 705
 706 static ssize_t
 707 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
 708 {
 709         struct w83627hf_data *data = w83627hf_update_device(dev);
 710         return sprintf(buf, "%ld\n", (long) data->vrm);
 711 }
 712 static ssize_t
 713 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 714 {
 715         struct w83627hf_data *data = dev_get_drvdata(dev);
 716         u32 val;
 717
 718         val = simple_strtoul(buf, NULL, 10);
 719         data->vrm = val;
 720
 721         return count;
 722 }
 723 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 724
 725 static ssize_t
 726 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
 727 {
 728         struct w83627hf_data *data = w83627hf_update_device(dev);
 729         return sprintf(buf, "%ld\n", (long) data->alarms);
 730 }
 731 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 732
 733 #define show_beep_reg(REG, reg) \
 734 static ssize_t show_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
 735 { \
 736         struct w83627hf_data *data = w83627hf_update_device(dev); \
 737         return sprintf(buf,"%ld\n", \
 738                       (long)BEEP_##REG##_FROM_REG(data->beep_##reg)); \
 739 }
 740 show_beep_reg(ENABLE, enable)
 741 show_beep_reg(MASK, mask)
 742
 743 #define BEEP_ENABLE                     0       /* Store beep_enable */
 744 #define BEEP_MASK                       1       /* Store beep_mask */
 745
 746 static ssize_t
 747 store_beep_reg(struct device *dev, const char *buf, size_t count,
 748                int update_mask)
 749 {
 750         struct w83627hf_data *data = dev_get_drvdata(dev);
 751         u32 val, val2;
 752
 753         val = simple_strtoul(buf, NULL, 10);
 754
 755         mutex_lock(&data->update_lock);
 756
 757         if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
 758                 data->beep_mask = BEEP_MASK_TO_REG(val);
 759                 w83627hf_write_value(data, W83781D_REG_BEEP_INTS1,
 760                                     data->beep_mask & 0xff);
 761                 w83627hf_write_value(data, W83781D_REG_BEEP_INTS3,
 762                                     ((data->beep_mask) >> 16) & 0xff);
 763                 val2 = (data->beep_mask >> 8) & 0x7f;
 764         } else {                /* We are storing beep_enable */
 765                 val2 =
 766                     w83627hf_read_value(data, W83781D_REG_BEEP_INTS2) & 0x7f;
 767                 data->beep_enable = BEEP_ENABLE_TO_REG(val);
 768         }
 769
 770         w83627hf_write_value(data, W83781D_REG_BEEP_INTS2,
 771                             val2 | data->beep_enable << 7);
 772
 773         mutex_unlock(&data->update_lock);
 774         return count;
 775 }
 776
 777 #define sysfs_beep(REG, reg) \
 778 static ssize_t show_regs_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
 779 { \
 780         return show_beep_##reg(dev, attr, buf); \
 781 } \
 782 static ssize_t \
 783 store_regs_beep_##reg (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
 784 { \
 785         return store_beep_reg(dev, buf, count, BEEP_##REG); \
 786 } \
 787 static DEVICE_ATTR(beep_##reg, S_IRUGO | S_IWUSR, \
 788                   show_regs_beep_##reg, store_regs_beep_##reg);
 789
 790 sysfs_beep(ENABLE, enable);
 791 sysfs_beep(MASK, mask);
 792
 793 static ssize_t
 794 show_fan_div_reg(struct device *dev, char *buf, int nr)
 795 {
 796         struct w83627hf_data *data = w83627hf_update_device(dev);
 797         return sprintf(buf, "%ld\n",
 798                        (long) DIV_FROM_REG(data->fan_div[nr - 1]));
 799 }
 800
 801 /* Note: we save and restore the fan minimum here, because its value is
 802    determined in part by the fan divisor.  This follows the principle of
 803    least surprise; the user doesn't expect the fan minimum to change just
 804    because the divisor changed. */
 805 static ssize_t
 806 store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
 807 {
 808         struct w83627hf_data *data = dev_get_drvdata(dev);
 809         unsigned long min;
 810         u8 reg;
 811         unsigned long val = simple_strtoul(buf, NULL, 10);
 812
 813         mutex_lock(&data->update_lock);
 814
 815         /* Save fan_min */
 816         min = FAN_FROM_REG(data->fan_min[nr],
 817                            DIV_FROM_REG(data->fan_div[nr]));
 818
 819         data->fan_div[nr] = DIV_TO_REG(val);
 820
 821         reg = (w83627hf_read_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
 822                & (nr==0 ? 0xcf : 0x3f))
 823             | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
 824         w83627hf_write_value(data, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
 825
 826         reg = (w83627hf_read_value(data, W83781D_REG_VBAT)
 827                & ~(1 << (5 + nr)))
 828             | ((data->fan_div[nr] & 0x04) << (3 + nr));
 829         w83627hf_write_value(data, W83781D_REG_VBAT, reg);
 830
 831         /* Restore fan_min */
 832         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 833         w83627hf_write_value(data, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
 834
 835         mutex_unlock(&data->update_lock);
 836         return count;
 837 }
 838
 839 #define sysfs_fan_div(offset) \
 840 static ssize_t show_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 841 { \
 842         return show_fan_div_reg(dev, buf, offset); \
 843 } \
 844 static ssize_t \
 845 store_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, \
 846                             const char *buf, size_t count) \
 847 { \
 848         return store_fan_div_reg(dev, buf, count, offset - 1); \
 849 } \
 850 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
 851                   show_regs_fan_div_##offset, store_regs_fan_div_##offset);
 852
 853 sysfs_fan_div(1);
 854 sysfs_fan_div(2);
 855 sysfs_fan_div(3);
 856
 857 static ssize_t
 858 show_pwm_reg(struct device *dev, char *buf, int nr)
 859 {
 860         struct w83627hf_data *data = w83627hf_update_device(dev);
 861         return sprintf(buf, "%ld\n", (long) data->pwm[nr - 1]);
 862 }
 863
 864 static ssize_t
 865 store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
 866 {
 867         struct w83627hf_data *data = dev_get_drvdata(dev);
 868         u32 val;
 869
 870         val = simple_strtoul(buf, NULL, 10);
 871
 872         mutex_lock(&data->update_lock);
 873
 874         if (data->type == w83627thf) {
 875                 /* bits 0-3 are reserved  in 627THF */
 876                 data->pwm[nr - 1] = PWM_TO_REG(val) & 0xf0;
 877                 w83627hf_write_value(data,
 878                                      W836X7HF_REG_PWM(data->type, nr),
 879                                      data->pwm[nr - 1] |
 880                                      (w83627hf_read_value(data,
 881                                      W836X7HF_REG_PWM(data->type, nr)) & 0x0f));
 882         } else {
 883                 data->pwm[nr - 1] = PWM_TO_REG(val);
 884                 w83627hf_write_value(data,
 885                                      W836X7HF_REG_PWM(data->type, nr),
 886                                      data->pwm[nr - 1]);
 887         }
 888
 889         mutex_unlock(&data->update_lock);
 890         return count;
 891 }
 892
 893 #define sysfs_pwm(offset) \
 894 static ssize_t show_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 895 { \
 896         return show_pwm_reg(dev, buf, offset); \
 897 } \
 898 static ssize_t \
 899 store_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
 900 { \
 901         return store_pwm_reg(dev, buf, count, offset); \
 902 } \
 903 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
 904                   show_regs_pwm_##offset, store_regs_pwm_##offset);
 905
 906 sysfs_pwm(1);
 907 sysfs_pwm(2);
 908 sysfs_pwm(3);
 909
 910 static ssize_t
 911 show_pwm_freq_reg(struct device *dev, char *buf, int nr)
 912 {
 913         struct w83627hf_data *data = w83627hf_update_device(dev);
 914         if (data->type == w83627hf)
 915                 return sprintf(buf, "%ld\n",
 916                         pwm_freq_from_reg_627hf(data->pwm_freq[nr - 1]));
 917         else
 918                 return sprintf(buf, "%ld\n",
 919                         pwm_freq_from_reg(data->pwm_freq[nr - 1]));
 920 }
 921
 922 static ssize_t
 923 store_pwm_freq_reg(struct device *dev, const char *buf, size_t count, int nr)
 924 {
 925         struct w83627hf_data *data = dev_get_drvdata(dev);
 926         static const u8 mask[]={0xF8, 0x8F};
 927         u32 val;
 928
 929         val = simple_strtoul(buf, NULL, 10);
 930
 931         mutex_lock(&data->update_lock);
 932
 933         if (data->type == w83627hf) {
 934                 data->pwm_freq[nr - 1] = pwm_freq_to_reg_627hf(val);
 935                 w83627hf_write_value(data, W83627HF_REG_PWM_FREQ,
 936                                 (data->pwm_freq[nr - 1] << ((nr - 1)*4)) |
 937                                 (w83627hf_read_value(data,
 938                                 W83627HF_REG_PWM_FREQ) & mask[nr - 1]));
 939         } else {
 940                 data->pwm_freq[nr - 1] = pwm_freq_to_reg(val);
 941                 w83627hf_write_value(data, W83637HF_REG_PWM_FREQ[nr - 1],
 942                                 data->pwm_freq[nr - 1]);
 943         }
 944
 945         mutex_unlock(&data->update_lock);
 946         return count;
 947 }
 948
 949 #define sysfs_pwm_freq(offset) \
 950 static ssize_t show_regs_pwm_freq_##offset(struct device *dev, \
 951                 struct device_attribute *attr, char *buf) \
 952 { \
 953         return show_pwm_freq_reg(dev, buf, offset); \
 954 } \
 955 static ssize_t \
 956 store_regs_pwm_freq_##offset(struct device *dev, \
 957                 struct device_attribute *attr, const char *buf, size_t count) \
 958 { \
 959         return store_pwm_freq_reg(dev, buf, count, offset); \
 960 } \
 961 static DEVICE_ATTR(pwm##offset##_freq, S_IRUGO | S_IWUSR, \
 962                   show_regs_pwm_freq_##offset, store_regs_pwm_freq_##offset);
 963
 964 sysfs_pwm_freq(1);
 965 sysfs_pwm_freq(2);
 966 sysfs_pwm_freq(3);
 967
 968 static ssize_t
 969 show_sensor_reg(struct device *dev, char *buf, int nr)
 970 {
 971         struct w83627hf_data *data = w83627hf_update_device(dev);
 972         return sprintf(buf, "%ld\n", (long) data->sens[nr - 1]);
 973 }
 974
 975 static ssize_t
 976 store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
 977 {
 978         struct w83627hf_data *data = dev_get_drvdata(dev);
 979         u32 val, tmp;
 980
 981         val = simple_strtoul(buf, NULL, 10);
 982
 983         mutex_lock(&data->update_lock);
 984
 985         switch (val) {
 986         case 1:         /* PII/Celeron diode */
 987                 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
 988                 w83627hf_write_value(data, W83781D_REG_SCFG1,
 989                                     tmp | BIT_SCFG1[nr - 1]);
 990                 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
 991                 w83627hf_write_value(data, W83781D_REG_SCFG2,
 992                                     tmp | BIT_SCFG2[nr - 1]);
 993                 data->sens[nr - 1] = val;
 994                 break;
 995         case 2:         /* 3904 */
 996                 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
 997                 w83627hf_write_value(data, W83781D_REG_SCFG1,
 998                                     tmp | BIT_SCFG1[nr - 1]);
 999                 tmp = w83627hf_read_value(data, W83781D_REG_SCFG2);
1000                 w83627hf_write_value(data, W83781D_REG_SCFG2,
1001                                     tmp & ~BIT_SCFG2[nr - 1]);
1002                 data->sens[nr - 1] = val;
1003                 break;
1004         case W83781D_DEFAULT_BETA:      /* thermistor */
1005                 tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1006                 w83627hf_write_value(data, W83781D_REG_SCFG1,
1007                                     tmp & ~BIT_SCFG1[nr - 1]);
1008                 data->sens[nr - 1] = val;
1009                 break;
1010         default:
1011                 dev_err(dev,
1012                        "Invalid sensor type %ld; must be 1, 2, or %d\n",
1013                        (long) val, W83781D_DEFAULT_BETA);
1014                 break;
1015         }
1016
1017         mutex_unlock(&data->update_lock);
1018         return count;
1019 }
1020
1021 #define sysfs_sensor(offset) \
1022 static ssize_t show_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
1023 { \
1024     return show_sensor_reg(dev, buf, offset); \
1025 } \
1026 static ssize_t \
1027 store_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
1028 { \
1029     return store_sensor_reg(dev, buf, count, offset); \
1030 } \
1031 static DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
1032                   show_regs_sensor_##offset, store_regs_sensor_##offset);
1033
1034 sysfs_sensor(1);
1035 sysfs_sensor(2);
1036 sysfs_sensor(3);
1037
1038 static ssize_t show_name(struct device *dev, struct device_attribute
1039                          *devattr, char *buf)
1040 {
1041         struct w83627hf_data *data = dev_get_drvdata(dev);
1042
1043         return sprintf(buf, "%s\n", data->name);
1044 }
1045 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
1046
1047 static int __init w83627hf_find(int sioaddr, unsigned short *addr,
1048                                 struct w83627hf_sio_data *sio_data)
1049 {
1050         int err = -ENODEV;
1051         u16 val;
1052
1053         static const __initdata char *names[] = {
1054                 "W83627HF",
1055                 "W83627THF",
1056                 "W83697HF",
1057                 "W83637HF",
1058                 "W83687THF",
1059         };
1060
1061         REG = sioaddr;
1062         VAL = sioaddr + 1;
1063
1064         superio_enter();
1065         val= superio_inb(DEVID);
1066         switch (val) {
1067         case W627_DEVID:
1068                 sio_data->type = w83627hf;
1069                 break;
1070         case W627THF_DEVID:
1071                 sio_data->type = w83627thf;
1072                 break;
1073         case W697_DEVID:
1074                 sio_data->type = w83697hf;
1075                 break;
1076         case W637_DEVID:
1077                 sio_data->type = w83637hf;
1078                 break;
1079         case W687THF_DEVID:
1080                 sio_data->type = w83687thf;
1081                 break;
1082         case 0xff:      /* No device at all */
1083                 goto exit;
1084         default:
1085                 pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%02x)\n", val);
1086                 goto exit;
1087         }
1088
1089         superio_select(W83627HF_LD_HWM);
1090         force_addr &= WINB_ALIGNMENT;
1091         if (force_addr) {
1092                 printk(KERN_WARNING DRVNAME ": Forcing address 0x%x\n",
1093                        force_addr);
1094                 superio_outb(WINB_BASE_REG, force_addr >> 8);
1095                 superio_outb(WINB_BASE_REG + 1, force_addr & 0xff);
1096         }
1097         val = (superio_inb(WINB_BASE_REG) << 8) |
1098                superio_inb(WINB_BASE_REG + 1);
1099         *addr = val & WINB_ALIGNMENT;
1100         if (*addr == 0) {
1101                 printk(KERN_WARNING DRVNAME ": Base address not set, "
1102                        "skipping\n");
1103                 goto exit;
1104         }
1105
1106         val = superio_inb(WINB_ACT_REG);
1107         if (!(val & 0x01)) {
1108                 printk(KERN_WARNING DRVNAME ": Enabling HWM logical device\n");
1109                 superio_outb(WINB_ACT_REG, val | 0x01);
1110         }
1111
1112         err = 0;
1113         pr_info(DRVNAME ": Found %s chip at %#x\n",
1114                 names[sio_data->type], *addr);
1115
1116  exit:
1117         superio_exit();
1118         return err;
1119 }
1120
1121 static struct attribute *w83627hf_attributes[] = {
1122         &dev_attr_in0_input.attr,
1123         &dev_attr_in0_min.attr,
1124         &dev_attr_in0_max.attr,
1125         &dev_attr_in2_input.attr,
1126         &dev_attr_in2_min.attr,
1127         &dev_attr_in2_max.attr,
1128         &dev_attr_in3_input.attr,
1129         &dev_attr_in3_min.attr,
1130         &dev_attr_in3_max.attr,
1131         &dev_attr_in4_input.attr,
1132         &dev_attr_in4_min.attr,
1133         &dev_attr_in4_max.attr,
1134         &dev_attr_in7_input.attr,
1135         &dev_attr_in7_min.attr,
1136         &dev_attr_in7_max.attr,
1137         &dev_attr_in8_input.attr,
1138         &dev_attr_in8_min.attr,
1139         &dev_attr_in8_max.attr,
1140
1141         &dev_attr_fan1_input.attr,
1142         &dev_attr_fan1_min.attr,
1143         &dev_attr_fan1_div.attr,
1144         &dev_attr_fan2_input.attr,
1145         &dev_attr_fan2_min.attr,
1146         &dev_attr_fan2_div.attr,
1147
1148         &dev_attr_temp1_input.attr,
1149         &dev_attr_temp1_max.attr,
1150         &dev_attr_temp1_max_hyst.attr,
1151         &dev_attr_temp1_type.attr,
1152         &dev_attr_temp2_input.attr,
1153         &dev_attr_temp2_max.attr,
1154         &dev_attr_temp2_max_hyst.attr,
1155         &dev_attr_temp2_type.attr,
1156
1157         &dev_attr_alarms.attr,
1158         &dev_attr_beep_enable.attr,
1159         &dev_attr_beep_mask.attr,
1160
1161         &dev_attr_pwm1.attr,
1162         &dev_attr_pwm2.attr,
1163
1164         &dev_attr_name.attr,
1165         NULL
1166 };
1167
1168 static const struct attribute_group w83627hf_group = {
1169         .attrs = w83627hf_attributes,
1170 };
1171
1172 static struct attribute *w83627hf_attributes_opt[] = {
1173         &dev_attr_in1_input.attr,
1174         &dev_attr_in1_min.attr,
1175         &dev_attr_in1_max.attr,
1176         &dev_attr_in5_input.attr,
1177         &dev_attr_in5_min.attr,
1178         &dev_attr_in5_max.attr,
1179         &dev_attr_in6_input.attr,
1180         &dev_attr_in6_min.attr,
1181         &dev_attr_in6_max.attr,
1182
1183         &dev_attr_fan3_input.attr,
1184         &dev_attr_fan3_min.attr,
1185         &dev_attr_fan3_div.attr,
1186
1187         &dev_attr_temp3_input.attr,
1188         &dev_attr_temp3_max.attr,
1189         &dev_attr_temp3_max_hyst.attr,
1190         &dev_attr_temp3_type.attr,
1191
1192         &dev_attr_pwm3.attr,
1193
1194         &dev_attr_pwm1_freq.attr,
1195         &dev_attr_pwm2_freq.attr,
1196         &dev_attr_pwm3_freq.attr,
1197         NULL
1198 };
1199
1200 static const struct attribute_group w83627hf_group_opt = {
1201         .attrs = w83627hf_attributes_opt,
1202 };
1203
1204 static int __devinit w83627hf_probe(struct platform_device *pdev)
1205 {
1206         struct device *dev = &pdev->dev;
1207         struct w83627hf_sio_data *sio_data = dev->platform_data;
1208         struct w83627hf_data *data;
1209         struct resource *res;
1210         int err;
1211
1212         static const char *names[] = {
1213                 "w83627hf",
1214                 "w83627thf",
1215                 "w83697hf",
1216                 "w83637hf",
1217                 "w83687thf",
1218         };
1219
1220         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1221         if (!request_region(res->start, WINB_REGION_SIZE, DRVNAME)) {
1222                 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
1223                         (unsigned long)res->start,
1224                         (unsigned long)(res->start + WINB_REGION_SIZE - 1));
1225                 err = -EBUSY;
1226                 goto ERROR0;
1227         }
1228
1229         if (!(data = kzalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
1230                 err = -ENOMEM;
1231                 goto ERROR1;
1232         }
1233         data->addr = res->start;
1234         data->type = sio_data->type;
1235         data->name = names[sio_data->type];
1236         mutex_init(&data->lock);
1237         mutex_init(&data->update_lock);
1238         platform_set_drvdata(pdev, data);
1239
1240         /* Initialize the chip */
1241         w83627hf_init_device(pdev);
1242
1243         /* A few vars need to be filled upon startup */
1244         data->fan_min[0] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(1));
1245         data->fan_min[1] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(2));
1246         data->fan_min[2] = w83627hf_read_value(data, W83781D_REG_FAN_MIN(3));
1247
1248         /* Register common device attributes */
1249         if ((err = sysfs_create_group(&dev->kobj, &w83627hf_group)))
1250                 goto ERROR3;
1251
1252         /* Register chip-specific device attributes */
1253         if (data->type == w83627hf || data->type == w83697hf)
1254                 if ((err = device_create_file(dev, &dev_attr_in5_input))
1255                  || (err = device_create_file(dev, &dev_attr_in5_min))
1256                  || (err = device_create_file(dev, &dev_attr_in5_max))
1257                  || (err = device_create_file(dev, &dev_attr_in6_input))
1258                  || (err = device_create_file(dev, &dev_attr_in6_min))
1259                  || (err = device_create_file(dev, &dev_attr_in6_max))
1260                  || (err = device_create_file(dev, &dev_attr_pwm1_freq))
1261                  || (err = device_create_file(dev, &dev_attr_pwm2_freq)))
1262                         goto ERROR4;
1263
1264         if (data->type != w83697hf)
1265                 if ((err = device_create_file(dev, &dev_attr_in1_input))
1266                  || (err = device_create_file(dev, &dev_attr_in1_min))
1267                  || (err = device_create_file(dev, &dev_attr_in1_max))
1268                  || (err = device_create_file(dev, &dev_attr_fan3_input))
1269                  || (err = device_create_file(dev, &dev_attr_fan3_min))
1270                  || (err = device_create_file(dev, &dev_attr_fan3_div))
1271                  || (err = device_create_file(dev, &dev_attr_temp3_input))
1272                  || (err = device_create_file(dev, &dev_attr_temp3_max))
1273                  || (err = device_create_file(dev, &dev_attr_temp3_max_hyst))
1274                  || (err = device_create_file(dev, &dev_attr_temp3_type)))
1275                         goto ERROR4;
1276
1277         if (data->type != w83697hf && data->vid != 0xff) {
1278                 /* Convert VID to voltage based on VRM */
1279                 data->vrm = vid_which_vrm();
1280
1281                 if ((err = device_create_file(dev, &dev_attr_cpu0_vid))
1282                  || (err = device_create_file(dev, &dev_attr_vrm)))
1283                         goto ERROR4;
1284         }
1285
1286         if (data->type == w83627thf || data->type == w83637hf
1287          || data->type == w83687thf)
1288                 if ((err = device_create_file(dev, &dev_attr_pwm3)))
1289                         goto ERROR4;
1290
1291         if (data->type == w83637hf || data->type == w83687thf)
1292                 if ((err = device_create_file(dev, &dev_attr_pwm1_freq))
1293                  || (err = device_create_file(dev, &dev_attr_pwm2_freq))
1294                  || (err = device_create_file(dev, &dev_attr_pwm3_freq)))
1295                         goto ERROR4;
1296
1297         data->class_dev = hwmon_device_register(dev);
1298         if (IS_ERR(data->class_dev)) {
1299                 err = PTR_ERR(data->class_dev);
1300                 goto ERROR4;
1301         }
1302
1303         return 0;
1304
1305       ERROR4:
1306         sysfs_remove_group(&dev->kobj, &w83627hf_group);
1307         sysfs_remove_group(&dev->kobj, &w83627hf_group_opt);
1308       ERROR3:
1309         platform_set_drvdata(pdev, NULL);
1310         kfree(data);
1311       ERROR1:
1312         release_region(res->start, WINB_REGION_SIZE);
1313       ERROR0:
1314         return err;
1315 }
1316
1317 static int __devexit w83627hf_remove(struct platform_device *pdev)
1318 {
1319         struct w83627hf_data *data = platform_get_drvdata(pdev);
1320         struct resource *res;
1321
1322         hwmon_device_unregister(data->class_dev);
1323
1324         sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group);
1325         sysfs_remove_group(&pdev->dev.kobj, &w83627hf_group_opt);
1326         platform_set_drvdata(pdev, NULL);
1327         kfree(data);
1328
1329         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1330         release_region(res->start, WINB_REGION_SIZE);
1331
1332         return 0;
1333 }
1334
1335
1336 static int w83627hf_read_value(struct w83627hf_data *data, u16 reg)
1337 {
1338         int res, word_sized;
1339
1340         mutex_lock(&data->lock);
1341         word_sized = (((reg & 0xff00) == 0x100)
1342                    || ((reg & 0xff00) == 0x200))
1343                   && (((reg & 0x00ff) == 0x50)
1344                    || ((reg & 0x00ff) == 0x53)
1345                    || ((reg & 0x00ff) == 0x55));
1346         if (reg & 0xff00) {
1347                 outb_p(W83781D_REG_BANK,
1348                        data->addr + W83781D_ADDR_REG_OFFSET);
1349                 outb_p(reg >> 8,
1350                        data->addr + W83781D_DATA_REG_OFFSET);
1351         }
1352         outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1353         res = inb_p(data->addr + W83781D_DATA_REG_OFFSET);
1354         if (word_sized) {
1355                 outb_p((reg & 0xff) + 1,
1356                        data->addr + W83781D_ADDR_REG_OFFSET);
1357                 res =
1358                     (res << 8) + inb_p(data->addr +
1359                                        W83781D_DATA_REG_OFFSET);
1360         }
1361         if (reg & 0xff00) {
1362                 outb_p(W83781D_REG_BANK,
1363                        data->addr + W83781D_ADDR_REG_OFFSET);
1364                 outb_p(0, data->addr + W83781D_DATA_REG_OFFSET);
1365         }
1366         mutex_unlock(&data->lock);
1367         return res;
1368 }
1369
1370 static int __devinit w83627thf_read_gpio5(struct platform_device *pdev)
1371 {
1372         int res = 0xff, sel;
1373
1374         superio_enter();
1375         superio_select(W83627HF_LD_GPIO5);
1376
1377         /* Make sure these GPIO pins are enabled */
1378         if (!(superio_inb(W83627THF_GPIO5_EN) & (1<<3))) {
1379                 dev_dbg(&pdev->dev, "GPIO5 disabled, no VID function\n");
1380                 goto exit;
1381         }
1382
1383         /* Make sure the pins are configured for input
1384            There must be at least five (VRM 9), and possibly 6 (VRM 10) */
1385         sel = superio_inb(W83627THF_GPIO5_IOSR) & 0x3f;
1386         if ((sel & 0x1f) != 0x1f) {
1387                 dev_dbg(&pdev->dev, "GPIO5 not configured for VID "
1388                         "function\n");
1389                 goto exit;
1390         }
1391
1392         dev_info(&pdev->dev, "Reading VID from GPIO5\n");
1393         res = superio_inb(W83627THF_GPIO5_DR) & sel;
1394
1395 exit:
1396         superio_exit();
1397         return res;
1398 }
1399
1400 static int __devinit w83687thf_read_vid(struct platform_device *pdev)
1401 {
1402         int res = 0xff;
1403
1404         superio_enter();
1405         superio_select(W83627HF_LD_HWM);
1406
1407         /* Make sure these GPIO pins are enabled */
1408         if (!(superio_inb(W83687THF_VID_EN) & (1 << 2))) {
1409                 dev_dbg(&pdev->dev, "VID disabled, no VID function\n");
1410                 goto exit;
1411         }
1412
1413         /* Make sure the pins are configured for input */
1414         if (!(superio_inb(W83687THF_VID_CFG) & (1 << 4))) {
1415                 dev_dbg(&pdev->dev, "VID configured as output, "
1416                         "no VID function\n");
1417                 goto exit;
1418         }
1419
1420         res = superio_inb(W83687THF_VID_DATA) & 0x3f;
1421
1422 exit:
1423         superio_exit();
1424         return res;
1425 }
1426
1427 static int w83627hf_write_value(struct w83627hf_data *data, u16 reg, u16 value)
1428 {
1429         int word_sized;
1430
1431         mutex_lock(&data->lock);
1432         word_sized = (((reg & 0xff00) == 0x100)
1433                    || ((reg & 0xff00) == 0x200))
1434                   && (((reg & 0x00ff) == 0x53)
1435                    || ((reg & 0x00ff) == 0x55));
1436         if (reg & 0xff00) {
1437                 outb_p(W83781D_REG_BANK,
1438                        data->addr + W83781D_ADDR_REG_OFFSET);
1439                 outb_p(reg >> 8,
1440                        data->addr + W83781D_DATA_REG_OFFSET);
1441         }
1442         outb_p(reg & 0xff, data->addr + W83781D_ADDR_REG_OFFSET);
1443         if (word_sized) {
1444                 outb_p(value >> 8,
1445                        data->addr + W83781D_DATA_REG_OFFSET);
1446                 outb_p((reg & 0xff) + 1,
1447                        data->addr + W83781D_ADDR_REG_OFFSET);
1448         }
1449         outb_p(value & 0xff,
1450                data->addr + W83781D_DATA_REG_OFFSET);
1451         if (reg & 0xff00) {
1452                 outb_p(W83781D_REG_BANK,
1453                        data->addr + W83781D_ADDR_REG_OFFSET);
1454                 outb_p(0, data->addr + W83781D_DATA_REG_OFFSET);
1455         }
1456         mutex_unlock(&data->lock);
1457         return 0;
1458 }
1459
1460 static void __devinit w83627hf_init_device(struct platform_device *pdev)
1461 {
1462         struct w83627hf_data *data = platform_get_drvdata(pdev);
1463         int i;
1464         enum chips type = data->type;
1465         u8 tmp;
1466
1467         if (reset) {
1468                 /* Resetting the chip has been the default for a long time,
1469                    but repeatedly caused problems (fans going to full
1470                    speed...) so it is now optional. It might even go away if
1471                    nobody reports it as being useful, as I see very little
1472                    reason why this would be needed at all. */
1473                 dev_info(&pdev->dev, "If reset=1 solved a problem you were "
1474                          "having, please report!\n");
1475
1476                 /* save this register */
1477                 i = w83627hf_read_value(data, W83781D_REG_BEEP_CONFIG);
1478                 /* Reset all except Watchdog values and last conversion values
1479                    This sets fan-divs to 2, among others */
1480                 w83627hf_write_value(data, W83781D_REG_CONFIG, 0x80);
1481                 /* Restore the register and disable power-on abnormal beep.
1482                    This saves FAN 1/2/3 input/output values set by BIOS. */
1483                 w83627hf_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
1484                 /* Disable master beep-enable (reset turns it on).
1485                    Individual beeps should be reset to off but for some reason
1486                    disabling this bit helps some people not get beeped */
1487                 w83627hf_write_value(data, W83781D_REG_BEEP_INTS2, 0);
1488         }
1489
1490         /* Minimize conflicts with other winbond i2c-only clients...  */
1491         /* disable i2c subclients... how to disable main i2c client?? */
1492         /* force i2c address to relatively uncommon address */
1493         w83627hf_write_value(data, W83781D_REG_I2C_SUBADDR, 0x89);
1494         w83627hf_write_value(data, W83781D_REG_I2C_ADDR, force_i2c);
1495
1496         /* Read VID only once */
1497         if (type == w83627hf || type == w83637hf) {
1498                 int lo = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1499                 int hi = w83627hf_read_value(data, W83781D_REG_CHIPID);
1500                 data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
1501         } else if (type == w83627thf) {
1502                 data->vid = w83627thf_read_gpio5(pdev);
1503         } else if (type == w83687thf) {
1504                 data->vid = w83687thf_read_vid(pdev);
1505         }
1506
1507         /* Read VRM & OVT Config only once */
1508         if (type == w83627thf || type == w83637hf || type == w83687thf) {
1509                 data->vrm_ovt =
1510                         w83627hf_read_value(data, W83627THF_REG_VRM_OVT_CFG);
1511         }
1512
1513         tmp = w83627hf_read_value(data, W83781D_REG_SCFG1);
1514         for (i = 1; i <= 3; i++) {
1515                 if (!(tmp & BIT_SCFG1[i - 1])) {
1516                         data->sens[i - 1] = W83781D_DEFAULT_BETA;
1517                 } else {
1518                         if (w83627hf_read_value
1519                             (data,
1520                              W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1521                                 data->sens[i - 1] = 1;
1522                         else
1523                                 data->sens[i - 1] = 2;
1524                 }
1525                 if ((type == w83697hf) && (i == 2))
1526                         break;
1527         }
1528
1529         if(init) {
1530                 /* Enable temp2 */
1531                 tmp = w83627hf_read_value(data, W83781D_REG_TEMP2_CONFIG);
1532                 if (tmp & 0x01) {
1533                         dev_warn(&pdev->dev, "Enabling temp2, readings "
1534                                  "might not make sense\n");
1535                         w83627hf_write_value(data, W83781D_REG_TEMP2_CONFIG,
1536                                 tmp & 0xfe);
1537                 }
1538
1539                 /* Enable temp3 */
1540                 if (type != w83697hf) {
1541                         tmp = w83627hf_read_value(data,
1542                                 W83781D_REG_TEMP3_CONFIG);
1543                         if (tmp & 0x01) {
1544                                 dev_warn(&pdev->dev, "Enabling temp3, "
1545                                          "readings might not make sense\n");
1546                                 w83627hf_write_value(data,
1547                                         W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1548                         }
1549                 }
1550         }
1551
1552         /* Start monitoring */
1553         w83627hf_write_value(data, W83781D_REG_CONFIG,
1554                             (w83627hf_read_value(data,
1555                                                 W83781D_REG_CONFIG) & 0xf7)
1556                             | 0x01);
1557 }
1558
1559 static struct w83627hf_data *w83627hf_update_device(struct device *dev)
1560 {
1561         struct w83627hf_data *data = dev_get_drvdata(dev);
1562         int i;
1563
1564         mutex_lock(&data->update_lock);
1565
1566         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1567             || !data->valid) {
1568                 for (i = 0; i <= 8; i++) {
1569                         /* skip missing sensors */
1570                         if (((data->type == w83697hf) && (i == 1)) ||
1571                             ((data->type != w83627hf && data->type != w83697hf)
1572                             && (i == 5 || i == 6)))
1573                                 continue;
1574                         data->in[i] =
1575                             w83627hf_read_value(data, W83781D_REG_IN(i));
1576                         data->in_min[i] =
1577                             w83627hf_read_value(data,
1578                                                W83781D_REG_IN_MIN(i));
1579                         data->in_max[i] =
1580                             w83627hf_read_value(data,
1581                                                W83781D_REG_IN_MAX(i));
1582                 }
1583                 for (i = 1; i <= 3; i++) {
1584                         data->fan[i - 1] =
1585                             w83627hf_read_value(data, W83781D_REG_FAN(i));
1586                         data->fan_min[i - 1] =
1587                             w83627hf_read_value(data,
1588                                                W83781D_REG_FAN_MIN(i));
1589                 }
1590                 for (i = 1; i <= 3; i++) {
1591                         u8 tmp = w83627hf_read_value(data,
1592                                 W836X7HF_REG_PWM(data->type, i));
1593                         /* bits 0-3 are reserved  in 627THF */
1594                         if (data->type == w83627thf)
1595                                 tmp &= 0xf0;
1596                         data->pwm[i - 1] = tmp;
1597                         if(i == 2 &&
1598                            (data->type == w83627hf || data->type == w83697hf))
1599                                 break;
1600                 }
1601                 if (data->type == w83627hf) {
1602                                 u8 tmp = w83627hf_read_value(data,
1603                                                 W83627HF_REG_PWM_FREQ);
1604                                 data->pwm_freq[0] = tmp & 0x07;
1605                                 data->pwm_freq[1] = (tmp >> 4) & 0x07;
1606                 } else if (data->type != w83627thf) {
1607                         for (i = 1; i <= 3; i++) {
1608                                 data->pwm_freq[i - 1] =
1609                                         w83627hf_read_value(data,
1610                                                 W83637HF_REG_PWM_FREQ[i - 1]);
1611                                 if (i == 2 && (data->type == w83697hf))
1612                                         break;
1613                         }
1614                 }
1615
1616                 data->temp = w83627hf_read_value(data, W83781D_REG_TEMP(1));
1617                 data->temp_max =
1618                     w83627hf_read_value(data, W83781D_REG_TEMP_OVER(1));
1619                 data->temp_max_hyst =
1620                     w83627hf_read_value(data, W83781D_REG_TEMP_HYST(1));
1621                 data->temp_add[0] =
1622                     w83627hf_read_value(data, W83781D_REG_TEMP(2));
1623                 data->temp_max_add[0] =
1624                     w83627hf_read_value(data, W83781D_REG_TEMP_OVER(2));
1625                 data->temp_max_hyst_add[0] =
1626                     w83627hf_read_value(data, W83781D_REG_TEMP_HYST(2));
1627                 if (data->type != w83697hf) {
1628                         data->temp_add[1] =
1629                           w83627hf_read_value(data, W83781D_REG_TEMP(3));
1630                         data->temp_max_add[1] =
1631                           w83627hf_read_value(data, W83781D_REG_TEMP_OVER(3));
1632                         data->temp_max_hyst_add[1] =
1633                           w83627hf_read_value(data, W83781D_REG_TEMP_HYST(3));
1634                 }
1635
1636                 i = w83627hf_read_value(data, W83781D_REG_VID_FANDIV);
1637                 data->fan_div[0] = (i >> 4) & 0x03;
1638                 data->fan_div[1] = (i >> 6) & 0x03;
1639                 if (data->type != w83697hf) {
1640                         data->fan_div[2] = (w83627hf_read_value(data,
1641                                                W83781D_REG_PIN) >> 6) & 0x03;
1642                 }
1643                 i = w83627hf_read_value(data, W83781D_REG_VBAT);
1644                 data->fan_div[0] |= (i >> 3) & 0x04;
1645                 data->fan_div[1] |= (i >> 4) & 0x04;
1646                 if (data->type != w83697hf)
1647                         data->fan_div[2] |= (i >> 5) & 0x04;
1648                 data->alarms =
1649                     w83627hf_read_value(data, W83781D_REG_ALARM1) |
1650                     (w83627hf_read_value(data, W83781D_REG_ALARM2) << 8) |
1651                     (w83627hf_read_value(data, W83781D_REG_ALARM3) << 16);
1652                 i = w83627hf_read_value(data, W83781D_REG_BEEP_INTS2);
1653                 data->beep_enable = i >> 7;
1654                 data->beep_mask = ((i & 0x7f) << 8) |
1655                     w83627hf_read_value(data, W83781D_REG_BEEP_INTS1) |
1656                     w83627hf_read_value(data, W83781D_REG_BEEP_INTS3) << 16;
1657                 data->last_updated = jiffies;
1658                 data->valid = 1;
1659         }
1660
1661         mutex_unlock(&data->update_lock);
1662
1663         return data;
1664 }
1665
1666 static int __init w83627hf_device_add(unsigned short address,
1667                                       const struct w83627hf_sio_data *sio_data)
1668 {
1669         struct resource res = {
1670                 .start  = address + WINB_REGION_OFFSET,
1671                 .end    = address + WINB_REGION_OFFSET + WINB_REGION_SIZE - 1,
1672                 .name   = DRVNAME,
1673                 .flags  = IORESOURCE_IO,
1674         };
1675         int err;
1676
1677         pdev = platform_device_alloc(DRVNAME, address);
1678         if (!pdev) {
1679                 err = -ENOMEM;
1680                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1681                 goto exit;
1682         }
1683
1684         err = platform_device_add_resources(pdev, &res, 1);
1685         if (err) {
1686                 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1687                        "(%d)\n", err);
1688                 goto exit_device_put;
1689         }
1690
1691         err = platform_device_add_data(pdev, sio_data,
1692                                        sizeof(struct w83627hf_sio_data));
1693         if (err) {
1694                 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1695                 goto exit_device_put;
1696         }
1697
1698         err = platform_device_add(pdev);
1699         if (err) {
1700                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1701                        err);
1702                 goto exit_device_put;
1703         }
1704
1705         return 0;
1706
1707 exit_device_put:
1708         platform_device_put(pdev);
1709 exit:
1710         return err;
1711 }
1712
1713 static int __init sensors_w83627hf_init(void)
1714 {
1715         int err;
1716         unsigned short address;
1717         struct w83627hf_sio_data sio_data;
1718
1719         if (w83627hf_find(0x2e, &address, &sio_data)
1720          && w83627hf_find(0x4e, &address, &sio_data))
1721                 return -ENODEV;
1722
1723         err = platform_driver_register(&w83627hf_driver);
1724         if (err)
1725                 goto exit;
1726
1727         /* Sets global pdev as a side effect */
1728         err = w83627hf_device_add(address, &sio_data);
1729         if (err)
1730                 goto exit_driver;
1731
1732         return 0;
1733
1734 exit_driver:
1735         platform_driver_unregister(&w83627hf_driver);
1736 exit:
1737         return err;
1738 }
1739
1740 static void __exit sensors_w83627hf_exit(void)
1741 {
1742         platform_device_unregister(pdev);
1743         platform_driver_unregister(&w83627hf_driver);
1744 }
1745
1746 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1747               "Philip Edelbrock <phil@netroedge.com>, "
1748               "and Mark Studebaker <mdsxyz123@yahoo.com>");
1749 MODULE_DESCRIPTION("W83627HF driver");
1750 MODULE_LICENSE("GPL");
1751
1752 module_init(sensors_w83627hf_init);
1753 module_exit(sensors_w83627hf_exit);