git.oblomov.eu Git - linux-2.6/blob - drivers/hwmon/w83627ehf.c

   1 /*
   2     w83627ehf - Driver for the hardware monitoring functionality of
   3                 the Winbond W83627EHF Super-I/O chip
   4     Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
   5     Copyright (C) 2006  Yuan Mu (Winbond),
   6                         Rudolf Marek <r.marek@assembler.cz>
   7                         David Hubbard <david.c.hubbard@gmail.com>
   8
   9     Shamelessly ripped from the w83627hf driver
  10     Copyright (C) 2003  Mark Studebaker
  11
  12     Thanks to Leon Moonen, Steve Cliffe and Grant Coady for their help
  13     in testing and debugging this driver.
  14
  15     This driver also supports the W83627EHG, which is the lead-free
  16     version of the W83627EHF.
  17
  18     This program is free software; you can redistribute it and/or modify
  19     it under the terms of the GNU General Public License as published by
  20     the Free Software Foundation; either version 2 of the License, or
  21     (at your option) any later version.
  22
  23     This program is distributed in the hope that it will be useful,
  24     but WITHOUT ANY WARRANTY; without even the implied warranty of
  25     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26     GNU General Public License for more details.
  27
  28     You should have received a copy of the GNU General Public License
  29     along with this program; if not, write to the Free Software
  30     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31
  32
  33     Supports the following chips:
  34
  35     Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
  36     w83627ehf   10      5       4       3      0x8850 0x88    0x5ca3
  37                                                0x8860 0xa1
  38     w83627dhg    9      5       4       3      0xa020 0xc1    0x5ca3
  39 */
  40
  41 #include <linux/module.h>
  42 #include <linux/init.h>
  43 #include <linux/slab.h>
  44 #include <linux/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 REGION_ALIGNMENT        ~7
 125 #define REGION_OFFSET           5
 126 #define REGION_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                 if (new_div > data->fan_div[nr])
 720                         data->fan[nr] >>= (data->fan_div[nr] - new_div);
 721                 else
 722                         data->fan[nr] <<= (new_div - data->fan_div[nr]);
 723
 724                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
 725                         nr + 1, div_from_reg(data->fan_div[nr]),
 726                         div_from_reg(new_div));
 727                 data->fan_div[nr] = new_div;
 728                 w83627ehf_write_fan_div(client, nr);
 729         }
 730         w83627ehf_write_value(client, W83627EHF_REG_FAN_MIN[nr],
 731                               data->fan_min[nr]);
 732         mutex_unlock(&data->update_lock);
 733
 734         return count;
 735 }
 736
 737 static struct sensor_device_attribute sda_fan_input[] = {
 738         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
 739         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
 740         SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
 741         SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
 742         SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
 743 };
 744
 745 static struct sensor_device_attribute sda_fan_alarm[] = {
 746         SENSOR_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6),
 747         SENSOR_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7),
 748         SENSOR_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11),
 749         SENSOR_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 10),
 750         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 23),
 751 };
 752
 753 static struct sensor_device_attribute sda_fan_min[] = {
 754         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
 755                     store_fan_min, 0),
 756         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
 757                     store_fan_min, 1),
 758         SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
 759                     store_fan_min, 2),
 760         SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
 761                     store_fan_min, 3),
 762         SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
 763                     store_fan_min, 4),
 764 };
 765
 766 static struct sensor_device_attribute sda_fan_div[] = {
 767         SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
 768         SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
 769         SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
 770         SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
 771         SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
 772 };
 773
 774 #define show_temp1_reg(reg) \
 775 static ssize_t \
 776 show_##reg(struct device *dev, struct device_attribute *attr, \
 777            char *buf) \
 778 { \
 779         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 780         return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
 781 }
 782 show_temp1_reg(temp1);
 783 show_temp1_reg(temp1_max);
 784 show_temp1_reg(temp1_max_hyst);
 785
 786 #define store_temp1_reg(REG, reg) \
 787 static ssize_t \
 788 store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
 789                   const char *buf, size_t count) \
 790 { \
 791         struct i2c_client *client = to_i2c_client(dev); \
 792         struct w83627ehf_data *data = i2c_get_clientdata(client); \
 793         u32 val = simple_strtoul(buf, NULL, 10); \
 794  \
 795         mutex_lock(&data->update_lock); \
 796         data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
 797         w83627ehf_write_value(client, W83627EHF_REG_TEMP1_##REG, \
 798                               data->temp1_##reg); \
 799         mutex_unlock(&data->update_lock); \
 800         return count; \
 801 }
 802 store_temp1_reg(OVER, max);
 803 store_temp1_reg(HYST, max_hyst);
 804
 805 #define show_temp_reg(reg) \
 806 static ssize_t \
 807 show_##reg(struct device *dev, struct device_attribute *attr, \
 808            char *buf) \
 809 { \
 810         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 811         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 812         int nr = sensor_attr->index; \
 813         return sprintf(buf, "%d\n", \
 814                        LM75_TEMP_FROM_REG(data->reg[nr])); \
 815 }
 816 show_temp_reg(temp);
 817 show_temp_reg(temp_max);
 818 show_temp_reg(temp_max_hyst);
 819
 820 #define store_temp_reg(REG, reg) \
 821 static ssize_t \
 822 store_##reg(struct device *dev, struct device_attribute *attr, \
 823             const char *buf, size_t count) \
 824 { \
 825         struct i2c_client *client = to_i2c_client(dev); \
 826         struct w83627ehf_data *data = i2c_get_clientdata(client); \
 827         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 828         int nr = sensor_attr->index; \
 829         u32 val = simple_strtoul(buf, NULL, 10); \
 830  \
 831         mutex_lock(&data->update_lock); \
 832         data->reg[nr] = LM75_TEMP_TO_REG(val); \
 833         w83627ehf_write_value(client, W83627EHF_REG_TEMP_##REG[nr], \
 834                               data->reg[nr]); \
 835         mutex_unlock(&data->update_lock); \
 836         return count; \
 837 }
 838 store_temp_reg(OVER, temp_max);
 839 store_temp_reg(HYST, temp_max_hyst);
 840
 841 static struct sensor_device_attribute sda_temp[] = {
 842         SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
 843         SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
 844         SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
 845         SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
 846                     store_temp1_max, 0),
 847         SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
 848                     store_temp_max, 0),
 849         SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
 850                     store_temp_max, 1),
 851         SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
 852                     store_temp1_max_hyst, 0),
 853         SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 854                     store_temp_max_hyst, 0),
 855         SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 856                     store_temp_max_hyst, 1),
 857         SENSOR_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4),
 858         SENSOR_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5),
 859         SENSOR_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13),
 860 };
 861
 862 #define show_pwm_reg(reg) \
 863 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
 864                                 char *buf) \
 865 { \
 866         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 867         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 868         int nr = sensor_attr->index; \
 869         return sprintf(buf, "%d\n", data->reg[nr]); \
 870 }
 871
 872 show_pwm_reg(pwm_mode)
 873 show_pwm_reg(pwm_enable)
 874 show_pwm_reg(pwm)
 875
 876 static ssize_t
 877 store_pwm_mode(struct device *dev, struct device_attribute *attr,
 878                         const char *buf, size_t count)
 879 {
 880         struct i2c_client *client = to_i2c_client(dev);
 881         struct w83627ehf_data *data = i2c_get_clientdata(client);
 882         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 883         int nr = sensor_attr->index;
 884         u32 val = simple_strtoul(buf, NULL, 10);
 885         u16 reg;
 886
 887         if (val > 1)
 888                 return -EINVAL;
 889         mutex_lock(&data->update_lock);
 890         reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
 891         data->pwm_mode[nr] = val;
 892         reg &= ~(1 << W83627EHF_PWM_MODE_SHIFT[nr]);
 893         if (!val)
 894                 reg |= 1 << W83627EHF_PWM_MODE_SHIFT[nr];
 895         w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
 896         mutex_unlock(&data->update_lock);
 897         return count;
 898 }
 899
 900 static ssize_t
 901 store_pwm(struct device *dev, struct device_attribute *attr,
 902                         const char *buf, size_t count)
 903 {
 904         struct i2c_client *client = to_i2c_client(dev);
 905         struct w83627ehf_data *data = i2c_get_clientdata(client);
 906         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 907         int nr = sensor_attr->index;
 908         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
 909
 910         mutex_lock(&data->update_lock);
 911         data->pwm[nr] = val;
 912         w83627ehf_write_value(client, W83627EHF_REG_PWM[nr], val);
 913         mutex_unlock(&data->update_lock);
 914         return count;
 915 }
 916
 917 static ssize_t
 918 store_pwm_enable(struct device *dev, struct device_attribute *attr,
 919                         const char *buf, size_t count)
 920 {
 921         struct i2c_client *client = to_i2c_client(dev);
 922         struct w83627ehf_data *data = i2c_get_clientdata(client);
 923         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 924         int nr = sensor_attr->index;
 925         u32 val = simple_strtoul(buf, NULL, 10);
 926         u16 reg;
 927
 928         if (!val || (val > 2))  /* only modes 1 and 2 are supported */
 929                 return -EINVAL;
 930         mutex_lock(&data->update_lock);
 931         reg = w83627ehf_read_value(client, W83627EHF_REG_PWM_ENABLE[nr]);
 932         data->pwm_enable[nr] = val;
 933         reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
 934         reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
 935         w83627ehf_write_value(client, W83627EHF_REG_PWM_ENABLE[nr], reg);
 936         mutex_unlock(&data->update_lock);
 937         return count;
 938 }
 939
 940
 941 #define show_tol_temp(reg) \
 942 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 943                                 char *buf) \
 944 { \
 945         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 946         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 947         int nr = sensor_attr->index; \
 948         return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
 949 }
 950
 951 show_tol_temp(tolerance)
 952 show_tol_temp(target_temp)
 953
 954 static ssize_t
 955 store_target_temp(struct device *dev, struct device_attribute *attr,
 956                         const char *buf, size_t count)
 957 {
 958         struct i2c_client *client = to_i2c_client(dev);
 959         struct w83627ehf_data *data = i2c_get_clientdata(client);
 960         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 961         int nr = sensor_attr->index;
 962         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
 963
 964         mutex_lock(&data->update_lock);
 965         data->target_temp[nr] = val;
 966         w83627ehf_write_value(client, W83627EHF_REG_TARGET[nr], val);
 967         mutex_unlock(&data->update_lock);
 968         return count;
 969 }
 970
 971 static ssize_t
 972 store_tolerance(struct device *dev, struct device_attribute *attr,
 973                         const char *buf, size_t count)
 974 {
 975         struct i2c_client *client = to_i2c_client(dev);
 976         struct w83627ehf_data *data = i2c_get_clientdata(client);
 977         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 978         int nr = sensor_attr->index;
 979         u16 reg;
 980         /* Limit the temp to 0C - 15C */
 981         u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
 982
 983         mutex_lock(&data->update_lock);
 984         reg = w83627ehf_read_value(client, W83627EHF_REG_TOLERANCE[nr]);
 985         data->tolerance[nr] = val;
 986         if (nr == 1)
 987                 reg = (reg & 0x0f) | (val << 4);
 988         else
 989                 reg = (reg & 0xf0) | val;
 990         w83627ehf_write_value(client, W83627EHF_REG_TOLERANCE[nr], reg);
 991         mutex_unlock(&data->update_lock);
 992         return count;
 993 }
 994
 995 static struct sensor_device_attribute sda_pwm[] = {
 996         SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
 997         SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
 998         SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
 999         SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
1000 };
1001
1002 static struct sensor_device_attribute sda_pwm_mode[] = {
1003         SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1004                     store_pwm_mode, 0),
1005         SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1006                     store_pwm_mode, 1),
1007         SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1008                     store_pwm_mode, 2),
1009         SENSOR_ATTR(pwm4_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
1010                     store_pwm_mode, 3),
1011 };
1012
1013 static struct sensor_device_attribute sda_pwm_enable[] = {
1014         SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1015                     store_pwm_enable, 0),
1016         SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1017                     store_pwm_enable, 1),
1018         SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1019                     store_pwm_enable, 2),
1020         SENSOR_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1021                     store_pwm_enable, 3),
1022 };
1023
1024 static struct sensor_device_attribute sda_target_temp[] = {
1025         SENSOR_ATTR(pwm1_target, S_IWUSR | S_IRUGO, show_target_temp,
1026                     store_target_temp, 0),
1027         SENSOR_ATTR(pwm2_target, S_IWUSR | S_IRUGO, show_target_temp,
1028                     store_target_temp, 1),
1029         SENSOR_ATTR(pwm3_target, S_IWUSR | S_IRUGO, show_target_temp,
1030                     store_target_temp, 2),
1031         SENSOR_ATTR(pwm4_target, S_IWUSR | S_IRUGO, show_target_temp,
1032                     store_target_temp, 3),
1033 };
1034
1035 static struct sensor_device_attribute sda_tolerance[] = {
1036         SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1037                     store_tolerance, 0),
1038         SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1039                     store_tolerance, 1),
1040         SENSOR_ATTR(pwm3_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1041                     store_tolerance, 2),
1042         SENSOR_ATTR(pwm4_tolerance, S_IWUSR | S_IRUGO, show_tolerance,
1043                     store_tolerance, 3),
1044 };
1045
1046 /* Smart Fan registers */
1047
1048 #define fan_functions(reg, REG) \
1049 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1050                        char *buf) \
1051 { \
1052         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1053         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1054         int nr = sensor_attr->index; \
1055         return sprintf(buf, "%d\n", data->reg[nr]); \
1056 }\
1057 static ssize_t \
1058 store_##reg(struct device *dev, struct device_attribute *attr, \
1059                             const char *buf, size_t count) \
1060 {\
1061         struct i2c_client *client = to_i2c_client(dev); \
1062         struct w83627ehf_data *data = i2c_get_clientdata(client); \
1063         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1064         int nr = sensor_attr->index; \
1065         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
1066         mutex_lock(&data->update_lock); \
1067         data->reg[nr] = val; \
1068         w83627ehf_write_value(client, W83627EHF_REG_##REG[nr],  val); \
1069         mutex_unlock(&data->update_lock); \
1070         return count; \
1071 }
1072
1073 fan_functions(fan_min_output, FAN_MIN_OUTPUT)
1074
1075 #define fan_time_functions(reg, REG) \
1076 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
1077                                 char *buf) \
1078 { \
1079         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1080         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1081         int nr = sensor_attr->index; \
1082         return sprintf(buf, "%d\n", \
1083                         step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
1084 } \
1085 \
1086 static ssize_t \
1087 store_##reg(struct device *dev, struct device_attribute *attr, \
1088                         const char *buf, size_t count) \
1089 { \
1090         struct i2c_client *client = to_i2c_client(dev); \
1091         struct w83627ehf_data *data = i2c_get_clientdata(client); \
1092         struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
1093         int nr = sensor_attr->index; \
1094         u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
1095                                         data->pwm_mode[nr]); \
1096         mutex_lock(&data->update_lock); \
1097         data->reg[nr] = val; \
1098         w83627ehf_write_value(client, W83627EHF_REG_##REG[nr], val); \
1099         mutex_unlock(&data->update_lock); \
1100         return count; \
1101 } \
1102
1103 fan_time_functions(fan_stop_time, FAN_STOP_TIME)
1104
1105
1106 static struct sensor_device_attribute sda_sf3_arrays_fan4[] = {
1107         SENSOR_ATTR(pwm4_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1108                     store_fan_stop_time, 3),
1109         SENSOR_ATTR(pwm4_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1110                     store_fan_min_output, 3),
1111 };
1112
1113 static struct sensor_device_attribute sda_sf3_arrays[] = {
1114         SENSOR_ATTR(pwm1_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1115                     store_fan_stop_time, 0),
1116         SENSOR_ATTR(pwm2_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1117                     store_fan_stop_time, 1),
1118         SENSOR_ATTR(pwm3_stop_time, S_IWUSR | S_IRUGO, show_fan_stop_time,
1119                     store_fan_stop_time, 2),
1120         SENSOR_ATTR(pwm1_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1121                     store_fan_min_output, 0),
1122         SENSOR_ATTR(pwm2_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1123                     store_fan_min_output, 1),
1124         SENSOR_ATTR(pwm3_min_output, S_IWUSR | S_IRUGO, show_fan_min_output,
1125                     store_fan_min_output, 2),
1126 };
1127
1128 /*
1129  * Driver and client management
1130  */
1131
1132 static void w83627ehf_device_remove_files(struct device *dev)
1133 {
1134         /* some entries in the following arrays may not have been used in
1135          * device_create_file(), but device_remove_file() will ignore them */
1136         int i;
1137
1138         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1139                 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
1140         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1141                 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
1142         for (i = 0; i < w83627ehf_num_in; i++) {
1143                 device_remove_file(dev, &sda_in_input[i].dev_attr);
1144                 device_remove_file(dev, &sda_in_alarm[i].dev_attr);
1145                 device_remove_file(dev, &sda_in_min[i].dev_attr);
1146                 device_remove_file(dev, &sda_in_max[i].dev_attr);
1147         }
1148         for (i = 0; i < 5; i++) {
1149                 device_remove_file(dev, &sda_fan_input[i].dev_attr);
1150                 device_remove_file(dev, &sda_fan_alarm[i].dev_attr);
1151                 device_remove_file(dev, &sda_fan_div[i].dev_attr);
1152                 device_remove_file(dev, &sda_fan_min[i].dev_attr);
1153         }
1154         for (i = 0; i < 4; i++) {
1155                 device_remove_file(dev, &sda_pwm[i].dev_attr);
1156                 device_remove_file(dev, &sda_pwm_mode[i].dev_attr);
1157                 device_remove_file(dev, &sda_pwm_enable[i].dev_attr);
1158                 device_remove_file(dev, &sda_target_temp[i].dev_attr);
1159                 device_remove_file(dev, &sda_tolerance[i].dev_attr);
1160         }
1161         for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
1162                 device_remove_file(dev, &sda_temp[i].dev_attr);
1163 }
1164
1165 static struct i2c_driver w83627ehf_driver;
1166
1167 static void w83627ehf_init_client(struct i2c_client *client)
1168 {
1169         int i;
1170         u8 tmp;
1171
1172         /* Start monitoring is needed */
1173         tmp = w83627ehf_read_value(client, W83627EHF_REG_CONFIG);
1174         if (!(tmp & 0x01))
1175                 w83627ehf_write_value(client, W83627EHF_REG_CONFIG,
1176                                       tmp | 0x01);
1177
1178         /* Enable temp2 and temp3 if needed */
1179         for (i = 0; i < 2; i++) {
1180                 tmp = w83627ehf_read_value(client,
1181                                            W83627EHF_REG_TEMP_CONFIG[i]);
1182                 if (tmp & 0x01)
1183                         w83627ehf_write_value(client,
1184                                               W83627EHF_REG_TEMP_CONFIG[i],
1185                                               tmp & 0xfe);
1186         }
1187 }
1188
1189 static int w83627ehf_detect(struct i2c_adapter *adapter)
1190 {
1191         struct i2c_client *client;
1192         struct w83627ehf_data *data;
1193         struct device *dev;
1194         u8 fan4pin, fan5pin;
1195         int i, err = 0;
1196
1197         if (!request_region(address + REGION_OFFSET, REGION_LENGTH,
1198                             w83627ehf_driver.driver.name)) {
1199                 err = -EBUSY;
1200                 goto exit;
1201         }
1202
1203         if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
1204                 err = -ENOMEM;
1205                 goto exit_release;
1206         }
1207
1208         client = &data->client;
1209         i2c_set_clientdata(client, data);
1210         client->addr = address;
1211         mutex_init(&data->lock);
1212         client->adapter = adapter;
1213         client->driver = &w83627ehf_driver;
1214         client->flags = 0;
1215         dev = &client->dev;
1216
1217         if (w83627ehf_num_in == 9)
1218                 strlcpy(client->name, "w83627dhg", I2C_NAME_SIZE);
1219         else    /* just say ehf. 627EHG is 627EHF in lead-free packaging. */
1220                 strlcpy(client->name, "w83627ehf", I2C_NAME_SIZE);
1221
1222         data->valid = 0;
1223         mutex_init(&data->update_lock);
1224
1225         /* Tell the i2c layer a new client has arrived */
1226         if ((err = i2c_attach_client(client)))
1227                 goto exit_free;
1228
1229         /* Initialize the chip */
1230         w83627ehf_init_client(client);
1231
1232         /* A few vars need to be filled upon startup */
1233         for (i = 0; i < 5; i++)
1234                 data->fan_min[i] = w83627ehf_read_value(client,
1235                                    W83627EHF_REG_FAN_MIN[i]);
1236
1237         /* fan4 and fan5 share some pins with the GPIO and serial flash */
1238
1239         superio_enter();
1240         fan5pin = superio_inb(0x24) & 0x2;
1241         fan4pin = superio_inb(0x29) & 0x6;
1242         superio_exit();
1243
1244         /* It looks like fan4 and fan5 pins can be alternatively used
1245            as fan on/off switches, but fan5 control is write only :/
1246            We assume that if the serial interface is disabled, designers
1247            connected fan5 as input unless they are emitting log 1, which
1248            is not the default. */
1249
1250         data->has_fan = 0x07; /* fan1, fan2 and fan3 */
1251         i = w83627ehf_read_value(client, W83627EHF_REG_FANDIV1);
1252         if ((i & (1 << 2)) && (!fan4pin))
1253                 data->has_fan |= (1 << 3);
1254         if (!(i & (1 << 1)) && (!fan5pin))
1255                 data->has_fan |= (1 << 4);
1256
1257         /* Register sysfs hooks */
1258         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1259                 if ((err = device_create_file(dev,
1260                         &sda_sf3_arrays[i].dev_attr)))
1261                         goto exit_remove;
1262
1263         /* if fan4 is enabled create the sf3 files for it */
1264         if (data->has_fan & (1 << 3))
1265                 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
1266                         if ((err = device_create_file(dev,
1267                                 &sda_sf3_arrays_fan4[i].dev_attr)))
1268                                 goto exit_remove;
1269                 }
1270
1271         for (i = 0; i < w83627ehf_num_in; i++)
1272                 if ((err = device_create_file(dev, &sda_in_input[i].dev_attr))
1273                         || (err = device_create_file(dev,
1274                                 &sda_in_alarm[i].dev_attr))
1275                         || (err = device_create_file(dev,
1276                                 &sda_in_min[i].dev_attr))
1277                         || (err = device_create_file(dev,
1278                                 &sda_in_max[i].dev_attr)))
1279                         goto exit_remove;
1280
1281         for (i = 0; i < 5; i++) {
1282                 if (data->has_fan & (1 << i)) {
1283                         if ((err = device_create_file(dev,
1284                                         &sda_fan_input[i].dev_attr))
1285                                 || (err = device_create_file(dev,
1286                                         &sda_fan_alarm[i].dev_attr))
1287                                 || (err = device_create_file(dev,
1288                                         &sda_fan_div[i].dev_attr))
1289                                 || (err = device_create_file(dev,
1290                                         &sda_fan_min[i].dev_attr)))
1291                                 goto exit_remove;
1292                         if (i < 4 && /* w83627ehf only has 4 pwm */
1293                                 ((err = device_create_file(dev,
1294                                         &sda_pwm[i].dev_attr))
1295                                 || (err = device_create_file(dev,
1296                                         &sda_pwm_mode[i].dev_attr))
1297                                 || (err = device_create_file(dev,
1298                                         &sda_pwm_enable[i].dev_attr))
1299                                 || (err = device_create_file(dev,
1300                                         &sda_target_temp[i].dev_attr))
1301                                 || (err = device_create_file(dev,
1302                                         &sda_tolerance[i].dev_attr))))
1303                                 goto exit_remove;
1304                 }
1305         }
1306
1307         for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
1308                 if ((err = device_create_file(dev, &sda_temp[i].dev_attr)))
1309                         goto exit_remove;
1310
1311         data->class_dev = hwmon_device_register(dev);
1312         if (IS_ERR(data->class_dev)) {
1313                 err = PTR_ERR(data->class_dev);
1314                 goto exit_remove;
1315         }
1316
1317         return 0;
1318
1319 exit_remove:
1320         w83627ehf_device_remove_files(dev);
1321         i2c_detach_client(client);
1322 exit_free:
1323         kfree(data);
1324 exit_release:
1325         release_region(address + REGION_OFFSET, REGION_LENGTH);
1326 exit:
1327         return err;
1328 }
1329
1330 static int w83627ehf_detach_client(struct i2c_client *client)
1331 {
1332         struct w83627ehf_data *data = i2c_get_clientdata(client);
1333         int err;
1334
1335         hwmon_device_unregister(data->class_dev);
1336         w83627ehf_device_remove_files(&client->dev);
1337
1338         if ((err = i2c_detach_client(client)))
1339                 return err;
1340         release_region(client->addr + REGION_OFFSET, REGION_LENGTH);
1341         kfree(data);
1342
1343         return 0;
1344 }
1345
1346 static struct i2c_driver w83627ehf_driver = {
1347         .driver = {
1348                 .owner  = THIS_MODULE,
1349                 .name   = "w83627ehf",
1350         },
1351         .attach_adapter = w83627ehf_detect,
1352         .detach_client  = w83627ehf_detach_client,
1353 };
1354
1355 static int __init w83627ehf_find(int sioaddr, unsigned short *addr)
1356 {
1357         u16 val;
1358
1359         REG = sioaddr;
1360         VAL = sioaddr + 1;
1361         superio_enter();
1362
1363         val = (superio_inb(SIO_REG_DEVID) << 8)
1364             | superio_inb(SIO_REG_DEVID + 1);
1365         switch (val & SIO_ID_MASK) {
1366         case SIO_W83627DHG_ID:
1367                 w83627ehf_num_in = 9;
1368                 break;
1369         case SIO_W83627EHF_ID:
1370         case SIO_W83627EHG_ID:
1371                 w83627ehf_num_in = 10;
1372                 break;
1373         default:
1374                 printk(KERN_WARNING "w83627ehf: unsupported chip ID: 0x%04x\n",
1375                         val);
1376                 superio_exit();
1377                 return -ENODEV;
1378         }
1379
1380         superio_select(W83627EHF_LD_HWM);
1381         val = (superio_inb(SIO_REG_ADDR) << 8)
1382             | superio_inb(SIO_REG_ADDR + 1);
1383         *addr = val & REGION_ALIGNMENT;
1384         if (*addr == 0) {
1385                 superio_exit();
1386                 return -ENODEV;
1387         }
1388
1389         /* Activate logical device if needed */
1390         val = superio_inb(SIO_REG_ENABLE);
1391         if (!(val & 0x01))
1392                 superio_outb(SIO_REG_ENABLE, val | 0x01);
1393
1394         superio_exit();
1395         return 0;
1396 }
1397
1398 static int __init sensors_w83627ehf_init(void)
1399 {
1400         if (w83627ehf_find(0x2e, &address)
1401          && w83627ehf_find(0x4e, &address))
1402                 return -ENODEV;
1403
1404         return i2c_isa_add_driver(&w83627ehf_driver);
1405 }
1406
1407 static void __exit sensors_w83627ehf_exit(void)
1408 {
1409         i2c_isa_del_driver(&w83627ehf_driver);
1410 }
1411
1412 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
1413 MODULE_DESCRIPTION("W83627EHF driver");
1414 MODULE_LICENSE("GPL");
1415
1416 module_init(sensors_w83627ehf_init);
1417 module_exit(sensors_w83627ehf_exit);