Merge branch 'release' of git://lm-sensors.org/kernel/mhoffman/hwmon-2.6
Linus Torvalds [Fri, 1 Aug 2008 18:33:19 +0000 (11:33 -0700)]
* 'release' of git://lm-sensors.org/kernel/mhoffman/hwmon-2.6:
  hwmon: needs new maintainer
  hwmon: (lm85) Simplify device initialization function
  hwmon: (lm85) Misc cleanups
  hwmon: (lm85) Don't write back cached values
  hwmon: (lm85) Drop dead code
  hwmon: (lm85) Coding-style cleanups
  hwmon: (lm75) add new-style driver binding
  hwmon: (lm75) cleanup/reorg
  hwmon: (adt7473) clarify an awkward bit of code
  hwmon: (adt7473) Remove unused defines
  hwmon: (dme1737) fix voltage scaling
  hwmon: (dme1737) probe all addresses
  hwmon: (dme1737) demacrofy for readability

Documentation/hwmon/dme1737
Documentation/hwmon/lm85
MAINTAINERS
drivers/hwmon/Kconfig
drivers/hwmon/adt7473.c
drivers/hwmon/dme1737.c
drivers/hwmon/lm75.c
drivers/hwmon/lm85.c

index 8f44607..b1fe009 100644 (file)
@@ -22,6 +22,10 @@ Module Parameters
                        and PWM output control functions. Using this parameter
                        shouldn't be required since the BIOS usually takes care
                        of this.
+* probe_all_addr: bool Include non-standard LPC addresses 0x162e and 0x164e
+                       when probing for ISA devices. This is required for the
+                       following boards:
+                       - VIA EPIA SN18000
 
 Note that there is no need to use this parameter if the driver loads without
 complaining. The driver will say so if it is necessary.
index 9549237..6d41db7 100644 (file)
@@ -96,11 +96,6 @@ initial testing of the ADM1027 it was 1.00 degC steps. Analog Devices has
 confirmed this "bug". The ADT7463 is reported to work as described in the
 documentation. The current lm85 driver does not show the offset register.
 
-The ADT7463 has a THERM asserted counter. This counter has a 22.76ms
-resolution and a range of 5.8 seconds. The driver implements a 32-bit
-accumulator of the counter value to extend the range to over a year. The
-counter will stay at it's max value until read.
-
 See the vendor datasheets for more information. There is application note
 from National (AN-1260) with some additional information about the LM85.
 The Analog Devices datasheet is very detailed and describes a procedure for
@@ -206,13 +201,15 @@ Configuration choices:
 
 The National LM85's have two vendor specific configuration
 features. Tach. mode and Spinup Control. For more details on these,
-see the LM85 datasheet or Application Note AN-1260.
+see the LM85 datasheet or Application Note AN-1260. These features
+are not currently supported by the lm85 driver.
 
 The Analog Devices ADM1027 has several vendor specific enhancements.
 The number of pulses-per-rev of the fans can be set, Tach monitoring
 can be optimized for PWM operation, and an offset can be applied to
 the temperatures to compensate for systemic errors in the
-measurements.
+measurements. These features are not currently supported by the lm85
+driver.
 
 In addition to the ADM1027 features, the ADT7463 also has Tmin control
 and THERM asserted counts. Automatic Tmin control acts to adjust the
index c65a5b9..5e6d6ab 100644 (file)
@@ -1878,13 +1878,9 @@ W:       http://gigaset307x.sourceforge.net/
 S:     Maintained
 
 HARDWARE MONITORING
-P:     Mark M. Hoffman
-M:     mhoffman@lightlink.com
 L:     lm-sensors@lm-sensors.org
 W:     http://www.lm-sensors.org/
-T:     git lm-sensors.org:/kernel/mhoffman/hwmon-2.6.git testing
-T:     git lm-sensors.org:/kernel/mhoffman/hwmon-2.6.git release
-S:     Maintained
+S:     Orphaned
 
 HARDWARE RANDOM NUMBER GENERATOR CORE
 S:     Orphaned
index 00ff533..c882fd0 100644 (file)
@@ -394,13 +394,24 @@ config SENSORS_LM75
        tristate "National Semiconductor LM75 and compatibles"
        depends on I2C
        help
-         If you say yes here you get support for National Semiconductor LM75
-         sensor chips and clones: Dallas Semiconductor DS75 and DS1775 (in
-         9-bit precision mode), and TelCom (now Microchip) TCN75.
-
-         The DS75 and DS1775 in 10- to 12-bit precision modes will require
-         a force module parameter. The driver will not handle the extra
-         precision anyhow.
+         If you say yes here you get support for one common type of
+         temperature sensor chip, with models including:
+
+               - Dallas Semiconductor DS75 and DS1775
+               - Maxim MAX6625 and MAX6626
+               - Microchip MCP980x
+               - National Semiconductor LM75
+               - NXP's LM75A
+               - ST Microelectronics STDS75
+               - TelCom (now Microchip) TCN75
+               - Texas Instruments TMP100, TMP101, TMP75, TMP175, TMP275
+
+         This driver supports driver model based binding through board
+         specific I2C device tables.
+
+         It also supports the "legacy" style of driver binding.  To use
+         that with some chips which don't replicate LM75 quirks exactly,
+         you may need the "force" module parameter.
 
          This driver can also be built as a module.  If so, the module
          will be called lm75.
index ce4a7cb..3a0b631 100644 (file)
@@ -39,32 +39,20 @@ I2C_CLIENT_INSMOD_1(adt7473);
 #define ADT7473_REG_BASE_ADDR                  0x20
 
 #define ADT7473_REG_VOLT_BASE_ADDR             0x21
-#define ADT7473_REG_VOLT_MAX_ADDR              0x22
 #define ADT7473_REG_VOLT_MIN_BASE_ADDR         0x46
-#define ADT7473_REG_VOLT_MIN_MAX_ADDR          0x49
 
 #define ADT7473_REG_TEMP_BASE_ADDR             0x25
-#define ADT7473_REG_TEMP_MAX_ADDR              0x27
 #define ADT7473_REG_TEMP_LIMITS_BASE_ADDR      0x4E
-#define ADT7473_REG_TEMP_LIMITS_MAX_ADDR       0x53
 #define ADT7473_REG_TEMP_TMIN_BASE_ADDR                0x67
-#define ADT7473_REG_TEMP_TMIN_MAX_ADDR         0x69
 #define ADT7473_REG_TEMP_TMAX_BASE_ADDR                0x6A
-#define ADT7473_REG_TEMP_TMAX_MAX_ADDR         0x6C
 
 #define ADT7473_REG_FAN_BASE_ADDR              0x28
-#define ADT7473_REG_FAN_MAX_ADDR               0x2F
 #define ADT7473_REG_FAN_MIN_BASE_ADDR          0x54
-#define ADT7473_REG_FAN_MIN_MAX_ADDR           0x5B
 
 #define ADT7473_REG_PWM_BASE_ADDR              0x30
-#define ADT7473_REG_PWM_MAX_ADDR               0x32
 #define        ADT7473_REG_PWM_MIN_BASE_ADDR           0x64
-#define ADT7473_REG_PWM_MIN_MAX_ADDR           0x66
 #define ADT7473_REG_PWM_MAX_BASE_ADDR          0x38
-#define ADT7473_REG_PWM_MAX_MAX_ADDR           0x3A
 #define ADT7473_REG_PWM_BHVR_BASE_ADDR         0x5C
-#define ADT7473_REG_PWM_BHVR_MAX_ADDR          0x5E
 #define                ADT7473_PWM_BHVR_MASK           0xE0
 #define                ADT7473_PWM_BHVR_SHIFT          5
 
@@ -102,7 +90,6 @@ I2C_CLIENT_INSMOD_1(adt7473);
 #define                ADT7473_FAN4_ALARM              0x20
 #define                ADT7473_R1T_SHORT               0x40
 #define                ADT7473_R2T_SHORT               0x80
-#define ADT7473_REG_MAX_ADDR                   0x80
 
 #define ALARM2(x)      ((x) << 8)
 
@@ -583,10 +570,9 @@ static ssize_t set_max_duty_at_crit(struct device *dev,
        struct i2c_client *client = to_i2c_client(dev);
        struct adt7473_data *data = i2c_get_clientdata(client);
        int temp = simple_strtol(buf, NULL, 10);
-       temp = temp && 0xFF;
 
        mutex_lock(&data->lock);
-       data->max_duty_at_overheat = temp;
+       data->max_duty_at_overheat = !!temp;
        reg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG4);
        if (temp)
                reg |= ADT7473_CFG4_MAX_DUTY_AT_OVT;
index 7673f65..5e2cf0a 100644 (file)
@@ -48,6 +48,11 @@ static unsigned short force_id;
 module_param(force_id, ushort, 0);
 MODULE_PARM_DESC(force_id, "Override the detected device ID");
 
+static int probe_all_addr;
+module_param(probe_all_addr, bool, 0);
+MODULE_PARM_DESC(probe_all_addr, "Include probing of non-standard LPC "
+                "addresses");
+
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END};
 
@@ -176,6 +181,7 @@ struct dme1737_data {
        int valid;                      /* !=0 if following fields are valid */
        unsigned long last_update;      /* in jiffies */
        unsigned long last_vbat;        /* in jiffies */
+       enum chips type;
 
        u8 vid;
        u8 pwm_rr_en;
@@ -210,20 +216,27 @@ struct dme1737_data {
 };
 
 /* Nominal voltage values */
-static const int IN_NOMINAL[] = {5000, 2250, 3300, 5000, 12000, 3300, 3300};
+static const int IN_NOMINAL_DME1737[] = {5000, 2250, 3300, 5000, 12000, 3300,
+                                        3300};
+static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300,
+                                        3300};
+#define IN_NOMINAL(ix, type)   (((type) == dme1737) ? \
+                               IN_NOMINAL_DME1737[(ix)] : \
+                               IN_NOMINAL_SCH311x[(ix)])
 
 /* Voltage input
  * Voltage inputs have 16 bits resolution, limit values have 8 bits
  * resolution. */
-static inline int IN_FROM_REG(int reg, int ix, int res)
+static inline int IN_FROM_REG(int reg, int ix, int res, int type)
 {
-       return (reg * IN_NOMINAL[ix] + (3 << (res - 3))) / (3 << (res - 2));
+       return (reg * IN_NOMINAL(ix, type) + (3 << (res - 3))) /
+               (3 << (res - 2));
 }
 
