drivers/hwmon/lm93.c

   1 /*
   2     lm93.c - Part of lm_sensors, Linux kernel modules for hardware monitoring
   3
   4     Author/Maintainer: Mark M. Hoffman <mhoffman@lightlink.com>
   5         Copyright (c) 2004 Utilitek Systems, Inc.
   6
   7     derived in part from lm78.c:
   8         Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   9
  10     derived in part from lm85.c:
  11         Copyright (c) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com>
  12         Copyright (c) 2003       Margit Schubert-While <margitsw@t-online.de>
  13
  14     derived in part from w83l785ts.c:
  15         Copyright (c) 2003-2004 Jean Delvare <khali@linux-fr.org>
  16
  17     Ported to Linux 2.6 by Eric J. Bowersox <ericb@aspsys.com>
  18         Copyright (c) 2005 Aspen Systems, Inc.
  19
  20     Adapted to 2.6.20 by Carsten Emde <cbe@osadl.org>
  21         Copyright (c) 2006 Carsten Emde, Open Source Automation Development Lab
  22
  23     Modified for mainline integration by Hans J. Koch <hjk@linutronix.de>
  24         Copyright (c) 2007 Hans J. Koch, Linutronix GmbH
  25
  26     This program is free software; you can redistribute it and/or modify
  27     it under the terms of the GNU General Public License as published by
  28     the Free Software Foundation; either version 2 of the License, or
  29     (at your option) any later version.
  30
  31     This program is distributed in the hope that it will be useful,
  32     but WITHOUT ANY WARRANTY; without even the implied warranty of
  33     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  34     GNU General Public License for more details.
  35
  36     You should have received a copy of the GNU General Public License
  37     along with this program; if not, write to the Free Software
  38     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  39 */
  40
  41 #include <linux/module.h>
  42 #include <linux/init.h>
  43 #include <linux/slab.h>
  44 #include <linux/i2c.h>
  45 #include <linux/hwmon.h>
  46 #include <linux/hwmon-sysfs.h>
  47 #include <linux/hwmon-vid.h>
  48 #include <linux/err.h>
  49 #include <linux/delay.h>
  50
  51 /* LM93 REGISTER ADDRESSES */
  52
  53 /* miscellaneous */
  54 #define LM93_REG_MFR_ID                 0x3e
  55 #define LM93_REG_VER                    0x3f
  56 #define LM93_REG_STATUS_CONTROL         0xe2
  57 #define LM93_REG_CONFIG                 0xe3
  58 #define LM93_REG_SLEEP_CONTROL          0xe4
  59
  60 /* alarm values start here */
  61 #define LM93_REG_HOST_ERROR_1           0x48
  62
  63 /* voltage inputs: in1-in16 (nr => 0-15) */
  64 #define LM93_REG_IN(nr)                 (0x56 + (nr))
  65 #define LM93_REG_IN_MIN(nr)             (0x90 + (nr) * 2)
  66 #define LM93_REG_IN_MAX(nr)             (0x91 + (nr) * 2)
  67
  68 /* temperature inputs: temp1-temp4 (nr => 0-3) */
  69 #define LM93_REG_TEMP(nr)               (0x50 + (nr))
  70 #define LM93_REG_TEMP_MIN(nr)           (0x78 + (nr) * 2)
  71 #define LM93_REG_TEMP_MAX(nr)           (0x79 + (nr) * 2)
  72
  73 /* temp[1-4]_auto_boost (nr => 0-3) */
  74 #define LM93_REG_BOOST(nr)              (0x80 + (nr))
  75
  76 /* #PROCHOT inputs: prochot1-prochot2 (nr => 0-1) */
  77 #define LM93_REG_PROCHOT_CUR(nr)        (0x67 + (nr) * 2)
  78 #define LM93_REG_PROCHOT_AVG(nr)        (0x68 + (nr) * 2)
  79 #define LM93_REG_PROCHOT_MAX(nr)        (0xb0 + (nr))
  80
  81 /* fan tach inputs: fan1-fan4 (nr => 0-3) */
  82 #define LM93_REG_FAN(nr)                (0x6e + (nr) * 2)
  83 #define LM93_REG_FAN_MIN(nr)            (0xb4 + (nr) * 2)
  84
  85 /* pwm outputs: pwm1-pwm2 (nr => 0-1, reg => 0-3) */
  86 #define LM93_REG_PWM_CTL(nr,reg)        (0xc8 + (reg) + (nr) * 4)
  87 #define LM93_PWM_CTL1   0x0
  88 #define LM93_PWM_CTL2   0x1
  89 #define LM93_PWM_CTL3   0x2
  90 #define LM93_PWM_CTL4   0x3
  91
  92 /* GPIO input state */
  93 #define LM93_REG_GPI                    0x6b
  94
  95 /* vid inputs: vid1-vid2 (nr => 0-1) */
  96 #define LM93_REG_VID(nr)                (0x6c + (nr))
  97
  98 /* vccp1 & vccp2: VID relative inputs (nr => 0-1) */
  99 #define LM93_REG_VCCP_LIMIT_OFF(nr)     (0xb2 + (nr))
 100
 101 /* temp[1-4]_auto_boost_hyst */
 102 #define LM93_REG_BOOST_HYST_12          0xc0
 103 #define LM93_REG_BOOST_HYST_34          0xc1
 104 #define LM93_REG_BOOST_HYST(nr)         (0xc0 + (nr)/2)
 105
 106 /* temp[1-4]_auto_pwm_[min|hyst] */
 107 #define LM93_REG_PWM_MIN_HYST_12        0xc3
 108 #define LM93_REG_PWM_MIN_HYST_34        0xc4
 109 #define LM93_REG_PWM_MIN_HYST(nr)       (0xc3 + (nr)/2)
 110
 111 /* prochot_override & prochot_interval */
 112 #define LM93_REG_PROCHOT_OVERRIDE       0xc6
 113 #define LM93_REG_PROCHOT_INTERVAL       0xc7
 114
 115 /* temp[1-4]_auto_base (nr => 0-3) */
 116 #define LM93_REG_TEMP_BASE(nr)          (0xd0 + (nr))
 117
 118 /* temp[1-4]_auto_offsets (step => 0-11) */
 119 #define LM93_REG_TEMP_OFFSET(step)      (0xd4 + (step))
 120
 121 /* #PROCHOT & #VRDHOT PWM ramp control */
 122 #define LM93_REG_PWM_RAMP_CTL           0xbf
 123
 124 /* miscellaneous */
 125 #define LM93_REG_SFC1           0xbc
 126 #define LM93_REG_SFC2           0xbd
 127 #define LM93_REG_GPI_VID_CTL    0xbe
 128 #define LM93_REG_SF_TACH_TO_PWM 0xe0
 129
 130 /* error masks */
 131 #define LM93_REG_GPI_ERR_MASK   0xec
 132 #define LM93_REG_MISC_ERR_MASK  0xed
 133
 134 /* LM93 REGISTER VALUES */
 135 #define LM93_MFR_ID             0x73
 136 #define LM93_MFR_ID_PROTOTYPE   0x72
 137
 138 /* SMBus capabilities */
 139 #define LM93_SMBUS_FUNC_FULL (I2C_FUNC_SMBUS_BYTE_DATA | \
 140                 I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_DATA)
 141 #define LM93_SMBUS_FUNC_MIN  (I2C_FUNC_SMBUS_BYTE_DATA | \
 142                 I2C_FUNC_SMBUS_WORD_DATA)
 143
 144 /* Addresses to scan */
 145 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
 146
 147 /* Insmod parameters */
 148 I2C_CLIENT_INSMOD_1(lm93);
 149
 150 static int disable_block;
 151 module_param(disable_block, bool, 0);
 152 MODULE_PARM_DESC(disable_block,
 153         "Set to non-zero to disable SMBus block data transactions.");
 154
 155 static int init;
 156 module_param(init, bool, 0);
 157 MODULE_PARM_DESC(init, "Set to non-zero to force chip initialization.");
 158
 159 static int vccp_limit_type[2] = {0,0};
 160 module_param_array(vccp_limit_type, int, NULL, 0);
 161 MODULE_PARM_DESC(vccp_limit_type, "Configures in7 and in8 limit modes.");
 162
 163 static int vid_agtl;
 164 module_param(vid_agtl, int, 0);
 165 MODULE_PARM_DESC(vid_agtl, "Configures VID pin input thresholds.");
 166
 167 /* Driver data */
 168 static struct i2c_driver lm93_driver;
 169
 170 /* LM93 BLOCK READ COMMANDS */
 171 static const struct { u8 cmd; u8 len; } lm93_block_read_cmds[12] = {
 172         { 0xf2,  8 },
 173         { 0xf3,  8 },
 174         { 0xf4,  6 },
 175         { 0xf5, 16 },
 176         { 0xf6,  4 },
 177         { 0xf7,  8 },
 178         { 0xf8, 12 },
 179         { 0xf9, 32 },
 180         { 0xfa,  8 },
 181         { 0xfb,  8 },
 182         { 0xfc, 16 },
 183         { 0xfd,  9 },
 184 };
 185
 186 /* ALARMS: SYSCTL format described further below
 187    REG: 64 bits in 8 registers, as immediately below */
 188 struct block1_t {
 189         u8 host_status_1;
 190         u8 host_status_2;
 191         u8 host_status_3;
 192         u8 host_status_4;
 193         u8 p1_prochot_status;
 194         u8 p2_prochot_status;
 195         u8 gpi_status;
 196         u8 fan_status;
 197 };
 198
 199 /*
 200  * Client-specific data
 201  */
 202 struct lm93_data {
 203         struct i2c_client client;
 204         struct class_device *class_dev;
 205
 206         struct mutex update_lock;
 207         unsigned long last_updated;     /* In jiffies */
 208
 209         /* client update function */
 210         void (*update)(struct lm93_data *, struct i2c_client *);
 211
 212         char valid; /* !=0 if following fields are valid */
 213
 214         /* register values, arranged by block read groups */
 215         struct block1_t block1;
 216
 217         /* temp1 - temp4: unfiltered readings
 218            temp1 - temp2: filtered readings */
 219         u8 block2[6];
 220
 221         /* vin1 - vin16: readings */
 222         u8 block3[16];
 223
 224         /* prochot1 - prochot2: readings */
 225         struct {
 226                 u8 cur;
 227                 u8 avg;
 228         } block4[2];
 229
 230         /* fan counts 1-4 => 14-bits, LE, *left* justified */
 231         u16 block5[4];
 232
 233         /* block6 has a lot of data we don't need */
 234         struct {
 235                 u8 min;
 236                 u8 max;
 237         } temp_lim[3];
 238
 239         /* vin1 - vin16: low and high limits */
 240         struct {
 241                 u8 min;
 242                 u8 max;
 243         } block7[16];
 244
 245         /* fan count limits 1-4 => same format as block5 */
 246         u16 block8[4];
 247
 248         /* pwm control registers (2 pwms, 4 regs) */
 249         u8 block9[2][4];
 250
 251         /* auto/pwm base temp and offset temp registers */
 252         struct {
 253                 u8 base[4];
 254                 u8 offset[12];
 255         } block10;
 256
 257         /* master config register */
 258         u8 config;
 259
 260         /* VID1 & VID2 => register format, 6-bits, right justified */
 261         u8 vid[2];
 262
 263         /* prochot1 - prochot2: limits */
 264         u8 prochot_max[2];
 265
 266         /* vccp1 & vccp2 (in7 & in8): VID relative limits (register format) */
 267         u8 vccp_limits[2];
 268
 269         /* GPIO input state (register format, i.e. inverted) */
 270         u8 gpi;
 271
 272         /* #PROCHOT override (register format) */
 273         u8 prochot_override;
 274
 275         /* #PROCHOT intervals (register format) */
 276         u8 prochot_interval;
 277
 278         /* Fan Boost Temperatures (register format) */
 279         u8 boost[4];
 280
 281         /* Fan Boost Hysteresis (register format) */
 282         u8 boost_hyst[2];
 283
 284         /* Temperature Zone Min. PWM & Hysteresis (register format) */
 285         u8 auto_pwm_min_hyst[2];
 286
 287         /* #PROCHOT & #VRDHOT PWM Ramp Control */
 288         u8 pwm_ramp_ctl;
 289
 290         /* miscellaneous setup regs */
 291         u8 sfc1;
 292         u8 sfc2;
 293         u8 sf_tach_to_pwm;
 294
 295         /* The two PWM CTL2  registers can read something other than what was
 296            last written for the OVR_DC field (duty cycle override).  So, we
 297            save the user-commanded value here. */
 298         u8 pwm_override[2];
 299 };
 300
 301 /* VID: mV
 302    REG: 6-bits, right justified, *always* using Intel VRM/VRD 10 */
 303 static int LM93_VID_FROM_REG(u8 reg)
 304 {
 305         return vid_from_reg((reg & 0x3f), 100);
 306 }
 307
 308 /* min, max, and nominal register values, per channel (u8) */
 309 static const u8 lm93_vin_reg_min[16] = {
 310         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 311         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae,
 312 };
 313 static const u8 lm93_vin_reg_max[16] = {
 314         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 315         0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1,
 316 };
 317 /* Values from the datasheet. They're here for documentation only.
 318 static const u8 lm93_vin_reg_nom[16] = {
 319         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
 320         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x40, 0xc0,
 321 };
 322 */
 323
 324 /* min, max, and nominal voltage readings, per channel (mV)*/
 325 static const unsigned long lm93_vin_val_min[16] = {
 326         0, 0, 0, 0, 0, 0, 0, 0,
 327         0, 0, 0, 0, 0, 0, 0, 3000,
 328 };
 329
 330 static const unsigned long lm93_vin_val_max[16] = {
 331         1236, 1236, 1236, 1600, 2000, 2000, 1600, 1600,
 332         4400, 6500, 3333, 2625, 1312, 1312, 1236, 3600,
 333 };
 334 /* Values from the datasheet. They're here for documentation only.
 335 static const unsigned long lm93_vin_val_nom[16] = {
 336          927,  927,  927, 1200, 1500, 1500, 1200, 1200,
 337         3300, 5000, 2500, 1969,  984,  984,  309, 3300,
 338 };
 339 */
 340
 341 static unsigned LM93_IN_FROM_REG(int nr, u8 reg)
 342 {
 343         const long uV_max = lm93_vin_val_max[nr] * 1000;
 344         const long uV_min = lm93_vin_val_min[nr] * 1000;
 345
 346         const long slope = (uV_max - uV_min) /
 347                 (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
 348         const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
 349
 350         return (slope * reg + intercept + 500) / 1000;
 351 }
 352
 353 /* IN: mV, limits determined by channel nr
 354    REG: scaling determined by channel nr */
 355 static u8 LM93_IN_TO_REG(int nr, unsigned val)
 356 {
 357         /* range limit */
 358         const long mV = SENSORS_LIMIT(val,
 359                 lm93_vin_val_min[nr], lm93_vin_val_max[nr]);
 360
 361         /* try not to lose too much precision here */
 362         const long uV = mV * 1000;
 363         const long uV_max = lm93_vin_val_max[nr] * 1000;
 364         const long uV_min = lm93_vin_val_min[nr] * 1000;
 365
 366         /* convert */
 367         const long slope = (uV_max - uV_min) /
 368                 (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
 369         const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
 370
 371         u8 result = ((uV - intercept + (slope/2)) / slope);
 372         result = SENSORS_LIMIT(result,
 373                         lm93_vin_reg_min[nr], lm93_vin_reg_max[nr]);
 374         return result;
 375 }
 376
 377 /* vid in mV, upper == 0 indicates low limit, otherwise upper limit */
 378 static unsigned LM93_IN_REL_FROM_REG(u8 reg, int upper, int vid)
 379 {
 380         const long uV_offset = upper ? (((reg >> 4 & 0x0f) + 1) * 12500) :
 381                                 (((reg >> 0 & 0x0f) + 1) * -25000);
 382         const long uV_vid = vid * 1000;
 383         return (uV_vid + uV_offset + 5000) / 10000;
 384 }
 385
 386 #define LM93_IN_MIN_FROM_REG(reg,vid)   LM93_IN_REL_FROM_REG(reg,0,vid)
 387 #define LM93_IN_MAX_FROM_REG(reg,vid)   LM93_IN_REL_FROM_REG(reg,1,vid)
 388
 389 /* vid in mV , upper == 0 indicates low limit, otherwise upper limit
 390    upper also determines which nibble of the register is returned
 391    (the other nibble will be 0x0) */
 392 static u8 LM93_IN_REL_TO_REG(unsigned val, int upper, int vid)
 393 {
 394         long uV_offset = vid * 1000 - val * 10000;
 395         if (upper) {
 396                 uV_offset = SENSORS_LIMIT(uV_offset, 12500, 200000);
 397                 return (u8)((uV_offset /  12500 - 1) << 4);
 398         } else {
 399                 uV_offset = SENSORS_LIMIT(uV_offset, -400000, -25000);
 400                 return (u8)((uV_offset / -25000 - 1) << 0);
 401         }
 402 }
 403
 404 /* TEMP: 1/1000 degrees C (-128C to +127C)
 405    REG: 1C/bit, two's complement */
 406 static int LM93_TEMP_FROM_REG(u8 reg)
 407 {
 408         return (s8)reg * 1000;
 409 }
 410
 411 #define LM93_TEMP_MIN (-128000)
 412 #define LM93_TEMP_MAX ( 127000)
 413
 414 /* TEMP: 1/1000 degrees C (-128C to +127C)
 415    REG: 1C/bit, two's complement */
 416 static u8 LM93_TEMP_TO_REG(int temp)
 417 {
 418         int ntemp = SENSORS_LIMIT(temp, LM93_TEMP_MIN, LM93_TEMP_MAX);
 419         ntemp += (ntemp<0 ? -500 : 500);
 420         return (u8)(ntemp / 1000);
 421 }
 422
 423 /* Determine 4-bit temperature offset resolution */
 424 static int LM93_TEMP_OFFSET_MODE_FROM_REG(u8 sfc2, int nr)
 425 {
 426         /* mode: 0 => 1C/bit, nonzero => 0.5C/bit */
 427         return sfc2 & (nr < 2 ? 0x10 : 0x20);
 428 }
 429
 430 /* This function is common to all 4-bit temperature offsets
 431    reg is 4 bits right justified
 432    mode 0 => 1C/bit, mode !0 => 0.5C/bit */
 433 static int LM93_TEMP_OFFSET_FROM_REG(u8 reg, int mode)
 434 {
 435         return (reg & 0x0f) * (mode ? 5 : 10);
 436 }
 437
 438 #define LM93_TEMP_OFFSET_MIN  (  0)
 439 #define LM93_TEMP_OFFSET_MAX0 (150)
 440 #define LM93_TEMP_OFFSET_MAX1 ( 75)
 441
 442 /* This function is common to all 4-bit temperature offsets
 443    returns 4 bits right justified
 444    mode 0 => 1C/bit, mode !0 => 0.5C/bit */
 445 static u8 LM93_TEMP_OFFSET_TO_REG(int off, int mode)
 446 {
 447         int factor = mode ? 5 : 10;
 448
 449         off = SENSORS_LIMIT(off, LM93_TEMP_OFFSET_MIN,
 450                 mode ? LM93_TEMP_OFFSET_MAX1 : LM93_TEMP_OFFSET_MAX0);
 451         return (u8)((off + factor/2) / factor);
 452 }
 453
 454 /* 0 <= nr <= 3 */
 455 static int LM93_TEMP_AUTO_OFFSET_FROM_REG(u8 reg, int nr, int mode)
 456 {
 457         /* temp1-temp2 (nr=0,1) use lower nibble */
 458         if (nr < 2)
 459                 return LM93_TEMP_OFFSET_FROM_REG(reg & 0x0f, mode);
 460
 461         /* temp3-temp4 (nr=2,3) use upper nibble */
 462         else
 463                 return LM93_TEMP_OFFSET_FROM_REG(reg >> 4 & 0x0f, mode);
 464 }
 465
 466 /* TEMP: 1/10 degrees C (0C to +15C (mode 0) or +7.5C (mode non-zero))
 467    REG: 1.0C/bit (mode 0) or 0.5C/bit (mode non-zero)
 468    0 <= nr <= 3 */
 469 static u8 LM93_TEMP_AUTO_OFFSET_TO_REG(u8 old, int off, int nr, int mode)
 470 {
 471         u8 new = LM93_TEMP_OFFSET_TO_REG(off, mode);
 472
 473         /* temp1-temp2 (nr=0,1) use lower nibble */
 474         if (nr < 2)
 475                 return (old & 0xf0) | (new & 0x0f);
 476
 477         /* temp3-temp4 (nr=2,3) use upper nibble */
 478         else
 479                 return (new << 4 & 0xf0) | (old & 0x0f);
 480 }
 481
 482 static int LM93_AUTO_BOOST_HYST_FROM_REGS(struct lm93_data *data, int nr,
 483                 int mode)
 484 {
 485         u8 reg;
 486
 487         switch (nr) {
 488         case 0:
 489                 reg = data->boost_hyst[0] & 0x0f;
 490                 break;
 491         case 1:
 492                 reg = data->boost_hyst[0] >> 4 & 0x0f;
 493                 break;
 494         case 2:
 495                 reg = data->boost_hyst[1] & 0x0f;
 496                 break;
 497         case 3:
 498         default:
 499                 reg = data->boost_hyst[1] >> 4 & 0x0f;
 500                 break;
 501         }
 502
 503         return LM93_TEMP_FROM_REG(data->boost[nr]) -
 504                         LM93_TEMP_OFFSET_FROM_REG(reg, mode);
 505 }
 506
 507 static u8 LM93_AUTO_BOOST_HYST_TO_REG(struct lm93_data *data, long hyst,
 508                 int nr, int mode)
 509 {
 510         u8 reg = LM93_TEMP_OFFSET_TO_REG(
 511                         (LM93_TEMP_FROM_REG(data->boost[nr]) - hyst), mode);
 512
 513         switch (nr) {
 514         case 0:
 515                 reg = (data->boost_hyst[0] & 0xf0) | (reg & 0x0f);
 516                 break;
 517         case 1:
 518                 reg = (reg << 4 & 0xf0) | (data->boost_hyst[0] & 0x0f);
 519                 break;
 520         case 2:
 521                 reg = (data->boost_hyst[1] & 0xf0) | (reg & 0x0f);
 522                 break;
 523         case 3:
 524         default:
 525                 reg = (reg << 4 & 0xf0) | (data->boost_hyst[1] & 0x0f);
 526                 break;
 527         }
 528
 529         return reg;
 530 }
 531
 532 /* PWM: 0-255 per sensors documentation
 533    REG: 0-13 as mapped below... right justified */
 534 typedef enum { LM93_PWM_MAP_HI_FREQ, LM93_PWM_MAP_LO_FREQ } pwm_freq_t;
 535 static int lm93_pwm_map[2][16] = {
 536         {
 537                 0x00, /*   0.00% */ 0x40, /*  25.00% */
 538                 0x50, /*  31.25% */ 0x60, /*  37.50% */
 539                 0x70, /*  43.75% */ 0x80, /*  50.00% */
 540                 0x90, /*  56.25% */ 0xa0, /*  62.50% */
 541                 0xb0, /*  68.75% */ 0xc0, /*  75.00% */
 542                 0xd0, /*  81.25% */ 0xe0, /*  87.50% */
 543                 0xf0, /*  93.75% */ 0xff, /* 100.00% */
 544                 0xff, 0xff, /* 14, 15 are reserved and should never occur */
 545         },
 546         {
 547                 0x00, /*   0.00% */ 0x40, /*  25.00% */
 548                 0x49, /*  28.57% */ 0x52, /*  32.14% */
 549                 0x5b, /*  35.71% */ 0x64, /*  39.29% */
 550                 0x6d, /*  42.86% */ 0x76, /*  46.43% */
 551                 0x80, /*  50.00% */ 0x89, /*  53.57% */
 552                 0x92, /*  57.14% */ 0xb6, /*  71.43% */
 553                 0xdb, /*  85.71% */ 0xff, /* 100.00% */
 554                 0xff, 0xff, /* 14, 15 are reserved and should never occur */
 555         },
 556 };
 557
 558 static int LM93_PWM_FROM_REG(u8 reg, pwm_freq_t freq)
 559 {
 560         return lm93_pwm_map[freq][reg & 0x0f];
 561 }
 562
 563 /* round up to nearest match */
 564 static u8 LM93_PWM_TO_REG(int pwm, pwm_freq_t freq)
 565 {
 566         int i;
 567         for (i = 0; i < 13; i++)
 568                 if (pwm <= lm93_pwm_map[freq][i])
 569                         break;
 570
 571         /* can fall through with i==13 */
 572         return (u8)i;
 573 }
 574
 575 static int LM93_FAN_FROM_REG(u16 regs)
 576 {
 577         const u16 count = le16_to_cpu(regs) >> 2;
 578         return count==0 ? -1 : count==0x3fff ? 0: 1350000 / count;
 579 }
 580
 581 /*
 582  * RPM: (82.5 to 1350000)
 583  * REG: 14-bits, LE, *left* justified
 584  */
 585 static u16 LM93_FAN_TO_REG(long rpm)
 586 {
 587         u16 count, regs;
 588
 589         if (rpm == 0) {
 590                 count = 0x3fff;
 591         } else {
 592                 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 593                 count = SENSORS_LIMIT((1350000 + rpm) / rpm, 1, 0x3ffe);
 594         }
 595
 596         regs = count << 2;
 597         return cpu_to_le16(regs);
 598 }
 599
 600 /* PWM FREQ: HZ
 601    REG: 0-7 as mapped below */
 602 static int lm93_pwm_freq_map[8] = {
 603         22500, 96, 84, 72, 60, 48, 36, 12
 604 };
 605
 606 static int LM93_PWM_FREQ_FROM_REG(u8 reg)
 607 {
 608         return lm93_pwm_freq_map[reg & 0x07];
 609 }
 610
 611 /* round up to nearest match */
 612 static u8 LM93_PWM_FREQ_TO_REG(int freq)
 613 {
 614         int i;
 615         for (i = 7; i > 0; i--)
 616                 if (freq <= lm93_pwm_freq_map[i])
 617                         break;
 618
 619         /* can fall through with i==0 */
 620         return (u8)i;
 621 }
 622
 623 /* TIME: 1/100 seconds
 624  * REG: 0-7 as mapped below */
 625 static int lm93_spinup_time_map[8] = {
 626         0, 10, 25, 40, 70, 100, 200, 400,
 627 };
 628
 629 static int LM93_SPINUP_TIME_FROM_REG(u8 reg)
 630 {
 631         return lm93_spinup_time_map[reg >> 5 & 0x07];
 632 }
 633
 634 /* round up to nearest match */
 635 static u8 LM93_SPINUP_TIME_TO_REG(int time)
 636 {
 637         int i;
 638         for (i = 0; i < 7; i++)
 639                 if (time <= lm93_spinup_time_map[i])
 640                         break;
 641
 642         /* can fall through with i==8 */
 643         return (u8)i;
 644 }
 645
 646 #define LM93_RAMP_MIN 0
 647 #define LM93_RAMP_MAX 75
 648
 649 static int LM93_RAMP_FROM_REG(u8 reg)
 650 {
 651         return (reg & 0x0f) * 5;
 652 }
 653
 654 /* RAMP: 1/100 seconds
 655    REG: 50mS/bit 4-bits right justified */
 656 static u8 LM93_RAMP_TO_REG(int ramp)
 657 {
 658         ramp = SENSORS_LIMIT(ramp, LM93_RAMP_MIN, LM93_RAMP_MAX);
 659         return (u8)((ramp + 2) / 5);
 660 }
 661
 662 /* PROCHOT: 0-255, 0 => 0%, 255 => > 96.6%
 663  * REG: (same) */
 664 static u8 LM93_PROCHOT_TO_REG(long prochot)
 665 {
 666         prochot = SENSORS_LIMIT(prochot, 0, 255);
 667         return (u8)prochot;
 668 }
 669
 670 /* PROCHOT-INTERVAL: 73 - 37200 (1/100 seconds)
 671  * REG: 0-9 as mapped below */
 672 static int lm93_interval_map[10] = {
 673         73, 146, 290, 580, 1170, 2330, 4660, 9320, 18600, 37200,
 674 };
 675
 676 static int LM93_INTERVAL_FROM_REG(u8 reg)
 677 {
 678         return lm93_interval_map[reg & 0x0f];
 679 }
 680
 681 /* round up to nearest match */
 682 static u8 LM93_INTERVAL_TO_REG(long interval)
 683 {
 684         int i;
 685         for (i = 0; i < 9; i++)
 686                 if (interval <= lm93_interval_map[i])
 687                         break;
 688
 689         /* can fall through with i==9 */
 690         return (u8)i;
 691 }
 692
 693 /* GPIO: 0-255, GPIO0 is LSB
 694  * REG: inverted */
 695 static unsigned LM93_GPI_FROM_REG(u8 reg)
 696 {
 697         return ~reg & 0xff;
 698 }
 699
 700 /* alarm bitmask definitions
 701    The LM93 has nearly 64 bits of error status... I've pared that down to
 702    what I think is a useful subset in order to fit it into 32 bits.
 703
 704    Especially note that the #VRD_HOT alarms are missing because we provide
 705    that information as values in another sysfs file.
 706
 707    If libsensors is extended to support 64 bit values, this could be revisited.
 708 */
 709 #define LM93_ALARM_IN1          0x00000001
 710 #define LM93_ALARM_IN2          0x00000002
 711 #define LM93_ALARM_IN3          0x00000004
 712 #define LM93_ALARM_IN4          0x00000008
 713 #define LM93_ALARM_IN5          0x00000010
 714 #define LM93_ALARM_IN6          0x00000020
 715 #define LM93_ALARM_IN7          0x00000040
 716 #define LM93_ALARM_IN8          0x00000080
 717 #define LM93_ALARM_IN9          0x00000100
 718 #define LM93_ALARM_IN10         0x00000200
 719 #define LM93_ALARM_IN11         0x00000400
 720 #define LM93_ALARM_IN12         0x00000800
 721 #define LM93_ALARM_IN13         0x00001000
 722 #define LM93_ALARM_IN14         0x00002000
 723 #define LM93_ALARM_IN15         0x00004000
 724 #define LM93_ALARM_IN16         0x00008000
 725 #define LM93_ALARM_FAN1         0x00010000
 726 #define LM93_ALARM_FAN2         0x00020000
 727 #define LM93_ALARM_FAN3         0x00040000
 728 #define LM93_ALARM_FAN4         0x00080000
 729 #define LM93_ALARM_PH1_ERR      0x00100000
 730 #define LM93_ALARM_PH2_ERR      0x00200000
 731 #define LM93_ALARM_SCSI1_ERR    0x00400000
 732 #define LM93_ALARM_SCSI2_ERR    0x00800000
 733 #define LM93_ALARM_DVDDP1_ERR   0x01000000
 734 #define LM93_ALARM_DVDDP2_ERR   0x02000000
 735 #define LM93_ALARM_D1_ERR       0x04000000
 736 #define LM93_ALARM_D2_ERR       0x08000000
 737 #define LM93_ALARM_TEMP1        0x10000000
 738 #define LM93_ALARM_TEMP2        0x20000000
 739 #define LM93_ALARM_TEMP3        0x40000000
 740
 741 static unsigned LM93_ALARMS_FROM_REG(struct block1_t b1)
 742 {
 743         unsigned result;
 744         result  = b1.host_status_2 & 0x3f;
 745
 746         if (vccp_limit_type[0])
 747                 result |= (b1.host_status_4 & 0x10) << 2;
 748         else
 749                 result |= b1.host_status_2 & 0x40;
 750
 751         if (vccp_limit_type[1])
 752                 result |= (b1.host_status_4 & 0x20) << 2;
 753         else
 754                 result |= b1.host_status_2 & 0x80;
 755
 756         result |= b1.host_status_3 << 8;
 757         result |= (b1.fan_status & 0x0f) << 16;
 758         result |= (b1.p1_prochot_status & 0x80) << 13;
 759         result |= (b1.p2_prochot_status & 0x80) << 14;
 760         result |= (b1.host_status_4 & 0xfc) << 20;
 761         result |= (b1.host_status_1 & 0x07) << 28;
 762         return result;
 763 }
 764
 765 #define MAX_RETRIES 5
 766
 767 static u8 lm93_read_byte(struct i2c_client *client, u8 reg)
 768 {
 769         int value, i;
 770
 771         /* retry in case of read errors */
 772         for (i=1; i<=MAX_RETRIES; i++) {
 773                 if ((value = i2c_smbus_read_byte_data(client, reg)) >= 0) {
 774                         return value;
 775                 } else {
 776                         dev_warn(&client->dev,"lm93: read byte data failed, "
 777                                 "address 0x%02x.\n", reg);
 778                         mdelay(i + 3);
 779                 }
 780
 781         }
 782
 783         /* <TODO> what to return in case of error? */
 784         dev_err(&client->dev,"lm93: All read byte retries failed!!\n");
 785         return 0;
 786 }
 787
 788 static int lm93_write_byte(struct i2c_client *client, u8 reg, u8 value)
 789 {
 790         int result;
 791
 792         /* <TODO> how to handle write errors? */
 793         result = i2c_smbus_write_byte_data(client, reg, value);
 794
 795         if (result < 0)
 796                 dev_warn(&client->dev,"lm93: write byte data failed, "
 797                          "0x%02x at address 0x%02x.\n", value, reg);
 798
 799         return result;
 800 }
 801
 802 static u16 lm93_read_word(struct i2c_client *client, u8 reg)
 803 {
 804         int value, i;
 805
 806         /* retry in case of read errors */
 807         for (i=1; i<=MAX_RETRIES; i++) {
 808                 if ((value = i2c_smbus_read_word_data(client, reg)) >= 0) {
 809                         return value;
 810                 } else {
 811                         dev_warn(&client->dev,"lm93: read word data failed, "
 812                                  "address 0x%02x.\n", reg);
 813                         mdelay(i + 3);
 814                 }
 815
 816         }
 817
 818         /* <TODO> what to return in case of error? */
 819         dev_err(&client->dev,"lm93: All read word retries failed!!\n");
 820         return 0;
 821 }
 822
 823 static int lm93_write_word(struct i2c_client *client, u8 reg, u16 value)
 824 {
 825         int result;
 826
 827         /* <TODO> how to handle write errors? */
 828         result = i2c_smbus_write_word_data(client, reg, value);
 829
 830         if (result < 0)
 831                 dev_warn(&client->dev,"lm93: write word data failed, "
 832                          "0x%04x at address 0x%02x.\n", value, reg);
 833
 834         return result;
 835 }
 836
 837 static u8 lm93_block_buffer[I2C_SMBUS_BLOCK_MAX];
 838
 839 /*
 840         read block data into values, retry if not expected length
 841         fbn => index to lm93_block_read_cmds table
 842                 (Fixed Block Number - section 14.5.2 of LM93 datasheet)
 843 */
 844 static void lm93_read_block(struct i2c_client *client, u8 fbn, u8 *values)
 845 {
 846         int i, result=0;
 847
 848         for (i = 1; i <= MAX_RETRIES; i++) {
 849                 result = i2c_smbus_read_block_data(client,
 850                         lm93_block_read_cmds[fbn].cmd, lm93_block_buffer);
 851
 852                 if (result == lm93_block_read_cmds[fbn].len) {
 853                         break;
 854                 } else {
 855                         dev_warn(&client->dev,"lm93: block read data failed, "
 856                                  "command 0x%02x.\n",
 857                                  lm93_block_read_cmds[fbn].cmd);
 858                         mdelay(i + 3);
 859                 }
 860         }
 861
 862         if (result == lm93_block_read_cmds[fbn].len) {
 863                 memcpy(values,lm93_block_buffer,lm93_block_read_cmds[fbn].len);
 864         } else {
 865                 /* <TODO> what to do in case of error? */
 866         }
 867 }
 868
 869 static struct lm93_data *lm93_update_device(struct device *dev)
 870 {
 871         struct i2c_client *client = to_i2c_client(dev);
 872         struct lm93_data *data = i2c_get_clientdata(client);
 873         const unsigned long interval = HZ + (HZ / 2);
 874
 875         mutex_lock(&data->update_lock);
 876
 877         if (time_after(jiffies, data->last_updated + interval) ||
 878                 !data->valid) {
 879
 880                 data->update(data, client);
 881                 data->last_updated = jiffies;
 882                 data->valid = 1;
 883         }
 884
 885         mutex_unlock(&data->update_lock);
 886         return data;
 887 }
 888
 889 /* update routine for data that has no corresponding SMBus block command */
 890 static void lm93_update_client_common(struct lm93_data *data,
 891                                       struct i2c_client *client)
 892 {
 893         int i;
 894         u8 *ptr;
 895
 896         /* temp1 - temp4: limits */
 897         for (i = 0; i < 4; i++) {
 898                 data->temp_lim[i].min =
 899                         lm93_read_byte(client, LM93_REG_TEMP_MIN(i));
 900                 data->temp_lim[i].max =
 901                         lm93_read_byte(client, LM93_REG_TEMP_MAX(i));
 902         }
 903
 904         /* config register */
 905         data->config = lm93_read_byte(client, LM93_REG_CONFIG);
 906
 907         /* vid1 - vid2: values */
 908         for (i = 0; i < 2; i++)
 909                 data->vid[i] = lm93_read_byte(client, LM93_REG_VID(i));
 910
 911         /* prochot1 - prochot2: limits */
 912         for (i = 0; i < 2; i++)
 913                 data->prochot_max[i] = lm93_read_byte(client,
 914                                 LM93_REG_PROCHOT_MAX(i));
 915
 916         /* vccp1 - vccp2: VID relative limits */
 917         for (i = 0; i < 2; i++)
 918                 data->vccp_limits[i] = lm93_read_byte(client,
 919                                 LM93_REG_VCCP_LIMIT_OFF(i));
 920
 921         /* GPIO input state */
 922         data->gpi = lm93_read_byte(client, LM93_REG_GPI);
 923
 924         /* #PROCHOT override state */
 925         data->prochot_override = lm93_read_byte(client,
 926                         LM93_REG_PROCHOT_OVERRIDE);
 927
 928         /* #PROCHOT intervals */
 929         data->prochot_interval = lm93_read_byte(client,
 930                         LM93_REG_PROCHOT_INTERVAL);
 931
 932         /* Fan Boost Termperature registers */
 933         for (i = 0; i < 4; i++)
 934                 data->boost[i] = lm93_read_byte(client, LM93_REG_BOOST(i));
 935
 936         /* Fan Boost Temperature Hyst. registers */
 937         data->boost_hyst[0] = lm93_read_byte(client, LM93_REG_BOOST_HYST_12);
 938         data->boost_hyst[1] = lm93_read_byte(client, LM93_REG_BOOST_HYST_34);
 939
 940         /* Temperature Zone Min. PWM & Hysteresis registers */
 941         data->auto_pwm_min_hyst[0] =
 942                         lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_12);
 943         data->auto_pwm_min_hyst[1] =
 944                         lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_34);
 945
 946         /* #PROCHOT & #VRDHOT PWM Ramp Control register */
 947         data->pwm_ramp_ctl = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
 948
 949         /* misc setup registers */
 950         data->sfc1 = lm93_read_byte(client, LM93_REG_SFC1);
 951         data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
 952         data->sf_tach_to_pwm = lm93_read_byte(client,
 953                         LM93_REG_SF_TACH_TO_PWM);
 954
 955         /* write back alarm values to clear */
 956         for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++)
 957                 lm93_write_byte(client, LM93_REG_HOST_ERROR_1 + i, *(ptr + i));
 958 }
 959
 960 /* update routine which uses SMBus block data commands */
 961 static void lm93_update_client_full(struct lm93_data *data,
 962                                     struct i2c_client *client)
 963 {
 964         dev_dbg(&client->dev,"starting device update (block data enabled)\n");
 965
 966         /* in1 - in16: values & limits */
 967         lm93_read_block(client, 3, (u8 *)(data->block3));
 968         lm93_read_block(client, 7, (u8 *)(data->block7));
 969
 970         /* temp1 - temp4: values */
 971         lm93_read_block(client, 2, (u8 *)(data->block2));
 972
 973         /* prochot1 - prochot2: values */
 974         lm93_read_block(client, 4, (u8 *)(data->block4));
 975
 976         /* fan1 - fan4: values & limits */
 977         lm93_read_block(client, 5, (u8 *)(data->block5));
 978         lm93_read_block(client, 8, (u8 *)(data->block8));
 979
 980         /* pmw control registers */
 981         lm93_read_block(client, 9, (u8 *)(data->block9));
 982
 983         /* alarm values */
 984         lm93_read_block(client, 1, (u8 *)(&data->block1));
 985
 986         /* auto/pwm registers */
 987         lm93_read_block(client, 10, (u8 *)(&data->block10));
 988
 989         lm93_update_client_common(data, client);
 990 }
 991
 992 /* update routine which uses SMBus byte/word data commands only */
 993 static void lm93_update_client_min(struct lm93_data *data,
 994                                    struct i2c_client *client)
 995 {
 996         int i,j;
 997         u8 *ptr;
 998
 999         dev_dbg(&client->dev,"starting device update (block data disabled)\n");
1000
1001         /* in1 - in16: values & limits */
1002         for (i = 0; i < 16; i++) {
1003                 data->block3[i] =
1004                         lm93_read_byte(client, LM93_REG_IN(i));
1005                 data->block7[i].min =
1006                         lm93_read_byte(client, LM93_REG_IN_MIN(i));
1007                 data->block7[i].max =
1008                         lm93_read_byte(client, LM93_REG_IN_MAX(i));
1009         }
1010
1011         /* temp1 - temp4: values */
1012         for (i = 0; i < 4; i++) {
1013                 data->block2[i] =
1014                         lm93_read_byte(client, LM93_REG_TEMP(i));
1015         }
1016
1017         /* prochot1 - prochot2: values */
1018         for (i = 0; i < 2; i++) {
1019                 data->block4[i].cur =
1020                         lm93_read_byte(client, LM93_REG_PROCHOT_CUR(i));
1021                 data->block4[i].avg =
1022                         lm93_read_byte(client, LM93_REG_PROCHOT_AVG(i));
1023         }
1024
1025         /* fan1 - fan4: values & limits */
1026         for (i = 0; i < 4; i++) {
1027                 data->block5[i] =
1028                         lm93_read_word(client, LM93_REG_FAN(i));
1029                 data->block8[i] =
1030                         lm93_read_word(client, LM93_REG_FAN_MIN(i));
1031         }
1032
1033         /* pwm control registers */
1034         for (i = 0; i < 2; i++) {
1035                 for (j = 0; j < 4; j++) {
1036                         data->block9[i][j] =
1037                                 lm93_read_byte(client, LM93_REG_PWM_CTL(i,j));
1038                 }
1039         }
1040
1041         /* alarm values */
1042         for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++) {
1043                 *(ptr + i) =
1044                         lm93_read_byte(client, LM93_REG_HOST_ERROR_1 + i);
1045         }
1046
1047         /* auto/pwm (base temp) registers */
1048         for (i = 0; i < 4; i++) {
1049                 data->block10.base[i] =
1050                         lm93_read_byte(client, LM93_REG_TEMP_BASE(i));
1051         }
1052
1053         /* auto/pwm (offset temp) registers */
1054         for (i = 0; i < 12; i++) {
1055                 data->block10.offset[i] =
1056                         lm93_read_byte(client, LM93_REG_TEMP_OFFSET(i));
1057         }
1058
1059         lm93_update_client_common(data, client);
1060 }
1061
1062 /* following are the sysfs callback functions */
1063 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
1064                         char *buf)
1065 {
1066         int nr = (to_sensor_dev_attr(attr))->index;
1067
1068         struct lm93_data *data = lm93_update_device(dev);
1069         return sprintf(buf, "%d\n", LM93_IN_FROM_REG(nr, data->block3[nr]));
1070 }
1071
1072 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 0);
1073 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 1);
1074 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 2);
1075 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 3);
1076 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 4);
1077 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 5);
1078 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 6);
1079 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 7);
1080 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_in, NULL, 8);
1081 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_in, NULL, 9);
1082 static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_in, NULL, 10);
1083 static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_in, NULL, 11);
1084 static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_in, NULL, 12);
1085 static SENSOR_DEVICE_ATTR(in14_input, S_IRUGO, show_in, NULL, 13);
1086 static SENSOR_DEVICE_ATTR(in15_input, S_IRUGO, show_in, NULL, 14);
1087 static SENSOR_DEVICE_ATTR(in16_input, S_IRUGO, show_in, NULL, 15);
1088
1089 static ssize_t show_in_min(struct device *dev,
1090                         struct device_attribute *attr, char *buf)
1091 {
1092         int nr = (to_sensor_dev_attr(attr))->index;
1093         struct lm93_data *data = lm93_update_device(dev);
1094         int vccp = nr - 6;
1095         long rc, vid;
1096
1097         if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1098                 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1099                 rc = LM93_IN_MIN_FROM_REG(data->vccp_limits[vccp], vid);
1100         }
1101         else {
1102                 rc = LM93_IN_FROM_REG(nr, data->block7[nr].min); \
1103         }
1104         return sprintf(buf, "%ld\n", rc); \
1105 }
1106
1107 static ssize_t store_in_min(struct device *dev, struct device_attribute *attr,
1108                             const char *buf, size_t count)
1109 {
1110         int nr = (to_sensor_dev_attr(attr))->index;
1111         struct i2c_client *client = to_i2c_client(dev);
1112         struct lm93_data *data = i2c_get_clientdata(client);
1113         u32 val = simple_strtoul(buf, NULL, 10);
1114         int vccp = nr - 6;
1115         long vid;
1116
1117         mutex_lock(&data->update_lock);
1118         if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1119                 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1120                 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0xf0) |
1121                                 LM93_IN_REL_TO_REG(val, 0, vid);
1122                 lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp),
1123                                 data->vccp_limits[vccp]);
1124         }
1125         else {
1126                 data->block7[nr].min = LM93_IN_TO_REG(nr,val);
1127                 lm93_write_byte(client, LM93_REG_IN_MIN(nr),
1128                                 data->block7[nr].min);
1129         }
1130         mutex_unlock(&data->update_lock);
1131         return count;
1132 }
1133
1134 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO,
1135                           show_in_min, store_in_min, 0);
1136 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO,
1137                           show_in_min, store_in_min, 1);
1138 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO,
1139                           show_in_min, store_in_min, 2);
1140 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO,
1141                           show_in_min, store_in_min, 3);
1142 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO,
1143                           show_in_min, store_in_min, 4);
1144 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO,
1145                           show_in_min, store_in_min, 5);
1146 static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO,
1147                           show_in_min, store_in_min, 6);
1148 static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO,
1149                           show_in_min, store_in_min, 7);
1150 static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO,
1151                           show_in_min, store_in_min, 8);
1152 static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO,
1153                           show_in_min, store_in_min, 9);
1154 static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO,
1155                           show_in_min, store_in_min, 10);
1156 static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO,
1157                           show_in_min, store_in_min, 11);
1158 static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO,
1159                           show_in_min, store_in_min, 12);
1160 static SENSOR_DEVICE_ATTR(in14_min, S_IWUSR | S_IRUGO,
1161                           show_in_min, store_in_min, 13);
1162 static SENSOR_DEVICE_ATTR(in15_min, S_IWUSR | S_IRUGO,
1163                           show_in_min, store_in_min, 14);
1164 static SENSOR_DEVICE_ATTR(in16_min, S_IWUSR | S_IRUGO,
1165                           show_in_min, store_in_min, 15);
1166
1167 static ssize_t show_in_max(struct device *dev,
1168                            struct device_attribute *attr, char *buf)
1169 {
1170         int nr = (to_sensor_dev_attr(attr))->index;
1171         struct lm93_data *data = lm93_update_device(dev);
1172         int vccp = nr - 6;
1173         long rc, vid;
1174
1175         if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1176                 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1177                 rc = LM93_IN_MAX_FROM_REG(data->vccp_limits[vccp],vid);
1178         }
1179         else {
1180                 rc = LM93_IN_FROM_REG(nr,data->block7[nr].max); \
1181         }
1182         return sprintf(buf,"%ld\n",rc); \
1183 }
1184
1185 static ssize_t store_in_max(struct device *dev, struct device_attribute *attr,
1186                             const char *buf, size_t count)
1187 {
1188         int nr = (to_sensor_dev_attr(attr))->index;
1189         struct i2c_client *client = to_i2c_client(dev);
1190         struct lm93_data *data = i2c_get_clientdata(client);
1191         u32 val = simple_strtoul(buf, NULL, 10);
1192         int vccp = nr - 6;
1193         long vid;
1194
1195         mutex_lock(&data->update_lock);
1196         if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1197                 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1198                 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0x0f) |
1199                                 LM93_IN_REL_TO_REG(val, 1, vid);
1200                 lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp),
1201                                 data->vccp_limits[vccp]);
1202         }
1203         else {
1204                 data->block7[nr].max = LM93_IN_TO_REG(nr,val);
1205                 lm93_write_byte(client, LM93_REG_IN_MAX(nr),
1206                                 data->block7[nr].max);
1207         }
1208         mutex_unlock(&data->update_lock);
1209         return count;
1210 }
1211
1212 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO,
1213                           show_in_max, store_in_max, 0);
1214 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO,
1215                           show_in_max, store_in_max, 1);
1216 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO,
1217                           show_in_max, store_in_max, 2);
1218 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO,
1219                           show_in_max, store_in_max, 3);
1220 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO,
1221                           show_in_max, store_in_max, 4);
1222 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO,
1223                           show_in_max, store_in_max, 5);
1224 static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO,
1225                           show_in_max, store_in_max, 6);
1226 static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO,
1227                           show_in_max, store_in_max, 7);
1228 static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO,
1229                           show_in_max, store_in_max, 8);
1230 static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO,
1231                           show_in_max, store_in_max, 9);
1232 static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO,
1233                           show_in_max, store_in_max, 10);
1234 static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO,
1235                           show_in_max, store_in_max, 11);
1236 static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO,
1237                           show_in_max, store_in_max, 12);
1238 static SENSOR_DEVICE_ATTR(in14_max, S_IWUSR | S_IRUGO,
1239                           show_in_max, store_in_max, 13);
1240 static SENSOR_DEVICE_ATTR(in15_max, S_IWUSR | S_IRUGO,
1241                           show_in_max, store_in_max, 14);
1242 static SENSOR_DEVICE_ATTR(in16_max, S_IWUSR | S_IRUGO,
1243                           show_in_max, store_in_max, 15);
1244
1245 static ssize_t show_temp(struct device *dev,
1246                          struct device_attribute *attr, char *buf)
1247 {
1248         int nr = (to_sensor_dev_attr(attr))->index;
1249         struct lm93_data *data = lm93_update_device(dev);
1250         return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block2[nr]));
1251 }
1252
1253 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1254 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1255 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1256
1257 static ssize_t show_temp_min(struct device *dev,
1258                                 struct device_attribute *attr, char *buf)
1259 {
1260         int nr = (to_sensor_dev_attr(attr))->index;
1261         struct lm93_data *data = lm93_update_device(dev);
1262         return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].min));
1263 }
1264
1265 static ssize_t store_temp_min(struct device *dev, struct device_attribute *attr,
1266                               const char *buf, size_t count)
1267 {
1268         int nr = (to_sensor_dev_attr(attr))->index;
1269         struct i2c_client *client = to_i2c_client(dev);
1270         struct lm93_data *data = i2c_get_clientdata(client);
1271         u32 val = simple_strtoul(buf, NULL, 10);
1272
1273         mutex_lock(&data->update_lock);
1274         data->temp_lim[nr].min = LM93_TEMP_TO_REG(val);
1275         lm93_write_byte(client, LM93_REG_TEMP_MIN(nr), data->temp_lim[nr].min);
1276         mutex_unlock(&data->update_lock);
1277         return count;
1278 }
1279
1280 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
1281                           show_temp_min, store_temp_min, 0);
1282 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO,
1283                           show_temp_min, store_temp_min, 1);
1284 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO,
1285                           show_temp_min, store_temp_min, 2);
1286
1287 static ssize_t show_temp_max(struct device *dev,
1288                              struct device_attribute *attr, char *buf)
1289 {
1290         int nr = (to_sensor_dev_attr(attr))->index;
1291         struct lm93_data *data = lm93_update_device(dev);
1292         return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].max));
1293 }
1294
1295 static ssize_t store_temp_max(struct device *dev, struct device_attribute *attr,
1296                               const char *buf, size_t count)
1297 {
1298         int nr = (to_sensor_dev_attr(attr))->index;
1299         struct i2c_client *client = to_i2c_client(dev);
1300         struct lm93_data *data = i2c_get_clientdata(client);
1301         u32 val = simple_strtoul(buf, NULL, 10);
1302
1303         mutex_lock(&data->update_lock);
1304         data->temp_lim[nr].max = LM93_TEMP_TO_REG(val);
1305         lm93_write_byte(client, LM93_REG_TEMP_MAX(nr), data->temp_lim[nr].max);
1306         mutex_unlock(&data->update_lock);
1307         return count;
1308 }
1309
1310 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
1311                           show_temp_max, store_temp_max, 0);
1312 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO,
1313                           show_temp_max, store_temp_max, 1);
1314 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO,
1315                           show_temp_max, store_temp_max, 2);
1316
1317 static ssize_t show_temp_auto_base(struct device *dev,
1318                                 struct device_attribute *attr, char *buf)
1319 {
1320         int nr = (to_sensor_dev_attr(attr))->index;
1321         struct lm93_data *data = lm93_update_device(dev);
1322         return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block10.base[nr]));
1323 }
1324
1325 static ssize_t store_temp_auto_base(struct device *dev,
1326                                         struct device_attribute *attr,
1327                                         const char *buf, size_t count)
1328 {
1329         int nr = (to_sensor_dev_attr(attr))->index;
1330         struct i2c_client *client = to_i2c_client(dev);
1331         struct lm93_data *data = i2c_get_clientdata(client);
1332         u32 val = simple_strtoul(buf, NULL, 10);
1333
1334         mutex_lock(&data->update_lock);
1335         data->block10.base[nr] = LM93_TEMP_TO_REG(val);
1336         lm93_write_byte(client, LM93_REG_TEMP_BASE(nr), data->block10.base[nr]);
1337         mutex_unlock(&data->update_lock);
1338         return count;
1339 }
1340
1341 static SENSOR_DEVICE_ATTR(temp1_auto_base, S_IWUSR | S_IRUGO,
1342                           show_temp_auto_base, store_temp_auto_base, 0);
1343 static SENSOR_DEVICE_ATTR(temp2_auto_base, S_IWUSR | S_IRUGO,
1344                           show_temp_auto_base, store_temp_auto_base, 1);
1345 static SENSOR_DEVICE_ATTR(temp3_auto_base, S_IWUSR | S_IRUGO,
1346                           show_temp_auto_base, store_temp_auto_base, 2);
1347
1348 static ssize_t show_temp_auto_boost(struct device *dev,
1349                                     struct device_attribute *attr,char *buf)
1350 {
1351         int nr = (to_sensor_dev_attr(attr))->index;
1352         struct lm93_data *data = lm93_update_device(dev);
1353         return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->boost[nr]));
1354 }
1355
1356 static ssize_t store_temp_auto_boost(struct device *dev,
1357                                      struct device_attribute *attr,
1358                                      const char *buf, size_t count)
1359 {
1360         int nr = (to_sensor_dev_attr(attr))->index;
1361         struct i2c_client *client = to_i2c_client(dev);
1362         struct lm93_data *data = i2c_get_clientdata(client);
1363         u32 val = simple_strtoul(buf, NULL, 10);
1364
1365         mutex_lock(&data->update_lock);
1366         data->boost[nr] = LM93_TEMP_TO_REG(val);
1367         lm93_write_byte(client, LM93_REG_BOOST(nr), data->boost[nr]);
1368         mutex_unlock(&data->update_lock);
1369         return count;
1370 }
1371
1372 static SENSOR_DEVICE_ATTR(temp1_auto_boost, S_IWUSR | S_IRUGO,
1373                           show_temp_auto_boost, store_temp_auto_boost, 0);
1374 static SENSOR_DEVICE_ATTR(temp2_auto_boost, S_IWUSR | S_IRUGO,
1375                           show_temp_auto_boost, store_temp_auto_boost, 1);
1376 static SENSOR_DEVICE_ATTR(temp3_auto_boost, S_IWUSR | S_IRUGO,
1377                           show_temp_auto_boost, store_temp_auto_boost, 2);
1378
1379 static ssize_t show_temp_auto_boost_hyst(struct device *dev,
1380                                          struct device_attribute *attr,
1381                                          char *buf)
1382 {
1383         int nr = (to_sensor_dev_attr(attr))->index;
1384         struct lm93_data *data = lm93_update_device(dev);
1385         int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1386         return sprintf(buf,"%d\n",
1387                        LM93_AUTO_BOOST_HYST_FROM_REGS(data, nr, mode));
1388 }
1389
1390 static ssize_t store_temp_auto_boost_hyst(struct device *dev,
1391                                           struct device_attribute *attr,
1392                                           const char *buf, size_t count)
1393 {
1394         int nr = (to_sensor_dev_attr(attr))->index;
1395         struct i2c_client *client = to_i2c_client(dev);
1396         struct lm93_data *data = i2c_get_clientdata(client);
1397         u32 val = simple_strtoul(buf, NULL, 10);
1398
1399         mutex_lock(&data->update_lock);
1400         /* force 0.5C/bit mode */
1401         data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1402         data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1403         lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1404         data->boost_hyst[nr/2] = LM93_AUTO_BOOST_HYST_TO_REG(data, val, nr, 1);
1405         lm93_write_byte(client, LM93_REG_BOOST_HYST(nr),
1406                         data->boost_hyst[nr/2]);
1407         mutex_unlock(&data->update_lock);
1408         return count;
1409 }
1410
1411 static SENSOR_DEVICE_ATTR(temp1_auto_boost_hyst, S_IWUSR | S_IRUGO,
1412                           show_temp_auto_boost_hyst,
1413                           store_temp_auto_boost_hyst, 0);
1414 static SENSOR_DEVICE_ATTR(temp2_auto_boost_hyst, S_IWUSR | S_IRUGO,
1415                           show_temp_auto_boost_hyst,
1416                           store_temp_auto_boost_hyst, 1);
1417 static SENSOR_DEVICE_ATTR(temp3_auto_boost_hyst, S_IWUSR | S_IRUGO,
1418                           show_temp_auto_boost_hyst,
1419                           store_temp_auto_boost_hyst, 2);
1420
1421 static ssize_t show_temp_auto_offset(struct device *dev,
1422                                 struct device_attribute *attr, char *buf)
1423 {
1424         struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr);
1425         int nr = s_attr->index;
1426         int ofs = s_attr->nr;
1427         struct lm93_data *data = lm93_update_device(dev);
1428         int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1429         return sprintf(buf,"%d\n",
1430                LM93_TEMP_AUTO_OFFSET_FROM_REG(data->block10.offset[ofs],
1431                                               nr,mode));
1432 }
1433
1434 static ssize_t store_temp_auto_offset(struct device *dev,
1435                                         struct device_attribute *attr,
1436                                         const char *buf, size_t count)
1437 {
1438         struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr);
1439         int nr = s_attr->index;
1440         int ofs = s_attr->nr;
1441         struct i2c_client *client = to_i2c_client(dev);
1442         struct lm93_data *data = i2c_get_clientdata(client);
1443         u32 val = simple_strtoul(buf, NULL, 10);
1444
1445         mutex_lock(&data->update_lock);
1446         /* force 0.5C/bit mode */
1447         data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1448         data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1449         lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1450         data->block10.offset[ofs] = LM93_TEMP_AUTO_OFFSET_TO_REG(
1451                         data->block10.offset[ofs], val, nr, 1);
1452         lm93_write_byte(client, LM93_REG_TEMP_OFFSET(ofs),
1453                         data->block10.offset[ofs]);
1454         mutex_unlock(&data->update_lock);
1455         return count;
1456 }
1457
1458 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset1, S_IWUSR | S_IRUGO,
1459                           show_temp_auto_offset, store_temp_auto_offset, 0, 0);
1460 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset2, S_IWUSR | S_IRUGO,
1461                           show_temp_auto_offset, store_temp_auto_offset, 1, 0);
1462 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset3, S_IWUSR | S_IRUGO,
1463                           show_temp_auto_offset, store_temp_auto_offset, 2, 0);
1464 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset4, S_IWUSR | S_IRUGO,
1465                           show_temp_auto_offset, store_temp_auto_offset, 3, 0);
1466 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset5, S_IWUSR | S_IRUGO,
1467                           show_temp_auto_offset, store_temp_auto_offset, 4, 0);
1468 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset6, S_IWUSR | S_IRUGO,
1469                           show_temp_auto_offset, store_temp_auto_offset, 5, 0);
1470 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset7, S_IWUSR | S_IRUGO,
1471                           show_temp_auto_offset, store_temp_auto_offset, 6, 0);
1472 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset8, S_IWUSR | S_IRUGO,
1473                           show_temp_auto_offset, store_temp_auto_offset, 7, 0);
1474 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset9, S_IWUSR | S_IRUGO,
1475                           show_temp_auto_offset, store_temp_auto_offset, 8, 0);
1476 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset10, S_IWUSR | S_IRUGO,
1477                           show_temp_auto_offset, store_temp_auto_offset, 9, 0);
1478 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset11, S_IWUSR | S_IRUGO,
1479                           show_temp_auto_offset, store_temp_auto_offset, 10, 0);
1480 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset12, S_IWUSR | S_IRUGO,
1481                           show_temp_auto_offset, store_temp_auto_offset, 11, 0);
1482 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset1, S_IWUSR | S_IRUGO,
1483                           show_temp_auto_offset, store_temp_auto_offset, 0, 1);
1484 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset2, S_IWUSR | S_IRUGO,
1485                           show_temp_auto_offset, store_temp_auto_offset, 1, 1);
1486 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset3, S_IWUSR | S_IRUGO,
1487                           show_temp_auto_offset, store_temp_auto_offset, 2, 1);
1488 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset4, S_IWUSR | S_IRUGO,
1489                           show_temp_auto_offset, store_temp_auto_offset, 3, 1);
1490 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset5, S_IWUSR | S_IRUGO,
1491                           show_temp_auto_offset, store_temp_auto_offset, 4, 1);
1492 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset6, S_IWUSR | S_IRUGO,
1493                           show_temp_auto_offset, store_temp_auto_offset, 5, 1);
1494 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset7, S_IWUSR | S_IRUGO,
1495                           show_temp_auto_offset, store_temp_auto_offset, 6, 1);
1496 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset8, S_IWUSR | S_IRUGO,
1497                           show_temp_auto_offset, store_temp_auto_offset, 7, 1);
1498 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset9, S_IWUSR | S_IRUGO,
1499                           show_temp_auto_offset, store_temp_auto_offset, 8, 1);
1500 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset10, S_IWUSR | S_IRUGO,
1501                           show_temp_auto_offset, store_temp_auto_offset, 9, 1);
1502 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset11, S_IWUSR | S_IRUGO,
1503                           show_temp_auto_offset, store_temp_auto_offset, 10, 1);
1504 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset12, S_IWUSR | S_IRUGO,
1505                           show_temp_auto_offset, store_temp_auto_offset, 11, 1);
1506 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset1, S_IWUSR | S_IRUGO,
1507                           show_temp_auto_offset, store_temp_auto_offset, 0, 2);
1508 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset2, S_IWUSR | S_IRUGO,
1509                           show_temp_auto_offset, store_temp_auto_offset, 1, 2);
1510 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset3, S_IWUSR | S_IRUGO,
1511                           show_temp_auto_offset, store_temp_auto_offset, 2, 2);
1512 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset4, S_IWUSR | S_IRUGO,
1513                           show_temp_auto_offset, store_temp_auto_offset, 3, 2);
1514 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset5, S_IWUSR | S_IRUGO,
1515                           show_temp_auto_offset, store_temp_auto_offset, 4, 2);
1516 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset6, S_IWUSR | S_IRUGO,
1517                           show_temp_auto_offset, store_temp_auto_offset, 5, 2);
1518 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset7, S_IWUSR | S_IRUGO,
1519                           show_temp_auto_offset, store_temp_auto_offset, 6, 2);
1520 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset8, S_IWUSR | S_IRUGO,
1521                           show_temp_auto_offset, store_temp_auto_offset, 7, 2);
1522 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset9, S_IWUSR | S_IRUGO,
1523                           show_temp_auto_offset, store_temp_auto_offset, 8, 2);
1524 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset10, S_IWUSR | S_IRUGO,
1525                           show_temp_auto_offset, store_temp_auto_offset, 9, 2);
1526 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset11, S_IWUSR | S_IRUGO,
1527                           show_temp_auto_offset, store_temp_auto_offset, 10, 2);
1528 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset12, S_IWUSR | S_IRUGO,
1529                           show_temp_auto_offset, store_temp_auto_offset, 11, 2);
1530
1531 static ssize_t show_temp_auto_pwm_min(struct device *dev,
1532                                 struct device_attribute *attr, char *buf)
1533 {
1534         int nr = (to_sensor_dev_attr(attr))->index;
1535         u8 reg, ctl4;
1536         struct lm93_data *data = lm93_update_device(dev);
1537         reg = data->auto_pwm_min_hyst[nr/2] >> 4 & 0x0f;
1538         ctl4 = data->block9[nr][LM93_PWM_CTL4];
1539         return sprintf(buf,"%d\n",LM93_PWM_FROM_REG(reg, (ctl4 & 0x07) ?
1540                                 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ));
1541 }
1542
1543 static ssize_t store_temp_auto_pwm_min(struct device *dev,
1544                                         struct device_attribute *attr,
1545                                         const char *buf, size_t count)
1546 {
1547         int nr = (to_sensor_dev_attr(attr))->index;
1548         struct i2c_client *client = to_i2c_client(dev);
1549         struct lm93_data *data = i2c_get_clientdata(client);
1550         u32 val = simple_strtoul(buf, NULL, 10);
1551         u8 reg, ctl4;
1552
1553         mutex_lock(&data->update_lock);
1554         reg = lm93_read_byte(client, LM93_REG_PWM_MIN_HYST(nr));
1555         ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1556         reg = (reg & 0x0f) |
1557                 LM93_PWM_TO_REG(val, (ctl4 & 0x07) ?
1558                                 LM93_PWM_MAP_LO_FREQ :
1559                                 LM93_PWM_MAP_HI_FREQ) << 4;
1560         data->auto_pwm_min_hyst[nr/2] = reg;
1561         lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
1562         mutex_unlock(&data->update_lock);
1563         return count;
1564 }
1565
1566 static SENSOR_DEVICE_ATTR(temp1_auto_pwm_min, S_IWUSR | S_IRUGO,
1567                           show_temp_auto_pwm_min,
1568                           store_temp_auto_pwm_min, 0);
1569 static SENSOR_DEVICE_ATTR(temp2_auto_pwm_min, S_IWUSR | S_IRUGO,
1570                           show_temp_auto_pwm_min,
1571                           store_temp_auto_pwm_min, 1);
1572 static SENSOR_DEVICE_ATTR(temp3_auto_pwm_min, S_IWUSR | S_IRUGO,
1573                           show_temp_auto_pwm_min,
1574                           store_temp_auto_pwm_min, 2);
1575
1576 static ssize_t show_temp_auto_offset_hyst(struct device *dev,
1577                                 struct device_attribute *attr, char *buf)
1578 {
1579         int nr = (to_sensor_dev_attr(attr))->index;
1580         struct lm93_data *data = lm93_update_device(dev);
1581         int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1582         return sprintf(buf,"%d\n",LM93_TEMP_OFFSET_FROM_REG(
1583                                         data->auto_pwm_min_hyst[nr/2], mode));
1584 }
1585
1586 static ssize_t store_temp_auto_offset_hyst(struct device *dev,
1587                                                 struct device_attribute *attr,
1588                                                 const char *buf, size_t count)
1589 {
1590         int nr = (to_sensor_dev_attr(attr))->index;
1591         struct i2c_client *client = to_i2c_client(dev);
1592         struct lm93_data *data = i2c_get_clientdata(client);
1593         u32 val = simple_strtoul(buf, NULL, 10);
1594         u8 reg;
1595
1596         mutex_lock(&data->update_lock);
1597         /* force 0.5C/bit mode */
1598         data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1599         data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1600         lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1601         reg = data->auto_pwm_min_hyst[nr/2];
1602         reg = (reg & 0xf0) | (LM93_TEMP_OFFSET_TO_REG(val, 1) & 0x0f);
1603         data->auto_pwm_min_hyst[nr/2] = reg;
1604         lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
1605         mutex_unlock(&data->update_lock);
1606         return count;
1607 }
1608
1609 static SENSOR_DEVICE_ATTR(temp1_auto_offset_hyst, S_IWUSR | S_IRUGO,
1610                           show_temp_auto_offset_hyst,
1611                           store_temp_auto_offset_hyst, 0);
1612 static SENSOR_DEVICE_ATTR(temp2_auto_offset_hyst, S_IWUSR | S_IRUGO,
1613                           show_temp_auto_offset_hyst,
1614                           store_temp_auto_offset_hyst, 1);
1615 static SENSOR_DEVICE_ATTR(temp3_auto_offset_hyst, S_IWUSR | S_IRUGO,
1616                           show_temp_auto_offset_hyst,
1617                           store_temp_auto_offset_hyst, 2);
1618
1619 static ssize_t show_fan_input(struct device *dev,
1620                 struct device_attribute *attr, char *buf)
1621 {
1622         struct sensor_device_attribute *s_attr = to_sensor_dev_attr(attr);
1623         int nr = s_attr->index;
1624         struct lm93_data *data = lm93_update_device(dev);
1625
1626         return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block5[nr]));
1627 }
1628
1629 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
1630 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
1631 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2);
1632 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_input, NULL, 3);
1633
1634 static ssize_t show_fan_min(struct device *dev,
1635                               struct device_attribute *attr, char *buf)
1636 {
1637         int nr = (to_sensor_dev_attr(attr))->index;
1638         struct lm93_data *data = lm93_update_device(dev);
1639
1640         return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block8[nr]));
1641 }
1642
1643 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
1644                                 const char *buf, size_t count)
1645 {
1646         int nr = (to_sensor_dev_attr(attr))->index;
1647         struct i2c_client *client = to_i2c_client(dev);
1648         struct lm93_data *data = i2c_get_clientdata(client);
1649         u32 val = simple_strtoul(buf, NULL, 10);
1650
1651         mutex_lock(&data->update_lock);
1652         data->block8[nr] = LM93_FAN_TO_REG(val);
1653         lm93_write_word(client,LM93_REG_FAN_MIN(nr),data->block8[nr]);
1654         mutex_unlock(&data->update_lock);
1655         return count;
1656 }
1657
1658 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
1659                           show_fan_min, store_fan_min, 0);
1660 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
1661                           show_fan_min, store_fan_min, 1);
1662 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO,
1663                           show_fan_min, store_fan_min, 2);
1664 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO,
1665                           show_fan_min, store_fan_min, 3);
1666
1667 /* some tedious bit-twiddling here to deal with the register format:
1668
1669         data->sf_tach_to_pwm: (tach to pwm mapping bits)
1670
1671                 bit |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0
1672                      T4:P2 T4:P1 T3:P2 T3:P1 T2:P2 T2:P1 T1:P2 T1:P1
1673
1674         data->sfc2: (enable bits)
1675
1676                 bit |  3  |  2  |  1  |  0
1677                        T4    T3    T2    T1
1678 */
1679
1680 static ssize_t show_fan_smart_tach(struct device *dev,
1681                                 struct device_attribute *attr, char *buf)
1682 {
1683         int nr = (to_sensor_dev_attr(attr))->index;
1684         struct lm93_data *data = lm93_update_device(dev);
1685         long rc = 0;
1686         int mapping;
1687
1688         /* extract the relevant mapping */
1689         mapping = (data->sf_tach_to_pwm >> (nr * 2)) & 0x03;
1690
1691         /* if there's a mapping and it's enabled */
1692         if (mapping && ((data->sfc2 >> nr) & 0x01))
1693                 rc = mapping;
1694         return sprintf(buf,"%ld\n",rc);
1695 }
1696
1697 /* helper function - must grab data->update_lock before calling
1698    fan is 0-3, indicating fan1-fan4 */
1699 static void lm93_write_fan_smart_tach(struct i2c_client *client,
1700         struct lm93_data *data, int fan, long value)
1701 {
1702         /* insert the new mapping and write it out */
1703         data->sf_tach_to_pwm = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
1704         data->sf_tach_to_pwm &= ~(0x3 << fan * 2);
1705         data->sf_tach_to_pwm |= value << fan * 2;
1706         lm93_write_byte(client, LM93_REG_SF_TACH_TO_PWM, data->sf_tach_to_pwm);
1707
1708         /* insert the enable bit and write it out */
1709         data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1710         if (value)
1711                 data->sfc2 |= 1 << fan;
1712         else
1713                 data->sfc2 &= ~(1 << fan);
1714         lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1715 }
1716
1717 static ssize_t store_fan_smart_tach(struct device *dev,
1718                                         struct device_attribute *attr,
1719                                         const char *buf, size_t count)
1720 {
1721         int nr = (to_sensor_dev_attr(attr))->index;
1722         struct i2c_client *client = to_i2c_client(dev);
1723         struct lm93_data *data = i2c_get_clientdata(client);
1724         u32 val = simple_strtoul(buf, NULL, 10);
1725
1726         mutex_lock(&data->update_lock);
1727         /* sanity test, ignore the write otherwise */
1728         if (0 <= val && val <= 2) {
1729                 /* can't enable if pwm freq is 22.5KHz */
1730                 if (val) {
1731                         u8 ctl4 = lm93_read_byte(client,
1732                                 LM93_REG_PWM_CTL(val-1,LM93_PWM_CTL4));
1733                         if ((ctl4 & 0x07) == 0)
1734                                 val = 0;
1735                 }
1736                 lm93_write_fan_smart_tach(client, data, nr, val);
1737         }
1738         mutex_unlock(&data->update_lock);
1739         return count;
1740 }
1741
1742 static SENSOR_DEVICE_ATTR(fan1_smart_tach, S_IWUSR | S_IRUGO,
1743                           show_fan_smart_tach, store_fan_smart_tach, 0);
1744 static SENSOR_DEVICE_ATTR(fan2_smart_tach, S_IWUSR | S_IRUGO,
1745                           show_fan_smart_tach, store_fan_smart_tach, 1);
1746 static SENSOR_DEVICE_ATTR(fan3_smart_tach, S_IWUSR | S_IRUGO,
1747                           show_fan_smart_tach, store_fan_smart_tach, 2);
1748 static SENSOR_DEVICE_ATTR(fan4_smart_tach, S_IWUSR | S_IRUGO,
1749                           show_fan_smart_tach, store_fan_smart_tach, 3);
1750
1751 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
1752                         char *buf)
1753 {
1754         int nr = (to_sensor_dev_attr(attr))->index;
1755         struct lm93_data *data = lm93_update_device(dev);
1756         u8 ctl2, ctl4;
1757         long rc;
1758
1759         ctl2 = data->block9[nr][LM93_PWM_CTL2];
1760         ctl4 = data->block9[nr][LM93_PWM_CTL4];
1761         if (ctl2 & 0x01) /* show user commanded value if enabled */
1762                 rc = data->pwm_override[nr];
1763         else /* show present h/w value if manual pwm disabled */
1764                 rc = LM93_PWM_FROM_REG(ctl2 >> 4, (ctl4 & 0x07) ?
1765                         LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ);
1766         return sprintf(buf,"%ld\n",rc);
1767 }
1768
1769 static ssize_t store_pwm(struct device *dev, struct device_attribute *attr,
1770                                 const char *buf, size_t count)
1771 {
1772         int nr = (to_sensor_dev_attr(attr))->index;
1773         struct i2c_client *client = to_i2c_client(dev);
1774         struct lm93_data *data = i2c_get_clientdata(client);
1775         u32 val = simple_strtoul(buf, NULL, 10);
1776         u8 ctl2, ctl4;
1777
1778         mutex_lock(&data->update_lock);
1779         ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2));
1780         ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1781         ctl2 = (ctl2 & 0x0f) | LM93_PWM_TO_REG(val,(ctl4 & 0x07) ?
1782                         LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ) << 4;
1783         /* save user commanded value */
1784         data->pwm_override[nr] = LM93_PWM_FROM_REG(ctl2 >> 4,
1785                         (ctl4 & 0x07) ?  LM93_PWM_MAP_LO_FREQ :
1786                         LM93_PWM_MAP_HI_FREQ);
1787         lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2);
1788         mutex_unlock(&data->update_lock);
1789         return count;
1790 }
1791
1792 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0);
1793 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1);
1794
1795 static ssize_t show_pwm_enable(struct device *dev,
1796                                 struct device_attribute *attr, char *buf)
1797 {
1798         int nr = (to_sensor_dev_attr(attr))->index;
1799         struct lm93_data *data = lm93_update_device(dev);
1800         u8 ctl2;
1801         long rc;
1802
1803         ctl2 = data->block9[nr][LM93_PWM_CTL2];
1804         if (ctl2 & 0x01) /* manual override enabled ? */
1805                 rc = ((ctl2 & 0xF0) == 0xF0) ? 0 : 1;
1806         else
1807                 rc = 2;
1808         return sprintf(buf,"%ld\n",rc);
1809 }
1810
1811 static ssize_t store_pwm_enable(struct device *dev,
1812                                 struct device_attribute *attr,
1813                                 const char *buf, size_t count)
1814 {
1815         int nr = (to_sensor_dev_attr(attr))->index;
1816         struct i2c_client *client = to_i2c_client(dev);
1817         struct lm93_data *data = i2c_get_clientdata(client);
1818         u32 val = simple_strtoul(buf, NULL, 10);
1819         u8 ctl2;
1820
1821         mutex_lock(&data->update_lock);
1822         ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2));
1823
1824         switch (val) {
1825         case 0:
1826                 ctl2 |= 0xF1; /* enable manual override, set PWM to max */
1827                 break;
1828         case 1: ctl2 |= 0x01; /* enable manual override */
1829                 break;
1830         case 2: ctl2 &= ~0x01; /* disable manual override */
1831                 break;
1832         default:
1833                 mutex_unlock(&data->update_lock);
1834                 return -EINVAL;
1835         }
1836
1837         lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2);
1838         mutex_unlock(&data->update_lock);
1839         return count;
1840 }
1841
1842 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
1843                                 show_pwm_enable, store_pwm_enable, 0);
1844 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
1845                                 show_pwm_enable, store_pwm_enable, 1);
1846
1847 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
1848                                 char *buf)
1849 {
1850         int nr = (to_sensor_dev_attr(attr))->index;
1851         struct lm93_data *data = lm93_update_device(dev);
1852         u8 ctl4;
1853
1854         ctl4 = data->block9[nr][LM93_PWM_CTL4];
1855         return sprintf(buf,"%d\n",LM93_PWM_FREQ_FROM_REG(ctl4));
1856 }
1857
1858 /* helper function - must grab data->update_lock before calling
1859    pwm is 0-1, indicating pwm1-pwm2
1860    this disables smart tach for all tach channels bound to the given pwm */
1861 static void lm93_disable_fan_smart_tach(struct i2c_client *client,
1862         struct lm93_data *data, int pwm)
1863 {
1864         int mapping = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
1865         int mask;
1866
1867         /* collapse the mapping into a mask of enable bits */
1868         mapping = (mapping >> pwm) & 0x55;
1869         mask = mapping & 0x01;
1870         mask |= (mapping & 0x04) >> 1;
1871         mask |= (mapping & 0x10) >> 2;
1872         mask |= (mapping & 0x40) >> 3;
1873
1874         /* disable smart tach according to the mask */
1875         data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1876         data->sfc2 &= ~mask;
1877         lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1878 }
1879
1880 static ssize_t store_pwm_freq(struct device *dev,
1881                                 struct device_attribute *attr,
1882                                 const char *buf, size_t count)
1883 {
1884         int nr = (to_sensor_dev_attr(attr))->index;
1885         struct i2c_client *client = to_i2c_client(dev);
1886         struct lm93_data *data = i2c_get_clientdata(client);
1887         u32 val = simple_strtoul(buf, NULL, 10);
1888         u8 ctl4;
1889
1890         mutex_lock(&data->update_lock);
1891         ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1892         ctl4 = (ctl4 & 0xf8) | LM93_PWM_FREQ_TO_REG(val);
1893         data->block9[nr][LM93_PWM_CTL4] = ctl4;
1894         /* ctl4 == 0 -> 22.5KHz -> disable smart tach */
1895         if (!ctl4)
1896                 lm93_disable_fan_smart_tach(client, data, nr);
1897         lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4), ctl4);
1898         mutex_unlock(&data->update_lock);
1899         return count;
1900 }
1901
1902 static SENSOR_DEVICE_ATTR(pwm1_freq, S_IWUSR | S_IRUGO,
1903                           show_pwm_freq, store_pwm_freq, 0);
1904 static SENSOR_DEVICE_ATTR(pwm2_freq, S_IWUSR | S_IRUGO,
1905                           show_pwm_freq, store_pwm_freq, 1);
1906
1907 static ssize_t show_pwm_auto_channels(struct device *dev,
1908                                 struct device_attribute *attr, char *buf)
1909 {
1910         int nr = (to_sensor_dev_attr(attr))->index;
1911         struct lm93_data *data = lm93_update_device(dev);
1912         return sprintf(buf,"%d\n",data->block9[nr][LM93_PWM_CTL1]);
1913 }
1914
1915 static ssize_t store_pwm_auto_channels(struct device *dev,
1916                                         struct device_attribute *attr,
1917                                         const char *buf, size_t count)
1918 {
1919         int nr = (to_sensor_dev_attr(attr))->index;
1920         struct i2c_client *client = to_i2c_client(dev);
1921         struct lm93_data *data = i2c_get_clientdata(client);
1922         u32 val = simple_strtoul(buf, NULL, 10);
1923
1924         mutex_lock(&data->update_lock);
1925         data->block9[nr][LM93_PWM_CTL1] = SENSORS_LIMIT(val, 0, 255);
1926         lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL1),
1927                                 data->block9[nr][LM93_PWM_CTL1]);
1928         mutex_unlock(&data->update_lock);
1929         return count;
1930 }
1931
1932 static SENSOR_DEVICE_ATTR(pwm1_auto_channels, S_IWUSR | S_IRUGO,
1933                           show_pwm_auto_channels, store_pwm_auto_channels, 0);
1934 static SENSOR_DEVICE_ATTR(pwm2_auto_channels, S_IWUSR | S_IRUGO,
1935                           show_pwm_auto_channels, store_pwm_auto_channels, 1);
1936
1937 static ssize_t show_pwm_auto_spinup_min(struct device *dev,
1938                                 struct device_attribute *attr,char *buf)
1939 {
1940         int nr = (to_sensor_dev_attr(attr))->index;
1941         struct lm93_data *data = lm93_update_device(dev);
1942         u8 ctl3, ctl4;
1943
1944         ctl3 = data->block9[nr][LM93_PWM_CTL3];
1945         ctl4 = data->block9[nr][LM93_PWM_CTL4];
1946         return sprintf(buf,"%d\n",
1947                        LM93_PWM_FROM_REG(ctl3 & 0x0f, (ctl4 & 0x07) ?
1948                         LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ));
1949 }
1950
1951 static ssize_t store_pwm_auto_spinup_min(struct device *dev,
1952                                                 struct device_attribute *attr,
1953                                                 const char *buf, size_t count)
1954 {
1955         int nr = (to_sensor_dev_attr(attr))->index;
1956         struct i2c_client *client = to_i2c_client(dev);
1957         struct lm93_data *data = i2c_get_clientdata(client);
1958         u32 val = simple_strtoul(buf, NULL, 10);
1959         u8 ctl3, ctl4;
1960
1961         mutex_lock(&data->update_lock);
1962         ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
1963         ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL4));
1964         ctl3 = (ctl3 & 0xf0) |  LM93_PWM_TO_REG(val, (ctl4 & 0x07) ?
1965                         LM93_PWM_MAP_LO_FREQ :
1966                         LM93_PWM_MAP_HI_FREQ);
1967         data->block9[nr][LM93_PWM_CTL3] = ctl3;
1968         lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
1969         mutex_unlock(&data->update_lock);
1970         return count;
1971 }
1972
1973 static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_min, S_IWUSR | S_IRUGO,
1974                           show_pwm_auto_spinup_min,
1975                           store_pwm_auto_spinup_min, 0);
1976 static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_min, S_IWUSR | S_IRUGO,
1977                           show_pwm_auto_spinup_min,
1978                           store_pwm_auto_spinup_min, 1);
1979
1980 static ssize_t show_pwm_auto_spinup_time(struct device *dev,
1981                                 struct device_attribute *attr, char *buf)
1982 {
1983         int nr = (to_sensor_dev_attr(attr))->index;
1984         struct lm93_data *data = lm93_update_device(dev);
1985         return sprintf(buf,"%d\n",LM93_SPINUP_TIME_FROM_REG(
1986                                 data->block9[nr][LM93_PWM_CTL3]));
1987 }
1988
1989 static ssize_t store_pwm_auto_spinup_time(struct device *dev,
1990                                                 struct device_attribute *attr,
1991                                                 const char *buf, size_t count)
1992 {
1993         int nr = (to_sensor_dev_attr(attr))->index;
1994         struct i2c_client *client = to_i2c_client(dev);
1995         struct lm93_data *data = i2c_get_clientdata(client);
1996         u32 val = simple_strtoul(buf, NULL, 10);
1997         u8 ctl3;
1998
1999         mutex_lock(&data->update_lock);
2000         ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
2001         ctl3 = (ctl3 & 0x1f) | (LM93_SPINUP_TIME_TO_REG(val) << 5 & 0xe0);
2002         data->block9[nr][LM93_PWM_CTL3] = ctl3;
2003         lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
2004         mutex_unlock(&data->update_lock);
2005         return count;
2006 }
2007
2008 static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_time, S_IWUSR | S_IRUGO,
2009                           show_pwm_auto_spinup_time,
2010                           store_pwm_auto_spinup_time, 0);
2011 static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_time, S_IWUSR | S_IRUGO,
2012                           show_pwm_auto_spinup_time,
2013                           store_pwm_auto_spinup_time, 1);
2014
2015 static ssize_t show_pwm_auto_prochot_ramp(struct device *dev,
2016                                 struct device_attribute *attr, char *buf)
2017 {
2018         struct lm93_data *data = lm93_update_device(dev);
2019         return sprintf(buf,"%d\n",
2020                        LM93_RAMP_FROM_REG(data->pwm_ramp_ctl >> 4 & 0x0f));
2021 }
2022
2023 static ssize_t store_pwm_auto_prochot_ramp(struct device *dev,
2024                                                 struct device_attribute *attr,
2025                                                 const char *buf, size_t count)
2026 {
2027         struct i2c_client *client = to_i2c_client(dev);
2028         struct lm93_data *data = i2c_get_clientdata(client);
2029         u32 val = simple_strtoul(buf, NULL, 10);
2030         u8 ramp;
2031
2032         mutex_lock(&data->update_lock);
2033         ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
2034         ramp = (ramp & 0x0f) | (LM93_RAMP_TO_REG(val) << 4 & 0xf0);
2035         lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp);
2036         mutex_unlock(&data->update_lock);
2037         return count;
2038 }
2039
2040 static DEVICE_ATTR(pwm_auto_prochot_ramp, S_IRUGO | S_IWUSR,
2041                         show_pwm_auto_prochot_ramp,
2042                         store_pwm_auto_prochot_ramp);
2043
2044 static ssize_t show_pwm_auto_vrdhot_ramp(struct device *dev,
2045                                 struct device_attribute *attr, char *buf)
2046 {
2047         struct lm93_data *data = lm93_update_device(dev);
2048         return sprintf(buf,"%d\n",
2049                        LM93_RAMP_FROM_REG(data->pwm_ramp_ctl & 0x0f));
2050 }
2051
2052 static ssize_t store_pwm_auto_vrdhot_ramp(struct device *dev,
2053                                                 struct device_attribute *attr,
2054                                                 const char *buf, size_t count)
2055 {
2056         struct i2c_client *client = to_i2c_client(dev);
2057         struct lm93_data *data = i2c_get_clientdata(client);
2058         u32 val = simple_strtoul(buf, NULL, 10);
2059         u8 ramp;
2060
2061         mutex_lock(&data->update_lock);
2062         ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
2063         ramp = (ramp & 0xf0) | (LM93_RAMP_TO_REG(val) & 0x0f);
2064         lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp);
2065         mutex_unlock(&data->update_lock);
2066         return 0;
2067 }
2068
2069 static DEVICE_ATTR(pwm_auto_vrdhot_ramp, S_IRUGO | S_IWUSR,
2070                         show_pwm_auto_vrdhot_ramp,
2071                         store_pwm_auto_vrdhot_ramp);
2072
2073 static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
2074                         char *buf)
2075 {
2076         int nr = (to_sensor_dev_attr(attr))->index;
2077         struct lm93_data *data = lm93_update_device(dev);
2078         return sprintf(buf,"%d\n",LM93_VID_FROM_REG(data->vid[nr]));
2079 }
2080
2081 static SENSOR_DEVICE_ATTR(vid1, S_IRUGO, show_vid, NULL, 0);
2082 static SENSOR_DEVICE_ATTR(vid2, S_IRUGO, show_vid, NULL, 1);
2083
2084 static ssize_t show_prochot(struct device *dev, struct device_attribute *attr,
2085                                 char *buf)
2086 {
2087         int nr = (to_sensor_dev_attr(attr))->index;
2088         struct lm93_data *data = lm93_update_device(dev);
2089         return sprintf(buf,"%d\n",data->block4[nr].cur);
2090 }
2091
2092 static SENSOR_DEVICE_ATTR(prochot1, S_IRUGO, show_prochot, NULL, 0);
2093 static SENSOR_DEVICE_ATTR(prochot2, S_IRUGO, show_prochot, NULL, 1);
2094
2095 static ssize_t show_prochot_avg(struct device *dev,
2096                                 struct device_attribute *attr, char *buf)
2097 {
2098         int nr = (to_sensor_dev_attr(attr))->index;
2099         struct lm93_data *data = lm93_update_device(dev);
2100         return sprintf(buf,"%d\n",data->block4[nr].avg);
2101 }
2102
2103 static SENSOR_DEVICE_ATTR(prochot1_avg, S_IRUGO, show_prochot_avg, NULL, 0);
2104 static SENSOR_DEVICE_ATTR(prochot2_avg, S_IRUGO, show_prochot_avg, NULL, 1);
2105
2106 static ssize_t show_prochot_max(struct device *dev,
2107                                 struct device_attribute *attr, char *buf)
2108 {
2109         int nr = (to_sensor_dev_attr(attr))->index;
2110         struct lm93_data *data = lm93_update_device(dev);
2111         return sprintf(buf,"%d\n",data->prochot_max[nr]);
2112 }
2113
2114 static ssize_t store_prochot_max(struct device *dev,
2115                                         struct device_attribute *attr,
2116                                         const char *buf, size_t count)
2117 {
2118         int nr = (to_sensor_dev_attr(attr))->index;
2119         struct i2c_client *client = to_i2c_client(dev);
2120         struct lm93_data *data = i2c_get_clientdata(client);
2121         u32 val = simple_strtoul(buf, NULL, 10);
2122
2123         mutex_lock(&data->update_lock);
2124         data->prochot_max[nr] = LM93_PROCHOT_TO_REG(val);
2125         lm93_write_byte(client, LM93_REG_PROCHOT_MAX(nr),
2126                         data->prochot_max[nr]);
2127         mutex_unlock(&data->update_lock);
2128         return count;
2129 }
2130
2131 static SENSOR_DEVICE_ATTR(prochot1_max, S_IWUSR | S_IRUGO,
2132                           show_prochot_max, store_prochot_max, 0);
2133 static SENSOR_DEVICE_ATTR(prochot2_max, S_IWUSR | S_IRUGO,
2134                           show_prochot_max, store_prochot_max, 1);
2135
2136 static const u8 prochot_override_mask[] = { 0x80, 0x40 };
2137
2138 static ssize_t show_prochot_override(struct device *dev,
2139                                 struct device_attribute *attr, char *buf)
2140 {
2141         int nr = (to_sensor_dev_attr(attr))->index;
2142         struct lm93_data *data = lm93_update_device(dev);
2143         return sprintf(buf,"%d\n",
2144                 (data->prochot_override & prochot_override_mask[nr]) ? 1 : 0);
2145 }
2146
2147 static ssize_t store_prochot_override(struct device *dev,
2148                                         struct device_attribute *attr,
2149                                         const char *buf, size_t count)
2150 {
2151         int nr = (to_sensor_dev_attr(attr))->index;
2152         struct i2c_client *client = to_i2c_client(dev);
2153         struct lm93_data *data = i2c_get_clientdata(client);
2154         u32 val = simple_strtoul(buf, NULL, 10);
2155
2156         mutex_lock(&data->update_lock);
2157         if (val)
2158                 data->prochot_override |= prochot_override_mask[nr];
2159         else
2160                 data->prochot_override &= (~prochot_override_mask[nr]);
2161         lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE,
2162                         data->prochot_override);
2163         mutex_unlock(&data->update_lock);
2164         return count;
2165 }
2166
2167 static SENSOR_DEVICE_ATTR(prochot1_override, S_IWUSR | S_IRUGO,
2168                           show_prochot_override, store_prochot_override, 0);
2169 static SENSOR_DEVICE_ATTR(prochot2_override, S_IWUSR | S_IRUGO,
2170                           show_prochot_override, store_prochot_override, 1);
2171
2172 static ssize_t show_prochot_interval(struct device *dev,
2173                                 struct device_attribute *attr, char *buf)
2174 {
2175         int nr = (to_sensor_dev_attr(attr))->index;
2176         struct lm93_data *data = lm93_update_device(dev);
2177         u8 tmp;
2178         if (nr==1)
2179                 tmp = (data->prochot_interval & 0xf0) >> 4;
2180         else
2181                 tmp = data->prochot_interval & 0x0f;
2182         return sprintf(buf,"%d\n",LM93_INTERVAL_FROM_REG(tmp));
2183 }
2184
2185 static ssize_t store_prochot_interval(struct device *dev,
2186                                         struct device_attribute *attr,
2187                                         const char *buf, size_t count)
2188 {
2189         int nr = (to_sensor_dev_attr(attr))->index;
2190         struct i2c_client *client = to_i2c_client(dev);
2191         struct lm93_data *data = i2c_get_clientdata(client);
2192         u32 val = simple_strtoul(buf, NULL, 10);
2193         u8 tmp;
2194
2195         mutex_lock(&data->update_lock);
2196         tmp = lm93_read_byte(client, LM93_REG_PROCHOT_INTERVAL);
2197         if (nr==1)
2198                 tmp = (tmp & 0x0f) | (LM93_INTERVAL_TO_REG(val) << 4);
2199         else
2200                 tmp = (tmp & 0xf0) | LM93_INTERVAL_TO_REG(val);
2201         data->prochot_interval = tmp;
2202         lm93_write_byte(client, LM93_REG_PROCHOT_INTERVAL, tmp);
2203         mutex_unlock(&data->update_lock);
2204         return count;
2205 }
2206
2207 static SENSOR_DEVICE_ATTR(prochot1_interval, S_IWUSR | S_IRUGO,
2208                           show_prochot_interval, store_prochot_interval, 0);
2209 static SENSOR_DEVICE_ATTR(prochot2_interval, S_IWUSR | S_IRUGO,
2210                           show_prochot_interval, store_prochot_interval, 1);
2211
2212 static ssize_t show_prochot_override_duty_cycle(struct device *dev,
2213                                                 struct device_attribute *attr,
2214                                                 char *buf)
2215 {
2216         struct lm93_data *data = lm93_update_device(dev);
2217         return sprintf(buf,"%d\n",data->prochot_override & 0x0f);
2218 }
2219
2220 static ssize_t store_prochot_override_duty_cycle(struct device *dev,
2221                                                 struct device_attribute *attr,
2222                                                 const char *buf, size_t count)
2223 {
2224         struct i2c_client *client = to_i2c_client(dev);
2225         struct lm93_data *data = i2c_get_clientdata(client);
2226         u32 val = simple_strtoul(buf, NULL, 10);
2227
2228         mutex_lock(&data->update_lock);
2229         data->prochot_override = (data->prochot_override & 0xf0) |
2230                                         SENSORS_LIMIT(val, 0, 15);
2231         lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE,
2232                         data->prochot_override);
2233         mutex_unlock(&data->update_lock);
2234         return count;
2235 }
2236
2237 static DEVICE_ATTR(prochot_override_duty_cycle, S_IRUGO | S_IWUSR,
2238                         show_prochot_override_duty_cycle,
2239                         store_prochot_override_duty_cycle);
2240
2241 static ssize_t show_prochot_short(struct device *dev,
2242                                 struct device_attribute *attr, char *buf)
2243 {
2244         struct lm93_data *data = lm93_update_device(dev);
2245         return sprintf(buf,"%d\n",(data->config & 0x10) ? 1 : 0);
2246 }
2247
2248 static ssize_t store_prochot_short(struct device *dev,
2249                                         struct device_attribute *attr,
2250                                         const char *buf, size_t count)
2251 {
2252         struct i2c_client *client = to_i2c_client(dev);
2253         struct lm93_data *data = i2c_get_clientdata(client);
2254         u32 val = simple_strtoul(buf, NULL, 10);
2255
2256         mutex_lock(&data->update_lock);
2257         if (val)
2258                 data->config |= 0x10;
2259         else
2260                 data->config &= ~0x10;
2261         lm93_write_byte(client, LM93_REG_CONFIG, data->config);
2262         mutex_unlock(&data->update_lock);
2263         return count;
2264 }
2265
2266 static DEVICE_ATTR(prochot_short, S_IRUGO | S_IWUSR,
2267                    show_prochot_short, store_prochot_short);
2268
2269 static ssize_t show_vrdhot(struct device *dev, struct device_attribute *attr,
2270                                 char *buf)
2271 {
2272         int nr = (to_sensor_dev_attr(attr))->index;
2273         struct lm93_data *data = lm93_update_device(dev);
2274         return sprintf(buf,"%d\n",
2275                        data->block1.host_status_1 & (1 << (nr+4)) ? 1 : 0);
2276 }
2277
2278 static SENSOR_DEVICE_ATTR(vrdhot1, S_IRUGO, show_vrdhot, NULL, 0);
2279 static SENSOR_DEVICE_ATTR(vrdhot2, S_IRUGO, show_vrdhot, NULL, 1);
2280
2281 static ssize_t show_gpio(struct device *dev, struct device_attribute *attr,
2282                                 char *buf)
2283 {
2284         struct lm93_data *data = lm93_update_device(dev);
2285         return sprintf(buf,"%d\n",LM93_GPI_FROM_REG(data->gpi));
2286 }
2287
2288 static DEVICE_ATTR(gpio, S_IRUGO, show_gpio, NULL);
2289
2290 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
2291                                 char *buf)
2292 {
2293         struct lm93_data *data = lm93_update_device(dev);
2294         return sprintf(buf,"%d\n",LM93_ALARMS_FROM_REG(data->block1));
2295 }
2296
2297 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
2298
2299 static struct attribute *lm93_attrs[] = {
2300         &sensor_dev_attr_in1_input.dev_attr.attr,
2301         &sensor_dev_attr_in2_input.dev_attr.attr,
2302         &sensor_dev_attr_in3_input.dev_attr.attr,
2303         &sensor_dev_attr_in4_input.dev_attr.attr,
2304         &sensor_dev_attr_in5_input.dev_attr.attr,
2305         &sensor_dev_attr_in6_input.dev_attr.attr,
2306         &sensor_dev_attr_in7_input.dev_attr.attr,
2307         &sensor_dev_attr_in8_input.dev_attr.attr,
2308         &sensor_dev_attr_in9_input.dev_attr.attr,
2309         &sensor_dev_attr_in10_input.dev_attr.attr,
2310         &sensor_dev_attr_in11_input.dev_attr.attr,
2311         &sensor_dev_attr_in12_input.dev_attr.attr,
2312         &sensor_dev_attr_in13_input.dev_attr.attr,
2313         &sensor_dev_attr_in14_input.dev_attr.attr,
2314         &sensor_dev_attr_in15_input.dev_attr.attr,
2315         &sensor_dev_attr_in16_input.dev_attr.attr,
2316         &sensor_dev_attr_in1_min.dev_attr.attr,
2317         &sensor_dev_attr_in2_min.dev_attr.attr,
2318         &sensor_dev_attr_in3_min.dev_attr.attr,
2319         &sensor_dev_attr_in4_min.dev_attr.attr,
2320         &sensor_dev_attr_in5_min.dev_attr.attr,
2321         &sensor_dev_attr_in6_min.dev_attr.attr,
2322         &sensor_dev_attr_in7_min.dev_attr.attr,
2323         &sensor_dev_attr_in8_min.dev_attr.attr,
2324         &sensor_dev_attr_in9_min.dev_attr.attr,
2325         &sensor_dev_attr_in10_min.dev_attr.attr,
2326         &sensor_dev_attr_in11_min.dev_attr.attr,
2327         &sensor_dev_attr_in12_min.dev_attr.attr,
2328         &sensor_dev_attr_in13_min.dev_attr.attr,
2329         &sensor_dev_attr_in14_min.dev_attr.attr,
2330         &sensor_dev_attr_in15_min.dev_attr.attr,
2331         &sensor_dev_attr_in16_min.dev_attr.attr,
2332         &sensor_dev_attr_in1_max.dev_attr.attr,
2333         &sensor_dev_attr_in2_max.dev_attr.attr,
2334         &sensor_dev_attr_in3_max.dev_attr.attr,
2335         &sensor_dev_attr_in4_max.dev_attr.attr,
2336         &sensor_dev_attr_in5_max.dev_attr.attr,
2337         &sensor_dev_attr_in6_max.dev_attr.attr,
2338         &sensor_dev_attr_in7_max.dev_attr.attr,
2339         &sensor_dev_attr_in8_max.dev_attr.attr,
2340         &sensor_dev_attr_in9_max.dev_attr.attr,
2341         &sensor_dev_attr_in10_max.dev_attr.attr,
2342         &sensor_dev_attr_in11_max.dev_attr.attr,
2343         &sensor_dev_attr_in12_max.dev_attr.attr,
2344         &sensor_dev_attr_in13_max.dev_attr.attr,
2345         &sensor_dev_attr_in14_max.dev_attr.attr,
2346         &sensor_dev_attr_in15_max.dev_attr.attr,
2347         &sensor_dev_attr_in16_max.dev_attr.attr,
2348         &sensor_dev_attr_temp1_input.dev_attr.attr,
2349         &sensor_dev_attr_temp2_input.dev_attr.attr,
2350         &sensor_dev_attr_temp3_input.dev_attr.attr,
2351         &sensor_dev_attr_temp1_min.dev_attr.attr,
2352         &sensor_dev_attr_temp2_min.dev_attr.attr,
2353         &sensor_dev_attr_temp3_min.dev_attr.attr,
2354         &sensor_dev_attr_temp1_max.dev_attr.attr,
2355         &sensor_dev_attr_temp2_max.dev_attr.attr,
2356         &sensor_dev_attr_temp3_max.dev_attr.attr,
2357         &sensor_dev_attr_temp1_auto_base.dev_attr.attr,
2358         &sensor_dev_attr_temp2_auto_base.dev_attr.attr,
2359         &sensor_dev_attr_temp3_auto_base.dev_attr.attr,
2360         &sensor_dev_attr_temp1_auto_boost.dev_attr.attr,
2361         &sensor_dev_attr_temp2_auto_boost.dev_attr.attr,
2362         &sensor_dev_attr_temp3_auto_boost.dev_attr.attr,
2363         &sensor_dev_attr_temp1_auto_boost_hyst.dev_attr.attr,
2364         &sensor_dev_attr_temp2_auto_boost_hyst.dev_attr.attr,
2365         &sensor_dev_attr_temp3_auto_boost_hyst.dev_attr.attr,
2366         &sensor_dev_attr_temp1_auto_offset1.dev_attr.attr,
2367         &sensor_dev_attr_temp1_auto_offset2.dev_attr.attr,
2368         &sensor_dev_attr_temp1_auto_offset3.dev_attr.attr,
2369         &sensor_dev_attr_temp1_auto_offset4.dev_attr.attr,
2370         &sensor_dev_attr_temp1_auto_offset5.dev_attr.attr,
2371         &sensor_dev_attr_temp1_auto_offset6.dev_attr.attr,
2372         &sensor_dev_attr_temp1_auto_offset7.dev_attr.attr,
2373         &sensor_dev_attr_temp1_auto_offset8.dev_attr.attr,
2374         &sensor_dev_attr_temp1_auto_offset9.dev_attr.attr,
2375         &sensor_dev_attr_temp1_auto_offset10.dev_attr.attr,
2376         &sensor_dev_attr_temp1_auto_offset11.dev_attr.attr,
2377         &sensor_dev_attr_temp1_auto_offset12.dev_attr.attr,
2378         &sensor_dev_attr_temp2_auto_offset1.dev_attr.attr,
2379         &sensor_dev_attr_temp2_auto_offset2.dev_attr.attr,
2380         &sensor_dev_attr_temp2_auto_offset3.dev_attr.attr,
2381         &sensor_dev_attr_temp2_auto_offset4.dev_attr.attr,
2382         &sensor_dev_attr_temp2_auto_offset5.dev_attr.attr,
2383         &sensor_dev_attr_temp2_auto_offset6.dev_attr.attr,
2384         &sensor_dev_attr_temp2_auto_offset7.dev_attr.attr,
2385         &sensor_dev_attr_temp2_auto_offset8.dev_attr.attr,
2386         &sensor_dev_attr_temp2_auto_offset9.dev_attr.attr,
2387         &sensor_dev_attr_temp2_auto_offset10.dev_attr.attr,
2388         &sensor_dev_attr_temp2_auto_offset11.dev_attr.attr,
2389         &sensor_dev_attr_temp2_auto_offset12.dev_attr.attr,
2390         &sensor_dev_attr_temp3_auto_offset1.dev_attr.attr,
2391         &sensor_dev_attr_temp3_auto_offset2.dev_attr.attr,
2392         &sensor_dev_attr_temp3_auto_offset3.dev_attr.attr,
2393         &sensor_dev_attr_temp3_auto_offset4.dev_attr.attr,
2394         &sensor_dev_attr_temp3_auto_offset5.dev_attr.attr,
2395         &sensor_dev_attr_temp3_auto_offset6.dev_attr.attr,
2396         &sensor_dev_attr_temp3_auto_offset7.dev_attr.attr,
2397         &sensor_dev_attr_temp3_auto_offset8.dev_attr.attr,
2398         &sensor_dev_attr_temp3_auto_offset9.dev_attr.attr,
2399         &sensor_dev_attr_temp3_auto_offset10.dev_attr.attr,
2400         &sensor_dev_attr_temp3_auto_offset11.dev_attr.attr,
2401         &sensor_dev_attr_temp3_auto_offset12.dev_attr.attr,
2402         &sensor_dev_attr_temp1_auto_pwm_min.dev_attr.attr,
2403         &sensor_dev_attr_temp2_auto_pwm_min.dev_attr.attr,
2404         &sensor_dev_attr_temp3_auto_pwm_min.dev_attr.attr,
2405         &sensor_dev_attr_temp1_auto_offset_hyst.dev_attr.attr,
2406         &sensor_dev_attr_temp2_auto_offset_hyst.dev_attr.attr,
2407         &sensor_dev_attr_temp3_auto_offset_hyst.dev_attr.attr,
2408         &sensor_dev_attr_fan1_input.dev_attr.attr,
2409         &sensor_dev_attr_fan2_input.dev_attr.attr,
2410         &sensor_dev_attr_fan3_input.dev_attr.attr,
2411         &sensor_dev_attr_fan4_input.dev_attr.attr,
2412         &sensor_dev_attr_fan1_min.dev_attr.attr,
2413         &sensor_dev_attr_fan2_min.dev_attr.attr,
2414         &sensor_dev_attr_fan3_min.dev_attr.attr,
2415         &sensor_dev_attr_fan4_min.dev_attr.attr,
2416         &sensor_dev_attr_fan1_smart_tach.dev_attr.attr,
2417         &sensor_dev_attr_fan2_smart_tach.dev_attr.attr,
2418         &sensor_dev_attr_fan3_smart_tach.dev_attr.attr,
2419         &sensor_dev_attr_fan4_smart_tach.dev_attr.attr,
2420         &sensor_dev_attr_pwm1.dev_attr.attr,
2421         &sensor_dev_attr_pwm2.dev_attr.attr,
2422         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
2423         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
2424         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
2425         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
2426         &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,
2427         &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,
2428         &sensor_dev_attr_pwm1_auto_spinup_min.dev_attr.attr,
2429         &sensor_dev_attr_pwm2_auto_spinup_min.dev_attr.attr,
2430         &sensor_dev_attr_pwm1_auto_spinup_time.dev_attr.attr,
2431         &sensor_dev_attr_pwm2_auto_spinup_time.dev_attr.attr,
2432         &dev_attr_pwm_auto_prochot_ramp.attr,
2433         &dev_attr_pwm_auto_vrdhot_ramp.attr,
2434         &sensor_dev_attr_vid1.dev_attr.attr,
2435         &sensor_dev_attr_vid2.dev_attr.attr,
2436         &sensor_dev_attr_prochot1.dev_attr.attr,
2437         &sensor_dev_attr_prochot2.dev_attr.attr,
2438         &sensor_dev_attr_prochot1_avg.dev_attr.attr,
2439         &sensor_dev_attr_prochot2_avg.dev_attr.attr,
2440         &sensor_dev_attr_prochot1_max.dev_attr.attr,
2441         &sensor_dev_attr_prochot2_max.dev_attr.attr,
2442         &sensor_dev_attr_prochot1_override.dev_attr.attr,
2443         &sensor_dev_attr_prochot2_override.dev_attr.attr,
2444         &sensor_dev_attr_prochot1_interval.dev_attr.attr,
2445         &sensor_dev_attr_prochot2_interval.dev_attr.attr,
2446         &dev_attr_prochot_override_duty_cycle.attr,
2447         &dev_attr_prochot_short.attr,
2448         &sensor_dev_attr_vrdhot1.dev_attr.attr,
2449         &sensor_dev_attr_vrdhot2.dev_attr.attr,
2450         &dev_attr_gpio.attr,
2451         &dev_attr_alarms.attr,
2452         NULL
2453 };
2454
2455 static struct attribute_group lm93_attr_grp = {
2456         .attrs = lm93_attrs,
2457 };
2458
2459 static void lm93_init_client(struct i2c_client *client)
2460 {
2461         int i;
2462         u8 reg;
2463
2464         /* configure VID pin input thresholds */
2465         reg = lm93_read_byte(client, LM93_REG_GPI_VID_CTL);
2466         lm93_write_byte(client, LM93_REG_GPI_VID_CTL,
2467                         reg | (vid_agtl ? 0x03 : 0x00));
2468
2469         if (init) {
2470                 /* enable #ALERT pin */
2471                 reg = lm93_read_byte(client, LM93_REG_CONFIG);
2472                 lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x08);
2473
2474                 /* enable ASF mode for BMC status registers */
2475                 reg = lm93_read_byte(client, LM93_REG_STATUS_CONTROL);
2476                 lm93_write_byte(client, LM93_REG_STATUS_CONTROL, reg | 0x02);
2477
2478                 /* set sleep state to S0 */
2479                 lm93_write_byte(client, LM93_REG_SLEEP_CONTROL, 0);
2480
2481                 /* unmask #VRDHOT and dynamic VCCP (if nec) error events */
2482                 reg = lm93_read_byte(client, LM93_REG_MISC_ERR_MASK);
2483                 reg &= ~0x03;
2484                 reg &= ~(vccp_limit_type[0] ? 0x10 : 0);
2485                 reg &= ~(vccp_limit_type[1] ? 0x20 : 0);
2486                 lm93_write_byte(client, LM93_REG_MISC_ERR_MASK, reg);
2487         }
2488
2489         /* start monitoring */
2490         reg = lm93_read_byte(client, LM93_REG_CONFIG);
2491         lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x01);
2492
2493         /* spin until ready */
2494         for (i=0; i<20; i++) {
2495                 msleep(10);
2496                 if ((lm93_read_byte(client, LM93_REG_CONFIG) & 0x80) == 0x80)
2497                         return;
2498         }
2499
2500         dev_warn(&client->dev,"timed out waiting for sensor "
2501                  "chip to signal ready!\n");
2502 }
2503
2504 static int lm93_detect(struct i2c_adapter *adapter, int address, int kind)
2505 {
2506         struct lm93_data *data;
2507         struct i2c_client *client;
2508
2509         int err = -ENODEV, func;
2510         void (*update)(struct lm93_data *, struct i2c_client *);
2511
2512         /* choose update routine based on bus capabilities */
2513         func = i2c_get_functionality(adapter);
2514         if ( ((LM93_SMBUS_FUNC_FULL & func) == LM93_SMBUS_FUNC_FULL) &&
2515                         (!disable_block) ) {
2516                 dev_dbg(&adapter->dev,"using SMBus block data transactions\n");
2517                 update = lm93_update_client_full;
2518         } else if ((LM93_SMBUS_FUNC_MIN & func) == LM93_SMBUS_FUNC_MIN) {
2519                 dev_dbg(&adapter->dev,"disabled SMBus block data "
2520                         "transactions\n");
2521                 update = lm93_update_client_min;
2522         } else {
2523                 dev_dbg(&adapter->dev,"detect failed, "
2524                         "smbus byte and/or word data not supported!\n");
2525                 goto err_out;
2526         }
2527
2528         /* OK. For now, we presume we have a valid client. We now create the
2529            client structure, even though we cannot fill it completely yet.
2530            But it allows us to access lm78_{read,write}_value. */
2531
2532         if ( !(data = kzalloc(sizeof(struct lm93_data), GFP_KERNEL))) {
2533                 dev_dbg(&adapter->dev,"out of memory!\n");
2534                 err = -ENOMEM;
2535                 goto err_out;
2536         }
2537
2538         client = &data->client;
2539         i2c_set_clientdata(client, data);
2540         client->addr = address;
2541         client->adapter = adapter;
2542         client->driver = &lm93_driver;
2543
2544         /* detection */
2545         if (kind < 0) {
2546                 int mfr = lm93_read_byte(client, LM93_REG_MFR_ID);
2547
2548                 if (mfr != 0x01) {
2549                         dev_dbg(&adapter->dev,"detect failed, "
2550                                 "bad manufacturer id 0x%02x!\n", mfr);
2551                         goto err_free;
2552                 }
2553         }
2554
2555         if (kind <= 0) {
2556                 int ver = lm93_read_byte(client, LM93_REG_VER);
2557
2558                 if ((ver == LM93_MFR_ID) || (ver == LM93_MFR_ID_PROTOTYPE)) {
2559                         kind = lm93;
2560                 } else {
2561                         dev_dbg(&adapter->dev,"detect failed, "
2562                                 "bad version id 0x%02x!\n", ver);
2563                         if (kind == 0)
2564                                 dev_dbg(&adapter->dev,
2565                                         "(ignored 'force' parameter)\n");
2566                         goto err_free;
2567                 }
2568         }
2569
2570         /* fill in remaining client fields */
2571         strlcpy(client->name, "lm93", I2C_NAME_SIZE);
2572         dev_dbg(&adapter->dev,"loading %s at %d,0x%02x\n",
2573                 client->name, i2c_adapter_id(client->adapter),
2574                 client->addr);
2575
2576         /* housekeeping */
2577         data->valid = 0;
2578         data->update = update;
2579         mutex_init(&data->update_lock);
2580
2581         /* tell the I2C layer a new client has arrived */
2582         if ((err = i2c_attach_client(client)))
2583                 goto err_free;
2584
2585         /* initialize the chip */
2586         lm93_init_client(client);
2587
2588         err = sysfs_create_group(&client->dev.kobj, &lm93_attr_grp);
2589         if (err)
2590                 goto err_detach;
2591
2592         /* Register hwmon driver class */
2593         data->class_dev = hwmon_device_register(&client->dev);
2594         if ( !IS_ERR(data->class_dev))
2595                 return 0;
2596
2597         err = PTR_ERR(data->class_dev);
2598         dev_err(&client->dev, "error registering hwmon device.\n");
2599         sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp);
2600 err_detach:
2601         i2c_detach_client(client);
2602 err_free:
2603         kfree(data);
2604 err_out:
2605         return err;
2606 }
2607
2608 /* This function is called when:
2609      * lm93_driver is inserted (when this module is loaded), for each
2610        available adapter
2611      * when a new adapter is inserted (and lm93_driver is still present) */
2612 static int lm93_attach_adapter(struct i2c_adapter *adapter)
2613 {
2614         return i2c_probe(adapter, &addr_data, lm93_detect);
2615 }
2616
2617 static int lm93_detach_client(struct i2c_client *client)
2618 {
2619         struct lm93_data *data = i2c_get_clientdata(client);
2620         int err = 0;
2621
2622         hwmon_device_unregister(data->class_dev);
2623         sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp);
2624
2625         err = i2c_detach_client(client);
2626         if (!err)
2627                 kfree(data);
2628         return err;
2629 }
2630
2631 static struct i2c_driver lm93_driver = {
2632         .driver = {
2633                 .name   = "lm93",
2634         },
2635         .attach_adapter = lm93_attach_adapter,
2636         .detach_client  = lm93_detach_client,
2637 };
2638
2639 static int __init lm93_init(void)
2640 {
2641         return i2c_add_driver(&lm93_driver);
2642 }
2643
2644 static void __exit lm93_exit(void)
2645 {
2646         i2c_del_driver(&lm93_driver);
2647 }
2648
2649 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>, "
2650                 "Hans J. Koch <hjk@linutronix.de");
2651 MODULE_DESCRIPTION("LM93 driver");
2652 MODULE_LICENSE("GPL");
2653
2654 module_init(lm93_init);
2655 module_exit(lm93_exit);