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