-static inline int IN_TO_REG(int val, int ix)
+static inline int IN_TO_REG(int val, int ix, int type)
 {
-       return SENSORS_LIMIT((val * 192 + IN_NOMINAL[ix] / 2) /
-                            IN_NOMINAL[ix], 0, 255);
+       return SENSORS_LIMIT((val * 192 + IN_NOMINAL(ix, type) / 2) /
+                            IN_NOMINAL(ix, type), 0, 255);
 }
 
 /* Temperature input
@@ -722,13 +735,13 @@ static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 
        switch (fn) {
        case SYS_IN_INPUT:
-               res = IN_FROM_REG(data->in[ix], ix, 16);
+               res = IN_FROM_REG(data->in[ix], ix, 16, data->type);
                break;
        case SYS_IN_MIN:
-               res = IN_FROM_REG(data->in_min[ix], ix, 8);
+               res = IN_FROM_REG(data->in_min[ix], ix, 8, data->type);
                break;
        case SYS_IN_MAX:
-               res = IN_FROM_REG(data->in_max[ix], ix, 8);
+               res = IN_FROM_REG(data->in_max[ix], ix, 8, data->type);
                break;
        case SYS_IN_ALARM:
                res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01;
@@ -755,12 +768,12 @@ static ssize_t set_in(struct device *dev, struct device_attribute *attr,
        mutex_lock(&data->update_lock);
        switch (fn) {
        case SYS_IN_MIN:
-               data->in_min[ix] = IN_TO_REG(val, ix);
+               data->in_min[ix] = IN_TO_REG(val, ix, data->type);
                dme1737_write(client, DME1737_REG_IN_MIN(ix),
                              data->in_min[ix]);
                break;
        case SYS_IN_MAX:
-               data->in_max[ix] = IN_TO_REG(val, ix);
+               data->in_max[ix] = IN_TO_REG(val, ix, data->type);
                dme1737_write(client, DME1737_REG_IN_MAX(ix),
                              data->in_max[ix]);
                break;
@@ -1501,9 +1514,9 @@ SENSOR_DEVICE_ATTR_PWM_1TO3(3);
 /* PWMs 5-6 */
 
 #define SENSOR_DEVICE_ATTR_PWM_5TO6(ix) \
-static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO | S_IWUSR, \
+static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \
        show_pwm, set_pwm, SYS_PWM, ix-1); \
-static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO | S_IWUSR, \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \
        show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \
 static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \
        show_pwm, NULL, SYS_PWM_ENABLE, ix-1)
@@ -1517,91 +1530,75 @@ static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);   /* for ISA devices */
 
