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
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 /*
  25     Supports following chips:
  26
  27     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  28     w83627hf    9       3       2       3       0x20    0x5ca3  no      yes(LPC)
  29     w83627thf   7       3       3       3       0x90    0x5ca3  no      yes(LPC)
  30     w83637hf    7       3       3       3       0x80    0x5ca3  no      yes(LPC)
  31     w83687thf   7       3       3       3       0x90    0x5ca3  no      yes(LPC)
  32     w83697hf    8       2       2       2       0x60    0x5ca3  no      yes(LPC)
  33
  34     For other winbond chips, and for i2c support in the above chips,
  35     use w83781d.c.
  36
  37     Note: automatic ("cruise") fan control for 697, 637 & 627thf not
  38     supported yet.
  39 */
  40
  41 #include <linux/module.h>
  42 #include <linux/init.h>
  43 #include <linux/slab.h>
  44 #include <linux/jiffies.h>
  45 #include <linux/i2c.h>
  46 #include <linux/i2c-isa.h>
  47 #include <linux/hwmon.h>
  48 #include <linux/hwmon-vid.h>
  49 #include <linux/err.h>
  50 #include <linux/mutex.h>
  51 #include <asm/io.h>
  52 #include "lm75.h"
  53
  54 static u16 force_addr;
  55 module_param(force_addr, ushort, 0);
  56 MODULE_PARM_DESC(force_addr,
  57                  "Initialize the base address of the sensors");
  58 static u8 force_i2c = 0x1f;
  59 module_param(force_i2c, byte, 0);
  60 MODULE_PARM_DESC(force_i2c,
  61                  "Initialize the i2c address of the sensors");
  62
  63 /* The actual ISA address is read from Super-I/O configuration space */
  64 static unsigned short address;
  65
  66 /* Insmod parameters */
  67 enum chips { any_chip, w83627hf, w83627thf, w83697hf, w83637hf, w83687thf };
  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 base address */
 160 #define W83781D_ADDR_REG_OFFSET 5
 161 #define W83781D_DATA_REG_OFFSET 6
 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 W83781D_REG_I2C_ADDR 0x48
 224 #define W83781D_REG_I2C_SUBADDR 0x4A
 225
 226 /* Sensor selection */
 227 #define W83781D_REG_SCFG1 0x5D
 228 static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
 229 #define W83781D_REG_SCFG2 0x59
 230 static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
 231 #define W83781D_DEFAULT_BETA 3435
 232
 233 /* Conversions. Limit checking is only done on the TO_REG
 234    variants. Note that you should be a bit careful with which arguments
 235    these macros are called: arguments may be evaluated more than once.
 236    Fixing this is just not worth it. */
 237 #define IN_TO_REG(val)  (SENSORS_LIMIT((((val) + 8)/16),0,255))
 238 #define IN_FROM_REG(val) ((val) * 16)
 239
 240 static inline u8 FAN_TO_REG(long rpm, int div)
 241 {
 242         if (rpm == 0)
 243                 return 255;
 244         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 245         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
 246                              254);
 247 }
 248
 249 #define TEMP_MIN (-128000)
 250 #define TEMP_MAX ( 127000)
 251
 252 /* TEMP: 0.001C/bit (-128C to +127C)
 253    REG: 1C/bit, two's complement */
 254 static u8 TEMP_TO_REG(int temp)
 255 {
 256         int ntemp = SENSORS_LIMIT(temp, TEMP_MIN, TEMP_MAX);
 257         ntemp += (ntemp<0 ? -500 : 500);
 258         return (u8)(ntemp / 1000);
 259 }
 260
 261 static int TEMP_FROM_REG(u8 reg)
 262 {
 263         return (s8)reg * 1000;
 264 }
 265
 266 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
 267
 268 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
 269
 270 #define BEEP_MASK_FROM_REG(val)          (val)
 271 #define BEEP_MASK_TO_REG(val)           ((val) & 0xffffff)
 272 #define BEEP_ENABLE_TO_REG(val)         ((val)?1:0)
 273 #define BEEP_ENABLE_FROM_REG(val)       ((val)?1:0)
 274
 275 #define DIV_FROM_REG(val) (1 << (val))
 276
 277 static inline u8 DIV_TO_REG(long val)
 278 {
 279         int i;
 280         val = SENSORS_LIMIT(val, 1, 128) >> 1;
 281         for (i = 0; i < 7; i++) {
 282                 if (val == 0)
 283                         break;
 284                 val >>= 1;
 285         }
 286         return ((u8) i);
 287 }
 288
 289 /* For each registered chip, we need to keep some data in memory. That
 290    data is pointed to by w83627hf_list[NR]->data. The structure itself is
 291    dynamically allocated, at the same time when a new client is allocated. */
 292 struct w83627hf_data {
 293         struct i2c_client client;
 294         struct class_device *class_dev;
 295         struct mutex lock;
 296         enum chips type;
 297
 298         struct mutex update_lock;
 299         char valid;             /* !=0 if following fields are valid */
 300         unsigned long last_updated;     /* In jiffies */
 301
 302         struct i2c_client *lm75;        /* for secondary I2C addresses */
 303         /* pointer to array of 2 subclients */
 304
 305         u8 in[9];               /* Register value */
 306         u8 in_max[9];           /* Register value */
 307         u8 in_min[9];           /* Register value */
 308         u8 fan[3];              /* Register value */
 309         u8 fan_min[3];          /* Register value */
 310         u8 temp;
 311         u8 temp_max;            /* Register value */
 312         u8 temp_max_hyst;       /* Register value */
 313         u16 temp_add[2];        /* Register value */
 314         u16 temp_max_add[2];    /* Register value */
 315         u16 temp_max_hyst_add[2]; /* Register value */
 316         u8 fan_div[3];          /* Register encoding, shifted right */
 317         u8 vid;                 /* Register encoding, combined */
 318         u32 alarms;             /* Register encoding, combined */
 319         u32 beep_mask;          /* Register encoding, combined */
 320         u8 beep_enable;         /* Boolean */
 321         u8 pwm[3];              /* Register value */
 322         u16 sens[3];            /* 782D/783S only.
 323                                    1 = pentium diode; 2 = 3904 diode;
 324                                    3000-5000 = thermistor beta.
 325                                    Default = 3435.
 326                                    Other Betas unimplemented */
 327         u8 vrm;
 328         u8 vrm_ovt;             /* Register value, 627THF/637HF/687THF only */
 329 };
 330
 331
 332 static int w83627hf_detect(struct i2c_adapter *adapter);
 333 static int w83627hf_detach_client(struct i2c_client *client);
 334
 335 static int w83627hf_read_value(struct i2c_client *client, u16 reg);
 336 static int w83627hf_write_value(struct i2c_client *client, u16 reg, u16 value);
 337 static struct w83627hf_data *w83627hf_update_device(struct device *dev);
 338 static void w83627hf_init_client(struct i2c_client *client);
 339
 340 static struct i2c_driver w83627hf_driver = {
 341         .driver = {
 342                 .name   = "w83627hf",
 343         },
 344         .attach_adapter = w83627hf_detect,
 345         .detach_client  = w83627hf_detach_client,
 346 };
 347
 348 /* following are the sysfs callback functions */
 349 #define show_in_reg(reg) \
 350 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 351 { \
 352         struct w83627hf_data *data = w83627hf_update_device(dev); \
 353         return sprintf(buf,"%ld\n", (long)IN_FROM_REG(data->reg[nr])); \
 354 }
 355 show_in_reg(in)
 356 show_in_reg(in_min)
 357 show_in_reg(in_max)
 358
 359 #define store_in_reg(REG, reg) \
 360 static ssize_t \
 361 store_in_##reg (struct device *dev, const char *buf, size_t count, int nr) \
 362 { \
 363         struct i2c_client *client = to_i2c_client(dev); \
 364         struct w83627hf_data *data = i2c_get_clientdata(client); \
 365         u32 val; \
 366          \
 367         val = simple_strtoul(buf, NULL, 10); \
 368          \
 369         mutex_lock(&data->update_lock); \
 370         data->in_##reg[nr] = IN_TO_REG(val); \
 371         w83627hf_write_value(client, W83781D_REG_IN_##REG(nr), \
 372                             data->in_##reg[nr]); \
 373          \
 374         mutex_unlock(&data->update_lock); \
 375         return count; \
 376 }
 377 store_in_reg(MIN, min)
 378 store_in_reg(MAX, max)
 379
 380 #define sysfs_in_offset(offset) \
 381 static ssize_t \
 382 show_regs_in_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 383 { \
 384         return show_in(dev, buf, offset); \
 385 } \
 386 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_regs_in_##offset, NULL);
 387
 388 #define sysfs_in_reg_offset(reg, offset) \
 389 static ssize_t show_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 390 { \
 391         return show_in_##reg (dev, buf, offset); \
 392 } \
 393 static ssize_t \
 394 store_regs_in_##reg##offset (struct device *dev, struct device_attribute *attr, \
 395                             const char *buf, size_t count) \
 396 { \
 397         return store_in_##reg (dev, buf, count, offset); \
 398 } \
 399 static DEVICE_ATTR(in##offset##_##reg, S_IRUGO| S_IWUSR, \
 400                   show_regs_in_##reg##offset, store_regs_in_##reg##offset);
 401
 402 #define sysfs_in_offsets(offset) \
 403 sysfs_in_offset(offset) \
 404 sysfs_in_reg_offset(min, offset) \
 405 sysfs_in_reg_offset(max, offset)
 406
 407 sysfs_in_offsets(1);
 408 sysfs_in_offsets(2);
 409 sysfs_in_offsets(3);
 410 sysfs_in_offsets(4);
 411 sysfs_in_offsets(5);
 412 sysfs_in_offsets(6);
 413 sysfs_in_offsets(7);
 414 sysfs_in_offsets(8);
 415
 416 /* use a different set of functions for in0 */
 417 static ssize_t show_in_0(struct w83627hf_data *data, char *buf, u8 reg)
 418 {
 419         long in0;
 420
 421         if ((data->vrm_ovt & 0x01) &&
 422                 (w83627thf == data->type || w83637hf == data->type
 423                  || w83687thf == data->type))
 424
 425                 /* use VRM9 calculation */
 426                 in0 = (long)((reg * 488 + 70000 + 50) / 100);
 427         else
 428                 /* use VRM8 (standard) calculation */
 429                 in0 = (long)IN_FROM_REG(reg);
 430
 431         return sprintf(buf,"%ld\n", in0);
 432 }
 433
 434 static ssize_t show_regs_in_0(struct device *dev, struct device_attribute *attr, char *buf)
 435 {
 436         struct w83627hf_data *data = w83627hf_update_device(dev);
 437         return show_in_0(data, buf, data->in[0]);
 438 }
 439
 440 static ssize_t show_regs_in_min0(struct device *dev, struct device_attribute *attr, char *buf)
 441 {
 442         struct w83627hf_data *data = w83627hf_update_device(dev);
 443         return show_in_0(data, buf, data->in_min[0]);
 444 }
 445
 446 static ssize_t show_regs_in_max0(struct device *dev, struct device_attribute *attr, char *buf)
 447 {
 448         struct w83627hf_data *data = w83627hf_update_device(dev);
 449         return show_in_0(data, buf, data->in_max[0]);
 450 }
 451
 452 static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *attr,
 453         const char *buf, size_t count)
 454 {
 455         struct i2c_client *client = to_i2c_client(dev);
 456         struct w83627hf_data *data = i2c_get_clientdata(client);
 457         u32 val;
 458
 459         val = simple_strtoul(buf, NULL, 10);
 460
 461         mutex_lock(&data->update_lock);
 462
 463         if ((data->vrm_ovt & 0x01) &&
 464                 (w83627thf == data->type || w83637hf == data->type
 465                  || w83687thf == data->type))
 466
 467                 /* use VRM9 calculation */
 468                 data->in_min[0] =
 469                         SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
 470                                         255);
 471         else
 472                 /* use VRM8 (standard) calculation */
 473                 data->in_min[0] = IN_TO_REG(val);
 474
 475         w83627hf_write_value(client, W83781D_REG_IN_MIN(0), data->in_min[0]);
 476         mutex_unlock(&data->update_lock);
 477         return count;
 478 }
 479
 480 static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *attr,
 481         const char *buf, size_t count)
 482 {
 483         struct i2c_client *client = to_i2c_client(dev);
 484         struct w83627hf_data *data = i2c_get_clientdata(client);
 485         u32 val;
 486
 487         val = simple_strtoul(buf, NULL, 10);
 488
 489         mutex_lock(&data->update_lock);
 490
 491         if ((data->vrm_ovt & 0x01) &&
 492                 (w83627thf == data->type || w83637hf == data->type
 493                  || w83687thf == data->type))
 494
 495                 /* use VRM9 calculation */
 496                 data->in_max[0] =
 497                         SENSORS_LIMIT(((val * 100) - 70000 + 244) / 488, 0,
 498                                         255);
 499         else
 500                 /* use VRM8 (standard) calculation */
 501                 data->in_max[0] = IN_TO_REG(val);
 502
 503         w83627hf_write_value(client, W83781D_REG_IN_MAX(0), data->in_max[0]);
 504         mutex_unlock(&data->update_lock);
 505         return count;
 506 }
 507
 508 static DEVICE_ATTR(in0_input, S_IRUGO, show_regs_in_0, NULL);
 509 static DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
 510         show_regs_in_min0, store_regs_in_min0);
 511 static DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
 512         show_regs_in_max0, store_regs_in_max0);
 513
 514 #define device_create_file_in(client, offset) \
 515 do { \
 516 device_create_file(&client->dev, &dev_attr_in##offset##_input); \
 517 device_create_file(&client->dev, &dev_attr_in##offset##_min); \
 518 device_create_file(&client->dev, &dev_attr_in##offset##_max); \
 519 } while (0)
 520
 521 #define show_fan_reg(reg) \
 522 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 523 { \
 524         struct w83627hf_data *data = w83627hf_update_device(dev); \
 525         return sprintf(buf,"%ld\n", \
 526                 FAN_FROM_REG(data->reg[nr-1], \
 527                             (long)DIV_FROM_REG(data->fan_div[nr-1]))); \
 528 }
 529 show_fan_reg(fan);
 530 show_fan_reg(fan_min);
 531
 532 static ssize_t
 533 store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
 534 {
 535         struct i2c_client *client = to_i2c_client(dev);
 536         struct w83627hf_data *data = i2c_get_clientdata(client);
 537         u32 val;
 538
 539         val = simple_strtoul(buf, NULL, 10);
 540
 541         mutex_lock(&data->update_lock);
 542         data->fan_min[nr - 1] =
 543             FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr - 1]));
 544         w83627hf_write_value(client, W83781D_REG_FAN_MIN(nr),
 545                             data->fan_min[nr - 1]);
 546
 547         mutex_unlock(&data->update_lock);
 548         return count;
 549 }
 550
 551 #define sysfs_fan_offset(offset) \
 552 static ssize_t show_regs_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 553 { \
 554         return show_fan(dev, buf, offset); \
 555 } \
 556 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_regs_fan_##offset, NULL);
 557
 558 #define sysfs_fan_min_offset(offset) \
 559 static ssize_t show_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 560 { \
 561         return show_fan_min(dev, buf, offset); \
 562 } \
 563 static ssize_t \
 564 store_regs_fan_min##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
 565 { \
 566         return store_fan_min(dev, buf, count, offset); \
 567 } \
 568 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 569                   show_regs_fan_min##offset, store_regs_fan_min##offset);
 570
 571 sysfs_fan_offset(1);
 572 sysfs_fan_min_offset(1);
 573 sysfs_fan_offset(2);
 574 sysfs_fan_min_offset(2);
 575 sysfs_fan_offset(3);
 576 sysfs_fan_min_offset(3);
 577
 578 #define device_create_file_fan(client, offset) \
 579 do { \
 580 device_create_file(&client->dev, &dev_attr_fan##offset##_input); \
 581 device_create_file(&client->dev, &dev_attr_fan##offset##_min); \
 582 } while (0)
 583
 584 #define show_temp_reg(reg) \
 585 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 586 { \
 587         struct w83627hf_data *data = w83627hf_update_device(dev); \
 588         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 589                 return sprintf(buf,"%ld\n", \
 590                         (long)LM75_TEMP_FROM_REG(data->reg##_add[nr-2])); \
 591         } else {        /* TEMP1 */ \
 592                 return sprintf(buf,"%ld\n", (long)TEMP_FROM_REG(data->reg)); \
 593         } \
 594 }
 595 show_temp_reg(temp);
 596 show_temp_reg(temp_max);
 597 show_temp_reg(temp_max_hyst);
 598
 599 #define store_temp_reg(REG, reg) \
 600 static ssize_t \
 601 store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
 602 { \
 603         struct i2c_client *client = to_i2c_client(dev); \
 604         struct w83627hf_data *data = i2c_get_clientdata(client); \
 605         u32 val; \
 606          \
 607         val = simple_strtoul(buf, NULL, 10); \
 608          \
 609         mutex_lock(&data->update_lock); \
 610          \
 611         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
 612                 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
 613                 w83627hf_write_value(client, W83781D_REG_TEMP_##REG(nr), \
 614                                 data->temp_##reg##_add[nr-2]); \
 615         } else {        /* TEMP1 */ \
 616                 data->temp_##reg = TEMP_TO_REG(val); \
 617                 w83627hf_write_value(client, W83781D_REG_TEMP_##REG(nr), \
 618                         data->temp_##reg); \
 619         } \
 620          \
 621         mutex_unlock(&data->update_lock); \
 622         return count; \
 623 }
 624 store_temp_reg(OVER, max);
 625 store_temp_reg(HYST, max_hyst);
 626
 627 #define sysfs_temp_offset(offset) \
 628 static ssize_t \
 629 show_regs_temp_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 630 { \
 631         return show_temp(dev, buf, offset); \
 632 } \
 633 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_regs_temp_##offset, NULL);
 634
 635 #define sysfs_temp_reg_offset(reg, offset) \
 636 static ssize_t show_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 637 { \
 638         return show_temp_##reg (dev, buf, offset); \
 639 } \
 640 static ssize_t \
 641 store_regs_temp_##reg##offset (struct device *dev, struct device_attribute *attr, \
 642                               const char *buf, size_t count) \
 643 { \
 644         return store_temp_##reg (dev, buf, count, offset); \
 645 } \
 646 static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, \
 647                   show_regs_temp_##reg##offset, store_regs_temp_##reg##offset);
 648
 649 #define sysfs_temp_offsets(offset) \
 650 sysfs_temp_offset(offset) \
 651 sysfs_temp_reg_offset(max, offset) \
 652 sysfs_temp_reg_offset(max_hyst, offset)
 653
 654 sysfs_temp_offsets(1);
 655 sysfs_temp_offsets(2);
 656 sysfs_temp_offsets(3);
 657
 658 #define device_create_file_temp(client, offset) \
 659 do { \
 660 device_create_file(&client->dev, &dev_attr_temp##offset##_input); \
 661 device_create_file(&client->dev, &dev_attr_temp##offset##_max); \
 662 device_create_file(&client->dev, &dev_attr_temp##offset##_max_hyst); \
 663 } while (0)
 664
 665 static ssize_t
 666 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
 667 {
 668         struct w83627hf_data *data = w83627hf_update_device(dev);
 669         return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
 670 }
 671 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 672 #define device_create_file_vid(client) \
 673 device_create_file(&client->dev, &dev_attr_cpu0_vid)
 674
 675 static ssize_t
 676 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
 677 {
 678         struct w83627hf_data *data = w83627hf_update_device(dev);
 679         return sprintf(buf, "%ld\n", (long) data->vrm);
 680 }
 681 static ssize_t
 682 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 683 {
 684         struct i2c_client *client = to_i2c_client(dev);
 685         struct w83627hf_data *data = i2c_get_clientdata(client);
 686         u32 val;
 687
 688         val = simple_strtoul(buf, NULL, 10);
 689         data->vrm = val;
 690
 691         return count;
 692 }
 693 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 694 #define device_create_file_vrm(client) \
 695 device_create_file(&client->dev, &dev_attr_vrm)
 696
 697 static ssize_t
 698 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
 699 {
 700         struct w83627hf_data *data = w83627hf_update_device(dev);
 701         return sprintf(buf, "%ld\n", (long) data->alarms);
 702 }
 703 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 704 #define device_create_file_alarms(client) \
 705 device_create_file(&client->dev, &dev_attr_alarms)
 706
 707 #define show_beep_reg(REG, reg) \
 708 static ssize_t show_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
 709 { \
 710         struct w83627hf_data *data = w83627hf_update_device(dev); \
 711         return sprintf(buf,"%ld\n", \
 712                       (long)BEEP_##REG##_FROM_REG(data->beep_##reg)); \
 713 }
 714 show_beep_reg(ENABLE, enable)
 715 show_beep_reg(MASK, mask)
 716
 717 #define BEEP_ENABLE                     0       /* Store beep_enable */
 718 #define BEEP_MASK                       1       /* Store beep_mask */
 719
 720 static ssize_t
 721 store_beep_reg(struct device *dev, const char *buf, size_t count,
 722                int update_mask)
 723 {
 724         struct i2c_client *client = to_i2c_client(dev);
 725         struct w83627hf_data *data = i2c_get_clientdata(client);
 726         u32 val, val2;
 727
 728         val = simple_strtoul(buf, NULL, 10);
 729
 730         mutex_lock(&data->update_lock);
 731
 732         if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
 733                 data->beep_mask = BEEP_MASK_TO_REG(val);
 734                 w83627hf_write_value(client, W83781D_REG_BEEP_INTS1,
 735                                     data->beep_mask & 0xff);
 736                 w83627hf_write_value(client, W83781D_REG_BEEP_INTS3,
 737                                     ((data->beep_mask) >> 16) & 0xff);
 738                 val2 = (data->beep_mask >> 8) & 0x7f;
 739         } else {                /* We are storing beep_enable */
 740                 val2 =
 741                     w83627hf_read_value(client, W83781D_REG_BEEP_INTS2) & 0x7f;
 742                 data->beep_enable = BEEP_ENABLE_TO_REG(val);
 743         }
 744
 745         w83627hf_write_value(client, W83781D_REG_BEEP_INTS2,
 746                             val2 | data->beep_enable << 7);
 747
 748         mutex_unlock(&data->update_lock);
 749         return count;
 750 }
 751
 752 #define sysfs_beep(REG, reg) \
 753 static ssize_t show_regs_beep_##reg (struct device *dev, struct device_attribute *attr, char *buf) \
 754 { \
 755         return show_beep_##reg(dev, attr, buf); \
 756 } \
 757 static ssize_t \
 758 store_regs_beep_##reg (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
 759 { \
 760         return store_beep_reg(dev, buf, count, BEEP_##REG); \
 761 } \
 762 static DEVICE_ATTR(beep_##reg, S_IRUGO | S_IWUSR, \
 763                   show_regs_beep_##reg, store_regs_beep_##reg);
 764
 765 sysfs_beep(ENABLE, enable);
 766 sysfs_beep(MASK, mask);
 767
 768 #define device_create_file_beep(client) \
 769 do { \
 770 device_create_file(&client->dev, &dev_attr_beep_enable); \
 771 device_create_file(&client->dev, &dev_attr_beep_mask); \
 772 } while (0)
 773
 774 static ssize_t
 775 show_fan_div_reg(struct device *dev, char *buf, int nr)
 776 {
 777         struct w83627hf_data *data = w83627hf_update_device(dev);
 778         return sprintf(buf, "%ld\n",
 779                        (long) DIV_FROM_REG(data->fan_div[nr - 1]));
 780 }
 781
 782 /* Note: we save and restore the fan minimum here, because its value is
 783    determined in part by the fan divisor.  This follows the principle of
 784    least surprise; the user doesn't expect the fan minimum to change just
 785    because the divisor changed. */
 786 static ssize_t
 787 store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
 788 {
 789         struct i2c_client *client = to_i2c_client(dev);
 790         struct w83627hf_data *data = i2c_get_clientdata(client);
 791         unsigned long min;
 792         u8 reg;
 793         unsigned long val = simple_strtoul(buf, NULL, 10);
 794
 795         mutex_lock(&data->update_lock);
 796
 797         /* Save fan_min */
 798         min = FAN_FROM_REG(data->fan_min[nr],
 799                            DIV_FROM_REG(data->fan_div[nr]));
 800
 801         data->fan_div[nr] = DIV_TO_REG(val);
 802
 803         reg = (w83627hf_read_value(client, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV)
 804                & (nr==0 ? 0xcf : 0x3f))
 805             | ((data->fan_div[nr] & 0x03) << (nr==0 ? 4 : 6));
 806         w83627hf_write_value(client, nr==2 ? W83781D_REG_PIN : W83781D_REG_VID_FANDIV, reg);
 807
 808         reg = (w83627hf_read_value(client, W83781D_REG_VBAT)
 809                & ~(1 << (5 + nr)))
 810             | ((data->fan_div[nr] & 0x04) << (3 + nr));
 811         w83627hf_write_value(client, W83781D_REG_VBAT, reg);
 812
 813         /* Restore fan_min */
 814         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 815         w83627hf_write_value(client, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
 816
 817         mutex_unlock(&data->update_lock);
 818         return count;
 819 }
 820
 821 #define sysfs_fan_div(offset) \
 822 static ssize_t show_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 823 { \
 824         return show_fan_div_reg(dev, buf, offset); \
 825 } \
 826 static ssize_t \
 827 store_regs_fan_div_##offset (struct device *dev, struct device_attribute *attr, \
 828                             const char *buf, size_t count) \
 829 { \
 830         return store_fan_div_reg(dev, buf, count, offset - 1); \
 831 } \
 832 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
 833                   show_regs_fan_div_##offset, store_regs_fan_div_##offset);
 834
 835 sysfs_fan_div(1);
 836 sysfs_fan_div(2);
 837 sysfs_fan_div(3);
 838
 839 #define device_create_file_fan_div(client, offset) \
 840 do { \
 841 device_create_file(&client->dev, &dev_attr_fan##offset##_div); \
 842 } while (0)
 843
 844 static ssize_t
 845 show_pwm_reg(struct device *dev, char *buf, int nr)
 846 {
 847         struct w83627hf_data *data = w83627hf_update_device(dev);
 848         return sprintf(buf, "%ld\n", (long) data->pwm[nr - 1]);
 849 }
 850
 851 static ssize_t
 852 store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
 853 {
 854         struct i2c_client *client = to_i2c_client(dev);
 855         struct w83627hf_data *data = i2c_get_clientdata(client);
 856         u32 val;
 857
 858         val = simple_strtoul(buf, NULL, 10);
 859
 860         mutex_lock(&data->update_lock);
 861
 862         if (data->type == w83627thf) {
 863                 /* bits 0-3 are reserved  in 627THF */
 864                 data->pwm[nr - 1] = PWM_TO_REG(val) & 0xf0;
 865                 w83627hf_write_value(client,
 866                                      W836X7HF_REG_PWM(data->type, nr),
 867                                      data->pwm[nr - 1] |
 868                                      (w83627hf_read_value(client,
 869                                      W836X7HF_REG_PWM(data->type, nr)) & 0x0f));
 870         } else {
 871                 data->pwm[nr - 1] = PWM_TO_REG(val);
 872                 w83627hf_write_value(client,
 873                                      W836X7HF_REG_PWM(data->type, nr),
 874                                      data->pwm[nr - 1]);
 875         }
 876
 877         mutex_unlock(&data->update_lock);
 878         return count;
 879 }
 880
 881 #define sysfs_pwm(offset) \
 882 static ssize_t show_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 883 { \
 884         return show_pwm_reg(dev, buf, offset); \
 885 } \
 886 static ssize_t \
 887 store_regs_pwm_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
 888 { \
 889         return store_pwm_reg(dev, buf, count, offset); \
 890 } \
 891 static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
 892                   show_regs_pwm_##offset, store_regs_pwm_##offset);
 893
 894 sysfs_pwm(1);
 895 sysfs_pwm(2);
 896 sysfs_pwm(3);
 897
 898 #define device_create_file_pwm(client, offset) \
 899 do { \
 900 device_create_file(&client->dev, &dev_attr_pwm##offset); \
 901 } while (0)
 902
 903 static ssize_t
 904 show_sensor_reg(struct device *dev, char *buf, int nr)
 905 {
 906         struct w83627hf_data *data = w83627hf_update_device(dev);
 907         return sprintf(buf, "%ld\n", (long) data->sens[nr - 1]);
 908 }
 909
 910 static ssize_t
 911 store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
 912 {
 913         struct i2c_client *client = to_i2c_client(dev);
 914         struct w83627hf_data *data = i2c_get_clientdata(client);
 915         u32 val, tmp;
 916
 917         val = simple_strtoul(buf, NULL, 10);
 918
 919         mutex_lock(&data->update_lock);
 920
 921         switch (val) {
 922         case 1:         /* PII/Celeron diode */
 923                 tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
 924                 w83627hf_write_value(client, W83781D_REG_SCFG1,
 925                                     tmp | BIT_SCFG1[nr - 1]);
 926                 tmp = w83627hf_read_value(client, W83781D_REG_SCFG2);
 927                 w83627hf_write_value(client, W83781D_REG_SCFG2,
 928                                     tmp | BIT_SCFG2[nr - 1]);
 929                 data->sens[nr - 1] = val;
 930                 break;
 931         case 2:         /* 3904 */
 932                 tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
 933                 w83627hf_write_value(client, W83781D_REG_SCFG1,
 934                                     tmp | BIT_SCFG1[nr - 1]);
 935                 tmp = w83627hf_read_value(client, W83781D_REG_SCFG2);
 936                 w83627hf_write_value(client, W83781D_REG_SCFG2,
 937                                     tmp & ~BIT_SCFG2[nr - 1]);
 938                 data->sens[nr - 1] = val;
 939                 break;
 940         case W83781D_DEFAULT_BETA:      /* thermistor */
 941                 tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
 942                 w83627hf_write_value(client, W83781D_REG_SCFG1,
 943                                     tmp & ~BIT_SCFG1[nr - 1]);
 944                 data->sens[nr - 1] = val;
 945                 break;
 946         default:
 947                 dev_err(&client->dev,
 948                        "Invalid sensor type %ld; must be 1, 2, or %d\n",
 949                        (long) val, W83781D_DEFAULT_BETA);
 950                 break;
 951         }
 952
 953         mutex_unlock(&data->update_lock);
 954         return count;
 955 }
 956
 957 #define sysfs_sensor(offset) \
 958 static ssize_t show_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 959 { \
 960     return show_sensor_reg(dev, buf, offset); \
 961 } \
 962 static ssize_t \
 963 store_regs_sensor_##offset (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
 964 { \
 965     return store_sensor_reg(dev, buf, count, offset); \
 966 } \
 967 static DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
 968                   show_regs_sensor_##offset, store_regs_sensor_##offset);
 969
 970 sysfs_sensor(1);
 971 sysfs_sensor(2);
 972 sysfs_sensor(3);
 973
 974 #define device_create_file_sensor(client, offset) \
 975 do { \
 976 device_create_file(&client->dev, &dev_attr_temp##offset##_type); \
 977 } while (0)
 978
 979
 980 static int __init w83627hf_find(int sioaddr, unsigned short *addr)
 981 {
 982         u16 val;
 983
 984         REG = sioaddr;
 985         VAL = sioaddr + 1;
 986
 987         superio_enter();
 988         val= superio_inb(DEVID);
 989         if(val != W627_DEVID &&
 990            val != W627THF_DEVID &&
 991            val != W697_DEVID &&
 992            val != W637_DEVID &&
 993            val != W687THF_DEVID) {
 994                 superio_exit();
 995                 return -ENODEV;
 996         }
 997
 998         superio_select(W83627HF_LD_HWM);
 999         val = (superio_inb(WINB_BASE_REG) << 8) |
1000                superio_inb(WINB_BASE_REG + 1);
1001         *addr = val & WINB_ALIGNMENT;
1002         if (*addr == 0 && force_addr == 0) {
1003                 superio_exit();
1004                 return -ENODEV;
1005         }
1006
1007         superio_exit();
1008         return 0;
1009 }
1010
1011 static int w83627hf_detect(struct i2c_adapter *adapter)
1012 {
1013         int val, kind;
1014         struct i2c_client *new_client;
1015         struct w83627hf_data *data;
1016         int err = 0;
1017         const char *client_name = "";
1018
1019         if(force_addr)
1020                 address = force_addr & WINB_ALIGNMENT;
1021
1022         if (!request_region(address + WINB_REGION_OFFSET, WINB_REGION_SIZE,
1023                             w83627hf_driver.driver.name)) {
1024                 err = -EBUSY;
1025                 goto ERROR0;
1026         }
1027
1028         if(force_addr) {
1029                 printk("w83627hf.o: forcing ISA address 0x%04X\n", address);
1030                 superio_enter();
1031                 superio_select(W83627HF_LD_HWM);
1032                 superio_outb(WINB_BASE_REG, address >> 8);
1033                 superio_outb(WINB_BASE_REG+1, address & 0xff);
1034                 superio_exit();
1035         }
1036
1037         superio_enter();
1038         val= superio_inb(DEVID);
1039         if(val == W627_DEVID)
1040                 kind = w83627hf;
1041         else if(val == W697_DEVID)
1042                 kind = w83697hf;
1043         else if(val == W627THF_DEVID)
1044                 kind = w83627thf;
1045         else if(val == W637_DEVID)
1046                 kind = w83637hf;
1047         else if (val == W687THF_DEVID)
1048                 kind = w83687thf;
1049         else {
1050                 dev_info(&adapter->dev,
1051                          "Unsupported chip (dev_id=0x%02X).\n", val);
1052                 goto ERROR1;
1053         }
1054
1055         superio_select(W83627HF_LD_HWM);
1056         if((val = 0x01 & superio_inb(WINB_ACT_REG)) == 0)
1057                 superio_outb(WINB_ACT_REG, 1);
1058         superio_exit();
1059
1060         /* OK. For now, we presume we have a valid client. We now create the
1061            client structure, even though we cannot fill it completely yet.
1062            But it allows us to access w83627hf_{read,write}_value. */
1063
1064         if (!(data = kzalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
1065                 err = -ENOMEM;
1066                 goto ERROR1;
1067         }
1068
1069         new_client = &data->client;
1070         i2c_set_clientdata(new_client, data);
1071         new_client->addr = address;
1072         mutex_init(&data->lock);
1073         new_client->adapter = adapter;
1074         new_client->driver = &w83627hf_driver;
1075         new_client->flags = 0;
1076
1077
1078         if (kind == w83627hf) {
1079                 client_name = "w83627hf";
1080         } else if (kind == w83627thf) {
1081                 client_name = "w83627thf";
1082         } else if (kind == w83697hf) {
1083                 client_name = "w83697hf";
1084         } else if (kind == w83637hf) {
1085                 client_name = "w83637hf";
1086         } else if (kind == w83687thf) {
1087                 client_name = "w83687thf";
1088         }
1089
1090         /* Fill in the remaining client fields and put into the global list */
1091         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
1092         data->type = kind;
1093         data->valid = 0;
1094         mutex_init(&data->update_lock);
1095
1096         /* Tell the I2C layer a new client has arrived */
1097         if ((err = i2c_attach_client(new_client)))
1098                 goto ERROR2;
1099
1100         data->lm75 = NULL;
1101
1102         /* Initialize the chip */
1103         w83627hf_init_client(new_client);
1104
1105         /* A few vars need to be filled upon startup */
1106         data->fan_min[0] = w83627hf_read_value(new_client, W83781D_REG_FAN_MIN(1));
1107         data->fan_min[1] = w83627hf_read_value(new_client, W83781D_REG_FAN_MIN(2));
1108         data->fan_min[2] = w83627hf_read_value(new_client, W83781D_REG_FAN_MIN(3));
1109
1110         /* Register sysfs hooks */
1111         data->class_dev = hwmon_device_register(&new_client->dev);
1112         if (IS_ERR(data->class_dev)) {
1113                 err = PTR_ERR(data->class_dev);
1114                 goto ERROR3;
1115         }
1116
1117         device_create_file_in(new_client, 0);
1118         if (kind != w83697hf)
1119                 device_create_file_in(new_client, 1);
1120         device_create_file_in(new_client, 2);
1121         device_create_file_in(new_client, 3);
1122         device_create_file_in(new_client, 4);
1123         if (kind == w83627hf || kind == w83697hf) {
1124                 device_create_file_in(new_client, 5);
1125                 device_create_file_in(new_client, 6);
1126         }
1127         device_create_file_in(new_client, 7);
1128         device_create_file_in(new_client, 8);
1129
1130         device_create_file_fan(new_client, 1);
1131         device_create_file_fan(new_client, 2);
1132         if (kind != w83697hf)
1133                 device_create_file_fan(new_client, 3);
1134
1135         device_create_file_temp(new_client, 1);
1136         device_create_file_temp(new_client, 2);
1137         if (kind != w83697hf)
1138                 device_create_file_temp(new_client, 3);
1139
1140         if (kind != w83697hf && data->vid != 0xff) {
1141                 device_create_file_vid(new_client);
1142                 device_create_file_vrm(new_client);
1143         }
1144
1145         device_create_file_fan_div(new_client, 1);
1146         device_create_file_fan_div(new_client, 2);
1147         if (kind != w83697hf)
1148                 device_create_file_fan_div(new_client, 3);
1149
1150         device_create_file_alarms(new_client);
1151
1152         device_create_file_beep(new_client);
1153
1154         device_create_file_pwm(new_client, 1);
1155         device_create_file_pwm(new_client, 2);
1156         if (kind == w83627thf || kind == w83637hf || kind == w83687thf)
1157                 device_create_file_pwm(new_client, 3);
1158
1159         device_create_file_sensor(new_client, 1);
1160         device_create_file_sensor(new_client, 2);
1161         if (kind != w83697hf)
1162                 device_create_file_sensor(new_client, 3);
1163
1164         return 0;
1165
1166       ERROR3:
1167         i2c_detach_client(new_client);
1168       ERROR2:
1169         kfree(data);
1170       ERROR1:
1171         release_region(address + WINB_REGION_OFFSET, WINB_REGION_SIZE);
1172       ERROR0:
1173         return err;
1174 }
1175
1176 static int w83627hf_detach_client(struct i2c_client *client)
1177 {
1178         struct w83627hf_data *data = i2c_get_clientdata(client);
1179         int err;
1180
1181         hwmon_device_unregister(data->class_dev);
1182
1183         if ((err = i2c_detach_client(client)))
1184                 return err;
1185
1186         release_region(client->addr + WINB_REGION_OFFSET, WINB_REGION_SIZE);
1187         kfree(data);
1188
1189         return 0;
1190 }
1191
1192
1193 /*
1194    ISA access must always be locked explicitly!
1195    We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
1196    would slow down the W83781D access and should not be necessary.
1197    There are some ugly typecasts here, but the good news is - they should
1198    nowhere else be necessary! */
1199 static int w83627hf_read_value(struct i2c_client *client, u16 reg)
1200 {
1201         struct w83627hf_data *data = i2c_get_clientdata(client);
1202         int res, word_sized;
1203
1204         mutex_lock(&data->lock);
1205         word_sized = (((reg & 0xff00) == 0x100)
1206                    || ((reg & 0xff00) == 0x200))
1207                   && (((reg & 0x00ff) == 0x50)
1208                    || ((reg & 0x00ff) == 0x53)
1209                    || ((reg & 0x00ff) == 0x55));
1210         if (reg & 0xff00) {
1211                 outb_p(W83781D_REG_BANK,
1212                        client->addr + W83781D_ADDR_REG_OFFSET);
1213                 outb_p(reg >> 8,
1214                        client->addr + W83781D_DATA_REG_OFFSET);
1215         }
1216         outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1217         res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
1218         if (word_sized) {
1219                 outb_p((reg & 0xff) + 1,
1220                        client->addr + W83781D_ADDR_REG_OFFSET);
1221                 res =
1222                     (res << 8) + inb_p(client->addr +
1223                                        W83781D_DATA_REG_OFFSET);
1224         }
1225         if (reg & 0xff00) {
1226                 outb_p(W83781D_REG_BANK,
1227                        client->addr + W83781D_ADDR_REG_OFFSET);
1228                 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1229         }
1230         mutex_unlock(&data->lock);
1231         return res;
1232 }
1233
1234 static int w83627thf_read_gpio5(struct i2c_client *client)
1235 {
1236         int res = 0xff, sel;
1237
1238         superio_enter();
1239         superio_select(W83627HF_LD_GPIO5);
1240
1241         /* Make sure these GPIO pins are enabled */
1242         if (!(superio_inb(W83627THF_GPIO5_EN) & (1<<3))) {
1243                 dev_dbg(&client->dev, "GPIO5 disabled, no VID function\n");
1244                 goto exit;
1245         }
1246
1247         /* Make sure the pins are configured for input
1248            There must be at least five (VRM 9), and possibly 6 (VRM 10) */
1249         sel = superio_inb(W83627THF_GPIO5_IOSR) & 0x3f;
1250         if ((sel & 0x1f) != 0x1f) {
1251                 dev_dbg(&client->dev, "GPIO5 not configured for VID "
1252                         "function\n");
1253                 goto exit;
1254         }
1255
1256         dev_info(&client->dev, "Reading VID from GPIO5\n");
1257         res = superio_inb(W83627THF_GPIO5_DR) & sel;
1258
1259 exit:
1260         superio_exit();
1261         return res;
1262 }
1263
1264 static int w83687thf_read_vid(struct i2c_client *client)
1265 {
1266         int res = 0xff;
1267
1268         superio_enter();
1269         superio_select(W83627HF_LD_HWM);
1270
1271         /* Make sure these GPIO pins are enabled */
1272         if (!(superio_inb(W83687THF_VID_EN) & (1 << 2))) {
1273                 dev_dbg(&client->dev, "VID disabled, no VID function\n");
1274                 goto exit;
1275         }
1276
1277         /* Make sure the pins are configured for input */
1278         if (!(superio_inb(W83687THF_VID_CFG) & (1 << 4))) {
1279                 dev_dbg(&client->dev, "VID configured as output, "
1280                         "no VID function\n");
1281                 goto exit;
1282         }
1283
1284         res = superio_inb(W83687THF_VID_DATA) & 0x3f;
1285
1286 exit:
1287         superio_exit();
1288         return res;
1289 }
1290
1291 static int w83627hf_write_value(struct i2c_client *client, u16 reg, u16 value)
1292 {
1293         struct w83627hf_data *data = i2c_get_clientdata(client);
1294         int word_sized;
1295
1296         mutex_lock(&data->lock);
1297         word_sized = (((reg & 0xff00) == 0x100)
1298                    || ((reg & 0xff00) == 0x200))
1299                   && (((reg & 0x00ff) == 0x53)
1300                    || ((reg & 0x00ff) == 0x55));
1301         if (reg & 0xff00) {
1302                 outb_p(W83781D_REG_BANK,
1303                        client->addr + W83781D_ADDR_REG_OFFSET);
1304                 outb_p(reg >> 8,
1305                        client->addr + W83781D_DATA_REG_OFFSET);
1306         }
1307         outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
1308         if (word_sized) {
1309                 outb_p(value >> 8,
1310                        client->addr + W83781D_DATA_REG_OFFSET);
1311                 outb_p((reg & 0xff) + 1,
1312                        client->addr + W83781D_ADDR_REG_OFFSET);
1313         }
1314         outb_p(value & 0xff,
1315                client->addr + W83781D_DATA_REG_OFFSET);
1316         if (reg & 0xff00) {
1317                 outb_p(W83781D_REG_BANK,
1318                        client->addr + W83781D_ADDR_REG_OFFSET);
1319                 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
1320         }
1321         mutex_unlock(&data->lock);
1322         return 0;
1323 }
1324
1325 static void w83627hf_init_client(struct i2c_client *client)
1326 {
1327         struct w83627hf_data *data = i2c_get_clientdata(client);
1328         int i;
1329         int type = data->type;
1330         u8 tmp;
1331
1332         if (reset) {
1333                 /* Resetting the chip has been the default for a long time,
1334                    but repeatedly caused problems (fans going to full
1335                    speed...) so it is now optional. It might even go away if
1336                    nobody reports it as being useful, as I see very little
1337                    reason why this would be needed at all. */
1338                 dev_info(&client->dev, "If reset=1 solved a problem you were "
1339                          "having, please report!\n");
1340
1341                 /* save this register */
1342                 i = w83627hf_read_value(client, W83781D_REG_BEEP_CONFIG);
1343                 /* Reset all except Watchdog values and last conversion values
1344                    This sets fan-divs to 2, among others */
1345                 w83627hf_write_value(client, W83781D_REG_CONFIG, 0x80);
1346                 /* Restore the register and disable power-on abnormal beep.
1347                    This saves FAN 1/2/3 input/output values set by BIOS. */
1348                 w83627hf_write_value(client, W83781D_REG_BEEP_CONFIG, i | 0x80);
1349                 /* Disable master beep-enable (reset turns it on).
1350                    Individual beeps should be reset to off but for some reason
1351                    disabling this bit helps some people not get beeped */
1352                 w83627hf_write_value(client, W83781D_REG_BEEP_INTS2, 0);
1353         }
1354
1355         /* Minimize conflicts with other winbond i2c-only clients...  */
1356         /* disable i2c subclients... how to disable main i2c client?? */
1357         /* force i2c address to relatively uncommon address */
1358         w83627hf_write_value(client, W83781D_REG_I2C_SUBADDR, 0x89);
1359         w83627hf_write_value(client, W83781D_REG_I2C_ADDR, force_i2c);
1360
1361         /* Read VID only once */
1362         if (w83627hf == data->type || w83637hf == data->type) {
1363                 int lo = w83627hf_read_value(client, W83781D_REG_VID_FANDIV);
1364                 int hi = w83627hf_read_value(client, W83781D_REG_CHIPID);
1365                 data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
1366         } else if (w83627thf == data->type) {
1367                 data->vid = w83627thf_read_gpio5(client);
1368         } else if (w83687thf == data->type) {
1369                 data->vid = w83687thf_read_vid(client);
1370         }
1371
1372         /* Read VRM & OVT Config only once */
1373         if (w83627thf == data->type || w83637hf == data->type
1374          || w83687thf == data->type) {
1375                 data->vrm_ovt =
1376                         w83627hf_read_value(client, W83627THF_REG_VRM_OVT_CFG);
1377         }
1378
1379         /* Convert VID to voltage based on VRM */
1380         data->vrm = vid_which_vrm();
1381
1382         tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
1383         for (i = 1; i <= 3; i++) {
1384                 if (!(tmp & BIT_SCFG1[i - 1])) {
1385                         data->sens[i - 1] = W83781D_DEFAULT_BETA;
1386                 } else {
1387                         if (w83627hf_read_value
1388                             (client,
1389                              W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
1390                                 data->sens[i - 1] = 1;
1391                         else
1392                                 data->sens[i - 1] = 2;
1393                 }
1394                 if ((type == w83697hf) && (i == 2))
1395                         break;
1396         }
1397
1398         if(init) {
1399                 /* Enable temp2 */
1400                 tmp = w83627hf_read_value(client, W83781D_REG_TEMP2_CONFIG);
1401                 if (tmp & 0x01) {
1402                         dev_warn(&client->dev, "Enabling temp2, readings "
1403                                  "might not make sense\n");
1404                         w83627hf_write_value(client, W83781D_REG_TEMP2_CONFIG,
1405                                 tmp & 0xfe);
1406                 }
1407
1408                 /* Enable temp3 */
1409                 if (type != w83697hf) {
1410                         tmp = w83627hf_read_value(client,
1411                                 W83781D_REG_TEMP3_CONFIG);
1412                         if (tmp & 0x01) {
1413                                 dev_warn(&client->dev, "Enabling temp3, "
1414                                          "readings might not make sense\n");
1415                                 w83627hf_write_value(client,
1416                                         W83781D_REG_TEMP3_CONFIG, tmp & 0xfe);
1417                         }
1418                 }
1419         }
1420
1421         /* Start monitoring */
1422         w83627hf_write_value(client, W83781D_REG_CONFIG,
1423                             (w83627hf_read_value(client,
1424                                                 W83781D_REG_CONFIG) & 0xf7)
1425                             | 0x01);
1426 }
1427
1428 static struct w83627hf_data *w83627hf_update_device(struct device *dev)
1429 {
1430         struct i2c_client *client = to_i2c_client(dev);
1431         struct w83627hf_data *data = i2c_get_clientdata(client);
1432         int i;
1433
1434         mutex_lock(&data->update_lock);
1435
1436         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1437             || !data->valid) {
1438                 for (i = 0; i <= 8; i++) {
1439                         /* skip missing sensors */
1440                         if (((data->type == w83697hf) && (i == 1)) ||
1441                             ((data->type != w83627hf && data->type != w83697hf)
1442                             && (i == 5 || i == 6)))
1443                                 continue;
1444                         data->in[i] =
1445                             w83627hf_read_value(client, W83781D_REG_IN(i));
1446                         data->in_min[i] =
1447                             w83627hf_read_value(client,
1448                                                W83781D_REG_IN_MIN(i));
1449                         data->in_max[i] =
1450                             w83627hf_read_value(client,
1451                                                W83781D_REG_IN_MAX(i));
1452                 }
1453                 for (i = 1; i <= 3; i++) {
1454                         data->fan[i - 1] =
1455                             w83627hf_read_value(client, W83781D_REG_FAN(i));
1456                         data->fan_min[i - 1] =
1457                             w83627hf_read_value(client,
1458                                                W83781D_REG_FAN_MIN(i));
1459                 }
1460                 for (i = 1; i <= 3; i++) {
1461                         u8 tmp = w83627hf_read_value(client,
1462                                 W836X7HF_REG_PWM(data->type, i));
1463                         /* bits 0-3 are reserved  in 627THF */
1464                         if (data->type == w83627thf)
1465                                 tmp &= 0xf0;
1466                         data->pwm[i - 1] = tmp;
1467                         if(i == 2 &&
1468                            (data->type == w83627hf || data->type == w83697hf))
1469                                 break;
1470                 }
1471
1472                 data->temp = w83627hf_read_value(client, W83781D_REG_TEMP(1));
1473                 data->temp_max =
1474                     w83627hf_read_value(client, W83781D_REG_TEMP_OVER(1));
1475                 data->temp_max_hyst =
1476                     w83627hf_read_value(client, W83781D_REG_TEMP_HYST(1));
1477                 data->temp_add[0] =
1478                     w83627hf_read_value(client, W83781D_REG_TEMP(2));
1479                 data->temp_max_add[0] =
1480                     w83627hf_read_value(client, W83781D_REG_TEMP_OVER(2));
1481                 data->temp_max_hyst_add[0] =
1482                     w83627hf_read_value(client, W83781D_REG_TEMP_HYST(2));
1483                 if (data->type != w83697hf) {
1484                         data->temp_add[1] =
1485                           w83627hf_read_value(client, W83781D_REG_TEMP(3));
1486                         data->temp_max_add[1] =
1487                           w83627hf_read_value(client, W83781D_REG_TEMP_OVER(3));
1488                         data->temp_max_hyst_add[1] =
1489                           w83627hf_read_value(client, W83781D_REG_TEMP_HYST(3));
1490                 }
1491
1492                 i = w83627hf_read_value(client, W83781D_REG_VID_FANDIV);
1493                 data->fan_div[0] = (i >> 4) & 0x03;
1494                 data->fan_div[1] = (i >> 6) & 0x03;
1495                 if (data->type != w83697hf) {
1496                         data->fan_div[2] = (w83627hf_read_value(client,
1497                                                W83781D_REG_PIN) >> 6) & 0x03;
1498                 }
1499                 i = w83627hf_read_value(client, W83781D_REG_VBAT);
1500                 data->fan_div[0] |= (i >> 3) & 0x04;
1501                 data->fan_div[1] |= (i >> 4) & 0x04;
1502                 if (data->type != w83697hf)
1503                         data->fan_div[2] |= (i >> 5) & 0x04;
1504                 data->alarms =
1505                     w83627hf_read_value(client, W83781D_REG_ALARM1) |
1506                     (w83627hf_read_value(client, W83781D_REG_ALARM2) << 8) |
1507                     (w83627hf_read_value(client, W83781D_REG_ALARM3) << 16);
1508                 i = w83627hf_read_value(client, W83781D_REG_BEEP_INTS2);
1509                 data->beep_enable = i >> 7;
1510                 data->beep_mask = ((i & 0x7f) << 8) |
1511                     w83627hf_read_value(client, W83781D_REG_BEEP_INTS1) |
1512                     w83627hf_read_value(client, W83781D_REG_BEEP_INTS3) << 16;
1513                 data->last_updated = jiffies;
1514                 data->valid = 1;
1515         }
1516
1517         mutex_unlock(&data->update_lock);
1518
1519         return data;
1520 }
1521
1522 static int __init sensors_w83627hf_init(void)
1523 {
1524         if (w83627hf_find(0x2e, &address)
1525          && w83627hf_find(0x4e, &address)) {
1526                 return -ENODEV;
1527         }
1528
1529         return i2c_isa_add_driver(&w83627hf_driver);
1530 }
1531
1532 static void __exit sensors_w83627hf_exit(void)
1533 {
1534         i2c_isa_del_driver(&w83627hf_driver);
1535 }
1536
1537 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
1538               "Philip Edelbrock <phil@netroedge.com>, "
1539               "and Mark Studebaker <mdsxyz123@yahoo.com>");
1540 MODULE_DESCRIPTION("W83627HF driver");
1541 MODULE_LICENSE("GPL");
1542
1543 module_init(sensors_w83627hf_init);
1544 module_exit(sensors_w83627hf_exit);