drivers/hwmon/dme1737.c

   1 /*
   2  * dme1737.c - Driver for the SMSC DME1737, Asus A8000, SMSC SCH311x, SCH5027,
   3  *             and SCH5127 Super-I/O chips integrated hardware monitoring
   4  *             features.
   5  * Copyright (c) 2007, 2008, 2009, 2010 Juerg Haefliger <juergh@gmail.com>
   6  *
   7  * This driver is an I2C/ISA hybrid, meaning that it uses the I2C bus to access
   8  * the chip registers if a DME1737, A8000, or SCH5027 is found and the ISA bus
   9  * if a SCH311x or SCH5127 chip is found. Both types of chips have very
  10  * similar hardware monitoring capabilities but differ in the way they can be
  11  * accessed.
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  */
  27
  28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  29
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/slab.h>
  33 #include <linux/jiffies.h>
  34 #include <linux/i2c.h>
  35 #include <linux/platform_device.h>
  36 #include <linux/hwmon.h>
  37 #include <linux/hwmon-sysfs.h>
  38 #include <linux/hwmon-vid.h>
  39 #include <linux/err.h>
  40 #include <linux/mutex.h>
  41 #include <linux/acpi.h>
  42 #include <linux/io.h>
  43
  44 /* ISA device, if found */
  45 static struct platform_device *pdev;
  46
  47 /* Module load parameters */
  48 static int force_start;
  49 module_param(force_start, bool, 0);
  50 MODULE_PARM_DESC(force_start, "Force the chip to start monitoring inputs");
  51
  52 static unsigned short force_id;
  53 module_param(force_id, ushort, 0);
  54 MODULE_PARM_DESC(force_id, "Override the detected device ID");
  55
  56 static int probe_all_addr;
  57 module_param(probe_all_addr, bool, 0);
  58 MODULE_PARM_DESC(probe_all_addr, "Include probing of non-standard LPC "
  59                  "addresses");
  60
  61 /* Addresses to scan */
  62 static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END};
  63
  64 enum chips { dme1737, sch5027, sch311x, sch5127 };
  65
  66 /* ---------------------------------------------------------------------
  67  * Registers
  68  *
  69  * The sensors are defined as follows:
  70  *
  71  * Voltages                          Temperatures
  72  * --------                          ------------
  73  * in0   +5VTR (+5V stdby)           temp1   Remote diode 1
  74  * in1   Vccp  (proc core)           temp2   Internal temp
  75  * in2   VCC   (internal +3.3V)      temp3   Remote diode 2
  76  * in3   +5V
  77  * in4   +12V
  78  * in5   VTR   (+3.3V stby)
  79  * in6   Vbat
  80  * in7   Vtrip (sch5127 only)
  81  *
  82  * --------------------------------------------------------------------- */
  83
  84 /* Voltages (in) numbered 0-7 (ix) */
  85 #define DME1737_REG_IN(ix)              ((ix) < 5 ? 0x20 + (ix) : \
  86                                          (ix) < 7 ? 0x94 + (ix) : \
  87                                                     0x1f)
  88 #define DME1737_REG_IN_MIN(ix)          ((ix) < 5 ? 0x44 + (ix) * 2 \
  89                                                   : 0x91 + (ix) * 2)
  90 #define DME1737_REG_IN_MAX(ix)          ((ix) < 5 ? 0x45 + (ix) * 2 \
  91                                                   : 0x92 + (ix) * 2)
  92
  93 /* Temperatures (temp) numbered 0-2 (ix) */
  94 #define DME1737_REG_TEMP(ix)            (0x25 + (ix))
  95 #define DME1737_REG_TEMP_MIN(ix)        (0x4e + (ix) * 2)
  96 #define DME1737_REG_TEMP_MAX(ix)        (0x4f + (ix) * 2)
  97 #define DME1737_REG_TEMP_OFFSET(ix)     ((ix) == 0 ? 0x1f \
  98                                                    : 0x1c + (ix))
  99
 100 /* Voltage and temperature LSBs
 101  * The LSBs (4 bits each) are stored in 5 registers with the following layouts:
 102  *    IN_TEMP_LSB(0) = [in5, in6]
 103  *    IN_TEMP_LSB(1) = [temp3, temp1]
 104  *    IN_TEMP_LSB(2) = [in4, temp2]
 105  *    IN_TEMP_LSB(3) = [in3, in0]
 106  *    IN_TEMP_LSB(4) = [in2, in1]
 107  *    IN_TEMP_LSB(5) = [res, in7] */
 108 #define DME1737_REG_IN_TEMP_LSB(ix)     (0x84 + (ix))
 109 static const u8 DME1737_REG_IN_LSB[] = {3, 4, 4, 3, 2, 0, 0, 5};
 110 static const u8 DME1737_REG_IN_LSB_SHL[] = {4, 4, 0, 0, 0, 0, 4, 4};
 111 static const u8 DME1737_REG_TEMP_LSB[] = {1, 2, 1};
 112 static const u8 DME1737_REG_TEMP_LSB_SHL[] = {4, 4, 0};
 113
 114 /* Fans numbered 0-5 (ix) */
 115 #define DME1737_REG_FAN(ix)             ((ix) < 4 ? 0x28 + (ix) * 2 \
 116                                                   : 0xa1 + (ix) * 2)
 117 #define DME1737_REG_FAN_MIN(ix)         ((ix) < 4 ? 0x54 + (ix) * 2 \
 118                                                   : 0xa5 + (ix) * 2)
 119 #define DME1737_REG_FAN_OPT(ix)         ((ix) < 4 ? 0x90 + (ix) \
 120                                                   : 0xb2 + (ix))
 121 #define DME1737_REG_FAN_MAX(ix)         (0xb4 + (ix)) /* only for fan[4-5] */
 122
 123 /* PWMs numbered 0-2, 4-5 (ix) */
 124 #define DME1737_REG_PWM(ix)             ((ix) < 3 ? 0x30 + (ix) \
 125                                                   : 0xa1 + (ix))
 126 #define DME1737_REG_PWM_CONFIG(ix)      (0x5c + (ix)) /* only for pwm[0-2] */
 127 #define DME1737_REG_PWM_MIN(ix)         (0x64 + (ix)) /* only for pwm[0-2] */
 128 #define DME1737_REG_PWM_FREQ(ix)        ((ix) < 3 ? 0x5f + (ix) \
 129                                                   : 0xa3 + (ix))
 130 /* The layout of the ramp rate registers is different from the other pwm
 131  * registers. The bits for the 3 PWMs are stored in 2 registers:
 132  *    PWM_RR(0) = [OFF3, OFF2,  OFF1,  RES,   RR1E, RR1-2, RR1-1, RR1-0]
 133  *    PWM_RR(1) = [RR2E, RR2-2, RR2-1, RR2-0, RR3E, RR3-2, RR3-1, RR3-0] */
 134 #define DME1737_REG_PWM_RR(ix)          (0x62 + (ix)) /* only for pwm[0-2] */
 135
 136 /* Thermal zones 0-2 */
 137 #define DME1737_REG_ZONE_LOW(ix)        (0x67 + (ix))
 138 #define DME1737_REG_ZONE_ABS(ix)        (0x6a + (ix))
 139 /* The layout of the hysteresis registers is different from the other zone
 140  * registers. The bits for the 3 zones are stored in 2 registers:
 141  *    ZONE_HYST(0) = [H1-3,  H1-2,  H1-1, H1-0, H2-3, H2-2, H2-1, H2-0]
 142  *    ZONE_HYST(1) = [H3-3,  H3-2,  H3-1, H3-0, RES,  RES,  RES,  RES] */
 143 #define DME1737_REG_ZONE_HYST(ix)       (0x6d + (ix))
 144
 145 /* Alarm registers and bit mapping
 146  * The 3 8-bit alarm registers will be concatenated to a single 32-bit
 147  * alarm value [0, ALARM3, ALARM2, ALARM1]. */
 148 #define DME1737_REG_ALARM1              0x41
 149 #define DME1737_REG_ALARM2              0x42
 150 #define DME1737_REG_ALARM3              0x83
 151 static const u8 DME1737_BIT_ALARM_IN[] = {0, 1, 2, 3, 8, 16, 17, 18};
 152 static const u8 DME1737_BIT_ALARM_TEMP[] = {4, 5, 6};
 153 static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
 154
 155 /* Miscellaneous registers */
 156 #define DME1737_REG_DEVICE              0x3d
 157 #define DME1737_REG_COMPANY             0x3e
 158 #define DME1737_REG_VERSTEP             0x3f
 159 #define DME1737_REG_CONFIG              0x40
 160 #define DME1737_REG_CONFIG2             0x7f
 161 #define DME1737_REG_VID                 0x43
 162 #define DME1737_REG_TACH_PWM            0x81
 163
 164 /* ---------------------------------------------------------------------
 165  * Misc defines
 166  * --------------------------------------------------------------------- */
 167
 168 /* Chip identification */
 169 #define DME1737_COMPANY_SMSC    0x5c
 170 #define DME1737_VERSTEP         0x88
 171 #define DME1737_VERSTEP_MASK    0xf8
 172 #define SCH311X_DEVICE          0x8c
 173 #define SCH5027_VERSTEP         0x69
 174 #define SCH5127_DEVICE          0x8e
 175
 176 /* Device ID values (global configuration register index 0x20) */
 177 #define DME1737_ID_1    0x77
 178 #define DME1737_ID_2    0x78
 179 #define SCH3112_ID      0x7c
 180 #define SCH3114_ID      0x7d
 181 #define SCH3116_ID      0x7f
 182 #define SCH5027_ID      0x89
 183 #define SCH5127_ID      0x86
 184
 185 /* Length of ISA address segment */
 186 #define DME1737_EXTENT  2
 187
 188 /* chip-dependent features */
 189 #define HAS_TEMP_OFFSET         (1 << 0)                /* bit 0 */
 190 #define HAS_VID                 (1 << 1)                /* bit 1 */
 191 #define HAS_ZONE3               (1 << 2)                /* bit 2 */
 192 #define HAS_ZONE_HYST           (1 << 3)                /* bit 3 */
 193 #define HAS_PWM_MIN             (1 << 4)                /* bit 4 */
 194 #define HAS_FAN(ix)             (1 << ((ix) + 5))       /* bits 5-10 */
 195 #define HAS_PWM(ix)             (1 << ((ix) + 11))      /* bits 11-16 */
 196 #define HAS_IN7                 (1 << 17)               /* bit 17 */
 197
 198 /* ---------------------------------------------------------------------
 199  * Data structures and manipulation thereof
 200  * --------------------------------------------------------------------- */
 201
 202 struct dme1737_data {
 203         struct i2c_client *client;      /* for I2C devices only */
 204         struct device *hwmon_dev;
 205         const char *name;
 206         unsigned int addr;              /* for ISA devices only */
 207
 208         struct mutex update_lock;
 209         int valid;                      /* !=0 if following fields are valid */
 210         unsigned long last_update;      /* in jiffies */
 211         unsigned long last_vbat;        /* in jiffies */
 212         enum chips type;
 213         const int *in_nominal;          /* pointer to IN_NOMINAL array */
 214
 215         u8 vid;
 216         u8 pwm_rr_en;
 217         u32 has_features;
 218
 219         /* Register values */
 220         u16 in[8];
 221         u8  in_min[8];
 222         u8  in_max[8];
 223         s16 temp[3];
 224         s8  temp_min[3];
 225         s8  temp_max[3];
 226         s8  temp_offset[3];
 227         u8  config;
 228         u8  config2;
 229         u8  vrm;
 230         u16 fan[6];
 231         u16 fan_min[6];
 232         u8  fan_max[2];
 233         u8  fan_opt[6];
 234         u8  pwm[6];
 235         u8  pwm_min[3];
 236         u8  pwm_config[3];
 237         u8  pwm_acz[3];
 238         u8  pwm_freq[6];
 239         u8  pwm_rr[2];
 240         u8  zone_low[3];
 241         u8  zone_abs[3];
 242         u8  zone_hyst[2];
 243         u32 alarms;
 244 };
 245
 246 /* Nominal voltage values */
 247 static const int IN_NOMINAL_DME1737[] = {5000, 2250, 3300, 5000, 12000, 3300,
 248                                          3300};
 249 static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300,
 250                                          3300};
 251 static const int IN_NOMINAL_SCH5027[] = {5000, 2250, 3300, 1125, 1125, 3300,
 252                                          3300};
 253 static const int IN_NOMINAL_SCH5127[] = {2500, 2250, 3300, 1125, 1125, 3300,
 254                                          3300, 1500};
 255 #define IN_NOMINAL(type)        ((type) == sch311x ? IN_NOMINAL_SCH311x : \
 256                                  (type) == sch5027 ? IN_NOMINAL_SCH5027 : \
 257                                  (type) == sch5127 ? IN_NOMINAL_SCH5127 : \
 258                                  IN_NOMINAL_DME1737)
 259
 260 /* Voltage input
 261  * Voltage inputs have 16 bits resolution, limit values have 8 bits
 262  * resolution. */
 263 static inline int IN_FROM_REG(int reg, int nominal, int res)
 264 {
 265         return (reg * nominal + (3 << (res - 3))) / (3 << (res - 2));
 266 }
 267
 268 static inline int IN_TO_REG(int val, int nominal)
 269 {
 270         return SENSORS_LIMIT((val * 192 + nominal / 2) / nominal, 0, 255);
 271 }
 272
 273 /* Temperature input
 274  * The register values represent temperatures in 2's complement notation from
 275  * -127 degrees C to +127 degrees C. Temp inputs have 16 bits resolution, limit
 276  * values have 8 bits resolution. */
 277 static inline int TEMP_FROM_REG(int reg, int res)
 278 {
 279         return (reg * 1000) >> (res - 8);
 280 }
 281
 282 static inline int TEMP_TO_REG(int val)
 283 {
 284         return SENSORS_LIMIT((val < 0 ? val - 500 : val + 500) / 1000,
 285                              -128, 127);
 286 }
 287
 288 /* Temperature range */
 289 static const int TEMP_RANGE[] = {2000, 2500, 3333, 4000, 5000, 6666, 8000,
 290                                  10000, 13333, 16000, 20000, 26666, 32000,
 291                                  40000, 53333, 80000};
 292
 293 static inline int TEMP_RANGE_FROM_REG(int reg)
 294 {
 295         return TEMP_RANGE[(reg >> 4) & 0x0f];
 296 }
 297
 298 static int TEMP_RANGE_TO_REG(int val, int reg)
 299 {
 300         int i;
 301
 302         for (i = 15; i > 0; i--) {
 303                 if (val > (TEMP_RANGE[i] + TEMP_RANGE[i - 1] + 1) / 2) {
 304                         break;
 305                 }
 306         }
 307
 308         return (reg & 0x0f) | (i << 4);
 309 }
 310
 311 /* Temperature hysteresis
 312  * Register layout:
 313  *    reg[0] = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0]
 314  *    reg[1] = [H3-3, H3-2, H3-1, H3-0, xxxx, xxxx, xxxx, xxxx] */
 315 static inline int TEMP_HYST_FROM_REG(int reg, int ix)
 316 {
 317         return (((ix == 1) ? reg : reg >> 4) & 0x0f) * 1000;
 318 }
 319
 320 static inline int TEMP_HYST_TO_REG(int val, int ix, int reg)
 321 {
 322         int hyst = SENSORS_LIMIT((val + 500) / 1000, 0, 15);
 323
 324         return (ix == 1) ? (reg & 0xf0) | hyst : (reg & 0x0f) | (hyst << 4);
 325 }
 326
 327 /* Fan input RPM */
 328 static inline int FAN_FROM_REG(int reg, int tpc)
 329 {
 330         if (tpc) {
 331                 return tpc * reg;
 332         } else {
 333                 return (reg == 0 || reg == 0xffff) ? 0 : 90000 * 60 / reg;
 334         }
 335 }
 336
 337 static inline int FAN_TO_REG(int val, int tpc)
 338 {
 339         if (tpc) {
 340                 return SENSORS_LIMIT(val / tpc, 0, 0xffff);
 341         } else {
 342                 return (val <= 0) ? 0xffff :
 343                         SENSORS_LIMIT(90000 * 60 / val, 0, 0xfffe);
 344         }
 345 }
 346
 347 /* Fan TPC (tach pulse count)
 348  * Converts a register value to a TPC multiplier or returns 0 if the tachometer
 349  * is configured in legacy (non-tpc) mode */
 350 static inline int FAN_TPC_FROM_REG(int reg)
 351 {
 352         return (reg & 0x20) ? 0 : 60 >> (reg & 0x03);
 353 }
 354
 355 /* Fan type
 356  * The type of a fan is expressed in number of pulses-per-revolution that it
 357  * emits */
 358 static inline int FAN_TYPE_FROM_REG(int reg)
 359 {
 360         int edge = (reg >> 1) & 0x03;
 361
 362         return (edge > 0) ? 1 << (edge - 1) : 0;
 363 }
 364
 365 static inline int FAN_TYPE_TO_REG(int val, int reg)
 366 {
 367         int edge = (val == 4) ? 3 : val;
 368
 369         return (reg & 0xf9) | (edge << 1);
 370 }
 371
 372 /* Fan max RPM */
 373 static const int FAN_MAX[] = {0x54, 0x38, 0x2a, 0x21, 0x1c, 0x18, 0x15, 0x12,
 374                               0x11, 0x0f, 0x0e};
 375
 376 static int FAN_MAX_FROM_REG(int reg)
 377 {
 378         int i;
 379
 380         for (i = 10; i > 0; i--) {
 381                 if (reg == FAN_MAX[i]) {
 382                         break;
 383                 }
 384         }
 385
 386         return 1000 + i * 500;
 387 }
 388
 389 static int FAN_MAX_TO_REG(int val)
 390 {
 391         int i;
 392
 393         for (i = 10; i > 0; i--) {
 394                 if (val > (1000 + (i - 1) * 500)) {
 395                         break;
 396                 }
 397         }
 398
 399         return FAN_MAX[i];
 400 }
 401
 402 /* PWM enable
 403  * Register to enable mapping:
 404  * 000:  2  fan on zone 1 auto
 405  * 001:  2  fan on zone 2 auto
 406  * 010:  2  fan on zone 3 auto
 407  * 011:  0  fan full on
 408  * 100: -1  fan disabled
 409  * 101:  2  fan on hottest of zones 2,3 auto
 410  * 110:  2  fan on hottest of zones 1,2,3 auto
 411  * 111:  1  fan in manual mode */
 412 static inline int PWM_EN_FROM_REG(int reg)
 413 {
 414         static const int en[] = {2, 2, 2, 0, -1, 2, 2, 1};
 415
 416         return en[(reg >> 5) & 0x07];
 417 }
 418
 419 static inline int PWM_EN_TO_REG(int val, int reg)
 420 {
 421         int en = (val == 1) ? 7 : 3;
 422
 423         return (reg & 0x1f) | ((en & 0x07) << 5);
 424 }
 425
 426 /* PWM auto channels zone
 427  * Register to auto channels zone mapping (ACZ is a bitfield with bit x
 428  * corresponding to zone x+1):
 429  * 000: 001  fan on zone 1 auto
 430  * 001: 010  fan on zone 2 auto
 431  * 010: 100  fan on zone 3 auto
 432  * 011: 000  fan full on
 433  * 100: 000  fan disabled
 434  * 101: 110  fan on hottest of zones 2,3 auto
 435  * 110: 111  fan on hottest of zones 1,2,3 auto
 436  * 111: 000  fan in manual mode */
 437 static inline int PWM_ACZ_FROM_REG(int reg)
 438 {
 439         static const int acz[] = {1, 2, 4, 0, 0, 6, 7, 0};
 440
 441         return acz[(reg >> 5) & 0x07];
 442 }
 443
 444 static inline int PWM_ACZ_TO_REG(int val, int reg)
 445 {
 446         int acz = (val == 4) ? 2 : val - 1;
 447
 448         return (reg & 0x1f) | ((acz & 0x07) << 5);
 449 }
 450
 451 /* PWM frequency */
 452 static const int PWM_FREQ[] = {11, 15, 22, 29, 35, 44, 59, 88,
 453                                15000, 20000, 30000, 25000, 0, 0, 0, 0};
 454
 455 static inline int PWM_FREQ_FROM_REG(int reg)
 456 {
 457         return PWM_FREQ[reg & 0x0f];
 458 }
 459
 460 static int PWM_FREQ_TO_REG(int val, int reg)
 461 {
 462         int i;
 463
 464         /* the first two cases are special - stupid chip design! */
 465         if (val > 27500) {
 466                 i = 10;
 467         } else if (val > 22500) {
 468                 i = 11;
 469         } else {
 470                 for (i = 9; i > 0; i--) {
 471                         if (val > (PWM_FREQ[i] + PWM_FREQ[i - 1] + 1) / 2) {
 472                                 break;
 473                         }
 474                 }
 475         }
 476
 477         return (reg & 0xf0) | i;
 478 }
 479
 480 /* PWM ramp rate
 481  * Register layout:
 482  *    reg[0] = [OFF3,  OFF2,  OFF1,  RES,   RR1-E, RR1-2, RR1-1, RR1-0]
 483  *    reg[1] = [RR2-E, RR2-2, RR2-1, RR2-0, RR3-E, RR3-2, RR3-1, RR3-0] */
 484 static const u8 PWM_RR[] = {206, 104, 69, 41, 26, 18, 10, 5};
 485
 486 static inline int PWM_RR_FROM_REG(int reg, int ix)
 487 {
 488         int rr = (ix == 1) ? reg >> 4 : reg;
 489
 490         return (rr & 0x08) ? PWM_RR[rr & 0x07] : 0;
 491 }
 492
 493 static int PWM_RR_TO_REG(int val, int ix, int reg)
 494 {
 495         int i;
 496
 497         for (i = 0; i < 7; i++) {
 498                 if (val > (PWM_RR[i] + PWM_RR[i + 1] + 1) / 2) {
 499                         break;
 500                 }
 501         }
 502
 503         return (ix == 1) ? (reg & 0x8f) | (i << 4) : (reg & 0xf8) | i;
 504 }
 505
 506 /* PWM ramp rate enable */
 507 static inline int PWM_RR_EN_FROM_REG(int reg, int ix)
 508 {
 509         return PWM_RR_FROM_REG(reg, ix) ? 1 : 0;
 510 }
 511
 512 static inline int PWM_RR_EN_TO_REG(int val, int ix, int reg)
 513 {
 514         int en = (ix == 1) ? 0x80 : 0x08;
 515
 516         return val ? reg | en : reg & ~en;
 517 }
 518
 519 /* PWM min/off
 520  * The PWM min/off bits are part of the PMW ramp rate register 0 (see above for
 521  * the register layout). */
 522 static inline int PWM_OFF_FROM_REG(int reg, int ix)
 523 {
 524         return (reg >> (ix + 5)) & 0x01;
 525 }
 526
 527 static inline int PWM_OFF_TO_REG(int val, int ix, int reg)
 528 {
 529         return (reg & ~(1 << (ix + 5))) | ((val & 0x01) << (ix + 5));
 530 }
 531
 532 /* ---------------------------------------------------------------------
 533  * Device I/O access
 534  *
 535  * ISA access is performed through an index/data register pair and needs to
 536  * be protected by a mutex during runtime (not required for initialization).
 537  * We use data->update_lock for this and need to ensure that we acquire it
 538  * before calling dme1737_read or dme1737_write.
 539  * --------------------------------------------------------------------- */
 540
 541 static u8 dme1737_read(const struct dme1737_data *data, u8 reg)
 542 {
 543         struct i2c_client *client = data->client;
 544         s32 val;
 545
 546         if (client) { /* I2C device */
 547                 val = i2c_smbus_read_byte_data(client, reg);
 548
 549                 if (val < 0) {
 550                         dev_warn(&client->dev, "Read from register "
 551                                  "0x%02x failed! Please report to the driver "
 552                                  "maintainer.\n", reg);
 553                 }
 554         } else { /* ISA device */
 555                 outb(reg, data->addr);
 556                 val = inb(data->addr + 1);
 557         }
 558
 559         return val;
 560 }
 561
 562 static s32 dme1737_write(const struct dme1737_data *data, u8 reg, u8 val)
 563 {
 564         struct i2c_client *client = data->client;
 565         s32 res = 0;
 566
 567         if (client) { /* I2C device */
 568                 res = i2c_smbus_write_byte_data(client, reg, val);
 569
 570                 if (res < 0) {
 571                         dev_warn(&client->dev, "Write to register "
 572                                  "0x%02x failed! Please report to the driver "
 573                                  "maintainer.\n", reg);
 574                 }
 575         } else { /* ISA device */
 576                 outb(reg, data->addr);
 577                 outb(val, data->addr + 1);
 578         }
 579
 580         return res;
 581 }
 582
 583 static struct dme1737_data *dme1737_update_device(struct device *dev)
 584 {
 585         struct dme1737_data *data = dev_get_drvdata(dev);
 586         int ix;
 587         u8 lsb[6];
 588
 589         mutex_lock(&data->update_lock);
 590
 591         /* Enable a Vbat monitoring cycle every 10 mins */
 592         if (time_after(jiffies, data->last_vbat + 600 * HZ) || !data->valid) {
 593                 dme1737_write(data, DME1737_REG_CONFIG, dme1737_read(data,
 594                                                 DME1737_REG_CONFIG) | 0x10);
 595                 data->last_vbat = jiffies;
 596         }
 597
 598         /* Sample register contents every 1 sec */
 599         if (time_after(jiffies, data->last_update + HZ) || !data->valid) {
 600                 if (data->has_features & HAS_VID) {
 601                         data->vid = dme1737_read(data, DME1737_REG_VID) &
 602                                 0x3f;
 603                 }
 604
 605                 /* In (voltage) registers */
 606                 for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
 607                         /* Voltage inputs are stored as 16 bit values even
 608                          * though they have only 12 bits resolution. This is
 609                          * to make it consistent with the temp inputs. */
 610                         if (ix == 7 && !(data->has_features & HAS_IN7)) {
 611                                 continue;
 612                         }
 613                         data->in[ix] = dme1737_read(data,
 614                                         DME1737_REG_IN(ix)) << 8;
 615                         data->in_min[ix] = dme1737_read(data,
 616                                         DME1737_REG_IN_MIN(ix));
 617                         data->in_max[ix] = dme1737_read(data,
 618                                         DME1737_REG_IN_MAX(ix));
 619                 }
 620
 621                 /* Temp registers */
 622                 for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) {
 623                         /* Temp inputs are stored as 16 bit values even
 624                          * though they have only 12 bits resolution. This is
 625                          * to take advantage of implicit conversions between
 626                          * register values (2's complement) and temp values
 627                          * (signed decimal). */
 628                         data->temp[ix] = dme1737_read(data,
 629                                         DME1737_REG_TEMP(ix)) << 8;
 630                         data->temp_min[ix] = dme1737_read(data,
 631                                         DME1737_REG_TEMP_MIN(ix));
 632                         data->temp_max[ix] = dme1737_read(data,
 633                                         DME1737_REG_TEMP_MAX(ix));
 634                         if (data->has_features & HAS_TEMP_OFFSET) {
 635                                 data->temp_offset[ix] = dme1737_read(data,
 636                                                 DME1737_REG_TEMP_OFFSET(ix));
 637                         }
 638                 }
 639
 640                 /* In and temp LSB registers
 641                  * The LSBs are latched when the MSBs are read, so the order in
 642                  * which the registers are read (MSB first, then LSB) is
 643                  * important! */
 644                 for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) {
 645                         if (ix == 5 && !(data->has_features & HAS_IN7)) {
 646                                 continue;
 647                         }
 648                         lsb[ix] = dme1737_read(data,
 649                                         DME1737_REG_IN_TEMP_LSB(ix));
 650                 }
 651                 for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
 652                         if (ix == 7 && !(data->has_features & HAS_IN7)) {
 653                                 continue;
 654                         }
 655                         data->in[ix] |= (lsb[DME1737_REG_IN_LSB[ix]] <<
 656                                         DME1737_REG_IN_LSB_SHL[ix]) & 0xf0;
 657                 }
 658                 for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) {
 659                         data->temp[ix] |= (lsb[DME1737_REG_TEMP_LSB[ix]] <<
 660                                         DME1737_REG_TEMP_LSB_SHL[ix]) & 0xf0;
 661                 }
 662
 663                 /* Fan registers */
 664                 for (ix = 0; ix < ARRAY_SIZE(data->fan); ix++) {
 665                         /* Skip reading registers if optional fans are not
 666                          * present */
 667                         if (!(data->has_features & HAS_FAN(ix))) {
 668                                 continue;
 669                         }
 670                         data->fan[ix] = dme1737_read(data,
 671                                         DME1737_REG_FAN(ix));
 672                         data->fan[ix] |= dme1737_read(data,
 673                                         DME1737_REG_FAN(ix) + 1) << 8;
 674                         data->fan_min[ix] = dme1737_read(data,
 675                                         DME1737_REG_FAN_MIN(ix));
 676                         data->fan_min[ix] |= dme1737_read(data,
 677                                         DME1737_REG_FAN_MIN(ix) + 1) << 8;
 678                         data->fan_opt[ix] = dme1737_read(data,
 679                                         DME1737_REG_FAN_OPT(ix));
 680                         /* fan_max exists only for fan[5-6] */
 681                         if (ix > 3) {
 682                                 data->fan_max[ix - 4] = dme1737_read(data,
 683                                         DME1737_REG_FAN_MAX(ix));
 684                         }
 685                 }
 686
 687                 /* PWM registers */
 688                 for (ix = 0; ix < ARRAY_SIZE(data->pwm); ix++) {
 689                         /* Skip reading registers if optional PWMs are not
 690                          * present */
 691                         if (!(data->has_features & HAS_PWM(ix))) {
 692                                 continue;
 693                         }
 694                         data->pwm[ix] = dme1737_read(data,
 695                                         DME1737_REG_PWM(ix));
 696                         data->pwm_freq[ix] = dme1737_read(data,
 697                                         DME1737_REG_PWM_FREQ(ix));
 698                         /* pwm_config and pwm_min exist only for pwm[1-3] */
 699                         if (ix < 3) {
 700                                 data->pwm_config[ix] = dme1737_read(data,
 701                                                 DME1737_REG_PWM_CONFIG(ix));
 702                                 data->pwm_min[ix] = dme1737_read(data,
 703                                                 DME1737_REG_PWM_MIN(ix));
 704                         }
 705                 }
 706                 for (ix = 0; ix < ARRAY_SIZE(data->pwm_rr); ix++) {
 707                         data->pwm_rr[ix] = dme1737_read(data,
 708                                                 DME1737_REG_PWM_RR(ix));
 709                 }
 710
 711                 /* Thermal zone registers */
 712                 for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) {
 713                         /* Skip reading registers if zone3 is not present */
 714                         if ((ix == 2) && !(data->has_features & HAS_ZONE3)) {
 715                                 continue;
 716                         }
 717                         /* sch5127 zone2 registers are special */
 718                         if ((ix == 1) && (data->type == sch5127)) {
 719                                 data->zone_low[1] = dme1737_read(data,
 720                                                 DME1737_REG_ZONE_LOW(2));
 721                                 data->zone_abs[1] = dme1737_read(data,
 722                                                 DME1737_REG_ZONE_ABS(2));
 723                         } else {
 724                                 data->zone_low[ix] = dme1737_read(data,
 725                                                 DME1737_REG_ZONE_LOW(ix));
 726                                 data->zone_abs[ix] = dme1737_read(data,
 727                                                 DME1737_REG_ZONE_ABS(ix));
 728                         }
 729                 }
 730                 if (data->has_features & HAS_ZONE_HYST) {
 731                         for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
 732                                 data->zone_hyst[ix] = dme1737_read(data,
 733                                                 DME1737_REG_ZONE_HYST(ix));
 734                         }
 735                 }
 736
 737                 /* Alarm registers */
 738                 data->alarms = dme1737_read(data,
 739                                                 DME1737_REG_ALARM1);
 740                 /* Bit 7 tells us if the other alarm registers are non-zero and
 741                  * therefore also need to be read */
 742                 if (data->alarms & 0x80) {
 743                         data->alarms |= dme1737_read(data,
 744                                                 DME1737_REG_ALARM2) << 8;
 745                         data->alarms |= dme1737_read(data,
 746                                                 DME1737_REG_ALARM3) << 16;
 747                 }
 748
 749                 /* The ISA chips require explicit clearing of alarm bits.
 750                  * Don't worry, an alarm will come back if the condition
 751                  * that causes it still exists */
 752                 if (!data->client) {
 753                         if (data->alarms & 0xff0000) {
 754                                 dme1737_write(data, DME1737_REG_ALARM3,
 755                                               0xff);
 756                         }
 757                         if (data->alarms & 0xff00) {
 758                                 dme1737_write(data, DME1737_REG_ALARM2,
 759                                               0xff);
 760                         }
 761                         if (data->alarms & 0xff) {
 762                                 dme1737_write(data, DME1737_REG_ALARM1,
 763                                               0xff);
 764                         }
 765                 }
 766
 767                 data->last_update = jiffies;
 768                 data->valid = 1;
 769         }
 770
 771         mutex_unlock(&data->update_lock);
 772
 773         return data;
 774 }
 775
 776 /* ---------------------------------------------------------------------
 777  * Voltage sysfs attributes
 778  * ix = [0-7]
 779  * --------------------------------------------------------------------- */
 780
 781 #define SYS_IN_INPUT    0
 782 #define SYS_IN_MIN      1
 783 #define SYS_IN_MAX      2
 784 #define SYS_IN_ALARM    3
 785
 786 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 787                        char *buf)
 788 {
 789         struct dme1737_data *data = dme1737_update_device(dev);
 790         struct sensor_device_attribute_2
 791                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
 792         int ix = sensor_attr_2->index;
 793         int fn = sensor_attr_2->nr;
 794         int res;
 795
 796         switch (fn) {
 797         case SYS_IN_INPUT:
 798                 res = IN_FROM_REG(data->in[ix], data->in_nominal[ix], 16);
 799                 break;
 800         case SYS_IN_MIN:
 801                 res = IN_FROM_REG(data->in_min[ix], data->in_nominal[ix], 8);
 802                 break;
 803         case SYS_IN_MAX:
 804                 res = IN_FROM_REG(data->in_max[ix], data->in_nominal[ix], 8);
 805                 break;
 806         case SYS_IN_ALARM:
 807                 res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01;
 808                 break;
 809         default:
 810                 res = 0;
 811                 dev_dbg(dev, "Unknown function %d.\n", fn);
 812         }
 813
 814         return sprintf(buf, "%d\n", res);
 815 }
 816
 817 static ssize_t set_in(struct device *dev, struct device_attribute *attr,
 818                       const char *buf, size_t count)
 819 {
 820         struct dme1737_data *data = dev_get_drvdata(dev);
 821         struct sensor_device_attribute_2
 822                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
 823         int ix = sensor_attr_2->index;
 824         int fn = sensor_attr_2->nr;
 825         long val = simple_strtol(buf, NULL, 10);
 826
 827         mutex_lock(&data->update_lock);
 828         switch (fn) {
 829         case SYS_IN_MIN:
 830                 data->in_min[ix] = IN_TO_REG(val, data->in_nominal[ix]);
 831                 dme1737_write(data, DME1737_REG_IN_MIN(ix),
 832                               data->in_min[ix]);
 833                 break;
 834         case SYS_IN_MAX:
 835                 data->in_max[ix] = IN_TO_REG(val, data->in_nominal[ix]);
 836                 dme1737_write(data, DME1737_REG_IN_MAX(ix),
 837                               data->in_max[ix]);
 838                 break;
 839         default:
 840                 dev_dbg(dev, "Unknown function %d.\n", fn);
 841         }
 842         mutex_unlock(&data->update_lock);
 843
 844         return count;
 845 }
 846
 847 /* ---------------------------------------------------------------------
 848  * Temperature sysfs attributes
 849  * ix = [0-2]
 850  * --------------------------------------------------------------------- */
 851
 852 #define SYS_TEMP_INPUT                  0
 853 #define SYS_TEMP_MIN                    1
 854 #define SYS_TEMP_MAX                    2
 855 #define SYS_TEMP_OFFSET                 3
 856 #define SYS_TEMP_ALARM                  4
 857 #define SYS_TEMP_FAULT                  5
 858
 859 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
 860                          char *buf)
 861 {
 862         struct dme1737_data *data = dme1737_update_device(dev);
 863         struct sensor_device_attribute_2
 864                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
 865         int ix = sensor_attr_2->index;
 866         int fn = sensor_attr_2->nr;
 867         int res;
 868
 869         switch (fn) {
 870         case SYS_TEMP_INPUT:
 871                 res = TEMP_FROM_REG(data->temp[ix], 16);
 872                 break;
 873         case SYS_TEMP_MIN:
 874                 res = TEMP_FROM_REG(data->temp_min[ix], 8);
 875                 break;
 876         case SYS_TEMP_MAX:
 877                 res = TEMP_FROM_REG(data->temp_max[ix], 8);
 878                 break;
 879         case SYS_TEMP_OFFSET:
 880                 res = TEMP_FROM_REG(data->temp_offset[ix], 8);
 881                 break;
 882         case SYS_TEMP_ALARM:
 883                 res = (data->alarms >> DME1737_BIT_ALARM_TEMP[ix]) & 0x01;
 884                 break;
 885         case SYS_TEMP_FAULT:
 886                 res = (((u16)data->temp[ix] & 0xff00) == 0x8000);
 887                 break;
 888         default:
 889                 res = 0;
 890                 dev_dbg(dev, "Unknown function %d.\n", fn);
 891         }
 892
 893         return sprintf(buf, "%d\n", res);
 894 }
 895
 896 static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
 897                         const char *buf, size_t count)
 898 {
 899         struct dme1737_data *data = dev_get_drvdata(dev);
 900         struct sensor_device_attribute_2
 901                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
 902         int ix = sensor_attr_2->index;
 903         int fn = sensor_attr_2->nr;
 904         long val = simple_strtol(buf, NULL, 10);
 905
 906         mutex_lock(&data->update_lock);
 907         switch (fn) {
 908         case SYS_TEMP_MIN:
 909                 data->temp_min[ix] = TEMP_TO_REG(val);
 910                 dme1737_write(data, DME1737_REG_TEMP_MIN(ix),
 911                               data->temp_min[ix]);
 912                 break;
 913         case SYS_TEMP_MAX:
 914                 data->temp_max[ix] = TEMP_TO_REG(val);
 915                 dme1737_write(data, DME1737_REG_TEMP_MAX(ix),
 916                               data->temp_max[ix]);
 917                 break;
 918         case SYS_TEMP_OFFSET:
 919                 data->temp_offset[ix] = TEMP_TO_REG(val);
 920                 dme1737_write(data, DME1737_REG_TEMP_OFFSET(ix),
 921                               data->temp_offset[ix]);
 922                 break;
 923         default:
 924                 dev_dbg(dev, "Unknown function %d.\n", fn);
 925         }
 926         mutex_unlock(&data->update_lock);
 927
 928         return count;
 929 }
 930
 931 /* ---------------------------------------------------------------------
 932  * Zone sysfs attributes
 933  * ix = [0-2]
 934  * --------------------------------------------------------------------- */
 935
 936 #define SYS_ZONE_AUTO_CHANNELS_TEMP     0
 937 #define SYS_ZONE_AUTO_POINT1_TEMP_HYST  1
 938 #define SYS_ZONE_AUTO_POINT1_TEMP       2
 939 #define SYS_ZONE_AUTO_POINT2_TEMP       3
 940 #define SYS_ZONE_AUTO_POINT3_TEMP       4
 941
 942 static ssize_t show_zone(struct device *dev, struct device_attribute *attr,
 943                          char *buf)
 944 {
 945         struct dme1737_data *data = dme1737_update_device(dev);
 946         struct sensor_device_attribute_2
 947                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
 948         int ix = sensor_attr_2->index;
 949         int fn = sensor_attr_2->nr;
 950         int res;
 951
 952         switch (fn) {
 953         case SYS_ZONE_AUTO_CHANNELS_TEMP:
 954                 /* check config2 for non-standard temp-to-zone mapping */
 955                 if ((ix == 1) && (data->config2 & 0x02)) {
 956                         res = 4;
 957                 } else {
 958                         res = 1 << ix;
 959                 }
 960                 break;
 961         case SYS_ZONE_AUTO_POINT1_TEMP_HYST:
 962                 res = TEMP_FROM_REG(data->zone_low[ix], 8) -
 963                       TEMP_HYST_FROM_REG(data->zone_hyst[ix == 2], ix);
 964                 break;
 965         case SYS_ZONE_AUTO_POINT1_TEMP:
 966                 res = TEMP_FROM_REG(data->zone_low[ix], 8);
 967                 break;
 968         case SYS_ZONE_AUTO_POINT2_TEMP:
 969                 /* pwm_freq holds the temp range bits in the upper nibble */
 970                 res = TEMP_FROM_REG(data->zone_low[ix], 8) +
 971                       TEMP_RANGE_FROM_REG(data->pwm_freq[ix]);
 972                 break;
 973         case SYS_ZONE_AUTO_POINT3_TEMP:
 974                 res = TEMP_FROM_REG(data->zone_abs[ix], 8);
 975                 break;
 976         default:
 977                 res = 0;
 978                 dev_dbg(dev, "Unknown function %d.\n", fn);
 979         }
 980
 981         return sprintf(buf, "%d\n", res);
 982 }
 983
 984 static ssize_t set_zone(struct device *dev, struct device_attribute *attr,
 985                         const char *buf, size_t count)
 986 {
 987         struct dme1737_data *data = dev_get_drvdata(dev);
 988         struct sensor_device_attribute_2
 989                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
 990         int ix = sensor_attr_2->index;
 991         int fn = sensor_attr_2->nr;
 992         long val = simple_strtol(buf, NULL, 10);
 993
 994         mutex_lock(&data->update_lock);
 995         switch (fn) {
 996         case SYS_ZONE_AUTO_POINT1_TEMP_HYST:
 997                 /* Refresh the cache */
 998                 data->zone_low[ix] = dme1737_read(data,
 999                                                   DME1737_REG_ZONE_LOW(ix));
1000                 /* Modify the temp hyst value */
1001                 data->zone_hyst[ix == 2] = TEMP_HYST_TO_REG(
1002                                         TEMP_FROM_REG(data->zone_low[ix], 8) -
1003                                         val, ix, dme1737_read(data,
1004                                         DME1737_REG_ZONE_HYST(ix == 2)));
1005                 dme1737_write(data, DME1737_REG_ZONE_HYST(ix == 2),
1006                               data->zone_hyst[ix == 2]);
1007                 break;
1008         case SYS_ZONE_AUTO_POINT1_TEMP:
1009                 data->zone_low[ix] = TEMP_TO_REG(val);
1010                 dme1737_write(data, DME1737_REG_ZONE_LOW(ix),
1011                               data->zone_low[ix]);
1012                 break;
1013         case SYS_ZONE_AUTO_POINT2_TEMP:
1014                 /* Refresh the cache */
1015                 data->zone_low[ix] = dme1737_read(data,
1016                                                   DME1737_REG_ZONE_LOW(ix));
1017                 /* Modify the temp range value (which is stored in the upper
1018                  * nibble of the pwm_freq register) */
1019                 data->pwm_freq[ix] = TEMP_RANGE_TO_REG(val -
1020                                         TEMP_FROM_REG(data->zone_low[ix], 8),
1021                                         dme1737_read(data,
1022                                         DME1737_REG_PWM_FREQ(ix)));
1023                 dme1737_write(data, DME1737_REG_PWM_FREQ(ix),
1024                               data->pwm_freq[ix]);
1025                 break;
1026         case SYS_ZONE_AUTO_POINT3_TEMP:
1027                 data->zone_abs[ix] = TEMP_TO_REG(val);
1028                 dme1737_write(data, DME1737_REG_ZONE_ABS(ix),
1029                               data->zone_abs[ix]);
1030                 break;
1031         default:
1032                 dev_dbg(dev, "Unknown function %d.\n", fn);
1033         }
1034         mutex_unlock(&data->update_lock);
1035
1036         return count;
1037 }
1038
1039 /* ---------------------------------------------------------------------
1040  * Fan sysfs attributes
1041  * ix = [0-5]
1042  * --------------------------------------------------------------------- */
1043
1044 #define SYS_FAN_INPUT   0
1045 #define SYS_FAN_MIN     1
1046 #define SYS_FAN_MAX     2
1047 #define SYS_FAN_ALARM   3
1048 #define SYS_FAN_TYPE    4
1049
1050 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
1051                         char *buf)
1052 {
1053         struct dme1737_data *data = dme1737_update_device(dev);
1054         struct sensor_device_attribute_2
1055                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
1056         int ix = sensor_attr_2->index;
1057         int fn = sensor_attr_2->nr;
1058         int res;
1059
1060         switch (fn) {
1061         case SYS_FAN_INPUT:
1062                 res = FAN_FROM_REG(data->fan[ix],
1063                                    ix < 4 ? 0 :
1064                                    FAN_TPC_FROM_REG(data->fan_opt[ix]));
1065                 break;
1066         case SYS_FAN_MIN:
1067                 res = FAN_FROM_REG(data->fan_min[ix],
1068                                    ix < 4 ? 0 :
1069                                    FAN_TPC_FROM_REG(data->fan_opt[ix]));
1070                 break;
1071         case SYS_FAN_MAX:
1072                 /* only valid for fan[5-6] */
1073                 res = FAN_MAX_FROM_REG(data->fan_max[ix - 4]);
1074                 break;
1075         case SYS_FAN_ALARM:
1076                 res = (data->alarms >> DME1737_BIT_ALARM_FAN[ix]) & 0x01;
1077                 break;
1078         case SYS_FAN_TYPE:
1079                 /* only valid for fan[1-4] */
1080                 res = FAN_TYPE_FROM_REG(data->fan_opt[ix]);
1081                 break;
1082         default:
1083                 res = 0;
1084                 dev_dbg(dev, "Unknown function %d.\n", fn);
1085         }
1086
1087         return sprintf(buf, "%d\n", res);
1088 }
1089
1090 static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
1091                        const char *buf, size_t count)
1092 {
1093         struct dme1737_data *data = dev_get_drvdata(dev);
1094         struct sensor_device_attribute_2
1095                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
1096         int ix = sensor_attr_2->index;
1097         int fn = sensor_attr_2->nr;
1098         long val = simple_strtol(buf, NULL, 10);
1099
1100         mutex_lock(&data->update_lock);
1101         switch (fn) {
1102         case SYS_FAN_MIN:
1103                 if (ix < 4) {
1104                         data->fan_min[ix] = FAN_TO_REG(val, 0);
1105                 } else {
1106                         /* Refresh the cache */
1107                         data->fan_opt[ix] = dme1737_read(data,
1108                                                 DME1737_REG_FAN_OPT(ix));
1109                         /* Modify the fan min value */
1110                         data->fan_min[ix] = FAN_TO_REG(val,
1111                                         FAN_TPC_FROM_REG(data->fan_opt[ix]));
1112                 }
1113                 dme1737_write(data, DME1737_REG_FAN_MIN(ix),
1114                               data->fan_min[ix] & 0xff);
1115                 dme1737_write(data, DME1737_REG_FAN_MIN(ix) + 1,
1116                               data->fan_min[ix] >> 8);
1117                 break;
1118         case SYS_FAN_MAX:
1119                 /* Only valid for fan[5-6] */
1120                 data->fan_max[ix - 4] = FAN_MAX_TO_REG(val);
1121                 dme1737_write(data, DME1737_REG_FAN_MAX(ix),
1122                               data->fan_max[ix - 4]);
1123                 break;
1124         case SYS_FAN_TYPE:
1125                 /* Only valid for fan[1-4] */
1126                 if (!(val == 1 || val == 2 || val == 4)) {
1127                         count = -EINVAL;
1128                         dev_warn(dev, "Fan type value %ld not "
1129                                  "supported. Choose one of 1, 2, or 4.\n",
1130                                  val);
1131                         goto exit;
1132                 }
1133                 data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(data,
1134                                         DME1737_REG_FAN_OPT(ix)));
1135                 dme1737_write(data, DME1737_REG_FAN_OPT(ix),
1136                               data->fan_opt[ix]);
1137                 break;
1138         default:
1139                 dev_dbg(dev, "Unknown function %d.\n", fn);
1140         }
1141 exit:
1142         mutex_unlock(&data->update_lock);
1143
1144         return count;
1145 }
1146
1147 /* ---------------------------------------------------------------------
1148  * PWM sysfs attributes
1149  * ix = [0-4]
1150  * --------------------------------------------------------------------- */
1151
1152 #define SYS_PWM                         0
1153 #define SYS_PWM_FREQ                    1
1154 #define SYS_PWM_ENABLE                  2
1155 #define SYS_PWM_RAMP_RATE               3
1156 #define SYS_PWM_AUTO_CHANNELS_ZONE      4
1157 #define SYS_PWM_AUTO_PWM_MIN            5
1158 #define SYS_PWM_AUTO_POINT1_PWM         6
1159 #define SYS_PWM_AUTO_POINT2_PWM         7
1160
1161 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
1162                         char *buf)
1163 {
1164         struct dme1737_data *data = dme1737_update_device(dev);
1165         struct sensor_device_attribute_2
1166                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
1167         int ix = sensor_attr_2->index;
1168         int fn = sensor_attr_2->nr;
1169         int res;
1170
1171         switch (fn) {
1172         case SYS_PWM:
1173                 if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 0) {
1174                         res = 255;
1175                 } else {
1176                         res = data->pwm[ix];
1177                 }
1178                 break;
1179         case SYS_PWM_FREQ:
1180                 res = PWM_FREQ_FROM_REG(data->pwm_freq[ix]);
1181                 break;
1182         case SYS_PWM_ENABLE:
1183                 if (ix >= 3) {
1184                         res = 1; /* pwm[5-6] hard-wired to manual mode */
1185                 } else {
1186                         res = PWM_EN_FROM_REG(data->pwm_config[ix]);
1187                 }
1188                 break;
1189         case SYS_PWM_RAMP_RATE:
1190                 /* Only valid for pwm[1-3] */
1191                 res = PWM_RR_FROM_REG(data->pwm_rr[ix > 0], ix);
1192                 break;
1193         case SYS_PWM_AUTO_CHANNELS_ZONE:
1194                 /* Only valid for pwm[1-3] */
1195                 if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
1196                         res = PWM_ACZ_FROM_REG(data->pwm_config[ix]);
1197                 } else {
1198                         res = data->pwm_acz[ix];
1199                 }
1200                 break;
1201         case SYS_PWM_AUTO_PWM_MIN:
1202                 /* Only valid for pwm[1-3] */
1203                 if (PWM_OFF_FROM_REG(data->pwm_rr[0], ix)) {
1204                         res = data->pwm_min[ix];
1205                 } else {
1206                         res = 0;
1207                 }
1208                 break;
1209         case SYS_PWM_AUTO_POINT1_PWM:
1210                 /* Only valid for pwm[1-3] */
1211                 res = data->pwm_min[ix];
1212                 break;
1213         case SYS_PWM_AUTO_POINT2_PWM:
1214                 /* Only valid for pwm[1-3] */
1215                 res = 255; /* hard-wired */
1216                 break;
1217         default:
1218                 res = 0;
1219                 dev_dbg(dev, "Unknown function %d.\n", fn);
1220         }
1221
1222         return sprintf(buf, "%d\n", res);
1223 }
1224
1225 static struct attribute *dme1737_pwm_chmod_attr[];
1226 static void dme1737_chmod_file(struct device*, struct attribute*, mode_t);
1227
1228 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
1229                        const char *buf, size_t count)
1230 {
1231         struct dme1737_data *data = dev_get_drvdata(dev);
1232         struct sensor_device_attribute_2
1233                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
1234         int ix = sensor_attr_2->index;
1235         int fn = sensor_attr_2->nr;
1236         long val = simple_strtol(buf, NULL, 10);
1237
1238         mutex_lock(&data->update_lock);
1239         switch (fn) {
1240         case SYS_PWM:
1241                 data->pwm[ix] = SENSORS_LIMIT(val, 0, 255);
1242                 dme1737_write(data, DME1737_REG_PWM(ix), data->pwm[ix]);
1243                 break;
1244         case SYS_PWM_FREQ:
1245                 data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(data,
1246                                                 DME1737_REG_PWM_FREQ(ix)));
1247                 dme1737_write(data, DME1737_REG_PWM_FREQ(ix),
1248                               data->pwm_freq[ix]);
1249                 break;
1250         case SYS_PWM_ENABLE:
1251                 /* Only valid for pwm[1-3] */
1252                 if (val < 0 || val > 2) {
1253                         count = -EINVAL;
1254                         dev_warn(dev, "PWM enable %ld not "
1255                                  "supported. Choose one of 0, 1, or 2.\n",
1256                                  val);
1257                         goto exit;
1258                 }
1259                 /* Refresh the cache */
1260                 data->pwm_config[ix] = dme1737_read(data,
1261                                                 DME1737_REG_PWM_CONFIG(ix));
1262                 if (val == PWM_EN_FROM_REG(data->pwm_config[ix])) {
1263                         /* Bail out if no change */
1264                         goto exit;
1265                 }
1266                 /* Do some housekeeping if we are currently in auto mode */
1267                 if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
1268                         /* Save the current zone channel assignment */
1269                         data->pwm_acz[ix] = PWM_ACZ_FROM_REG(
1270                                                         data->pwm_config[ix]);
1271                         /* Save the current ramp rate state and disable it */
1272                         data->pwm_rr[ix > 0] = dme1737_read(data,
1273                                                 DME1737_REG_PWM_RR(ix > 0));
1274                         data->pwm_rr_en &= ~(1 << ix);
1275                         if (PWM_RR_EN_FROM_REG(data->pwm_rr[ix > 0], ix)) {
1276                                 data->pwm_rr_en |= (1 << ix);
1277                                 data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(0, ix,
1278                                                         data->pwm_rr[ix > 0]);
1279                                 dme1737_write(data,
1280                                               DME1737_REG_PWM_RR(ix > 0),
1281                                               data->pwm_rr[ix > 0]);
1282                         }
1283                 }
1284                 /* Set the new PWM mode */
1285                 switch (val) {
1286                 case 0:
1287                         /* Change permissions of pwm[ix] to read-only */
1288                         dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
1289                                            S_IRUGO);
1290                         /* Turn fan fully on */
1291                         data->pwm_config[ix] = PWM_EN_TO_REG(0,
1292                                                         data->pwm_config[ix]);
1293                         dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
1294                                       data->pwm_config[ix]);
1295                         break;
1296                 case 1:
1297                         /* Turn on manual mode */
1298                         data->pwm_config[ix] = PWM_EN_TO_REG(1,
1299                                                         data->pwm_config[ix]);
1300                         dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
1301                                       data->pwm_config[ix]);
1302                         /* Change permissions of pwm[ix] to read-writeable */
1303                         dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
1304                                            S_IRUGO | S_IWUSR);
1305                         break;
1306                 case 2:
1307                         /* Change permissions of pwm[ix] to read-only */
1308                         dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
1309                                            S_IRUGO);
1310                         /* Turn on auto mode using the saved zone channel
1311                          * assignment */
1312                         data->pwm_config[ix] = PWM_ACZ_TO_REG(
1313                                                         data->pwm_acz[ix],
1314                                                         data->pwm_config[ix]);
1315                         dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
1316                                       data->pwm_config[ix]);
1317                         /* Enable PWM ramp rate if previously enabled */
1318                         if (data->pwm_rr_en & (1 << ix)) {
1319                                 data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(1, ix,
1320                                                 dme1737_read(data,
1321                                                 DME1737_REG_PWM_RR(ix > 0)));
1322                                 dme1737_write(data,
1323                                               DME1737_REG_PWM_RR(ix > 0),
1324                                               data->pwm_rr[ix > 0]);
1325                         }
1326                         break;
1327                 }
1328                 break;
1329         case SYS_PWM_RAMP_RATE:
1330                 /* Only valid for pwm[1-3] */
1331                 /* Refresh the cache */
1332                 data->pwm_config[ix] = dme1737_read(data,
1333                                                 DME1737_REG_PWM_CONFIG(ix));
1334                 data->pwm_rr[ix > 0] = dme1737_read(data,
1335                                                 DME1737_REG_PWM_RR(ix > 0));
1336                 /* Set the ramp rate value */
1337                 if (val > 0) {
1338                         data->pwm_rr[ix > 0] = PWM_RR_TO_REG(val, ix,
1339                                                         data->pwm_rr[ix > 0]);
1340                 }
1341                 /* Enable/disable the feature only if the associated PWM
1342                  * output is in automatic mode. */
1343                 if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
1344                         data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(val > 0, ix,
1345                                                         data->pwm_rr[ix > 0]);
1346                 }
1347                 dme1737_write(data, DME1737_REG_PWM_RR(ix > 0),
1348                               data->pwm_rr[ix > 0]);
1349                 break;
1350         case SYS_PWM_AUTO_CHANNELS_ZONE:
1351                 /* Only valid for pwm[1-3] */
1352                 if (!(val == 1 || val == 2 || val == 4 ||
1353                       val == 6 || val == 7)) {
1354                         count = -EINVAL;
1355                         dev_warn(dev, "PWM auto channels zone %ld "
1356                                  "not supported. Choose one of 1, 2, 4, 6, "
1357                                  "or 7.\n", val);
1358                         goto exit;
1359                 }
1360                 /* Refresh the cache */
1361                 data->pwm_config[ix] = dme1737_read(data,
1362                                                 DME1737_REG_PWM_CONFIG(ix));
1363                 if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
1364                         /* PWM is already in auto mode so update the temp
1365                          * channel assignment */
1366                         data->pwm_config[ix] = PWM_ACZ_TO_REG(val,
1367                                                 data->pwm_config[ix]);
1368                         dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
1369                                       data->pwm_config[ix]);
1370                 } else {
1371                         /* PWM is not in auto mode so we save the temp
1372                          * channel assignment for later use */
1373                         data->pwm_acz[ix] = val;
1374                 }
1375                 break;
1376         case SYS_PWM_AUTO_PWM_MIN:
1377                 /* Only valid for pwm[1-3] */
1378                 /* Refresh the cache */
1379                 data->pwm_min[ix] = dme1737_read(data,
1380                                                 DME1737_REG_PWM_MIN(ix));
1381                 /* There are only 2 values supported for the auto_pwm_min
1382                  * value: 0 or auto_point1_pwm. So if the temperature drops
1383                  * below the auto_point1_temp_hyst value, the fan either turns
1384                  * off or runs at auto_point1_pwm duty-cycle. */
1385                 if (val > ((data->pwm_min[ix] + 1) / 2)) {
1386                         data->pwm_rr[0] = PWM_OFF_TO_REG(1, ix,
1387                                                 dme1737_read(data,
1388                                                 DME1737_REG_PWM_RR(0)));
1389                 } else {
1390                         data->pwm_rr[0] = PWM_OFF_TO_REG(0, ix,
1391                                                 dme1737_read(data,
1392                                                 DME1737_REG_PWM_RR(0)));
1393                 }
1394                 dme1737_write(data, DME1737_REG_PWM_RR(0),
1395                               data->pwm_rr[0]);
1396                 break;
1397         case SYS_PWM_AUTO_POINT1_PWM:
1398                 /* Only valid for pwm[1-3] */
1399                 data->pwm_min[ix] = SENSORS_LIMIT(val, 0, 255);
1400                 dme1737_write(data, DME1737_REG_PWM_MIN(ix),
1401                               data->pwm_min[ix]);
1402                 break;
1403         default:
1404                 dev_dbg(dev, "Unknown function %d.\n", fn);
1405         }
1406 exit:
1407         mutex_unlock(&data->update_lock);
1408
1409         return count;
1410 }
1411
1412 /* ---------------------------------------------------------------------
1413  * Miscellaneous sysfs attributes
1414  * --------------------------------------------------------------------- */
1415
1416 static ssize_t show_vrm(struct device *dev, struct device_attribute *attr,
1417                         char *buf)
1418 {
1419         struct i2c_client *client = to_i2c_client(dev);
1420         struct dme1737_data *data = i2c_get_clientdata(client);
1421
1422         return sprintf(buf, "%d\n", data->vrm);
1423 }
1424
1425 static ssize_t set_vrm(struct device *dev, struct device_attribute *attr,
1426                        const char *buf, size_t count)
1427 {
1428         struct dme1737_data *data = dev_get_drvdata(dev);
1429         long val = simple_strtol(buf, NULL, 10);
1430
1431         data->vrm = val;
1432         return count;
1433 }
1434
1435 static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
1436                         char *buf)
1437 {
1438         struct dme1737_data *data = dme1737_update_device(dev);
1439
1440         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
1441 }
1442
1443 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
1444                          char *buf)
1445 {
1446         struct dme1737_data *data = dev_get_drvdata(dev);
1447
1448         return sprintf(buf, "%s\n", data->name);
1449 }
1450
1451 /* ---------------------------------------------------------------------
1452  * Sysfs device attribute defines and structs
1453  * --------------------------------------------------------------------- */
1454
1455 /* Voltages 0-7 */
1456
1457 #define SENSOR_DEVICE_ATTR_IN(ix) \
1458 static SENSOR_DEVICE_ATTR_2(in##ix##_input, S_IRUGO, \
1459         show_in, NULL, SYS_IN_INPUT, ix); \
1460 static SENSOR_DEVICE_ATTR_2(in##ix##_min, S_IRUGO | S_IWUSR, \
1461         show_in, set_in, SYS_IN_MIN, ix); \
1462 static SENSOR_DEVICE_ATTR_2(in##ix##_max, S_IRUGO | S_IWUSR, \
1463         show_in, set_in, SYS_IN_MAX, ix); \
1464 static SENSOR_DEVICE_ATTR_2(in##ix##_alarm, S_IRUGO, \
1465         show_in, NULL, SYS_IN_ALARM, ix)
1466
1467 SENSOR_DEVICE_ATTR_IN(0);
1468 SENSOR_DEVICE_ATTR_IN(1);
1469 SENSOR_DEVICE_ATTR_IN(2);
1470 SENSOR_DEVICE_ATTR_IN(3);
1471 SENSOR_DEVICE_ATTR_IN(4);
1472 SENSOR_DEVICE_ATTR_IN(5);
1473 SENSOR_DEVICE_ATTR_IN(6);
1474 SENSOR_DEVICE_ATTR_IN(7);
1475
1476 /* Temperatures 1-3 */
1477
1478 #define SENSOR_DEVICE_ATTR_TEMP(ix) \
1479 static SENSOR_DEVICE_ATTR_2(temp##ix##_input, S_IRUGO, \
1480         show_temp, NULL, SYS_TEMP_INPUT, ix-1); \
1481 static SENSOR_DEVICE_ATTR_2(temp##ix##_min, S_IRUGO | S_IWUSR, \
1482         show_temp, set_temp, SYS_TEMP_MIN, ix-1); \
1483 static SENSOR_DEVICE_ATTR_2(temp##ix##_max, S_IRUGO | S_IWUSR, \
1484         show_temp, set_temp, SYS_TEMP_MAX, ix-1); \
1485 static SENSOR_DEVICE_ATTR_2(temp##ix##_offset, S_IRUGO, \
1486         show_temp, set_temp, SYS_TEMP_OFFSET, ix-1); \
1487 static SENSOR_DEVICE_ATTR_2(temp##ix##_alarm, S_IRUGO, \
1488         show_temp, NULL, SYS_TEMP_ALARM, ix-1); \
1489 static SENSOR_DEVICE_ATTR_2(temp##ix##_fault, S_IRUGO, \
1490         show_temp, NULL, SYS_TEMP_FAULT, ix-1)
1491
1492 SENSOR_DEVICE_ATTR_TEMP(1);
1493 SENSOR_DEVICE_ATTR_TEMP(2);
1494 SENSOR_DEVICE_ATTR_TEMP(3);
1495
1496 /* Zones 1-3 */
1497
1498 #define SENSOR_DEVICE_ATTR_ZONE(ix) \
1499 static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_channels_temp, S_IRUGO, \
1500         show_zone, NULL, SYS_ZONE_AUTO_CHANNELS_TEMP, ix-1); \
1501 static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp_hyst, S_IRUGO, \
1502         show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP_HYST, ix-1); \
1503 static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp, S_IRUGO, \
1504         show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP, ix-1); \
1505 static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point2_temp, S_IRUGO, \
1506         show_zone, set_zone, SYS_ZONE_AUTO_POINT2_TEMP, ix-1); \
1507 static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point3_temp, S_IRUGO, \
1508         show_zone, set_zone, SYS_ZONE_AUTO_POINT3_TEMP, ix-1)
1509
1510 SENSOR_DEVICE_ATTR_ZONE(1);
1511 SENSOR_DEVICE_ATTR_ZONE(2);
1512 SENSOR_DEVICE_ATTR_ZONE(3);
1513
1514 /* Fans 1-4 */
1515
1516 #define SENSOR_DEVICE_ATTR_FAN_1TO4(ix) \
1517 static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \
1518         show_fan, NULL, SYS_FAN_INPUT, ix-1); \
1519 static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \
1520         show_fan, set_fan, SYS_FAN_MIN, ix-1); \
1521 static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \
1522         show_fan, NULL, SYS_FAN_ALARM, ix-1); \
1523 static SENSOR_DEVICE_ATTR_2(fan##ix##_type, S_IRUGO | S_IWUSR, \
1524         show_fan, set_fan, SYS_FAN_TYPE, ix-1)
1525
1526 SENSOR_DEVICE_ATTR_FAN_1TO4(1);
1527 SENSOR_DEVICE_ATTR_FAN_1TO4(2);
1528 SENSOR_DEVICE_ATTR_FAN_1TO4(3);
1529 SENSOR_DEVICE_ATTR_FAN_1TO4(4);
1530
1531 /* Fans 5-6 */
1532
1533 #define SENSOR_DEVICE_ATTR_FAN_5TO6(ix) \
1534 static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \
1535         show_fan, NULL, SYS_FAN_INPUT, ix-1); \
1536 static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \
1537         show_fan, set_fan, SYS_FAN_MIN, ix-1); \
1538 static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \
1539         show_fan, NULL, SYS_FAN_ALARM, ix-1); \
1540 static SENSOR_DEVICE_ATTR_2(fan##ix##_max, S_IRUGO | S_IWUSR, \
1541         show_fan, set_fan, SYS_FAN_MAX, ix-1)
1542
1543 SENSOR_DEVICE_ATTR_FAN_5TO6(5);
1544 SENSOR_DEVICE_ATTR_FAN_5TO6(6);
1545
1546 /* PWMs 1-3 */
1547
1548 #define SENSOR_DEVICE_ATTR_PWM_1TO3(ix) \
1549 static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \
1550         show_pwm, set_pwm, SYS_PWM, ix-1); \
1551 static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \
1552         show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \
1553 static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \
1554         show_pwm, set_pwm, SYS_PWM_ENABLE, ix-1); \
1555 static SENSOR_DEVICE_ATTR_2(pwm##ix##_ramp_rate, S_IRUGO, \
1556         show_pwm, set_pwm, SYS_PWM_RAMP_RATE, ix-1); \
1557 static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_channels_zone, S_IRUGO, \
1558         show_pwm, set_pwm, SYS_PWM_AUTO_CHANNELS_ZONE, ix-1); \
1559 static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_pwm_min, S_IRUGO, \
1560         show_pwm, set_pwm, SYS_PWM_AUTO_PWM_MIN, ix-1); \
1561 static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point1_pwm, S_IRUGO, \
1562         show_pwm, set_pwm, SYS_PWM_AUTO_POINT1_PWM, ix-1); \
1563 static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point2_pwm, S_IRUGO, \
1564         show_pwm, NULL, SYS_PWM_AUTO_POINT2_PWM, ix-1)
1565
1566 SENSOR_DEVICE_ATTR_PWM_1TO3(1);
1567 SENSOR_DEVICE_ATTR_PWM_1TO3(2);
1568 SENSOR_DEVICE_ATTR_PWM_1TO3(3);
1569
1570 /* PWMs 5-6 */
1571
1572 #define SENSOR_DEVICE_ATTR_PWM_5TO6(ix) \
1573 static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \
1574         show_pwm, set_pwm, SYS_PWM, ix-1); \
1575 static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \
1576         show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \
1577 static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \
1578         show_pwm, NULL, SYS_PWM_ENABLE, ix-1)
1579
1580 SENSOR_DEVICE_ATTR_PWM_5TO6(5);
1581 SENSOR_DEVICE_ATTR_PWM_5TO6(6);
1582
1583 /* Misc */
1584
1585 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
1586 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
1587 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);   /* for ISA devices */
1588
1589 /* This struct holds all the attributes that are always present and need to be
1590  * created unconditionally. The attributes that need modification of their
1591  * permissions are created read-only and write permissions are added or removed
1592  * on the fly when required */
1593 static struct attribute *dme1737_attr[] = {
1594         /* Voltages */
1595         &sensor_dev_attr_in0_input.dev_attr.attr,
1596         &sensor_dev_attr_in0_min.dev_attr.attr,
1597         &sensor_dev_attr_in0_max.dev_attr.attr,
1598         &sensor_dev_attr_in0_alarm.dev_attr.attr,
1599         &sensor_dev_attr_in1_input.dev_attr.attr,
1600         &sensor_dev_attr_in1_min.dev_attr.attr,
1601         &sensor_dev_attr_in1_max.dev_attr.attr,
1602         &sensor_dev_attr_in1_alarm.dev_attr.attr,
1603         &sensor_dev_attr_in2_input.dev_attr.attr,
1604         &sensor_dev_attr_in2_min.dev_attr.attr,
1605         &sensor_dev_attr_in2_max.dev_attr.attr,
1606         &sensor_dev_attr_in2_alarm.dev_attr.attr,
1607         &sensor_dev_attr_in3_input.dev_attr.attr,
1608         &sensor_dev_attr_in3_min.dev_attr.attr,
1609         &sensor_dev_attr_in3_max.dev_attr.attr,
1610         &sensor_dev_attr_in3_alarm.dev_attr.attr,
1611         &sensor_dev_attr_in4_input.dev_attr.attr,
1612         &sensor_dev_attr_in4_min.dev_attr.attr,
1613         &sensor_dev_attr_in4_max.dev_attr.attr,
1614         &sensor_dev_attr_in4_alarm.dev_attr.attr,
1615         &sensor_dev_attr_in5_input.dev_attr.attr,
1616         &sensor_dev_attr_in5_min.dev_attr.attr,
1617         &sensor_dev_attr_in5_max.dev_attr.attr,
1618         &sensor_dev_attr_in5_alarm.dev_attr.attr,
1619         &sensor_dev_attr_in6_input.dev_attr.attr,
1620         &sensor_dev_attr_in6_min.dev_attr.attr,
1621         &sensor_dev_attr_in6_max.dev_attr.attr,
1622         &sensor_dev_attr_in6_alarm.dev_attr.attr,
1623         /* Temperatures */
1624         &sensor_dev_attr_temp1_input.dev_attr.attr,
1625         &sensor_dev_attr_temp1_min.dev_attr.attr,
1626         &sensor_dev_attr_temp1_max.dev_attr.attr,
1627         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1628         &sensor_dev_attr_temp1_fault.dev_attr.attr,
1629         &sensor_dev_attr_temp2_input.dev_attr.attr,
1630         &sensor_dev_attr_temp2_min.dev_attr.attr,
1631         &sensor_dev_attr_temp2_max.dev_attr.attr,
1632         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1633         &sensor_dev_attr_temp2_fault.dev_attr.attr,
1634         &sensor_dev_attr_temp3_input.dev_attr.attr,
1635         &sensor_dev_attr_temp3_min.dev_attr.attr,
1636         &sensor_dev_attr_temp3_max.dev_attr.attr,
1637         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1638         &sensor_dev_attr_temp3_fault.dev_attr.attr,
1639         /* Zones */
1640         &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
1641         &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
1642         &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
1643         &sensor_dev_attr_zone1_auto_channels_temp.dev_attr.attr,
1644         &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
1645         &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
1646         &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
1647         &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr,
1648         NULL
1649 };
1650
1651 static const struct attribute_group dme1737_group = {
1652         .attrs = dme1737_attr,
1653 };
1654
1655 /* The following struct holds temp offset attributes, which are not available
1656  * in all chips. The following chips support them:
1657  * DME1737, SCH311x */
1658 static struct attribute *dme1737_temp_offset_attr[] = {
1659         &sensor_dev_attr_temp1_offset.dev_attr.attr,
1660         &sensor_dev_attr_temp2_offset.dev_attr.attr,
1661         &sensor_dev_attr_temp3_offset.dev_attr.attr,
1662         NULL
1663 };
1664
1665 static const struct attribute_group dme1737_temp_offset_group = {
1666         .attrs = dme1737_temp_offset_attr,
1667 };
1668
1669 /* The following struct holds VID related attributes, which are not available
1670  * in all chips. The following chips support them:
1671  * DME1737 */
1672 static struct attribute *dme1737_vid_attr[] = {
1673         &dev_attr_vrm.attr,
1674         &dev_attr_cpu0_vid.attr,
1675         NULL
1676 };
1677
1678 static const struct attribute_group dme1737_vid_group = {
1679         .attrs = dme1737_vid_attr,
1680 };
1681
1682 /* The following struct holds temp zone 3 related attributes, which are not
1683  * available in all chips. The following chips support them:
1684  * DME1737, SCH311x, SCH5027 */
1685 static struct attribute *dme1737_zone3_attr[] = {
1686         &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
1687         &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
1688         &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
1689         &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr,
1690         NULL
1691 };
1692
1693 static const struct attribute_group dme1737_zone3_group = {
1694         .attrs = dme1737_zone3_attr,
1695 };
1696
1697
1698 /* The following struct holds temp zone hysteresis related attributes, which
1699  * are not available in all chips. The following chips support them:
1700  * DME1737, SCH311x */
1701 static struct attribute *dme1737_zone_hyst_attr[] = {
1702         &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
1703         &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
1704         &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
1705         NULL
1706 };
1707
1708 static const struct attribute_group dme1737_zone_hyst_group = {
1709         .attrs = dme1737_zone_hyst_attr,
1710 };
1711
1712 /* The following struct holds voltage in7 related attributes, which
1713  * are not available in all chips. The following chips support them:
1714  * SCH5127 */
1715 static struct attribute *dme1737_in7_attr[] = {
1716         &sensor_dev_attr_in7_input.dev_attr.attr,
1717         &sensor_dev_attr_in7_min.dev_attr.attr,
1718         &sensor_dev_attr_in7_max.dev_attr.attr,
1719         &sensor_dev_attr_in7_alarm.dev_attr.attr,
1720         NULL
1721 };
1722
1723 static const struct attribute_group dme1737_in7_group = {
1724         .attrs = dme1737_in7_attr,
1725 };
1726
1727 /* The following structs hold the PWM attributes, some of which are optional.
1728  * Their creation depends on the chip configuration which is determined during
1729  * module load. */
1730 static struct attribute *dme1737_pwm1_attr[] = {
1731         &sensor_dev_attr_pwm1.dev_attr.attr,
1732         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
1733         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1734         &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
1735         &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
1736         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1737         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1738         NULL
1739 };
1740 static struct attribute *dme1737_pwm2_attr[] = {
1741         &sensor_dev_attr_pwm2.dev_attr.attr,
1742         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
1743         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1744         &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
1745         &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
1746         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1747         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1748         NULL
1749 };
1750 static struct attribute *dme1737_pwm3_attr[] = {
1751         &sensor_dev_attr_pwm3.dev_attr.attr,
1752         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
1753         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1754         &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
1755         &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
1756         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1757         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1758         NULL
1759 };
1760 static struct attribute *dme1737_pwm5_attr[] = {
1761         &sensor_dev_attr_pwm5.dev_attr.attr,
1762         &sensor_dev_attr_pwm5_freq.dev_attr.attr,
1763         &sensor_dev_attr_pwm5_enable.dev_attr.attr,
1764         NULL
1765 };
1766 static struct attribute *dme1737_pwm6_attr[] = {
1767         &sensor_dev_attr_pwm6.dev_attr.attr,
1768         &sensor_dev_attr_pwm6_freq.dev_attr.attr,
1769         &sensor_dev_attr_pwm6_enable.dev_attr.attr,
1770         NULL
1771 };
1772
1773 static const struct attribute_group dme1737_pwm_group[] = {
1774         { .attrs = dme1737_pwm1_attr },
1775         { .attrs = dme1737_pwm2_attr },
1776         { .attrs = dme1737_pwm3_attr },
1777         { .attrs = NULL },
1778         { .attrs = dme1737_pwm5_attr },
1779         { .attrs = dme1737_pwm6_attr },
1780 };
1781
1782 /* The following struct holds auto PWM min attributes, which are not available
1783  * in all chips. Their creation depends on the chip type which is determined
1784  * during module load. */
1785 static struct attribute *dme1737_auto_pwm_min_attr[] = {
1786         &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
1787         &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
1788         &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
1789 };
1790
1791 /* The following structs hold the fan attributes, some of which are optional.
1792  * Their creation depends on the chip configuration which is determined during
1793  * module load. */
1794 static struct attribute *dme1737_fan1_attr[] = {
1795         &sensor_dev_attr_fan1_input.dev_attr.attr,
1796         &sensor_dev_attr_fan1_min.dev_attr.attr,
1797         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1798         &sensor_dev_attr_fan1_type.dev_attr.attr,
1799         NULL
1800 };
1801 static struct attribute *dme1737_fan2_attr[] = {
1802         &sensor_dev_attr_fan2_input.dev_attr.attr,
1803         &sensor_dev_attr_fan2_min.dev_attr.attr,
1804         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1805         &sensor_dev_attr_fan2_type.dev_attr.attr,
1806         NULL
1807 };
1808 static struct attribute *dme1737_fan3_attr[] = {
1809         &sensor_dev_attr_fan3_input.dev_attr.attr,
1810         &sensor_dev_attr_fan3_min.dev_attr.attr,
1811         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1812         &sensor_dev_attr_fan3_type.dev_attr.attr,
1813         NULL
1814 };
1815 static struct attribute *dme1737_fan4_attr[] = {
1816         &sensor_dev_attr_fan4_input.dev_attr.attr,
1817         &sensor_dev_attr_fan4_min.dev_attr.attr,
1818         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1819         &sensor_dev_attr_fan4_type.dev_attr.attr,
1820         NULL
1821 };
1822 static struct attribute *dme1737_fan5_attr[] = {
1823         &sensor_dev_attr_fan5_input.dev_attr.attr,
1824         &sensor_dev_attr_fan5_min.dev_attr.attr,
1825         &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1826         &sensor_dev_attr_fan5_max.dev_attr.attr,
1827         NULL
1828 };
1829 static struct attribute *dme1737_fan6_attr[] = {
1830         &sensor_dev_attr_fan6_input.dev_attr.attr,
1831         &sensor_dev_attr_fan6_min.dev_attr.attr,
1832         &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1833         &sensor_dev_attr_fan6_max.dev_attr.attr,
1834         NULL
1835 };
1836
1837 static const struct attribute_group dme1737_fan_group[] = {
1838         { .attrs = dme1737_fan1_attr },
1839         { .attrs = dme1737_fan2_attr },
1840         { .attrs = dme1737_fan3_attr },
1841         { .attrs = dme1737_fan4_attr },
1842         { .attrs = dme1737_fan5_attr },
1843         { .attrs = dme1737_fan6_attr },
1844 };
1845
1846 /* The permissions of the following zone attributes are changed to read-
1847  * writeable if the chip is *not* locked. Otherwise they stay read-only. */
1848 static struct attribute *dme1737_zone_chmod_attr[] = {
1849         &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
1850         &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
1851         &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
1852         &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
1853         &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
1854         &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
1855         NULL
1856 };
1857
1858 static const struct attribute_group dme1737_zone_chmod_group = {
1859         .attrs = dme1737_zone_chmod_attr,
1860 };
1861
1862
1863 /* The permissions of the following zone 3 attributes are changed to read-
1864  * writeable if the chip is *not* locked. Otherwise they stay read-only. */
1865 static struct attribute *dme1737_zone3_chmod_attr[] = {
1866         &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
1867         &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
1868         &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
1869         NULL
1870 };
1871
1872 static const struct attribute_group dme1737_zone3_chmod_group = {
1873         .attrs = dme1737_zone3_chmod_attr,
1874 };
1875
1876 /* The permissions of the following PWM attributes are changed to read-
1877  * writeable if the chip is *not* locked and the respective PWM is available.
1878  * Otherwise they stay read-only. */
1879 static struct attribute *dme1737_pwm1_chmod_attr[] = {
1880         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
1881         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1882         &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
1883         &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
1884         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1885         NULL
1886 };
1887 static struct attribute *dme1737_pwm2_chmod_attr[] = {
1888         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
1889         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1890         &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
1891         &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
1892         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1893         NULL
1894 };
1895 static struct attribute *dme1737_pwm3_chmod_attr[] = {
1896         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
1897         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1898         &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
1899         &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
1900         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1901         NULL
1902 };
1903 static struct attribute *dme1737_pwm5_chmod_attr[] = {
1904         &sensor_dev_attr_pwm5.dev_attr.attr,
1905         &sensor_dev_attr_pwm5_freq.dev_attr.attr,
1906         NULL
1907 };
1908 static struct attribute *dme1737_pwm6_chmod_attr[] = {
1909         &sensor_dev_attr_pwm6.dev_attr.attr,
1910         &sensor_dev_attr_pwm6_freq.dev_attr.attr,
1911         NULL
1912 };
1913
1914 static const struct attribute_group dme1737_pwm_chmod_group[] = {
1915         { .attrs = dme1737_pwm1_chmod_attr },
1916         { .attrs = dme1737_pwm2_chmod_attr },
1917         { .attrs = dme1737_pwm3_chmod_attr },
1918         { .attrs = NULL },
1919         { .attrs = dme1737_pwm5_chmod_attr },
1920         { .attrs = dme1737_pwm6_chmod_attr },
1921 };
1922
1923 /* Pwm[1-3] are read-writeable if the associated pwm is in manual mode and the
1924  * chip is not locked. Otherwise they are read-only. */
1925 static struct attribute *dme1737_pwm_chmod_attr[] = {
1926         &sensor_dev_attr_pwm1.dev_attr.attr,
1927         &sensor_dev_attr_pwm2.dev_attr.attr,
1928         &sensor_dev_attr_pwm3.dev_attr.attr,
1929 };
1930
1931 /* ---------------------------------------------------------------------
1932  * Super-IO functions
1933  * --------------------------------------------------------------------- */
1934
1935 static inline void dme1737_sio_enter(int sio_cip)
1936 {
1937         outb(0x55, sio_cip);
1938 }
1939
1940 static inline void dme1737_sio_exit(int sio_cip)
1941 {
1942         outb(0xaa, sio_cip);
1943 }
1944
1945 static inline int dme1737_sio_inb(int sio_cip, int reg)
1946 {
1947         outb(reg, sio_cip);
1948         return inb(sio_cip + 1);
1949 }
1950
1951 static inline void dme1737_sio_outb(int sio_cip, int reg, int val)
1952 {
1953         outb(reg, sio_cip);
1954         outb(val, sio_cip + 1);
1955 }
1956
1957 /* ---------------------------------------------------------------------
1958  * Device initialization
1959  * --------------------------------------------------------------------- */
1960
1961 static int dme1737_i2c_get_features(int, struct dme1737_data*);
1962
1963 static void dme1737_chmod_file(struct device *dev,
1964                                struct attribute *attr, mode_t mode)
1965 {
1966         if (sysfs_chmod_file(&dev->kobj, attr, mode)) {
1967                 dev_warn(dev, "Failed to change permissions of %s.\n",
1968                          attr->name);
1969         }
1970 }
1971
1972 static void dme1737_chmod_group(struct device *dev,
1973                                 const struct attribute_group *group,
1974                                 mode_t mode)
1975 {
1976         struct attribute **attr;
1977
1978         for (attr = group->attrs; *attr; attr++) {
1979                 dme1737_chmod_file(dev, *attr, mode);
1980         }
1981 }
1982
1983 static void dme1737_remove_files(struct device *dev)
1984 {
1985         struct dme1737_data *data = dev_get_drvdata(dev);
1986         int ix;
1987
1988         for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
1989                 if (data->has_features & HAS_FAN(ix)) {
1990                         sysfs_remove_group(&dev->kobj,
1991                                            &dme1737_fan_group[ix]);
1992                 }
1993         }
1994
1995         for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
1996                 if (data->has_features & HAS_PWM(ix)) {
1997                         sysfs_remove_group(&dev->kobj,
1998                                            &dme1737_pwm_group[ix]);
1999                         if ((data->has_features & HAS_PWM_MIN) && ix < 3) {
2000                                 sysfs_remove_file(&dev->kobj,
2001                                                 dme1737_auto_pwm_min_attr[ix]);
2002                         }
2003                 }
2004         }
2005
2006         if (data->has_features & HAS_TEMP_OFFSET) {
2007                 sysfs_remove_group(&dev->kobj, &dme1737_temp_offset_group);
2008         }
2009         if (data->has_features & HAS_VID) {
2010                 sysfs_remove_group(&dev->kobj, &dme1737_vid_group);
2011         }
2012         if (data->has_features & HAS_ZONE3) {
2013                 sysfs_remove_group(&dev->kobj, &dme1737_zone3_group);
2014         }
2015         if (data->has_features & HAS_ZONE_HYST) {
2016                 sysfs_remove_group(&dev->kobj, &dme1737_zone_hyst_group);
2017         }
2018         if (data->has_features & HAS_IN7) {
2019                 sysfs_remove_group(&dev->kobj, &dme1737_in7_group);
2020         }
2021         sysfs_remove_group(&dev->kobj, &dme1737_group);
2022
2023         if (!data->client) {
2024                 sysfs_remove_file(&dev->kobj, &dev_attr_name.attr);
2025         }
2026 }
2027
2028 static int dme1737_create_files(struct device *dev)
2029 {
2030         struct dme1737_data *data = dev_get_drvdata(dev);
2031         int err, ix;
2032
2033         /* Create a name attribute for ISA devices */
2034         if (!data->client) {
2035                 err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr);
2036                 if (err) {
2037                         goto exit;
2038                 }
2039         }
2040
2041         /* Create standard sysfs attributes */
2042         err = sysfs_create_group(&dev->kobj, &dme1737_group);
2043         if (err) {
2044                 goto exit_remove;
2045         }
2046
2047         /* Create chip-dependent sysfs attributes */
2048         if (data->has_features & HAS_TEMP_OFFSET) {
2049                 err = sysfs_create_group(&dev->kobj,
2050                                          &dme1737_temp_offset_group);
2051                 if (err) {
2052                         goto exit_remove;
2053                 }
2054         }
2055         if (data->has_features & HAS_VID) {
2056                 err = sysfs_create_group(&dev->kobj, &dme1737_vid_group);
2057                 if (err) {
2058                         goto exit_remove;
2059                 }
2060         }
2061         if (data->has_features & HAS_ZONE3) {
2062                 err = sysfs_create_group(&dev->kobj, &dme1737_zone3_group);
2063                 if (err) {
2064                         goto exit_remove;
2065                 }
2066         }
2067         if (data->has_features & HAS_ZONE_HYST) {
2068                 err = sysfs_create_group(&dev->kobj, &dme1737_zone_hyst_group);
2069                 if (err) {
2070                         goto exit_remove;
2071                 }
2072         }
2073         if (data->has_features & HAS_IN7) {
2074                 err = sysfs_create_group(&dev->kobj, &dme1737_in7_group);
2075                 if (err) {
2076                         goto exit_remove;
2077                 }
2078         }
2079
2080         /* Create fan sysfs attributes */
2081         for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
2082                 if (data->has_features & HAS_FAN(ix)) {
2083                         err = sysfs_create_group(&dev->kobj,
2084                                                  &dme1737_fan_group[ix]);
2085                         if (err) {
2086                                 goto exit_remove;
2087                         }
2088                 }
2089         }
2090
2091         /* Create PWM sysfs attributes */
2092         for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
2093                 if (data->has_features & HAS_PWM(ix)) {
2094                         err = sysfs_create_group(&dev->kobj,
2095                                                  &dme1737_pwm_group[ix]);
2096                         if (err) {
2097                                 goto exit_remove;
2098                         }
2099                         if ((data->has_features & HAS_PWM_MIN) && (ix < 3)) {
2100                                 err = sysfs_create_file(&dev->kobj,
2101                                                 dme1737_auto_pwm_min_attr[ix]);
2102                                 if (err) {
2103                                         goto exit_remove;
2104                                 }
2105                         }
2106                 }
2107         }
2108
2109         /* Inform if the device is locked. Otherwise change the permissions of
2110          * selected attributes from read-only to read-writeable. */
2111         if (data->config & 0x02) {
2112                 dev_info(dev, "Device is locked. Some attributes "
2113                          "will be read-only.\n");
2114         } else {
2115                 /* Change permissions of zone sysfs attributes */
2116                 dme1737_chmod_group(dev, &dme1737_zone_chmod_group,
2117                                     S_IRUGO | S_IWUSR);
2118
2119                 /* Change permissions of chip-dependent sysfs attributes */
2120                 if (data->has_features & HAS_TEMP_OFFSET) {
2121                         dme1737_chmod_group(dev, &dme1737_temp_offset_group,
2122                                             S_IRUGO | S_IWUSR);
2123                 }
2124                 if (data->has_features & HAS_ZONE3) {
2125                         dme1737_chmod_group(dev, &dme1737_zone3_chmod_group,
2126                                             S_IRUGO | S_IWUSR);
2127                 }
2128                 if (data->has_features & HAS_ZONE_HYST) {
2129                         dme1737_chmod_group(dev, &dme1737_zone_hyst_group,
2130                                             S_IRUGO | S_IWUSR);
2131                 }
2132
2133                 /* Change permissions of PWM sysfs attributes */
2134                 for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_chmod_group); ix++) {
2135                         if (data->has_features & HAS_PWM(ix)) {
2136                                 dme1737_chmod_group(dev,
2137                                                 &dme1737_pwm_chmod_group[ix],
2138                                                 S_IRUGO | S_IWUSR);
2139                                 if ((data->has_features & HAS_PWM_MIN) &&
2140                                     ix < 3) {
2141                                         dme1737_chmod_file(dev,
2142                                                 dme1737_auto_pwm_min_attr[ix],
2143                                                 S_IRUGO | S_IWUSR);
2144                                 }
2145                         }
2146                 }
2147
2148                 /* Change permissions of pwm[1-3] if in manual mode */
2149                 for (ix = 0; ix < 3; ix++) {
2150                         if ((data->has_features & HAS_PWM(ix)) &&
2151                             (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) {
2152                                 dme1737_chmod_file(dev,
2153                                                 dme1737_pwm_chmod_attr[ix],
2154                                                 S_IRUGO | S_IWUSR);
2155                         }
2156                 }
2157         }
2158
2159         return 0;
2160
2161 exit_remove:
2162         dme1737_remove_files(dev);
2163 exit:
2164         return err;
2165 }
2166
2167 static int dme1737_init_device(struct device *dev)
2168 {
2169         struct dme1737_data *data = dev_get_drvdata(dev);
2170         struct i2c_client *client = data->client;
2171         int ix;
2172         u8 reg;
2173
2174         /* Point to the right nominal voltages array */
2175         data->in_nominal = IN_NOMINAL(data->type);
2176
2177         data->config = dme1737_read(data, DME1737_REG_CONFIG);
2178         /* Inform if part is not monitoring/started */
2179         if (!(data->config & 0x01)) {
2180                 if (!force_start) {
2181                         dev_err(dev, "Device is not monitoring. "
2182                                 "Use the force_start load parameter to "
2183                                 "override.\n");
2184                         return -EFAULT;
2185                 }
2186
2187                 /* Force monitoring */
2188                 data->config |= 0x01;
2189                 dme1737_write(data, DME1737_REG_CONFIG, data->config);
2190         }
2191         /* Inform if part is not ready */
2192         if (!(data->config & 0x04)) {
2193                 dev_err(dev, "Device is not ready.\n");
2194                 return -EFAULT;
2195         }
2196
2197         /* Determine which optional fan and pwm features are enabled (only
2198          * valid for I2C devices) */
2199         if (client) {   /* I2C chip */
2200                 data->config2 = dme1737_read(data, DME1737_REG_CONFIG2);
2201                 /* Check if optional fan3 input is enabled */
2202                 if (data->config2 & 0x04) {
2203                         data->has_features |= HAS_FAN(2);
2204                 }
2205
2206                 /* Fan4 and pwm3 are only available if the client's I2C address
2207                  * is the default 0x2e. Otherwise the I/Os associated with
2208                  * these functions are used for addr enable/select. */
2209                 if (client->addr == 0x2e) {
2210                         data->has_features |= HAS_FAN(3) | HAS_PWM(2);
2211                 }
2212
2213                 /* Determine which of the optional fan[5-6] and pwm[5-6]
2214                  * features are enabled. For this, we need to query the runtime
2215                  * registers through the Super-IO LPC interface. Try both
2216                  * config ports 0x2e and 0x4e. */
2217                 if (dme1737_i2c_get_features(0x2e, data) &&
2218                     dme1737_i2c_get_features(0x4e, data)) {
2219                         dev_warn(dev, "Failed to query Super-IO for optional "
2220                                  "features.\n");
2221                 }
2222         }
2223
2224         /* Fan[1-2] and pwm[1-2] are present in all chips */
2225         data->has_features |= HAS_FAN(0) | HAS_FAN(1) | HAS_PWM(0) | HAS_PWM(1);
2226
2227         /* Chip-dependent features */
2228         switch (data->type) {
2229         case dme1737:
2230                 data->has_features |= HAS_TEMP_OFFSET | HAS_VID | HAS_ZONE3 |
2231                         HAS_ZONE_HYST | HAS_PWM_MIN;
2232                 break;
2233         case sch311x:
2234                 data->has_features |= HAS_TEMP_OFFSET | HAS_ZONE3 |
2235                         HAS_ZONE_HYST | HAS_PWM_MIN | HAS_FAN(2) | HAS_PWM(2);
2236                 break;
2237         case sch5027:
2238                 data->has_features |= HAS_ZONE3;
2239                 break;
2240         case sch5127:
2241                 data->has_features |= HAS_FAN(2) | HAS_PWM(2) | HAS_IN7;
2242                 break;
2243         default:
2244                 break;
2245         }
2246
2247         dev_info(dev, "Optional features: pwm3=%s, pwm5=%s, pwm6=%s, "
2248                  "fan3=%s, fan4=%s, fan5=%s, fan6=%s.\n",
2249                  (data->has_features & HAS_PWM(2)) ? "yes" : "no",
2250                  (data->has_features & HAS_PWM(4)) ? "yes" : "no",
2251                  (data->has_features & HAS_PWM(5)) ? "yes" : "no",
2252                  (data->has_features & HAS_FAN(2)) ? "yes" : "no",
2253                  (data->has_features & HAS_FAN(3)) ? "yes" : "no",
2254                  (data->has_features & HAS_FAN(4)) ? "yes" : "no",
2255                  (data->has_features & HAS_FAN(5)) ? "yes" : "no");
2256
2257         reg = dme1737_read(data, DME1737_REG_TACH_PWM);
2258         /* Inform if fan-to-pwm mapping differs from the default */
2259         if (client && reg != 0xa4) {   /* I2C chip */
2260                 dev_warn(dev, "Non-standard fan to pwm mapping: "
2261                          "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d, "
2262                          "fan4->pwm%d. Please report to the driver "
2263                          "maintainer.\n",
2264                          (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1,
2265                          ((reg >> 4) & 0x03) + 1, ((reg >> 6) & 0x03) + 1);
2266         } else if (!client && reg != 0x24) {   /* ISA chip */
2267                 dev_warn(dev, "Non-standard fan to pwm mapping: "
2268                          "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d. "
2269                          "Please report to the driver maintainer.\n",
2270                          (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1,
2271                          ((reg >> 4) & 0x03) + 1);
2272         }
2273
2274         /* Switch pwm[1-3] to manual mode if they are currently disabled and
2275          * set the duty-cycles to 0% (which is identical to the PWMs being
2276          * disabled). */
2277         if (!(data->config & 0x02)) {
2278                 for (ix = 0; ix < 3; ix++) {
2279                         data->pwm_config[ix] = dme1737_read(data,
2280                                                 DME1737_REG_PWM_CONFIG(ix));
2281                         if ((data->has_features & HAS_PWM(ix)) &&
2282                             (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) {
2283                                 dev_info(dev, "Switching pwm%d to "
2284                                          "manual mode.\n", ix + 1);
2285                                 data->pwm_config[ix] = PWM_EN_TO_REG(1,
2286                                                         data->pwm_config[ix]);
2287                                 dme1737_write(data, DME1737_REG_PWM(ix), 0);
2288                                 dme1737_write(data,
2289                                               DME1737_REG_PWM_CONFIG(ix),
2290                                               data->pwm_config[ix]);
2291                         }
2292                 }
2293         }
2294
2295         /* Initialize the default PWM auto channels zone (acz) assignments */
2296         data->pwm_acz[0] = 1;   /* pwm1 -> zone1 */
2297         data->pwm_acz[1] = 2;   /* pwm2 -> zone2 */
2298         data->pwm_acz[2] = 4;   /* pwm3 -> zone3 */
2299
2300         /* Set VRM */
2301         if (data->has_features & HAS_VID) {
2302                 data->vrm = vid_which_vrm();
2303         }
2304
2305         return 0;
2306 }
2307
2308 /* ---------------------------------------------------------------------
2309  * I2C device detection and registration
2310  * --------------------------------------------------------------------- */
2311
2312 static struct i2c_driver dme1737_i2c_driver;
2313
2314 static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data)
2315 {
2316         int err = 0, reg;
2317         u16 addr;
2318
2319         dme1737_sio_enter(sio_cip);
2320
2321         /* Check device ID
2322          * We currently know about two kinds of DME1737 and SCH5027. */
2323         reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20);
2324         if (!(reg == DME1737_ID_1 || reg == DME1737_ID_2 ||
2325               reg == SCH5027_ID)) {
2326                 err = -ENODEV;
2327                 goto exit;
2328         }
2329
2330         /* Select logical device A (runtime registers) */
2331         dme1737_sio_outb(sio_cip, 0x07, 0x0a);
2332
2333         /* Get the base address of the runtime registers */
2334         addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) |
2335                 dme1737_sio_inb(sio_cip, 0x61);
2336         if (!addr) {
2337                 err = -ENODEV;
2338                 goto exit;
2339         }
2340
2341         /* Read the runtime registers to determine which optional features
2342          * are enabled and available. Bits [3:2] of registers 0x43-0x46 are set
2343          * to '10' if the respective feature is enabled. */
2344         if ((inb(addr + 0x43) & 0x0c) == 0x08) { /* fan6 */
2345                 data->has_features |= HAS_FAN(5);
2346         }
2347         if ((inb(addr + 0x44) & 0x0c) == 0x08) { /* pwm6 */
2348                 data->has_features |= HAS_PWM(5);
2349         }
2350         if ((inb(addr + 0x45) & 0x0c) == 0x08) { /* fan5 */
2351                 data->has_features |= HAS_FAN(4);
2352         }
2353         if ((inb(addr + 0x46) & 0x0c) == 0x08) { /* pwm5 */
2354                 data->has_features |= HAS_PWM(4);
2355         }
2356
2357 exit:
2358         dme1737_sio_exit(sio_cip);
2359
2360         return err;
2361 }
2362
2363 /* Return 0 if detection is successful, -ENODEV otherwise */
2364 static int dme1737_i2c_detect(struct i2c_client *client,
2365                               struct i2c_board_info *info)
2366 {
2367         struct i2c_adapter *adapter = client->adapter;
2368         struct device *dev = &adapter->dev;
2369         u8 company, verstep = 0;
2370         const char *name;
2371
2372         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
2373                 return -ENODEV;
2374         }
2375
2376         company = i2c_smbus_read_byte_data(client, DME1737_REG_COMPANY);
2377         verstep = i2c_smbus_read_byte_data(client, DME1737_REG_VERSTEP);
2378
2379         if (company == DME1737_COMPANY_SMSC &&
2380             verstep == SCH5027_VERSTEP) {
2381                 name = "sch5027";
2382         } else if (company == DME1737_COMPANY_SMSC &&
2383                    (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) {
2384                 name = "dme1737";
2385         } else {
2386                 return -ENODEV;
2387         }
2388
2389         dev_info(dev, "Found a %s chip at 0x%02x (rev 0x%02x).\n",
2390                  verstep == SCH5027_VERSTEP ? "SCH5027" : "DME1737",
2391                  client->addr, verstep);
2392         strlcpy(info->type, name, I2C_NAME_SIZE);
2393
2394         return 0;
2395 }
2396
2397 static int dme1737_i2c_probe(struct i2c_client *client,
2398                              const struct i2c_device_id *id)
2399 {
2400         struct dme1737_data *data;
2401         struct device *dev = &client->dev;
2402         int err;
2403
2404         data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL);
2405         if (!data) {
2406                 err = -ENOMEM;
2407                 goto exit;
2408         }
2409
2410         i2c_set_clientdata(client, data);
2411         data->type = id->driver_data;
2412         data->client = client;
2413         data->name = client->name;
2414         mutex_init(&data->update_lock);
2415
2416         /* Initialize the DME1737 chip */
2417         err = dme1737_init_device(dev);
2418         if (err) {
2419                 dev_err(dev, "Failed to initialize device.\n");
2420                 goto exit_kfree;
2421         }
2422
2423         /* Create sysfs files */
2424         err = dme1737_create_files(dev);
2425         if (err) {
2426                 dev_err(dev, "Failed to create sysfs files.\n");
2427                 goto exit_kfree;
2428         }
2429
2430         /* Register device */
2431         data->hwmon_dev = hwmon_device_register(dev);
2432         if (IS_ERR(data->hwmon_dev)) {
2433                 dev_err(dev, "Failed to register device.\n");
2434                 err = PTR_ERR(data->hwmon_dev);
2435                 goto exit_remove;
2436         }
2437
2438         return 0;
2439
2440 exit_remove:
2441         dme1737_remove_files(dev);
2442 exit_kfree:
2443         kfree(data);
2444 exit:
2445         return err;
2446 }
2447
2448 static int dme1737_i2c_remove(struct i2c_client *client)
2449 {
2450         struct dme1737_data *data = i2c_get_clientdata(client);
2451
2452         hwmon_device_unregister(data->hwmon_dev);
2453         dme1737_remove_files(&client->dev);
2454
2455         kfree(data);
2456         return 0;
2457 }
2458
2459 static const struct i2c_device_id dme1737_id[] = {
2460         { "dme1737", dme1737 },
2461         { "sch5027", sch5027 },
2462         { }
2463 };
2464 MODULE_DEVICE_TABLE(i2c, dme1737_id);
2465
2466 static struct i2c_driver dme1737_i2c_driver = {
2467         .class = I2C_CLASS_HWMON,
2468         .driver = {
2469                 .name = "dme1737",
2470         },
2471         .probe = dme1737_i2c_probe,
2472         .remove = dme1737_i2c_remove,
2473         .id_table = dme1737_id,
2474         .detect = dme1737_i2c_detect,
2475         .address_list = normal_i2c,
2476 };
2477
2478 /* ---------------------------------------------------------------------
2479  * ISA device detection and registration
2480  * --------------------------------------------------------------------- */
2481
2482 static int __init dme1737_isa_detect(int sio_cip, unsigned short *addr)
2483 {
2484         int err = 0, reg;
2485         unsigned short base_addr;
2486
2487         dme1737_sio_enter(sio_cip);
2488
2489         /* Check device ID
2490          * We currently know about SCH3112, SCH3114, SCH3116, and SCH5127 */
2491         reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20);
2492         if (!(reg == SCH3112_ID || reg == SCH3114_ID || reg == SCH3116_ID ||
2493               reg == SCH5127_ID)) {
2494                 err = -ENODEV;
2495                 goto exit;
2496         }
2497
2498         /* Select logical device A (runtime registers) */
2499         dme1737_sio_outb(sio_cip, 0x07, 0x0a);
2500
2501         /* Get the base address of the runtime registers */
2502         base_addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) |
2503                      dme1737_sio_inb(sio_cip, 0x61);
2504         if (!base_addr) {
2505                 pr_err("Base address not set\n");
2506                 err = -ENODEV;
2507                 goto exit;
2508         }
2509
2510         /* Access to the hwmon registers is through an index/data register
2511          * pair located at offset 0x70/0x71. */
2512         *addr = base_addr + 0x70;
2513
2514 exit:
2515         dme1737_sio_exit(sio_cip);
2516         return err;
2517 }
2518
2519 static int __init dme1737_isa_device_add(unsigned short addr)
2520 {
2521         struct resource res = {
2522                 .start  = addr,
2523                 .end    = addr + DME1737_EXTENT - 1,
2524                 .name   = "dme1737",
2525                 .flags  = IORESOURCE_IO,
2526         };
2527         int err;
2528
2529         err = acpi_check_resource_conflict(&res);
2530         if (err)
2531                 goto exit;
2532
2533         pdev = platform_device_alloc("dme1737", addr);
2534         if (!pdev) {
2535                 pr_err("Failed to allocate device\n");
2536                 err = -ENOMEM;
2537                 goto exit;
2538         }
2539
2540         err = platform_device_add_resources(pdev, &res, 1);
2541         if (err) {
2542                 pr_err("Failed to add device resource (err = %d)\n", err);
2543                 goto exit_device_put;
2544         }
2545
2546         err = platform_device_add(pdev);
2547         if (err) {
2548                 pr_err("Failed to add device (err = %d)\n", err);
2549                 goto exit_device_put;
2550         }
2551
2552         return 0;
2553
2554 exit_device_put:
2555         platform_device_put(pdev);
2556         pdev = NULL;
2557 exit:
2558         return err;
2559 }
2560
2561 static int __devinit dme1737_isa_probe(struct platform_device *pdev)
2562 {
2563         u8 company, device;
2564         struct resource *res;
2565         struct dme1737_data *data;
2566         struct device *dev = &pdev->dev;
2567         int err;
2568
2569         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
2570         if (!request_region(res->start, DME1737_EXTENT, "dme1737")) {
2571                 dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n",
2572                         (unsigned short)res->start,
2573                         (unsigned short)res->start + DME1737_EXTENT - 1);
2574                 err = -EBUSY;
2575                 goto exit;
2576         }
2577
2578         data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL);
2579         if (!data) {
2580                 err = -ENOMEM;
2581                 goto exit_release_region;
2582         }
2583
2584         data->addr = res->start;
2585         platform_set_drvdata(pdev, data);
2586
2587         /* Skip chip detection if module is loaded with force_id parameter */
2588         switch (force_id) {
2589         case SCH3112_ID:
2590         case SCH3114_ID:
2591         case SCH3116_ID:
2592                 data->type = sch311x;
2593                 break;
2594         case SCH5127_ID:
2595                 data->type = sch5127;
2596                 break;
2597         default:
2598                 company = dme1737_read(data, DME1737_REG_COMPANY);
2599                 device = dme1737_read(data, DME1737_REG_DEVICE);
2600
2601                 if ((company == DME1737_COMPANY_SMSC) &&
2602                     (device == SCH311X_DEVICE)) {
2603                         data->type = sch311x;
2604                 } else if ((company == DME1737_COMPANY_SMSC) &&
2605                            (device == SCH5127_DEVICE)) {
2606                         data->type = sch5127;
2607                 } else {
2608                         err = -ENODEV;
2609                         goto exit_kfree;
2610                 }
2611         }
2612
2613         if (data->type == sch5127) {
2614                 data->name = "sch5127";
2615         } else {
2616                 data->name = "sch311x";
2617         }
2618
2619         /* Initialize the mutex */
2620         mutex_init(&data->update_lock);
2621
2622         dev_info(dev, "Found a %s chip at 0x%04x\n",
2623                  data->type == sch5127 ? "SCH5127" : "SCH311x", data->addr);
2624
2625         /* Initialize the chip */
2626         err = dme1737_init_device(dev);
2627         if (err) {
2628                 dev_err(dev, "Failed to initialize device.\n");
2629                 goto exit_kfree;
2630         }
2631
2632         /* Create sysfs files */
2633         err = dme1737_create_files(dev);
2634         if (err) {
2635                 dev_err(dev, "Failed to create sysfs files.\n");
2636                 goto exit_kfree;
2637         }
2638
2639         /* Register device */
2640         data->hwmon_dev = hwmon_device_register(dev);
2641         if (IS_ERR(data->hwmon_dev)) {
2642                 dev_err(dev, "Failed to register device.\n");
2643                 err = PTR_ERR(data->hwmon_dev);
2644                 goto exit_remove_files;
2645         }
2646
2647         return 0;
2648
2649 exit_remove_files:
2650         dme1737_remove_files(dev);
2651 exit_kfree:
2652         platform_set_drvdata(pdev, NULL);
2653         kfree(data);
2654 exit_release_region:
2655         release_region(res->start, DME1737_EXTENT);
2656 exit:
2657         return err;
2658 }
2659
2660 static int __devexit dme1737_isa_remove(struct platform_device *pdev)
2661 {
2662         struct dme1737_data *data = platform_get_drvdata(pdev);
2663
2664         hwmon_device_unregister(data->hwmon_dev);
2665         dme1737_remove_files(&pdev->dev);
2666         release_region(data->addr, DME1737_EXTENT);
2667         platform_set_drvdata(pdev, NULL);
2668         kfree(data);
2669
2670         return 0;
2671 }
2672
2673 static struct platform_driver dme1737_isa_driver = {
2674         .driver = {
2675                 .owner = THIS_MODULE,
2676                 .name = "dme1737",
2677         },
2678         .probe = dme1737_isa_probe,
2679         .remove = __devexit_p(dme1737_isa_remove),
2680 };
2681
2682 /* ---------------------------------------------------------------------
2683  * Module initialization and cleanup
2684  * --------------------------------------------------------------------- */
2685
2686 static int __init dme1737_init(void)
2687 {
2688         int err;
2689         unsigned short addr;
2690
2691         err = i2c_add_driver(&dme1737_i2c_driver);
2692         if (err) {
2693                 goto exit;
2694         }
2695
2696         if (dme1737_isa_detect(0x2e, &addr) &&
2697             dme1737_isa_detect(0x4e, &addr) &&
2698             (!probe_all_addr ||
2699              (dme1737_isa_detect(0x162e, &addr) &&
2700               dme1737_isa_detect(0x164e, &addr)))) {
2701                 /* Return 0 if we didn't find an ISA device */
2702                 return 0;
2703         }
2704
2705         err = platform_driver_register(&dme1737_isa_driver);
2706         if (err) {
2707                 goto exit_del_i2c_driver;
2708         }
2709
2710         /* Sets global pdev as a side effect */
2711         err = dme1737_isa_device_add(addr);
2712         if (err) {
2713                 goto exit_del_isa_driver;
2714         }
2715
2716         return 0;
2717
2718 exit_del_isa_driver:
2719         platform_driver_unregister(&dme1737_isa_driver);
2720 exit_del_i2c_driver:
2721         i2c_del_driver(&dme1737_i2c_driver);
2722 exit:
2723         return err;
2724 }
2725
2726 static void __exit dme1737_exit(void)
2727 {
2728         if (pdev) {
2729                 platform_device_unregister(pdev);
2730                 platform_driver_unregister(&dme1737_isa_driver);
2731         }
2732
2733         i2c_del_driver(&dme1737_i2c_driver);
2734 }
2735
2736 MODULE_AUTHOR("Juerg Haefliger <juergh@gmail.com>");
2737 MODULE_DESCRIPTION("DME1737 sensors");
2738 MODULE_LICENSE("GPL");
2739
2740 module_init(dme1737_init);
2741 module_exit(dme1737_exit);