-#define SENSOR_DEV_ATTR_IN(ix) \
-&sensor_dev_attr_in##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_in##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_in##ix##_max.dev_attr.attr, \
-&sensor_dev_attr_in##ix##_alarm.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_TEMP_LOCK(ix) \
-&sensor_dev_attr_temp##ix##_offset.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_TEMP(ix) \
-SENSOR_DEV_ATTR_TEMP_LOCK(ix), \
-&sensor_dev_attr_temp##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_max.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_alarm.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_fault.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_ZONE_LOCK(ix) \
-&sensor_dev_attr_zone##ix##_auto_point1_temp_hyst.dev_attr.attr, \
-&sensor_dev_attr_zone##ix##_auto_point1_temp.dev_attr.attr, \
-&sensor_dev_attr_zone##ix##_auto_point2_temp.dev_attr.attr, \
-&sensor_dev_attr_zone##ix##_auto_point3_temp.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_ZONE(ix) \
-SENSOR_DEV_ATTR_ZONE_LOCK(ix), \
-&sensor_dev_attr_zone##ix##_auto_channels_temp.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_FAN_1TO4(ix) \
-&sensor_dev_attr_fan##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_alarm.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_type.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_FAN_5TO6(ix) \
-&sensor_dev_attr_fan##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_alarm.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_max.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_PWM_1TO3_LOCK(ix) \
-&sensor_dev_attr_pwm##ix##_freq.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_enable.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_ramp_rate.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_channels_zone.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_pwm_min.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_point1_pwm.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_PWM_1TO3(ix) \
-SENSOR_DEV_ATTR_PWM_1TO3_LOCK(ix), \
-&sensor_dev_attr_pwm##ix.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_point2_pwm.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_PWM_5TO6_LOCK(ix) \
-&sensor_dev_attr_pwm##ix.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_freq.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_PWM_5TO6(ix) \
-SENSOR_DEV_ATTR_PWM_5TO6_LOCK(ix), \
-&sensor_dev_attr_pwm##ix##_enable.dev_attr.attr
-
 /* This struct holds all the attributes that are always present and need to be
  * created unconditionally. The attributes that need modification of their
  * permissions are created read-only and write permissions are added or removed
  * on the fly when required */
 static struct attribute *dme1737_attr[] ={
        /* Voltages */
-       SENSOR_DEV_ATTR_IN(0),
-       SENSOR_DEV_ATTR_IN(1),
-       SENSOR_DEV_ATTR_IN(2),
-       SENSOR_DEV_ATTR_IN(3),
-       SENSOR_DEV_ATTR_IN(4),
-       SENSOR_DEV_ATTR_IN(5),
-       SENSOR_DEV_ATTR_IN(6),
+       &sensor_dev_attr_in0_input.dev_attr.attr,
+       &sensor_dev_attr_in0_min.dev_attr.attr,
+       &sensor_dev_attr_in0_max.dev_attr.attr,
+       &sensor_dev_attr_in0_alarm.dev_attr.attr,
+       &sensor_dev_attr_in1_input.dev_attr.attr,
+       &sensor_dev_attr_in1_min.dev_attr.attr,
+       &sensor_dev_attr_in1_max.dev_attr.attr,
+       &sensor_dev_attr_in1_alarm.dev_attr.attr,
+       &sensor_dev_attr_in2_input.dev_attr.attr,
+       &sensor_dev_attr_in2_min.dev_attr.attr,
+       &sensor_dev_attr_in2_max.dev_attr.attr,
+       &sensor_dev_attr_in2_alarm.dev_attr.attr,
+       &sensor_dev_attr_in3_input.dev_attr.attr,
+       &sensor_dev_attr_in3_min.dev_attr.attr,
+       &sensor_dev_attr_in3_max.dev_attr.attr,
+       &sensor_dev_attr_in3_alarm.dev_attr.attr,
+       &sensor_dev_attr_in4_input.dev_attr.attr,
+       &sensor_dev_attr_in4_min.dev_attr.attr,
+       &sensor_dev_attr_in4_max.dev_attr.attr,
+       &sensor_dev_attr_in4_alarm.dev_attr.attr,
+       &sensor_dev_attr_in5_input.dev_attr.attr,
+       &sensor_dev_attr_in5_min.dev_attr.attr,
+       &sensor_dev_attr_in5_max.dev_attr.attr,
+       &sensor_dev_attr_in5_alarm.dev_attr.attr,
+       &sensor_dev_attr_in6_input.dev_attr.attr,
+       &sensor_dev_attr_in6_min.dev_attr.attr,
+       &sensor_dev_attr_in6_max.dev_attr.attr,
+       &sensor_dev_attr_in6_alarm.dev_attr.attr,
        /* Temperatures */
-       SENSOR_DEV_ATTR_TEMP(1),
-       SENSOR_DEV_ATTR_TEMP(2),
-       SENSOR_DEV_ATTR_TEMP(3),
+       &sensor_dev_attr_temp1_input.dev_attr.attr,
+       &sensor_dev_attr_temp1_min.dev_attr.attr,
+       &sensor_dev_attr_temp1_max.dev_attr.attr,
+       &sensor_dev_attr_temp1_alarm.dev_attr.attr,
+       &sensor_dev_attr_temp1_fault.dev_attr.attr,
+       &sensor_dev_attr_temp1_offset.dev_attr.attr,
+       &sensor_dev_attr_temp2_input.dev_attr.attr,
+       &sensor_dev_attr_temp2_min.dev_attr.attr,
+       &sensor_dev_attr_temp2_max.dev_attr.attr,
+       &sensor_dev_attr_temp2_alarm.dev_attr.attr,
+       &sensor_dev_attr_temp2_fault.dev_attr.attr,
+       &sensor_dev_attr_temp2_offset.dev_attr.attr,
+       &sensor_dev_attr_temp3_input.dev_attr.attr,
+       &sensor_dev_attr_temp3_min.dev_attr.attr,
+       &sensor_dev_attr_temp3_max.dev_attr.attr,
+       &sensor_dev_attr_temp3_alarm.dev_attr.attr,
+       &sensor_dev_attr_temp3_fault.dev_attr.attr,
+       &sensor_dev_attr_temp3_offset.dev_attr.attr,
        /* Zones */
-       SENSOR_DEV_ATTR_ZONE(1),
-       SENSOR_DEV_ATTR_ZONE(2),
-       SENSOR_DEV_ATTR_ZONE(3),
+       &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
+       &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
+       &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
+       &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
+       &sensor_dev_attr_zone1_auto_channels_temp.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr,
        /* Misc */
        &dev_attr_vrm.attr,
        &dev_attr_cpu0_vid.attr,
@@ -1616,23 +1613,48 @@ static const struct attribute_group dme1737_group = {
  * Their creation depends on the chip configuration which is determined during
  * module load. */
 static struct attribute *dme1737_attr_pwm1[] = {
-       SENSOR_DEV_ATTR_PWM_1TO3(1),
+       &sensor_dev_attr_pwm1.dev_attr.attr,
+       &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
+       &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
+       &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
+       &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
+       &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm2[] = {
-       SENSOR_DEV_ATTR_PWM_1TO3(2),
+       &sensor_dev_attr_pwm2.dev_attr.attr,
+       &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
+       &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
+       &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
+       &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
+       &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm3[] = {
-       SENSOR_DEV_ATTR_PWM_1TO3(3),
+       &sensor_dev_attr_pwm3.dev_attr.attr,
+       &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
+       &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
+       &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
+       &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
+       &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm5[] = {
-       SENSOR_DEV_ATTR_PWM_5TO6(5),
+       &sensor_dev_attr_pwm5.dev_attr.attr,
+       &sensor_dev_attr_pwm5_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm5_enable.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm6[] = {
-       SENSOR_DEV_ATTR_PWM_5TO6(6),
+       &sensor_dev_attr_pwm6.dev_attr.attr,
+       &sensor_dev_attr_pwm6_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm6_enable.dev_attr.attr,
        NULL
 };
 
@@ -1649,27 +1671,45 @@ static const struct attribute_group dme1737_pwm_group[] = {
  * Their creation depends on the chip configuration which is determined during
  * module load. */
 static struct attribute *dme1737_attr_fan1[] = {
-       SENSOR_DEV_ATTR_FAN_1TO4(1),
+       &sensor_dev_attr_fan1_input.dev_attr.attr,
+       &sensor_dev_attr_fan1_min.dev_attr.attr,
+       &sensor_dev_attr_fan1_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan1_type.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_fan2[] = {
-       SENSOR_DEV_ATTR_FAN_1TO4(2),
+       &sensor_dev_attr_fan2_input.dev_attr.attr,
+       &sensor_dev_attr_fan2_min.dev_attr.attr,
+       &sensor_dev_attr_fan2_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan2_type.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_fan3[] = {
-       SENSOR_DEV_ATTR_FAN_1TO4(3),
+       &sensor_dev_attr_fan3_input.dev_attr.attr,
+       &sensor_dev_attr_fan3_min.dev_attr.attr,
+       &sensor_dev_attr_fan3_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan3_type.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_fan4[] = {
-       SENSOR_DEV_ATTR_FAN_1TO4(4),
+       &sensor_dev_attr_fan4_input.dev_attr.attr,
+       &sensor_dev_attr_fan4_min.dev_attr.attr,
+       &sensor_dev_attr_fan4_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan4_type.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_fan5[] = {
-       SENSOR_DEV_ATTR_FAN_5TO6(5),
+       &sensor_dev_attr_fan5_input.dev_attr.attr,
+       &sensor_dev_attr_fan5_min.dev_attr.attr,
+       &sensor_dev_attr_fan5_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan5_max.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_fan6[] = {
-       SENSOR_DEV_ATTR_FAN_5TO6(6),
+       &sensor_dev_attr_fan6_input.dev_attr.attr,
+       &sensor_dev_attr_fan6_min.dev_attr.attr,
+       &sensor_dev_attr_fan6_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan6_max.dev_attr.attr,
        NULL
 };
 
@@ -1686,13 +1726,22 @@ static const struct attribute_group dme1737_fan_group[] = {
  * writeable if the chip is *not* locked. Otherwise they stay read-only. */
 static struct attribute *dme1737_attr_lock[] = {
        /* Temperatures */
-       SENSOR_DEV_ATTR_TEMP_LOCK(1),
-       SENSOR_DEV_ATTR_TEMP_LOCK(2),
-       SENSOR_DEV_ATTR_TEMP_LOCK(3),
+       &sensor_dev_attr_temp1_offset.dev_attr.attr,
+       &sensor_dev_attr_temp2_offset.dev_attr.attr,
+       &sensor_dev_attr_temp3_offset.dev_attr.attr,
        /* Zones */
-       SENSOR_DEV_ATTR_ZONE_LOCK(1),
-       SENSOR_DEV_ATTR_ZONE_LOCK(2),
-       SENSOR_DEV_ATTR_ZONE_LOCK(3),
+       &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
+       &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
+       &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
+       &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
+       &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
+       &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
        NULL
 };
 
@@ -1704,23 +1753,40 @@ static const struct attribute_group dme1737_lock_group = {
  * writeable if the chip is *not* locked and the respective PWM is available.
  * Otherwise they stay read-only. */
 static struct attribute *dme1737_attr_pwm1_lock[] = {
-       SENSOR_DEV_ATTR_PWM_1TO3_LOCK(1),
+       &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
+       &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
+       &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
+       &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm2_lock[] = {
-       SENSOR_DEV_ATTR_PWM_1TO3_LOCK(2),
+       &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
+       &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
+       &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
+       &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm3_lock[] = {
-       SENSOR_DEV_ATTR_PWM_1TO3_LOCK(3),
+       &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+       &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
+       &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
+       &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
+       &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm5_lock[] = {
-       SENSOR_DEV_ATTR_PWM_5TO6_LOCK(5),
+       &sensor_dev_attr_pwm5.dev_attr.attr,
+       &sensor_dev_attr_pwm5_freq.dev_attr.attr,
        NULL
 };
 static struct attribute *dme1737_attr_pwm6_lock[] = {
-       SENSOR_DEV_ATTR_PWM_5TO6_LOCK(6),
+       &sensor_dev_attr_pwm6.dev_attr.attr,
+       &sensor_dev_attr_pwm6_freq.dev_attr.attr,
        NULL
 };
 
@@ -2109,6 +2175,7 @@ static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
 
        kind = dme1737;
        name = "dme1737";
+       data->type = kind;
 
        /* Fill in the remaining client fields and put it into the global
         * list */
@@ -2301,6 +2368,7 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
                err = -ENODEV;
                goto exit_kfree;
        }
+       data->type = -1;
 
        /* Fill in the remaining client fields and initialize the mutex */
        strlcpy(client->name, "sch311x", I2C_NAME_SIZE);
@@ -2377,7 +2445,10 @@ static int __init dme1737_init(void)
        }
 
        if (dme1737_isa_detect(0x2e, &addr) &&
-           dme1737_isa_detect(0x4e, &addr)) {
+           dme1737_isa_detect(0x4e, &addr) &&
+           (!probe_all_addr ||
+            (dme1737_isa_detect(0x162e, &addr) &&
+             dme1737_isa_detect(0x164e, &addr)))) {
                /* Return 0 if we didn't find an ISA device */
                return 0;
        }
index de698dc..7880c27 100644 (file)
 #include "lm75.h"
 
 
-/* Addresses to scan */
+/*
+ * This driver handles the LM75 and compatible digital temperature sensors.
+ * Only types which are _not_ listed in I2C_CLIENT_INSMOD_*() need to be
+ * listed here.  We start at 9 since I2C_CLIENT_INSMOD_*() currently allow
+ * definition of up to 8 chip types (plus zero).
+ */
+
+enum lm75_type {               /* keep sorted in alphabetical order */
+       ds1775 = 9,
+       ds75,
+       /* lm75 -- in I2C_CLIENT_INSMOD_1() */
+       lm75a,
+       max6625,
+       max6626,
+       mcp980x,
+       stds75,
+       tcn75,
+       tmp100,
+       tmp101,
+       tmp175,
+       tmp275,
+       tmp75,
+};
+
+/* Addresses scanned by legacy style driver binding */
 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
                                        0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
 
-/* Insmod parameters */
+/* Insmod parameters (only for legacy style driver binding) */
 I2C_CLIENT_INSMOD_1(lm75);
 
-/* Many LM75 constants specified below */
 
 /* The LM75 registers */
 #define LM75_REG_CONF          0x01
@@ -49,10 +72,11 @@ static const u8 LM75_REG_TEMP[3] = {
 
 /* Each client has this additional data */
 struct lm75_data {
-       struct i2c_client       client;
-       struct device *hwmon_dev;
+       struct i2c_client       *client;
+       struct device           *hwmon_dev;
        struct mutex            update_lock;
-       char                    valid;          /* !=0 if following fields are valid */
+       u8                      orig_conf;
+       char                    valid;          /* !=0 if registers are valid */
        unsigned long           last_updated;   /* In jiffies */
        u16                     temp[3];        /* Register values,
                                                   0 = input
@@ -60,23 +84,14 @@ struct lm75_data {
                                                   2 = hyst */
 };
 
-static int lm75_attach_adapter(struct i2c_adapter *adapter);
-static int lm75_detect(struct i2c_adapter *adapter, int address, int kind);
-static void lm75_init_client(struct i2c_client *client);
-static int lm75_detach_client(struct i2c_client *client);
 static int lm75_read_value(struct i2c_client *client, u8 reg);
 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
 static struct lm75_data *lm75_update_device(struct device *dev);
 
 
-/* This is the driver that will be inserted */
-static struct i2c_driver lm75_driver = {
-       .driver = {
-               .name   = "lm75",
-       },
-       .attach_adapter = lm75_attach_adapter,
-       .detach_client  = lm75_detach_client,
-};
+/*-----------------------------------------------------------------------*/
+
+/* sysfs attributes for hwmon */
 
 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
                         char *buf)
@@ -109,13 +124,6 @@ static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
                        show_temp, set_temp, 2);
 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 
-static int lm75_attach_adapter(struct i2c_adapter *adapter)
-{
-       if (!(adapter->class & I2C_CLASS_HWMON))
-               return 0;
-       return i2c_probe(adapter, &addr_data, lm75_detect);
-}
-
 static struct attribute *lm75_attributes[] = {
        &sensor_dev_attr_temp1_input.dev_attr.attr,
        &sensor_dev_attr_temp1_max.dev_attr.attr,
@@ -128,32 +136,144 @@ static const struct attribute_group lm75_group = {
        .attrs = lm75_attributes,
 };
 
+/*-----------------------------------------------------------------------*/
+
+/* "New style" I2C driver binding -- following the driver model */
+
+static int
+lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+       struct lm75_data *data;
+       int status;
+       u8 set_mask, clr_mask;
+       int new;
+
+       if (!i2c_check_functionality(client->adapter,
+                       I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
+               return -EIO;
+
+       data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
+       if (!data)
+               return -ENOMEM;
+
+       i2c_set_clientdata(client, data);
+
+       data->client = client;
+       mutex_init(&data->update_lock);
+
+       /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
+        * Then tweak to be more precise when appropriate.
+        */
+       set_mask = 0;
+       clr_mask = (1 << 0)                     /* continuous conversions */
+               | (1 << 6) | (1 << 5);          /* 9-bit mode */
+
+       /* configure as specified */
+       status = lm75_read_value(client, LM75_REG_CONF);
+       if (status < 0) {
+               dev_dbg(&client->dev, "Can't read config? %d\n", status);
+               goto exit_free;
+       }
+       data->orig_conf = status;
+       new = status & ~clr_mask;
+       new |= set_mask;
+       if (status != new)
+               lm75_write_value(client, LM75_REG_CONF, new);
+       dev_dbg(&client->dev, "Config %02x\n", new);
+
+       /* Register sysfs hooks */
+       status = sysfs_create_group(&client->dev.kobj, &lm75_group);
+       if (status)
+               goto exit_free;
+
+       data->hwmon_dev = hwmon_device_register(&client->dev);
+       if (IS_ERR(data->hwmon_dev)) {
+               status = PTR_ERR(data->hwmon_dev);
+               goto exit_remove;
+       }
+
+       dev_info(&client->dev, "%s: sensor '%s'\n",
+               data->hwmon_dev->bus_id, client->name);
+
+       return 0;
+
+exit_remove:
+       sysfs_remove_group(&client->dev.kobj, &lm75_group);
+exit_free:
+       i2c_set_clientdata(client, NULL);
+       kfree(data);
+       return status;
+}
+
+static int lm75_remove(struct i2c_client *client)
+{
+       struct lm75_data *data = i2c_get_clientdata(client);
+
+       hwmon_device_unregister(data->hwmon_dev);
+       sysfs_remove_group(&client->dev.kobj, &lm75_group);
+       lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
+       i2c_set_clientdata(client, NULL);
+       kfree(data);
+       return 0;
+}
+
+static const struct i2c_device_id lm75_ids[] = {
+       { "ds1775", ds1775, },
+       { "ds75", ds75, },
+       { "lm75", lm75, },
+       { "lm75a", lm75a, },
+       { "max6625", max6625, },
+       { "max6626", max6626, },
+       { "mcp980x", mcp980x, },
+       { "stds75", stds75, },
+       { "tcn75", tcn75, },
+       { "tmp100", tmp100, },
+       { "tmp101", tmp101, },
+       { "tmp175", tmp175, },
+       { "tmp275", tmp275, },
+       { "tmp75", tmp75, },
+       { /* LIST END */ }
+};
+MODULE_DEVICE_TABLE(i2c, lm75_ids);
+
+static struct i2c_driver lm75_driver = {
+       .driver = {
+               .name   = "lm75",
+       },
+       .probe          = lm75_probe,
+       .remove         = lm75_remove,
+       .id_table       = lm75_ids,
+};
+
+/*-----------------------------------------------------------------------*/
+
+/* "Legacy" I2C driver binding */
+
+static struct i2c_driver lm75_legacy_driver;
+
 /* This function is called by i2c_probe */
 static int lm75_detect(struct i2c_adapter *adapter, int address, int kind)
 {
        int i;
        struct i2c_client *new_client;
-       struct lm75_data *data;
        int err = 0;
-       const char *name = "";
 
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
                                     I2C_FUNC_SMBUS_WORD_DATA))
                goto exit;
 
-       /* OK. For now, we presume we have a valid client. We now create the
-          client structure, even though we cannot fill it completely yet.
-          But it allows us to access lm75_{read,write}_value. */
-       if (!(data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL))) {
+       /* OK. For now, we presume we have a valid address. We create the
+          client structure, even though there may be no sensor present.
+          But it allows us to use i2c_smbus_read_*_data() calls. */
+       new_client = kzalloc(sizeof *new_client, GFP_KERNEL);
+       if (!new_client) {
                err = -ENOMEM;
                goto exit;
        }
 
-       new_client = &data->client;
-       i2c_set_clientdata(new_client, data);
        new_client->addr = address;
        new_client->adapter = adapter;
-       new_client->driver = &lm75_driver;
+       new_client->driver = &lm75_legacy_driver;
        new_client->flags = 0;
 
        /* Now, we do the remaining detection. There is no identification-
@@ -174,17 +294,17 @@ static int lm75_detect(struct i2c_adapter *adapter, int address, int kind)
                 || i2c_smbus_read_word_data(new_client, 5) != hyst
                 || i2c_smbus_read_word_data(new_client, 6) != hyst
                 || i2c_smbus_read_word_data(new_client, 7) != hyst)
-                       goto exit_free;
+                       goto exit_free;
                os = i2c_smbus_read_word_data(new_client, 3);
                if (i2c_smbus_read_word_data(new_client, 4) != os
                 || i2c_smbus_read_word_data(new_client, 5) != os
                 || i2c_smbus_read_word_data(new_client, 6) != os
                 || i2c_smbus_read_word_data(new_client, 7) != os)
-                       goto exit_free;
+                       goto exit_free;
 
                /* Unused bits */
                if (conf & 0xe0)
-                       goto exit_free;
+                       goto exit_free;
 
                /* Addresses cycling */
                for (i = 8; i < 0xff; i += 8)
@@ -194,58 +314,57 @@ static int lm75_detect(struct i2c_adapter *adapter, int address, int kind)
                                goto exit_free;
        }
 
-       /* Determine the chip type - only one kind supported! */
-       if (kind <= 0)
-               kind = lm75;
-
-       if (kind == lm75) {
-               name = "lm75";
-       }
-
-       /* Fill in the remaining client fields and put it into the global list */
-       strlcpy(new_client->name, name, I2C_NAME_SIZE);
-       data->valid = 0;
-       mutex_init(&data->update_lock);
+       /* NOTE: we treat "force=..." and "force_lm75=..." the same.
+        * Only new-style driver binding distinguishes chip types.
+        */
+       strlcpy(new_client->name, "lm75", I2C_NAME_SIZE);
 
        /* Tell the I2C layer a new client has arrived */
-       if ((err = i2c_attach_client(new_client)))
+       err = i2c_attach_client(new_client);
+       if (err)
                goto exit_free;
 
-       /* Initialize the LM75 chip */
-       lm75_init_client(new_client);
-       
-       /* Register sysfs hooks */
-       if ((err = sysfs_create_group(&new_client->dev.kobj, &lm75_group)))
+       err = lm75_probe(new_client, NULL);
+       if (err < 0)
                goto exit_detach;
 
-       data->hwmon_dev = hwmon_device_register(&new_client->dev);
-       if (IS_ERR(data->hwmon_dev)) {
-               err = PTR_ERR(data->hwmon_dev);
-               goto exit_remove;
-       }
-
        return 0;
 
-exit_remove:
-       sysfs_remove_group(&new_client->dev.kobj, &lm75_group);
 exit_detach:
        i2c_detach_client(new_client);
 exit_free:
-       kfree(data);
+       kfree(new_client);
 exit:
        return err;
 }
 
+static int lm75_attach_adapter(struct i2c_adapter *adapter)
+{
+       if (!(adapter->class & I2C_CLASS_HWMON))
+               return 0;
+       return i2c_probe(adapter, &addr_data, lm75_detect);
+}
+
 static int lm75_detach_client(struct i2c_client *client)
 {
-       struct lm75_data *data = i2c_get_clientdata(client);
-       hwmon_device_unregister(data->hwmon_dev);
-       sysfs_remove_group(&client->dev.kobj, &lm75_group);
+       lm75_remove(client);
        i2c_detach_client(client);
-       kfree(data);
+       kfree(client);
        return 0;
 }
 
+static struct i2c_driver lm75_legacy_driver = {
+       .driver = {
+               .name   = "lm75_legacy",
+       },
+       .attach_adapter = lm75_attach_adapter,
+       .detach_client  = lm75_detach_client,
+};
+
+/*-----------------------------------------------------------------------*/
+
+/* register access */
+
 /* All registers are word-sized, except for the configuration register.
    LM75 uses a high-byte first convention, which is exactly opposite to
    the SMBus standard. */
@@ -268,16 +387,6 @@ static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
                return i2c_smbus_write_word_data(client, reg, swab16(value));
 }
 
-static void lm75_init_client(struct i2c_client *client)
-{
-       int reg;
-
-       /* Enable if in shutdown mode */
-       reg = lm75_read_value(client, LM75_REG_CONF);
-       if (reg >= 0 && (reg & 0x01))
-               lm75_write_value(client, LM75_REG_CONF, reg & 0xfe);
-}
-
 static struct lm75_data *lm75_update_device(struct device *dev)
 {
        struct i2c_client *client = to_i2c_client(dev);
@@ -309,13 +418,28 @@ static struct lm75_data *lm75_update_device(struct device *dev)
        return data;
 }
 
+/*-----------------------------------------------------------------------*/
+
+/* module glue */
+
 static int __init sensors_lm75_init(void)
 {
-       return i2c_add_driver(&lm75_driver);
+       int status;
+
+       status = i2c_add_driver(&lm75_driver);
+       if (status < 0)
+               return status;
+
+       status = i2c_add_driver(&lm75_legacy_driver);
+       if (status < 0)
+               i2c_del_driver(&lm75_driver);
+
+       return status;
 }
 
 static void __exit sensors_lm75_exit(void)
 {
+       i2c_del_driver(&lm75_legacy_driver);
        i2c_del_driver(&lm75_driver);
 }
 
index ee5eca1..12d446f 100644 (file)
@@ -1,7 +1,7 @@
 /*
     lm85.c - Part of lm_sensors, Linux kernel modules for hardware
              monitoring
-    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> 
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
     Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
     Copyright (c) 2003        Margit Schubert-While <margitsw@t-online.de>
     Copyright (c) 2004        Justin Thiessen <jthiessen@penguincomputing.com>
@@ -51,24 +51,17 @@ I2C_CLIENT_INSMOD_6(lm85b, lm85c, adm1027, adt7463, emc6d100, emc6d102);
 #define        LM85_REG_TEMP_MAX(nr)           (0x4f + (nr) * 2)
 
 /* Fan speeds are LSB, MSB (2 bytes) */
-#define        LM85_REG_FAN(nr)                (0x28 + (nr) *2)
-#define        LM85_REG_FAN_MIN(nr)            (0x54 + (nr) *2)
+#define        LM85_REG_FAN(nr)                (0x28 + (nr) * 2)
+#define        LM85_REG_FAN_MIN(nr)            (0x54 + (nr) * 2)
 
 #define        LM85_REG_PWM(nr)                (0x30 + (nr))
 
-#define        ADT7463_REG_OPPOINT(nr)         (0x33 + (nr))
-
-#define        ADT7463_REG_TMIN_CTL1           0x36
-#define        ADT7463_REG_TMIN_CTL2           0x37
-
-#define        LM85_REG_DEVICE                 0x3d
 #define        LM85_REG_COMPANY                0x3e
 #define        LM85_REG_VERSTEP                0x3f
 /* These are the recognized values for the above regs */
-#define        LM85_DEVICE_ADX                 0x27
 #define        LM85_COMPANY_NATIONAL           0x01
 #define        LM85_COMPANY_ANALOG_DEV         0x41
-#define        LM85_COMPANY_SMSC               0x5c
+#define        LM85_COMPANY_SMSC               0x5c
 #define        LM85_VERSTEP_VMASK              0xf0
 #define        LM85_VERSTEP_GENERIC            0x60
 #define        LM85_VERSTEP_LM85C              0x60
@@ -91,58 +84,45 @@ I2C_CLIENT_INSMOD_6(lm85b, lm85c, adm1027, adt7463, emc6d100, emc6d102);
 #define        LM85_REG_AFAN_CONFIG(nr)        (0x5c + (nr))
 #define        LM85_REG_AFAN_RANGE(nr)         (0x5f + (nr))
 #define        LM85_REG_AFAN_SPIKE1            0x62
-#define        LM85_REG_AFAN_SPIKE2            0x63
 #define        LM85_REG_AFAN_MINPWM(nr)        (0x64 + (nr))
 #define        LM85_REG_AFAN_LIMIT(nr)         (0x67 + (nr))
 #define        LM85_REG_AFAN_CRITICAL(nr)      (0x6a + (nr))
 #define        LM85_REG_AFAN_HYST1             0x6d
 #define        LM85_REG_AFAN_HYST2             0x6e
 
-#define        LM85_REG_TACH_MODE              0x74
-#define        LM85_REG_SPINUP_CTL             0x75
-
-#define        ADM1027_REG_TEMP_OFFSET(nr)     (0x70 + (nr))
-#define        ADM1027_REG_CONFIG2             0x73
-#define        ADM1027_REG_INTMASK1            0x74
-#define        ADM1027_REG_INTMASK2            0x75
 #define        ADM1027_REG_EXTEND_ADC1         0x76
 #define        ADM1027_REG_EXTEND_ADC2         0x77
-#define        ADM1027_REG_CONFIG3             0x78
-#define        ADM1027_REG_FAN_PPR             0x7b
-
-#define        ADT7463_REG_THERM               0x79
-#define        ADT7463_REG_THERM_LIMIT         0x7A
 
 #define EMC6D100_REG_ALARM3             0x7d
 /* IN5, IN6 and IN7 */
-#define        EMC6D100_REG_IN(nr)             (0x70 + ((nr)-5))
-#define        EMC6D100_REG_IN_MIN(nr)         (0x73 + ((nr)-5) * 2)
-#define        EMC6D100_REG_IN_MAX(nr)         (0x74 + ((nr)-5) * 2)
+#define        EMC6D100_REG_IN(nr)             (0x70 + ((nr) - 5))
+#define        EMC6D100_REG_IN_MIN(nr)         (0x73 + ((nr) - 5) * 2)
+#define        EMC6D100_REG_IN_MAX(nr)         (0x74 + ((nr) - 5) * 2)
 #define        EMC6D102_REG_EXTEND_ADC1        0x85
 #define        EMC6D102_REG_EXTEND_ADC2        0x86
 #define        EMC6D102_REG_EXTEND_ADC3        0x87
 #define        EMC6D102_REG_EXTEND_ADC4        0x88
 
 
-/* Conversions. Rounding and limit checking is only done on the TO_REG 
+/* Conversions. Rounding and limit checking is only done on the TO_REG
    variants. Note that you should be a bit careful with which arguments
    these macros are called: arguments may be evaluated more than once.
  */
 
 /* IN are scaled acording to built-in resistors */
-static int lm85_scaling[] = {  /* .001 Volts */
-               2500, 2250, 3300, 5000, 12000,
-               3300, 1500, 1800 /*EMC6D100*/
-       };
-#define SCALE(val,from,to)             (((val)*(to) + ((from)/2))/(from))
+static const int lm85_scaling[] = {  /* .001 Volts */
+       2500, 2250, 3300, 5000, 12000,
+       3300, 1500, 1800 /*EMC6D100*/
+};
+#define SCALE(val, from, to)   (((val) * (to) + ((from) / 2)) / (from))
 
-#define INS_TO_REG(n,val)      \
-               SENSORS_LIMIT(SCALE(val,lm85_scaling[n],192),0,255)
+#define INS_TO_REG(n, val)     \
+               SENSORS_LIMIT(SCALE(val, lm85_scaling[n], 192), 0, 255)
 
-#define INSEXT_FROM_REG(n,val,ext)     \
+#define INSEXT_FROM_REG(n, val, ext)   \
                SCALE(((val) << 4) + (ext), 192 << 4, lm85_scaling[n])
 
-#define INS_FROM_REG(n,val)    SCALE((val), 192, lm85_scaling[n])
+#define INS_FROM_REG(n, val)   SCALE((val), 192, lm85_scaling[n])
 
 /* FAN speed is measured using 90kHz clock */
 static inline u16 FAN_TO_REG(unsigned long val)
@@ -151,16 +131,17 @@ static inline u16 FAN_TO_REG(unsigned long val)
                return 0xffff;
        return SENSORS_LIMIT(5400000 / val, 1, 0xfffe);
 }
-#define FAN_FROM_REG(val)      ((val)==0?-1:(val)==0xffff?0:5400000/(val))
+#define FAN_FROM_REG(val)      ((val) == 0 ? -1 : (val) == 0xffff ? 0 : \
+                                5400000 / (val))
 
 /* Temperature is reported in .001 degC increments */
 #define TEMP_TO_REG(val)       \
-               SENSORS_LIMIT(SCALE(val,1000,1),-127,127)
-#define TEMPEXT_FROM_REG(val,ext)      \
+               SENSORS_LIMIT(SCALE(val, 1000, 1), -127, 127)
+#define TEMPEXT_FROM_REG(val, ext)     \
                SCALE(((val) << 4) + (ext), 16, 1000)
 #define TEMP_FROM_REG(val)     ((val) * 1000)
 
-#define PWM_TO_REG(val)                        (SENSORS_LIMIT(val,0,255))
+#define PWM_TO_REG(val)                        SENSORS_LIMIT(val, 0, 255)
 #define PWM_FROM_REG(val)              (val)
 
 
@@ -183,17 +164,17 @@ static inline u16 FAN_TO_REG(unsigned long val)
  */
 
 /* These are the zone temperature range encodings in .001 degree C */
-static int lm85_range_map[] = {   
-               2000,  2500,  3300,  4000,  5000,  6600,
-               8000, 10000, 13300, 16000, 20000, 26600,
-               32000, 40000, 53300, 80000
-       };
-static int RANGE_TO_REG( int range )
+static const int lm85_range_map[] = {
+       2000, 2500, 3300, 4000, 5000, 6600, 8000, 10000,
+       13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000
+};
+
+static int RANGE_TO_REG(int range)
 {
        int i;
 
        if (range >= lm85_range_map[15])
-               return 15 ;
+               return 15;
 
        /* Find the closest match */
        for (i = 14; i >= 0; --i) {
@@ -207,28 +188,25 @@ static int RANGE_TO_REG( int range )
 
        return 0;
 }
-#define RANGE_FROM_REG(val) (lm85_range_map[(val)&0x0f])
+#define RANGE_FROM_REG(val)    lm85_range_map[(val) & 0x0f]
 
-/* These are the Acoustic Enhancement, or Temperature smoothing encodings
- * NOTE: The enable/disable bit is INCLUDED in these encodings as the
- *       MSB (bit 3, value 8).  If the enable bit is 0, the encoded value
- *       is ignored, or set to 0.
- */
 /* These are the PWM frequency encodings */
-static int lm85_freq_map[] = { /* .1 Hz */
-               100, 150, 230, 300, 380, 470, 620, 940
-       };
-static int FREQ_TO_REG( int freq )
+static const int lm85_freq_map[] = { /* .1 Hz */
+       100, 150, 230, 300, 380, 470, 620, 940
+};
+
+static int FREQ_TO_REG(int freq)
 {
        int i;
 
-       if( freq >= lm85_freq_map[7] ) { return 7 ; }
-       for( i = 0 ; i < 7 ; ++i )
-               if( freq <= lm85_freq_map[i] )
-                       break ;
-       return( i & 0x07 );
+       if (freq >= lm85_freq_map[7])
+               return 7;
+       for (i = 0; i < 7; ++i)
+               if (freq <= lm85_freq_map[i])
+                       break;
+       return i;
 }
-#define FREQ_FROM_REG(val) (lm85_freq_map[(val)&0x07])
+#define FREQ_FROM_REG(val)     lm85_freq_map[(val) & 0x07]
 
 /* Since we can't use strings, I'm abusing these numbers
  *   to stand in for the following meanings:
@@ -242,30 +220,23 @@ static int FREQ_TO_REG( int freq )
  *     -2 -- PWM responds to manual control
  */
 
-static int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
-#define ZONE_FROM_REG(val) (lm85_zone_map[((val)>>5)&0x07])
+static const int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
+#define ZONE_FROM_REG(val)     lm85_zone_map[(val) >> 5]
 
-static int ZONE_TO_REG( int zone )
+static int ZONE_TO_REG(int zone)
 {
        int i;
 
-       for( i = 0 ; i <= 7 ; ++i )
-               if( zone == lm85_zone_map[i] )
-                       break ;
-       if( i > 7 )   /* Not found. */
+       for (i = 0; i <= 7; ++i)
+               if (zone == lm85_zone_map[i])
+                       break;
+       if (i > 7)   /* Not found. */
                i = 3;  /* Always 100% */
-       return( (i & 0x07)<<5 );
+       return i << 5;
 }
 
-#define HYST_TO_REG(val) (SENSORS_LIMIT(((val)+500)/1000,0,15))
-#define HYST_FROM_REG(val) ((val)*1000)
-
-#define OFFSET_TO_REG(val) (SENSORS_LIMIT((val)/25,-127,127))
-#define OFFSET_FROM_REG(val) ((val)*25)
-
-#define PPR_MASK(fan) (0x03<<(fan *2))
-#define PPR_TO_REG(val,fan) (SENSORS_LIMIT((val)-1,0,3)<<(fan *2))
-#define PPR_FROM_REG(val,fan) ((((val)>>(fan * 2))&0x03)+1)
+#define HYST_TO_REG(val)       SENSORS_LIMIT(((val) + 500) / 1000, 0, 15)
+#define HYST_FROM_REG(val)     ((val) * 1000)
 
 /* Chip sampling rates
  *
@@ -292,11 +263,11 @@ struct lm85_zone {
        u8 hyst;        /* Low limit hysteresis. (0-15) */
        u8 range;       /* Temp range, encoded */
        s8 critical;    /* "All fans ON" temp limit */
-       u8 off_desired; /* Actual "off" temperature specified.  Preserved 
+       u8 off_desired; /* Actual "off" temperature specified.  Preserved
                         * to prevent "drift" as other autofan control
                         * values change.
                         */
-       u8 max_desired; /* Actual "max" temperature specified.  Preserved 
+       u8 max_desired; /* Actual "max" temperature specified.  Preserved
                         * to prevent "drift" as other autofan control
                         * values change.
                         */
@@ -327,23 +298,13 @@ struct lm85_data {
        s8 temp[3];             /* Register value */
        s8 temp_min[3];         /* Register value */
        s8 temp_max[3];         /* Register value */
-       s8 temp_offset[3];      /* Register value */
        u16 fan[4];             /* Register value */
        u16 fan_min[4];         /* Register value */
        u8 pwm[3];              /* Register value */
-       u8 spinup_ctl;          /* Register encoding, combined */
-       u8 tach_mode;           /* Register encoding, combined */
        u8 temp_ext[3];         /* Decoded values */
        u8 in_ext[8];           /* Decoded values */
-       u8 fan_ppr;             /* Register value */
-       u8 smooth[3];           /* Register encoding */
        u8 vid;                 /* Register value */
        u8 vrm;                 /* VRM version */
-       u8 syncpwm3;            /* Saved PWM3 for TACH 2,3,4 config */
-       u8 oppoint[3];          /* Register value */
-       u16 tmin_ctl;           /* Register value */
-       unsigned long therm_total; /* Cummulative therm count */
-       u8 therm_limit;         /* Register value */
        u32 alarms;             /* Register encoding, combined */
        struct lm85_autofan autofan[3];
        struct lm85_zone zone[3];
@@ -355,9 +316,8 @@ static int lm85_detect(struct i2c_adapter *adapter, int address,
 static int lm85_detach_client(struct i2c_client *client);
 
 static int lm85_read_value(struct i2c_client *client, u8 reg);
-static int lm85_write_value(struct i2c_client *client, u8 reg, int value);
+static void lm85_write_value(struct i2c_client *client, u8 reg, int value);
 static struct lm85_data *lm85_update_device(struct device *dev);
-static void lm85_init_client(struct i2c_client *client);
 
 
 static struct i2c_driver lm85_driver = {
@@ -375,7 +335,7 @@ static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr]) );
+       return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr]));
 }
 
 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
@@ -383,7 +343,7 @@ static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr]) );
+       return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr]));
 }
 
 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
