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