drivers/hwmon/w83627ehf.c

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