@@ -414,7 +374,8 @@ show_fan_offset(4);
 
 /* vid, vrm, alarms */
 
-static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr,
+               char *buf)
 {
        struct lm85_data *data = lm85_update_device(dev);
        int vid;
@@ -432,13 +393,15 @@ static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, c
 
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 
-static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr,
+               char *buf)
 {
        struct lm85_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%ld\n", (long) data->vrm);
 }
 
-static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
+               const char *buf, size_t count)
 {
        struct lm85_data *data = dev_get_drvdata(dev);
        data->vrm = simple_strtoul(buf, NULL, 10);
@@ -447,7 +410,8 @@ static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 
-static ssize_t show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_alarms_reg(struct device *dev, struct device_attribute
+               *attr, char *buf)
 {
        struct lm85_data *data = lm85_update_device(dev);
        return sprintf(buf, "%u\n", data->alarms);
@@ -488,7 +452,7 @@ static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", PWM_FROM_REG(data->pwm[nr]) );
+       return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
 }
 
 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
@@ -581,17 +545,16 @@ static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf( buf, "%d\n", INSEXT_FROM_REG(nr,
-                                                    data->in[nr],
-                                                    data->in_ext[nr]));
+       return sprintf(buf, "%d\n", INSEXT_FROM_REG(nr, data->in[nr],
+                                                   data->in_ext[nr]));
 }
 
-static ssize_t show_in_min(struct device *dev,  struct device_attribute *attr,
+static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
                char *buf)
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", INS_FROM_REG(nr, data->in_min[nr]) );
+       return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
 }
 
 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
@@ -614,7 +577,7 @@ static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", INS_FROM_REG(nr, data->in_max[nr]) );
+       return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
 }
 
 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
@@ -656,8 +619,8 @@ static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", TEMPEXT_FROM_REG(data->temp[nr],
-                                                   data->temp_ext[nr]));
+       return sprintf(buf, "%d\n", TEMPEXT_FROM_REG(data->temp[nr],
+                                                    data->temp_ext[nr]));
 }
 
 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
@@ -665,7 +628,7 @@ static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", TEMP_FROM_REG(data->temp_min[nr]) );
+       return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
 }
 
 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
@@ -688,7 +651,7 @@ static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", TEMP_FROM_REG(data->temp_max[nr]) );
+       return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
 }
 
 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
@@ -697,7 +660,7 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
        int nr = to_sensor_dev_attr(attr)->index;
        struct i2c_client *client = to_i2c_client(dev);
        struct lm85_data *data = i2c_get_clientdata(client);
-       long val = simple_strtol(buf, NULL, 10);        
+       long val = simple_strtol(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
        data->temp_max[nr] = TEMP_TO_REG(val);
@@ -726,7 +689,7 @@ static ssize_t show_pwm_auto_channels(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", ZONE_FROM_REG(data->autofan[nr].config));
+       return sprintf(buf, "%d\n", ZONE_FROM_REG(data->autofan[nr].config));
 }
 
 static ssize_t set_pwm_auto_channels(struct device *dev,
@@ -735,11 +698,11 @@ static ssize_t set_pwm_auto_channels(struct device *dev,
        int nr = to_sensor_dev_attr(attr)->index;
        struct i2c_client *client = to_i2c_client(dev);
        struct lm85_data *data = i2c_get_clientdata(client);
-       long val = simple_strtol(buf, NULL, 10);   
+       long val = simple_strtol(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
        data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))
-               | ZONE_TO_REG(val) ;
+               | ZONE_TO_REG(val);
        lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
                data->autofan[nr].config);
        mutex_unlock(&data->update_lock);
@@ -751,7 +714,7 @@ static ssize_t show_pwm_auto_pwm_min(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
+       return sprintf(buf, "%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
 }
 
 static ssize_t set_pwm_auto_pwm_min(struct device *dev,
@@ -775,7 +738,7 @@ static ssize_t show_pwm_auto_pwm_minctl(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", data->autofan[nr].min_off);
+       return sprintf(buf, "%d\n", data->autofan[nr].min_off);
 }
 
 static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
@@ -785,15 +748,15 @@ static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
        struct i2c_client *client = to_i2c_client(dev);
        struct lm85_data *data = i2c_get_clientdata(client);
        long val = simple_strtol(buf, NULL, 10);
+       u8 tmp;
 
        mutex_lock(&data->update_lock);
        data->autofan[nr].min_off = val;
-       lm85_write_value(client, LM85_REG_AFAN_SPIKE1, data->smooth[0]
-               | data->syncpwm3
-               | (data->autofan[0].min_off ? 0x20 : 0)
-               | (data->autofan[1].min_off ? 0x40 : 0)
-               | (data->autofan[2].min_off ? 0x80 : 0)
-       );
+       tmp = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
+       tmp &= ~(0x20 << nr);
+       if (data->autofan[nr].min_off)
+               tmp |= 0x20 << nr;
+       lm85_write_value(client, LM85_REG_AFAN_SPIKE1, tmp);
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -803,7 +766,7 @@ static ssize_t show_pwm_auto_pwm_freq(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", FREQ_FROM_REG(data->autofan[nr].freq));
+       return sprintf(buf, "%d\n", FREQ_FROM_REG(data->autofan[nr].freq));
 }
 
 static ssize_t set_pwm_auto_pwm_freq(struct device *dev,
@@ -818,8 +781,7 @@ static ssize_t set_pwm_auto_pwm_freq(struct device *dev,
        data->autofan[nr].freq = FREQ_TO_REG(val);
        lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
                (data->zone[nr].range << 4)
-               | data->autofan[nr].freq
-       ); 
+               | data->autofan[nr].freq);
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -849,7 +811,7 @@ static ssize_t show_temp_auto_temp_off(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
+       return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
                HYST_FROM_REG(data->zone[nr].hyst));
 }
 
@@ -866,15 +828,13 @@ static ssize_t set_temp_auto_temp_off(struct device *dev,
        min = TEMP_FROM_REG(data->zone[nr].limit);
        data->zone[nr].off_desired = TEMP_TO_REG(val);
        data->zone[nr].hyst = HYST_TO_REG(min - val);
-       if ( nr == 0 || nr == 1 ) {
+       if (nr == 0 || nr == 1) {
                lm85_write_value(client, LM85_REG_AFAN_HYST1,
                        (data->zone[0].hyst << 4)
-                       | data->zone[1].hyst
-                       );
+                       | data->zone[1].hyst);
        } else {
                lm85_write_value(client, LM85_REG_AFAN_HYST2,
-                       (data->zone[2].hyst << 4)
-               );
+                       (data->zone[2].hyst << 4));
        }
        mutex_unlock(&data->update_lock);
        return count;
@@ -885,7 +845,7 @@ static ssize_t show_temp_auto_temp_min(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) );
+       return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit));
 }
 
 static ssize_t set_temp_auto_temp_min(struct device *dev,
@@ -913,15 +873,13 @@ static ssize_t set_temp_auto_temp_min(struct device *dev,
        data->zone[nr].hyst = HYST_TO_REG(TEMP_FROM_REG(
                data->zone[nr].limit) - TEMP_FROM_REG(
                data->zone[nr].off_desired));
-       if ( nr == 0 || nr == 1 ) {
+       if (nr == 0 || nr == 1) {
                lm85_write_value(client, LM85_REG_AFAN_HYST1,
                        (data->zone[0].hyst << 4)
-                       | data->zone[1].hyst
-                       );
+                       | data->zone[1].hyst);
        } else {
                lm85_write_value(client, LM85_REG_AFAN_HYST2,
-                       (data->zone[2].hyst << 4)
-               );
+                       (data->zone[2].hyst << 4));
        }
        mutex_unlock(&data->update_lock);
        return count;
@@ -932,7 +890,7 @@ static ssize_t show_temp_auto_temp_max(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
+       return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
                RANGE_FROM_REG(data->zone[nr].range));
 }
 
@@ -962,11 +920,11 @@ static ssize_t show_temp_auto_temp_crit(struct device *dev,
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct lm85_data *data = lm85_update_device(dev);
-       return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].critical));
+       return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].critical));
 }
 
 static ssize_t set_temp_auto_temp_crit(struct device *dev,
-               struct device_attribute *attr,const char *buf, size_t count)
+               struct device_attribute *attr, const char *buf, size_t count)
 {
        int nr = to_sensor_dev_attr(attr)->index;
        struct i2c_client *client = to_i2c_client(dev);
@@ -1127,20 +1085,37 @@ static const struct attribute_group lm85_group_in567 = {
        .attrs = lm85_attributes_in567,
 };
 
+static void lm85_init_client(struct i2c_client *client)
+{
+       int value;
+
+       /* Start monitoring if needed */
+       value = lm85_read_value(client, LM85_REG_CONFIG);
+       if (!(value & 0x01)) {
+               dev_info(&client->dev, "Starting monitoring\n");
+               lm85_write_value(client, LM85_REG_CONFIG, value | 0x01);
+       }
+
+       /* Warn about unusual configuration bits */
+       if (value & 0x02)
+               dev_warn(&client->dev, "Device configuration is locked\n");
+       if (!(value & 0x04))
+               dev_warn(&client->dev, "Device is not ready\n");
+}
+
 static int lm85_detect(struct i2c_adapter *adapter, int address,
                int kind)
 {
-       int company, verstep ;
-       struct i2c_client *new_client = NULL;
+       int company, verstep;
+       struct i2c_client *client;
        struct lm85_data *data;
        int err = 0;
-       const char *type_name = "";
+       const char *type_name;
 
-       if (!i2c_check_functionality(adapter,
-                                       I2C_FUNC_SMBUS_BYTE_DATA)) {
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                /* We need to be able to do byte I/O */
-               goto ERROR0 ;
-       };
+               goto ERROR0;
+       }
 
        /* OK. For now, we presume we have a valid client. We now create the
           client structure, even though we cannot fill it completely yet.
@@ -1151,138 +1126,145 @@ static int lm85_detect(struct i2c_adapter *adapter, int address,
                goto ERROR0;
        }
 
-       new_client = &data->client;
-       i2c_set_clientdata(new_client, data);
-       new_client->addr = address;
-       new_client->adapter = adapter;
-       new_client->driver = &lm85_driver;
-       new_client->flags = 0;
+       client = &data->client;
+       i2c_set_clientdata(client, data);
+       client->addr = address;
+       client->adapter = adapter;
+       client->driver = &lm85_driver;
 
        /* Now, we do the remaining detection. */
 
-       company = lm85_read_value(new_client, LM85_REG_COMPANY);
-       verstep = lm85_read_value(new_client, LM85_REG_VERSTEP);
+       company = lm85_read_value(client, LM85_REG_COMPANY);
+       verstep = lm85_read_value(client, LM85_REG_VERSTEP);
 
        dev_dbg(&adapter->dev, "Detecting device at %d,0x%02x with"
                " COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
-               i2c_adapter_id(new_client->adapter), new_client->addr,
+               i2c_adapter_id(client->adapter), client->addr,
                company, verstep);
 
        /* If auto-detecting, Determine the chip type. */
        if (kind <= 0) {
                dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x ...\n",
-                       i2c_adapter_id(adapter), address );
-               if( company == LM85_COMPANY_NATIONAL
-                   && verstep == LM85_VERSTEP_LM85C ) {
-                       kind = lm85c ;
-               } else if( company == LM85_COMPANY_NATIONAL
-                   && verstep == LM85_VERSTEP_LM85B ) {
-                       kind = lm85b ;
-               } else if( company == LM85_COMPANY_NATIONAL
-                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC ) {
+                       i2c_adapter_id(adapter), address);
+               if (company == LM85_COMPANY_NATIONAL
+                   && verstep == LM85_VERSTEP_LM85C) {
+                       kind = lm85c;
+               } else if (company == LM85_COMPANY_NATIONAL
+                   && verstep == LM85_VERSTEP_LM85B) {
+                       kind = lm85b;
+               } else if (company == LM85_COMPANY_NATIONAL
+                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
                        dev_err(&adapter->dev, "Unrecognized version/stepping 0x%02x"
                                " Defaulting to LM85.\n", verstep);
-                       kind = any_chip ;
-               } else if( company == LM85_COMPANY_ANALOG_DEV
-                   && verstep == LM85_VERSTEP_ADM1027 ) {
-                       kind = adm1027 ;
-               } else if( company == LM85_COMPANY_ANALOG_DEV
+                       kind = any_chip;
+               } else if (company == LM85_COMPANY_ANALOG_DEV
+                   && verstep == LM85_VERSTEP_ADM1027) {
+                       kind = adm1027;
+               } else if (company == LM85_COMPANY_ANALOG_DEV
                    && (verstep == LM85_VERSTEP_ADT7463
-                        || verstep == LM85_VERSTEP_ADT7463C) ) {
-                       kind = adt7463 ;
-               } else if( company == LM85_COMPANY_ANALOG_DEV
-                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC ) {
+                        || verstep == LM85_VERSTEP_ADT7463C)) {
+                       kind = adt7463;
+               } else if (company == LM85_COMPANY_ANALOG_DEV
+                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
                        dev_err(&adapter->dev, "Unrecognized version/stepping 0x%02x"
-                               " Defaulting to Generic LM85.\n", verstep );
-                       kind = any_chip ;
-               } else if( company == LM85_COMPANY_SMSC
+                               " Defaulting to Generic LM85.\n", verstep);
+                       kind = any_chip;
+               } else if (company == LM85_COMPANY_SMSC
                    && (verstep == LM85_VERSTEP_EMC6D100_A0
-                        || verstep == LM85_VERSTEP_EMC6D100_A1) ) {
+                        || verstep == LM85_VERSTEP_EMC6D100_A1)) {
                        /* Unfortunately, we can't tell a '100 from a '101
                         * from the registers.  Since a '101 is a '100
                         * in a package with fewer pins and therefore no
                         * 3.3V, 1.5V or 1.8V inputs, perhaps if those
                         * inputs read 0, then it's a '101.
                         */
-                       kind = emc6d100 ;
-               } else if( company == LM85_COMPANY_SMSC
+                       kind = emc6d100;
+               } else if (company == LM85_COMPANY_SMSC
                    && verstep == LM85_VERSTEP_EMC6D102) {
-                       kind = emc6d102 ;
-               } else if( company == LM85_COMPANY_SMSC
+                       kind = emc6d102;
+               } else if (company == LM85_COMPANY_SMSC
                    && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
                        dev_err(&adapter->dev, "lm85: Detected SMSC chip\n");
                        dev_err(&adapter->dev, "lm85: Unrecognized version/stepping 0x%02x"
-                           " Defaulting to Generic LM85.\n", verstep );
-                       kind = any_chip ;
-               } else if( kind == any_chip
+                           " Defaulting to Generic LM85.\n", verstep);
+                       kind = any_chip;
+               } else if (kind == any_chip
                    && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
                        dev_err(&adapter->dev, "Generic LM85 Version 6 detected\n");
                        /* Leave kind as "any_chip" */
                } else {
                        dev_dbg(&adapter->dev, "Autodetection failed\n");
-                       /* Not an LM85 ... */
-                       if( kind == any_chip ) {  /* User used force=x,y */
+                       /* Not an LM85... */
+                       if (kind == any_chip) {  /* User used force=x,y */
                                dev_err(&adapter->dev, "Generic LM85 Version 6 not"
                                        " found at %d,0x%02x. Try force_lm85c.\n",
-                                       i2c_adapter_id(adapter), address );
+                                       i2c_adapter_id(adapter), address);
                        }
-                       err = 0 ;
+                       err = 0;
                        goto ERROR1;
                }
        }
 
        /* Fill in the chip specific driver values */
-       if ( kind == any_chip ) {
-               type_name = "lm85";
-       } else if ( kind == lm85b ) {
+       switch (kind) {
+       case lm85b:
                type_name = "lm85b";
-       } else if ( kind == lm85c ) {
+               break;
+       case lm85c:
                type_name = "lm85c";
-       } else if ( kind == adm1027 ) {
+               break;
+       case adm1027:
                type_name = "adm1027";
-       } else if ( kind == adt7463 ) {
+               break;
+       case adt7463:
                type_name = "adt7463";
-       } else if ( kind == emc6d100){
+               break;
+       case emc6d100:
                type_name = "emc6d100";
-       } else if ( kind == emc6d102 ) {
+               break;
+       case emc6d102:
                type_name = "emc6d102";
+               break;
+       default:
+               type_name = "lm85";
        }
-       strlcpy(new_client->name, type_name, I2C_NAME_SIZE);
+       strlcpy(client->name, type_name, I2C_NAME_SIZE);
 
        /* Fill in the remaining client fields */
        data->type = kind;
-       data->valid = 0;
        mutex_init(&data->update_lock);
 
        /* Tell the I2C layer a new client has arrived */
-       if ((err = i2c_attach_client(new_client)))
+       err = i2c_attach_client(client);
+       if (err)
                goto ERROR1;
 
        /* Set the VRM version */
        data->vrm = vid_which_vrm();
 
        /* Initialize the LM85 chip */
-       lm85_init_client(new_client);
+       lm85_init_client(client);
 
        /* Register sysfs hooks */
-       if ((err = sysfs_create_group(&new_client->dev.kobj, &lm85_group)))
+       err = sysfs_create_group(&client->dev.kobj, &lm85_group);
+       if (err)
                goto ERROR2;
 
        /* The ADT7463 has an optional VRM 10 mode where pin 21 is used
           as a sixth digital VID input rather than an analog input. */
-       data->vid = lm85_read_value(new_client, LM85_REG_VID);
+       data->vid = lm85_read_value(client, LM85_REG_VID);
        if (!(kind == adt7463 && (data->vid & 0x80)))
-               if ((err = sysfs_create_group(&new_client->dev.kobj,
+               if ((err = sysfs_create_group(&client->dev.kobj,
                                        &lm85_group_in4)))
                        goto ERROR3;
 
        /* The EMC6D100 has 3 additional voltage inputs */
        if (kind == emc6d100)
-               if ((err = sysfs_create_group(&new_client->dev.kobj,
+               if ((err = sysfs_create_group(&client->dev.kobj,
                                        &lm85_group_in567)))
                        goto ERROR3;
 
-       data->hwmon_dev = hwmon_device_register(&new_client->dev);
+       data->hwmon_dev = hwmon_device_register(&client->dev);
        if (IS_ERR(data->hwmon_dev)) {
                err = PTR_ERR(data->hwmon_dev);
                goto ERROR3;
@@ -1291,16 +1273,16 @@ static int lm85_detect(struct i2c_adapter *adapter, int address,
        return 0;
 
        /* Error out and cleanup code */
-    ERROR3:
-       sysfs_remove_group(&new_client->dev.kobj, &lm85_group);
-       sysfs_remove_group(&new_client->dev.kobj, &lm85_group_in4);
+ ERROR3:
+       sysfs_remove_group(&client->dev.kobj, &lm85_group);
+       sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
        if (kind == emc6d100)
-               sysfs_remove_group(&new_client->dev.kobj, &lm85_group_in567);
-    ERROR2:
-       i2c_detach_client(new_client);
-    ERROR1:
+               sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
+ ERROR2:
+       i2c_detach_client(client);
+ ERROR1:
        kfree(data);
-    ERROR0:
+ ERROR0:
        return err;
 }
 
@@ -1323,100 +1305,46 @@ static int lm85_read_value(struct i2c_client *client, u8 reg)
        int res;
 
        /* What size location is it? */
-       switch( reg ) {
-       case LM85_REG_FAN(0) :  /* Read WORD data */
-       case LM85_REG_FAN(1) :
-       case LM85_REG_FAN(2) :
-       case LM85_REG_FAN(3) :
-       case LM85_REG_FAN_MIN(0) :
-       case LM85_REG_FAN_MIN(1) :
-       case LM85_REG_FAN_MIN(2) :
-       case LM85_REG_FAN_MIN(3) :
-       case LM85_REG_ALARM1 :  /* Read both bytes at once */
-               res = i2c_smbus_read_byte_data(client, reg) & 0xff ;
-               res |= i2c_smbus_read_byte_data(client, reg+1) << 8 ;
-               break ;
-       case ADT7463_REG_TMIN_CTL1 :  /* Read WORD MSB, LSB */
-               res = i2c_smbus_read_byte_data(client, reg) << 8 ;
-               res |= i2c_smbus_read_byte_data(client, reg+1) & 0xff ;
-               break ;
+       switch (reg) {
+       case LM85_REG_FAN(0):  /* Read WORD data */
+       case LM85_REG_FAN(1):
+       case LM85_REG_FAN(2):
+       case LM85_REG_FAN(3):
+       case LM85_REG_FAN_MIN(0):
+       case LM85_REG_FAN_MIN(1):
+       case LM85_REG_FAN_MIN(2):
+       case LM85_REG_FAN_MIN(3):
+       case LM85_REG_ALARM1:   /* Read both bytes at once */
+               res = i2c_smbus_read_byte_data(client, reg) & 0xff;
+               res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;
+               break;
        default:        /* Read BYTE data */
                res = i2c_smbus_read_byte_data(client, reg);
-               break ;
+               break;
        }
 
-       return res ;
+       return res;
 }
 
-static int lm85_write_value(struct i2c_client *client, u8 reg, int value)
+static void lm85_write_value(struct i2c_client *client, u8 reg, int value)
 {
-       int res ;
-
-       switch( reg ) {
-       case LM85_REG_FAN(0) :  /* Write WORD data */
-       case LM85_REG_FAN(1) :
-       case LM85_REG_FAN(2) :
-       case LM85_REG_FAN(3) :
-       case LM85_REG_FAN_MIN(0) :
-       case LM85_REG_FAN_MIN(1) :
-       case LM85_REG_FAN_MIN(2) :
-       case LM85_REG_FAN_MIN(3) :
+       switch (reg) {
+       case LM85_REG_FAN(0):  /* Write WORD data */
+       case LM85_REG_FAN(1):
+       case LM85_REG_FAN(2):
+       case LM85_REG_FAN(3):
+       case LM85_REG_FAN_MIN(0):
+       case LM85_REG_FAN_MIN(1):
+       case LM85_REG_FAN_MIN(2):
+       case LM85_REG_FAN_MIN(3):
        /* NOTE: ALARM is read only, so not included here */
-               res = i2c_smbus_write_byte_data(client, reg, value & 0xff) ;
-               res |= i2c_smbus_write_byte_data(client, reg+1, (value>>8) & 0xff) ;
-               break ;
-       case ADT7463_REG_TMIN_CTL1 :  /* Write WORD MSB, LSB */
-               res = i2c_smbus_write_byte_data(client, reg, (value>>8) & 0xff);
-               res |= i2c_smbus_write_byte_data(client, reg+1, value & 0xff) ;
-               break ;
+               i2c_smbus_write_byte_data(client, reg, value & 0xff);
+               i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
+               break;
        default:        /* Write BYTE data */
-               res = i2c_smbus_write_byte_data(client, reg, value);
-               break ;
+               i2c_smbus_write_byte_data(client, reg, value);
+               break;
        }
-
-       return res ;
-}
-
-static void lm85_init_client(struct i2c_client *client)
-{
-       int value;
-       struct lm85_data *data = i2c_get_clientdata(client);
-
-       dev_dbg(&client->dev, "Initializing device\n");
-
-       /* Warn if part was not "READY" */
-       value = lm85_read_value(client, LM85_REG_CONFIG);
-       dev_dbg(&client->dev, "LM85_REG_CONFIG is: 0x%02x\n", value);
-       if( value & 0x02 ) {
-               dev_err(&client->dev, "Client (%d,0x%02x) config is locked.\n",
-                           i2c_adapter_id(client->adapter), client->addr );
-       };
-       if( ! (value & 0x04) ) {
-               dev_err(&client->dev, "Client (%d,0x%02x) is not ready.\n",
-                           i2c_adapter_id(client->adapter), client->addr );
-       };
-       if( value & 0x10
-           && ( data->type == adm1027
-               || data->type == adt7463 ) ) {
-               dev_err(&client->dev, "Client (%d,0x%02x) VxI mode is set.  "
-                       "Please report this to the lm85 maintainer.\n",
-                           i2c_adapter_id(client->adapter), client->addr );
-       };
-
-       /* WE INTENTIONALLY make no changes to the limits,
-        *   offsets, pwms, fans and zones.  If they were
-        *   configured, we don't want to mess with them.
-        *   If they weren't, the default is 100% PWM, no
-        *   control and will suffice until 'sensors -s'
-        *   can be run by the user.
-        */
-
-       /* Start monitoring */
-       value = lm85_read_value(client, LM85_REG_CONFIG);
-       /* Try to clear LOCK, Set START, save everything else */
-       value = (value & ~ 0x02) | 0x01 ;
-       dev_dbg(&client->dev, "Setting CONFIG to: 0x%02x\n", value);
-       lm85_write_value(client, LM85_REG_CONFIG, value);
 }
 
 static struct lm85_data *lm85_update_device(struct device *dev)
@@ -1427,28 +1355,30 @@ static struct lm85_data *lm85_update_device(struct device *dev)
 
        mutex_lock(&data->update_lock);
 
-       if ( !data->valid ||
-            time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL) ) {
+       if (!data->valid ||
+            time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) {
                /* Things that change quickly */
                dev_dbg(&client->dev, "Reading sensor values\n");
-               
+
                /* Have to read extended bits first to "freeze" the
                 * more significant bits that are read later.
                 * There are 2 additional resolution bits per channel and we
                 * have room for 4, so we shift them to the left.
                 */
-               if ( (data->type == adm1027) || (data->type == adt7463) ) {
+               if (data->type == adm1027 || data->type == adt7463) {
                        int ext1 = lm85_read_value(client,
                                                   ADM1027_REG_EXTEND_ADC1);
                        int ext2 =  lm85_read_value(client,
                                                    ADM1027_REG_EXTEND_ADC2);
                        int val = (ext1 << 8) + ext2;
 
-                       for(i = 0; i <= 4; i++)
-                               data->in_ext[i] = ((val>>(i * 2))&0x03) << 2;
+                       for (i = 0; i <= 4; i++)
+                               data->in_ext[i] =
+                                       ((val >> (i * 2)) & 0x03) << 2;
 
-                       for(i = 0; i <= 2; i++)
-                               data->temp_ext[i] = (val>>((i + 4) * 2))&0x0c;
+                       for (i = 0; i <= 2; i++)
+                               data->temp_ext[i] =
+                                       (val >> ((i + 4) * 2)) & 0x0c;
                }
 
                data->vid = lm85_read_value(client, LM85_REG_VID);
@@ -1456,6 +1386,8 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                for (i = 0; i <= 3; ++i) {
                        data->in[i] =
                            lm85_read_value(client, LM85_REG_IN(i));
+                       data->fan[i] =
+                           lm85_read_value(client, LM85_REG_FAN(i));
                }
 
                if (!(data->type == adt7463 && (data->vid & 0x80))) {
@@ -1463,38 +1395,25 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                                      LM85_REG_IN(4));
                }
 
-               for (i = 0; i <= 3; ++i) {
-                       data->fan[i] =
-                           lm85_read_value(client, LM85_REG_FAN(i));
-               }
-
                for (i = 0; i <= 2; ++i) {
                        data->temp[i] =
                            lm85_read_value(client, LM85_REG_TEMP(i));
-               }
-
-               for (i = 0; i <= 2; ++i) {
                        data->pwm[i] =
                            lm85_read_value(client, LM85_REG_PWM(i));
                }
 
                data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
 
-               if ( data->type == adt7463 ) {
-                       if( data->therm_total < ULONG_MAX - 256 ) {
-                           data->therm_total +=
-                               lm85_read_value(client, ADT7463_REG_THERM );
-                       }
-               } else if ( data->type == emc6d100 ) {
+               if (data->type == emc6d100) {
                        /* Three more voltage sensors */
                        for (i = 5; i <= 7; ++i) {
-                               data->in[i] =
-                                       lm85_read_value(client, EMC6D100_REG_IN(i));
+                               data->in[i] = lm85_read_value(client,
+                                                       EMC6D100_REG_IN(i));
                        }
                        /* More alarm bits */
-                       data->alarms |=
-                               lm85_read_value(client, EMC6D100_REG_ALARM3) << 16;
-               } else if (data->type == emc6d102 ) {
+                       data->alarms |= lm85_read_value(client,
+                                               EMC6D100_REG_ALARM3) << 16;
+               } else if (data->type == emc6d102) {
                        /* Have to read LSB bits after the MSB ones because
                           the reading of the MSB bits has frozen the
                           LSBs (backward from the ADM1027).
@@ -1509,20 +1428,20 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                                                   EMC6D102_REG_EXTEND_ADC4);
                        data->in_ext[0] = ext3 & 0x0f;
                        data->in_ext[1] = ext4 & 0x0f;
-                       data->in_ext[2] = (ext4 >> 4) & 0x0f;
-                       data->in_ext[3] = (ext3 >> 4) & 0x0f;
-                       data->in_ext[4] = (ext2 >> 4) & 0x0f;
+                       data->in_ext[2] = ext4 >> 4;
+                       data->in_ext[3] = ext3 >> 4;
+                       data->in_ext[4] = ext2 >> 4;
 
                        data->temp_ext[0] = ext1 & 0x0f;
                        data->temp_ext[1] = ext2 & 0x0f;
-                       data->temp_ext[2] = (ext1 >> 4) & 0x0f;
+                       data->temp_ext[2] = ext1 >> 4;
                }
 
-               data->last_reading = jiffies ;
-       };  /* last_reading */
+               data->last_reading = jiffies;
+       }  /* last_reading */
 
-       if ( !data->valid ||
-            time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL) ) {
+       if (!data->valid ||
+            time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {
                /* Things that don't change often */
                dev_dbg(&client->dev, "Reading config values\n");
 
@@ -1531,6 +1450,8 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                            lm85_read_value(client, LM85_REG_IN_MIN(i));
                        data->in_max[i] =
                            lm85_read_value(client, LM85_REG_IN_MAX(i));
+                       data->fan_min[i] =
+                           lm85_read_value(client, LM85_REG_FAN_MIN(i));
                }
 
                if (!(data->type == adt7463 && (data->vid & 0x80))) {
@@ -1540,34 +1461,28 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                                          LM85_REG_IN_MAX(4));
                }
 
-               if ( data->type == emc6d100 ) {
+               if (data->type == emc6d100) {
                        for (i = 5; i <= 7; ++i) {
-                               data->in_min[i] =
-                                       lm85_read_value(client, EMC6D100_REG_IN_MIN(i));
-                               data->in_max[i] =
-                                       lm85_read_value(client, EMC6D100_REG_IN_MAX(i));
+                               data->in_min[i] = lm85_read_value(client,
+                                               EMC6D100_REG_IN_MIN(i));
+                               data->in_max[i] = lm85_read_value(client,
+                                               EMC6D100_REG_IN_MAX(i));
                        }
                }
 
-               for (i = 0; i <= 3; ++i) {
-                       data->fan_min[i] =
-                           lm85_read_value(client, LM85_REG_FAN_MIN(i));
-               }
-
                for (i = 0; i <= 2; ++i) {
+                       int val;
+
                        data->temp_min[i] =
                            lm85_read_value(client, LM85_REG_TEMP_MIN(i));
                        data->temp_max[i] =
                            lm85_read_value(client, LM85_REG_TEMP_MAX(i));
-               }
 
-               for (i = 0; i <= 2; ++i) {
-                       int val ;
                        data->autofan[i].config =
                            lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
                        val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
-                       data->autofan[i].freq = val & 0x07 ;
-                       data->zone[i].range = (val >> 4) & 0x0f ;
+                       data->autofan[i].freq = val & 0x07;
+                       data->zone[i].range = val >> 4;
                        data->autofan[i].min_pwm =
                            lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
                        data->zone[i].limit =
@@ -1577,50 +1492,19 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                }
 
                i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
-               data->smooth[0] = i & 0x0f ;
-               data->syncpwm3 = i & 0x10 ;  /* Save PWM3 config */
-               data->autofan[0].min_off = (i & 0x20) != 0 ;
-               data->autofan[1].min_off = (i & 0x40) != 0 ;
-               data->autofan[2].min_off = (i & 0x80) != 0 ;
-               i = lm85_read_value(client, LM85_REG_AFAN_SPIKE2);
-               data->smooth[1] = (i>>4) & 0x0f ;
-               data->smooth[2] = i & 0x0f ;
+               data->autofan[0].min_off = (i & 0x20) != 0;
+               data->autofan[1].min_off = (i & 0x40) != 0;
+               data->autofan[2].min_off = (i & 0x80) != 0;
 
                i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
-               data->zone[0].hyst = (i>>4) & 0x0f ;
-               data->zone[1].hyst = i & 0x0f ;
+               data->zone[0].hyst = i >> 4;
+               data->zone[1].hyst = i & 0x0f;
 
                i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
-               data->zone[2].hyst = (i>>4) & 0x0f ;
-
-               if ( (data->type == lm85b) || (data->type == lm85c) ) {
-                       data->tach_mode = lm85_read_value(client,
-                               LM85_REG_TACH_MODE );
-                       data->spinup_ctl = lm85_read_value(client,
-                               LM85_REG_SPINUP_CTL );
-               } else if ( (data->type == adt7463) || (data->type == adm1027) ) {
-                       if ( data->type == adt7463 ) {
-                               for (i = 0; i <= 2; ++i) {
-                                   data->oppoint[i] = lm85_read_value(client,
-                                       ADT7463_REG_OPPOINT(i) );
-                               }
-                               data->tmin_ctl = lm85_read_value(client,
-                                       ADT7463_REG_TMIN_CTL1 );
-                               data->therm_limit = lm85_read_value(client,
-                                       ADT7463_REG_THERM_LIMIT );
-                       }
-                       for (i = 0; i <= 2; ++i) {
-                           data->temp_offset[i] = lm85_read_value(client,
-                               ADM1027_REG_TEMP_OFFSET(i) );
-                       }
-                       data->tach_mode = lm85_read_value(client,
-                               ADM1027_REG_CONFIG3 );
-                       data->fan_ppr = lm85_read_value(client,
-                               ADM1027_REG_FAN_PPR );
-               }
-       
+               data->zone[2].hyst = i >> 4;
+
                data->last_config = jiffies;
-       };  /* last_config */
+       }  /* last_config */
 
        data->valid = 1;
 
@@ -1635,17 +1519,15 @@ static int __init sm_lm85_init(void)
        return i2c_add_driver(&lm85_driver);
 }
 
-static void  __exit sm_lm85_exit(void)
+static void __exit sm_lm85_exit(void)
 {
        i2c_del_driver(&lm85_driver);
 }
 
-/* Thanks to Richard Barrington for adding the LM85 to sensors-detect.
- * Thanks to Margit Schubert-While <margitsw@t-online.de> for help with
- *     post 2.7.0 CVS changes.
- */
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, Margit Schubert-While <margitsw@t-online.de>, Justin Thiessen <jthiessen@penguincomputing.com");
+MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
+       "Margit Schubert-While <margitsw@t-online.de>, "
+       "Justin Thiessen <jthiessen@penguincomputing.com>");
 MODULE_DESCRIPTION("LM85-B, LM85-C driver");
 
 module_init(sm_lm85_init);