← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/hwmon/lm85.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/hwmon/lm85.c
 
1
/*
 
2
    lm85.c - Part of lm_sensors, Linux kernel modules for hardware
 
3
             monitoring
 
4
    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
 
5
    Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
 
6
    Copyright (c) 2003        Margit Schubert-While <margitsw@t-online.de>
 
7
    Copyright (c) 2004        Justin Thiessen <jthiessen@penguincomputing.com>
 
8
    Copyright (C) 2007--2009  Jean Delvare <khali@linux-fr.org>
 
9
 
 
10
    Chip details at           <http://www.national.com/ds/LM/LM85.pdf>
 
11
 
 
12
    This program is free software; you can redistribute it and/or modify
 
13
    it under the terms of the GNU General Public License as published by
 
14
    the Free Software Foundation; either version 2 of the License, or
 
15
    (at your option) any later version.
 
16
 
 
17
    This program is distributed in the hope that it will be useful,
 
18
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
    GNU General Public License for more details.
 
21
 
 
22
    You should have received a copy of the GNU General Public License
 
23
    along with this program; if not, write to the Free Software
 
24
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
25
*/
 
26
 
 
27
#include <linux/module.h>
 
28
#include <linux/init.h>
 
29
#include <linux/slab.h>
 
30
#include <linux/jiffies.h>
 
31
#include <linux/i2c.h>
 
32
#include <linux/hwmon.h>
 
33
#include <linux/hwmon-vid.h>
 
34
#include <linux/hwmon-sysfs.h>
 
35
#include <linux/err.h>
 
36
#include <linux/mutex.h>
 
37
 
 
38
/* Addresses to scan */
 
39
static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
 
40
 
 
41
enum chips {
 
42
        any_chip, lm85b, lm85c,
 
43
        adm1027, adt7463, adt7468,
 
44
        emc6d100, emc6d102, emc6d103, emc6d103s
 
45
};
 
46
 
 
47
/* The LM85 registers */
 
48
 
 
49
#define LM85_REG_IN(nr)                 (0x20 + (nr))
 
50
#define LM85_REG_IN_MIN(nr)             (0x44 + (nr) * 2)
 
51
#define LM85_REG_IN_MAX(nr)             (0x45 + (nr) * 2)
 
52
 
 
53
#define LM85_REG_TEMP(nr)               (0x25 + (nr))
 
54
#define LM85_REG_TEMP_MIN(nr)           (0x4e + (nr) * 2)
 
55
#define LM85_REG_TEMP_MAX(nr)           (0x4f + (nr) * 2)
 
56
 
 
57
/* Fan speeds are LSB, MSB (2 bytes) */
 
58
#define LM85_REG_FAN(nr)                (0x28 + (nr) * 2)
 
59
#define LM85_REG_FAN_MIN(nr)            (0x54 + (nr) * 2)
 
60
 
 
61
#define LM85_REG_PWM(nr)                (0x30 + (nr))
 
62
 
 
63
#define LM85_REG_COMPANY                0x3e
 
64
#define LM85_REG_VERSTEP                0x3f
 
65
 
 
66
#define ADT7468_REG_CFG5                0x7c
 
67
#define         ADT7468_OFF64           (1 << 0)
 
68
#define         ADT7468_HFPWM           (1 << 1)
 
69
#define IS_ADT7468_OFF64(data)          \
 
70
        ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_OFF64))
 
71
#define IS_ADT7468_HFPWM(data)          \
 
72
        ((data)->type == adt7468 && !((data)->cfg5 & ADT7468_HFPWM))
 
73
 
 
74
/* These are the recognized values for the above regs */
 
75
#define LM85_COMPANY_NATIONAL           0x01
 
76
#define LM85_COMPANY_ANALOG_DEV         0x41
 
77
#define LM85_COMPANY_SMSC               0x5c
 
78
#define LM85_VERSTEP_VMASK              0xf0
 
79
#define LM85_VERSTEP_GENERIC            0x60
 
80
#define LM85_VERSTEP_GENERIC2           0x70
 
81
#define LM85_VERSTEP_LM85C              0x60
 
82
#define LM85_VERSTEP_LM85B              0x62
 
83
#define LM85_VERSTEP_LM96000_1          0x68
 
84
#define LM85_VERSTEP_LM96000_2          0x69
 
85
#define LM85_VERSTEP_ADM1027            0x60
 
86
#define LM85_VERSTEP_ADT7463            0x62
 
87
#define LM85_VERSTEP_ADT7463C           0x6A
 
88
#define LM85_VERSTEP_ADT7468_1          0x71
 
89
#define LM85_VERSTEP_ADT7468_2          0x72
 
90
#define LM85_VERSTEP_EMC6D100_A0        0x60
 
91
#define LM85_VERSTEP_EMC6D100_A1        0x61
 
92
#define LM85_VERSTEP_EMC6D102           0x65
 
93
#define LM85_VERSTEP_EMC6D103_A0        0x68
 
94
#define LM85_VERSTEP_EMC6D103_A1        0x69
 
95
#define LM85_VERSTEP_EMC6D103S          0x6A    /* Also known as EMC6D103:A2 */
 
96
 
 
97
#define LM85_REG_CONFIG                 0x40
 
98
 
 
99
#define LM85_REG_ALARM1                 0x41
 
100
#define LM85_REG_ALARM2                 0x42
 
101
 
 
102
#define LM85_REG_VID                    0x43
 
103
 
 
104
/* Automated FAN control */
 
105
#define LM85_REG_AFAN_CONFIG(nr)        (0x5c + (nr))
 
106
#define LM85_REG_AFAN_RANGE(nr)         (0x5f + (nr))
 
107
#define LM85_REG_AFAN_SPIKE1            0x62
 
108
#define LM85_REG_AFAN_MINPWM(nr)        (0x64 + (nr))
 
109
#define LM85_REG_AFAN_LIMIT(nr)         (0x67 + (nr))
 
110
#define LM85_REG_AFAN_CRITICAL(nr)      (0x6a + (nr))
 
111
#define LM85_REG_AFAN_HYST1             0x6d
 
112
#define LM85_REG_AFAN_HYST2             0x6e
 
113
 
 
114
#define ADM1027_REG_EXTEND_ADC1         0x76
 
115
#define ADM1027_REG_EXTEND_ADC2         0x77
 
116
 
 
117
#define EMC6D100_REG_ALARM3             0x7d
 
118
/* IN5, IN6 and IN7 */
 
119
#define EMC6D100_REG_IN(nr)             (0x70 + ((nr) - 5))
 
120
#define EMC6D100_REG_IN_MIN(nr)         (0x73 + ((nr) - 5) * 2)
 
121
#define EMC6D100_REG_IN_MAX(nr)         (0x74 + ((nr) - 5) * 2)
 
122
#define EMC6D102_REG_EXTEND_ADC1        0x85
 
123
#define EMC6D102_REG_EXTEND_ADC2        0x86
 
124
#define EMC6D102_REG_EXTEND_ADC3        0x87
 
125
#define EMC6D102_REG_EXTEND_ADC4        0x88
 
126
 
 
127
 
 
128
/* Conversions. Rounding and limit checking is only done on the TO_REG
 
129
   variants. Note that you should be a bit careful with which arguments
 
130
   these macros are called: arguments may be evaluated more than once.
 
131
 */
 
132
 
 
133
/* IN are scaled according to built-in resistors */
 
134
static const int lm85_scaling[] = {  /* .001 Volts */
 
135
        2500, 2250, 3300, 5000, 12000,
 
136
        3300, 1500, 1800 /*EMC6D100*/
 
137
};
 
138
#define SCALE(val, from, to)    (((val) * (to) + ((from) / 2)) / (from))
 
139
 
 
140
#define INS_TO_REG(n, val)      \
 
141
                SENSORS_LIMIT(SCALE(val, lm85_scaling[n], 192), 0, 255)
 
142
 
 
143
#define INSEXT_FROM_REG(n, val, ext)    \
 
144
                SCALE(((val) << 4) + (ext), 192 << 4, lm85_scaling[n])
 
145
 
 
146
#define INS_FROM_REG(n, val)    SCALE((val), 192, lm85_scaling[n])
 
147
 
 
148
/* FAN speed is measured using 90kHz clock */
 
149
static inline u16 FAN_TO_REG(unsigned long val)
 
150
{
 
151
        if (!val)
 
152
                return 0xffff;
 
153
        return SENSORS_LIMIT(5400000 / val, 1, 0xfffe);
 
154
}
 
155
#define FAN_FROM_REG(val)       ((val) == 0 ? -1 : (val) == 0xffff ? 0 : \
 
156
                                 5400000 / (val))
 
157
 
 
158
/* Temperature is reported in .001 degC increments */
 
159
#define TEMP_TO_REG(val)        \
 
160
                SENSORS_LIMIT(SCALE(val, 1000, 1), -127, 127)
 
161
#define TEMPEXT_FROM_REG(val, ext)      \
 
162
                SCALE(((val) << 4) + (ext), 16, 1000)
 
163
#define TEMP_FROM_REG(val)      ((val) * 1000)
 
164
 
 
165
#define PWM_TO_REG(val)                 SENSORS_LIMIT(val, 0, 255)
 
166
#define PWM_FROM_REG(val)               (val)
 
167
 
 
168
 
 
169
/* ZONEs have the following parameters:
 
170
 *    Limit (low) temp,           1. degC
 
171
 *    Hysteresis (below limit),   1. degC (0-15)
 
172
 *    Range of speed control,     .1 degC (2-80)
 
173
 *    Critical (high) temp,       1. degC
 
174
 *
 
175
 * FAN PWMs have the following parameters:
 
176
 *    Reference Zone,                 1, 2, 3, etc.
 
177
 *    Spinup time,                    .05 sec
 
178
 *    PWM value at limit/low temp,    1 count
 
179
 *    PWM Frequency,                  1. Hz
 
180
 *    PWM is Min or OFF below limit,  flag
 
181
 *    Invert PWM output,              flag
 
182
 *
 
183
 * Some chips filter the temp, others the fan.
 
184
 *    Filter constant (or disabled)   .1 seconds
 
185
 */
 
186
 
 
187
/* These are the zone temperature range encodings in .001 degree C */
 
188
static const int lm85_range_map[] = {
 
189
        2000, 2500, 3300, 4000, 5000, 6600, 8000, 10000,
 
190
        13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000
 
191
};
 
192
 
 
193
static int RANGE_TO_REG(int range)
 
194
{
 
195
        int i;
 
196
 
 
197
        /* Find the closest match */
 
198
        for (i = 0; i < 15; ++i) {
 
199
                if (range <= (lm85_range_map[i] + lm85_range_map[i + 1]) / 2)
 
200
                        break;
 
201
        }
 
202
 
 
203
        return i;
 
204
}
 
205
#define RANGE_FROM_REG(val)     lm85_range_map[(val) & 0x0f]
 
206
 
 
207
/* These are the PWM frequency encodings */
 
208
static const int lm85_freq_map[8] = { /* 1 Hz */
 
209
        10, 15, 23, 30, 38, 47, 61, 94
 
210
};
 
211
static const int adm1027_freq_map[8] = { /* 1 Hz */
 
212
        11, 15, 22, 29, 35, 44, 59, 88
 
213
};
 
214
 
 
215
static int FREQ_TO_REG(const int *map, int freq)
 
216
{
 
217
        int i;
 
218
 
 
219
        /* Find the closest match */
 
220
        for (i = 0; i < 7; ++i)
 
221
                if (freq <= (map[i] + map[i + 1]) / 2)
 
222
                        break;
 
223
        return i;
 
224
}
 
225
 
 
226
static int FREQ_FROM_REG(const int *map, u8 reg)
 
227
{
 
228
        return map[reg & 0x07];
 
229
}
 
230
 
 
231
/* Since we can't use strings, I'm abusing these numbers
 
232
 *   to stand in for the following meanings:
 
233
 *      1 -- PWM responds to Zone 1
 
234
 *      2 -- PWM responds to Zone 2
 
235
 *      3 -- PWM responds to Zone 3
 
236
 *     23 -- PWM responds to the higher temp of Zone 2 or 3
 
237
 *    123 -- PWM responds to highest of Zone 1, 2, or 3
 
238
 *      0 -- PWM is always at 0% (ie, off)
 
239
 *     -1 -- PWM is always at 100%
 
240
 *     -2 -- PWM responds to manual control
 
241
 */
 
242
 
 
243
static const int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
 
244
#define ZONE_FROM_REG(val)      lm85_zone_map[(val) >> 5]
 
245
 
 
246
static int ZONE_TO_REG(int zone)
 
247
{
 
248
        int i;
 
249
 
 
250
        for (i = 0; i <= 7; ++i)
 
251
                if (zone == lm85_zone_map[i])
 
252
                        break;
 
253
        if (i > 7)   /* Not found. */
 
254
                i = 3;  /* Always 100% */
 
255
        return i << 5;
 
256
}
 
257
 
 
258
#define HYST_TO_REG(val)        SENSORS_LIMIT(((val) + 500) / 1000, 0, 15)
 
259
#define HYST_FROM_REG(val)      ((val) * 1000)
 
260
 
 
261
/* Chip sampling rates
 
262
 *
 
263
 * Some sensors are not updated more frequently than once per second
 
264
 *    so it doesn't make sense to read them more often than that.
 
265
 *    We cache the results and return the saved data if the driver
 
266
 *    is called again before a second has elapsed.
 
267
 *
 
268
 * Also, there is significant configuration data for this chip
 
269
 *    given the automatic PWM fan control that is possible.  There
 
270
 *    are about 47 bytes of config data to only 22 bytes of actual
 
271
 *    readings.  So, we keep the config data up to date in the cache
 
272
 *    when it is written and only sample it once every 1 *minute*
 
273
 */
 
274
#define LM85_DATA_INTERVAL  (HZ + HZ / 2)
 
275
#define LM85_CONFIG_INTERVAL  (1 * 60 * HZ)
 
276
 
 
277
/* LM85 can automatically adjust fan speeds based on temperature
 
278
 * This structure encapsulates an entire Zone config.  There are
 
279
 * three zones (one for each temperature input) on the lm85
 
280
 */
 
281
struct lm85_zone {
 
282
        s8 limit;       /* Low temp limit */
 
283
        u8 hyst;        /* Low limit hysteresis. (0-15) */
 
284
        u8 range;       /* Temp range, encoded */
 
285
        s8 critical;    /* "All fans ON" temp limit */
 
286
        u8 max_desired; /* Actual "max" temperature specified.  Preserved
 
287
                         * to prevent "drift" as other autofan control
 
288
                         * values change.
 
289
                         */
 
290
};
 
291
 
 
292
struct lm85_autofan {
 
293
        u8 config;      /* Register value */
 
294
        u8 min_pwm;     /* Minimum PWM value, encoded */
 
295
        u8 min_off;     /* Min PWM or OFF below "limit", flag */
 
296
};
 
297
 
 
298
/* For each registered chip, we need to keep some data in memory.
 
299
   The structure is dynamically allocated. */
 
300
struct lm85_data {
 
301
        struct device *hwmon_dev;
 
302
        const int *freq_map;
 
303
        enum chips type;
 
304
 
 
305
        bool has_vid5;  /* true if VID5 is configured for ADT7463 or ADT7468 */
 
306
 
 
307
        struct mutex update_lock;
 
308
        int valid;              /* !=0 if following fields are valid */
 
309
        unsigned long last_reading;     /* In jiffies */
 
310
        unsigned long last_config;      /* In jiffies */
 
311
 
 
312
        u8 in[8];               /* Register value */
 
313
        u8 in_max[8];           /* Register value */
 
314
        u8 in_min[8];           /* Register value */
 
315
        s8 temp[3];             /* Register value */
 
316
        s8 temp_min[3];         /* Register value */
 
317
        s8 temp_max[3];         /* Register value */
 
318
        u16 fan[4];             /* Register value */
 
319
        u16 fan_min[4];         /* Register value */
 
320
        u8 pwm[3];              /* Register value */
 
321
        u8 pwm_freq[3];         /* Register encoding */
 
322
        u8 temp_ext[3];         /* Decoded values */
 
323
        u8 in_ext[8];           /* Decoded values */
 
324
        u8 vid;                 /* Register value */
 
325
        u8 vrm;                 /* VRM version */
 
326
        u32 alarms;             /* Register encoding, combined */
 
327
        u8 cfg5;                /* Config Register 5 on ADT7468 */
 
328
        struct lm85_autofan autofan[3];
 
329
        struct lm85_zone zone[3];
 
330
};
 
331
 
 
332
static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info);
 
333
static int lm85_probe(struct i2c_client *client,
 
334
                      const struct i2c_device_id *id);
 
335
static int lm85_remove(struct i2c_client *client);
 
336
 
 
337
static int lm85_read_value(struct i2c_client *client, u8 reg);
 
338
static void lm85_write_value(struct i2c_client *client, u8 reg, int value);
 
339
static struct lm85_data *lm85_update_device(struct device *dev);
 
340
 
 
341
 
 
342
static const struct i2c_device_id lm85_id[] = {
 
343
        { "adm1027", adm1027 },
 
344
        { "adt7463", adt7463 },
 
345
        { "adt7468", adt7468 },
 
346
        { "lm85", any_chip },
 
347
        { "lm85b", lm85b },
 
348
        { "lm85c", lm85c },
 
349
        { "emc6d100", emc6d100 },
 
350
        { "emc6d101", emc6d100 },
 
351
        { "emc6d102", emc6d102 },
 
352
        { "emc6d103", emc6d103 },
 
353
        { "emc6d103s", emc6d103s },
 
354
        { }
 
355
};
 
356
MODULE_DEVICE_TABLE(i2c, lm85_id);
 
357
 
 
358
static struct i2c_driver lm85_driver = {
 
359
        .class          = I2C_CLASS_HWMON,
 
360
        .driver = {
 
361
                .name   = "lm85",
 
362
        },
 
363
        .probe          = lm85_probe,
 
364
        .remove         = lm85_remove,
 
365
        .id_table       = lm85_id,
 
366
        .detect         = lm85_detect,
 
367
        .address_list   = normal_i2c,
 
368
};
 
369
 
 
370
 
 
371
/* 4 Fans */
 
372
static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
 
373
                char *buf)
 
374
{
 
375
        int nr = to_sensor_dev_attr(attr)->index;
 
376
        struct lm85_data *data = lm85_update_device(dev);
 
377
        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr]));
 
378
}
 
379
 
 
380
static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
 
381
                char *buf)
 
382
{
 
383
        int nr = to_sensor_dev_attr(attr)->index;
 
384
        struct lm85_data *data = lm85_update_device(dev);
 
385
        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr]));
 
386
}
 
387
 
 
388
static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 
389
                const char *buf, size_t count)
 
390
{
 
391
        int nr = to_sensor_dev_attr(attr)->index;
 
392
        struct i2c_client *client = to_i2c_client(dev);
 
393
        struct lm85_data *data = i2c_get_clientdata(client);
 
394
        unsigned long val = simple_strtoul(buf, NULL, 10);
 
395
 
 
396
        mutex_lock(&data->update_lock);
 
397
        data->fan_min[nr] = FAN_TO_REG(val);
 
398
        lm85_write_value(client, LM85_REG_FAN_MIN(nr), data->fan_min[nr]);
 
399
        mutex_unlock(&data->update_lock);
 
400
        return count;
 
401
}
 
402
 
 
403
#define show_fan_offset(offset)                                         \
 
404
static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
 
405
                show_fan, NULL, offset - 1);                            \
 
406
static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
 
407
                show_fan_min, set_fan_min, offset - 1)
 
408
 
 
409
show_fan_offset(1);
 
410
show_fan_offset(2);
 
411
show_fan_offset(3);
 
412
show_fan_offset(4);
 
413
 
 
414
/* vid, vrm, alarms */
 
415
 
 
416
static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr,
 
417
                char *buf)
 
418
{
 
419
        struct lm85_data *data = lm85_update_device(dev);
 
420
        int vid;
 
421
 
 
422
        if (data->has_vid5) {
 
423
                /* 6-pin VID (VRM 10) */
 
424
                vid = vid_from_reg(data->vid & 0x3f, data->vrm);
 
425
        } else {
 
426
                /* 5-pin VID (VRM 9) */
 
427
                vid = vid_from_reg(data->vid & 0x1f, data->vrm);
 
428
        }
 
429
 
 
430
        return sprintf(buf, "%d\n", vid);
 
431
}
 
432
 
 
433
static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 
434
 
 
435
static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr,
 
436
                char *buf)
 
437
{
 
438
        struct lm85_data *data = dev_get_drvdata(dev);
 
439
        return sprintf(buf, "%ld\n", (long) data->vrm);
 
440
}
 
441
 
 
442
static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
 
443
                const char *buf, size_t count)
 
444
{
 
445
        struct lm85_data *data = dev_get_drvdata(dev);
 
446
        data->vrm = simple_strtoul(buf, NULL, 10);
 
447
        return count;
 
448
}
 
449
 
 
450
static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 
451
 
 
452
static ssize_t show_alarms_reg(struct device *dev, struct device_attribute
 
453
                *attr, char *buf)
 
454
{
 
455
        struct lm85_data *data = lm85_update_device(dev);
 
456
        return sprintf(buf, "%u\n", data->alarms);
 
457
}
 
458
 
 
459
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
 
460
 
 
461
static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 
462
                char *buf)
 
463
{
 
464
        int nr = to_sensor_dev_attr(attr)->index;
 
465
        struct lm85_data *data = lm85_update_device(dev);
 
466
        return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 
467
}
 
468
 
 
469
static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 
470
static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 
471
static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 
472
static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 
473
static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 
474
static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 18);
 
475
static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 16);
 
476
static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 17);
 
477
static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 
478
static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_alarm, NULL, 14);
 
479
static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
 
480
static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 6);
 
481
static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 15);
 
482
static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10);
 
483
static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11);
 
484
static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 12);
 
485
static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 13);
 
486
 
 
487
/* pwm */
 
488
 
 
489
static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
 
490
                char *buf)
 
491
{
 
492
        int nr = to_sensor_dev_attr(attr)->index;
 
493
        struct lm85_data *data = lm85_update_device(dev);
 
494
        return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
 
495
}
 
496
 
 
497
static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
 
498
                const char *buf, size_t count)
 
499
{
 
500
        int nr = to_sensor_dev_attr(attr)->index;
 
501
        struct i2c_client *client = to_i2c_client(dev);
 
502
        struct lm85_data *data = i2c_get_clientdata(client);
 
503
        long val = simple_strtol(buf, NULL, 10);
 
504
 
 
505
        mutex_lock(&data->update_lock);
 
506
        data->pwm[nr] = PWM_TO_REG(val);
 
507
        lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]);
 
508
        mutex_unlock(&data->update_lock);
 
509
        return count;
 
510
}
 
511
 
 
512
static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
 
513
                *attr, char *buf)
 
514
{
 
515
        int nr = to_sensor_dev_attr(attr)->index;
 
516
        struct lm85_data *data = lm85_update_device(dev);
 
517
        int pwm_zone, enable;
 
518
 
 
519
        pwm_zone = ZONE_FROM_REG(data->autofan[nr].config);
 
520
        switch (pwm_zone) {
 
521
        case -1:        /* PWM is always at 100% */
 
522
                enable = 0;
 
523
                break;
 
524
        case 0:         /* PWM is always at 0% */
 
525
        case -2:        /* PWM responds to manual control */
 
526
                enable = 1;
 
527
                break;
 
528
        default:        /* PWM in automatic mode */
 
529
                enable = 2;
 
530
        }
 
531
        return sprintf(buf, "%d\n", enable);
 
532
}
 
533
 
 
534
static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
 
535
                *attr, const char *buf, size_t count)
 
536
{
 
537
        int nr = to_sensor_dev_attr(attr)->index;
 
538
        struct i2c_client *client = to_i2c_client(dev);
 
539
        struct lm85_data *data = i2c_get_clientdata(client);
 
540
        long val = simple_strtol(buf, NULL, 10);
 
541
        u8 config;
 
542
 
 
543
        switch (val) {
 
544
        case 0:
 
545
                config = 3;
 
546
                break;
 
547
        case 1:
 
548
                config = 7;
 
549
                break;
 
550
        case 2:
 
551
                /* Here we have to choose arbitrarily one of the 5 possible
 
552
                   configurations; I go for the safest */
 
553
                config = 6;
 
554
                break;
 
555
        default:
 
556
                return -EINVAL;
 
557
        }
 
558
 
 
559
        mutex_lock(&data->update_lock);
 
560
        data->autofan[nr].config = lm85_read_value(client,
 
561
                LM85_REG_AFAN_CONFIG(nr));
 
562
        data->autofan[nr].config = (data->autofan[nr].config & ~0xe0)
 
563
                | (config << 5);
 
564
        lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
 
565
                data->autofan[nr].config);
 
566
        mutex_unlock(&data->update_lock);
 
567
        return count;
 
568
}
 
569
 
 
570
static ssize_t show_pwm_freq(struct device *dev,
 
571
                struct device_attribute *attr, char *buf)
 
572
{
 
573
        int nr = to_sensor_dev_attr(attr)->index;
 
574
        struct lm85_data *data = lm85_update_device(dev);
 
575
        int freq;
 
576
 
 
577
        if (IS_ADT7468_HFPWM(data))
 
578
                freq = 22500;
 
579
        else
 
580
                freq = FREQ_FROM_REG(data->freq_map, data->pwm_freq[nr]);
 
581
 
 
582
        return sprintf(buf, "%d\n", freq);
 
583
}
 
584
 
 
585
static ssize_t set_pwm_freq(struct device *dev,
 
586
                struct device_attribute *attr, const char *buf, size_t count)
 
587
{
 
588
        int nr = to_sensor_dev_attr(attr)->index;
 
589
        struct i2c_client *client = to_i2c_client(dev);
 
590
        struct lm85_data *data = i2c_get_clientdata(client);
 
591
        long val = simple_strtol(buf, NULL, 10);
 
592
 
 
593
        mutex_lock(&data->update_lock);
 
594
        /* The ADT7468 has a special high-frequency PWM output mode,
 
595
         * where all PWM outputs are driven by a 22.5 kHz clock.
 
596
         * This might confuse the user, but there's not much we can do. */
 
597
        if (data->type == adt7468 && val >= 11300) {    /* High freq. mode */
 
598
                data->cfg5 &= ~ADT7468_HFPWM;
 
599
                lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);
 
600
        } else {                                        /* Low freq. mode */
 
601
                data->pwm_freq[nr] = FREQ_TO_REG(data->freq_map, val);
 
602
                lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
 
603
                                 (data->zone[nr].range << 4)
 
604
                                 | data->pwm_freq[nr]);
 
605
                if (data->type == adt7468) {
 
606
                        data->cfg5 |= ADT7468_HFPWM;
 
607
                        lm85_write_value(client, ADT7468_REG_CFG5, data->cfg5);
 
608
                }
 
609
        }
 
610
        mutex_unlock(&data->update_lock);
 
611
        return count;
 
612
}
 
613
 
 
614
#define show_pwm_reg(offset)                                            \
 
615
static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,               \
 
616
                show_pwm, set_pwm, offset - 1);                         \
 
617
static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,      \
 
618
                show_pwm_enable, set_pwm_enable, offset - 1);           \
 
619
static SENSOR_DEVICE_ATTR(pwm##offset##_freq, S_IRUGO | S_IWUSR,        \
 
620
                show_pwm_freq, set_pwm_freq, offset - 1)
 
621
 
 
622
show_pwm_reg(1);
 
623
show_pwm_reg(2);
 
624
show_pwm_reg(3);
 
625
 
 
626
/* Voltages */
 
627
 
 
628
static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 
629
                char *buf)
 
630
{
 
631
        int nr = to_sensor_dev_attr(attr)->index;
 
632
        struct lm85_data *data = lm85_update_device(dev);
 
633
        return sprintf(buf, "%d\n", INSEXT_FROM_REG(nr, data->in[nr],
 
634
                                                    data->in_ext[nr]));
 
635
}
 
636
 
 
637
static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
 
638
                char *buf)
 
639
{
 
640
        int nr = to_sensor_dev_attr(attr)->index;
 
641
        struct lm85_data *data = lm85_update_device(dev);
 
642
        return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
 
643
}
 
644
 
 
645
static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
 
646
                const char *buf, size_t count)
 
647
{
 
648
        int nr = to_sensor_dev_attr(attr)->index;
 
649
        struct i2c_client *client = to_i2c_client(dev);
 
650
        struct lm85_data *data = i2c_get_clientdata(client);
 
651
        long val = simple_strtol(buf, NULL, 10);
 
652
 
 
653
        mutex_lock(&data->update_lock);
 
654
        data->in_min[nr] = INS_TO_REG(nr, val);
 
655
        lm85_write_value(client, LM85_REG_IN_MIN(nr), data->in_min[nr]);
 
656
        mutex_unlock(&data->update_lock);
 
657
        return count;
 
658
}
 
659
 
 
660
static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
 
661
                char *buf)
 
662
{
 
663
        int nr = to_sensor_dev_attr(attr)->index;
 
664
        struct lm85_data *data = lm85_update_device(dev);
 
665
        return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
 
666
}
 
667
 
 
668
static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
 
669
                const char *buf, size_t count)
 
670
{
 
671
        int nr = to_sensor_dev_attr(attr)->index;
 
672
        struct i2c_client *client = to_i2c_client(dev);
 
673
        struct lm85_data *data = i2c_get_clientdata(client);
 
674
        long val = simple_strtol(buf, NULL, 10);
 
675
 
 
676
        mutex_lock(&data->update_lock);
 
677
        data->in_max[nr] = INS_TO_REG(nr, val);
 
678
        lm85_write_value(client, LM85_REG_IN_MAX(nr), data->in_max[nr]);
 
679
        mutex_unlock(&data->update_lock);
 
680
        return count;
 
681
}
 
682
 
 
683
#define show_in_reg(offset)                                             \
 
684
static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,                  \
 
685
                show_in, NULL, offset);                                 \
 
686
static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,          \
 
687
                show_in_min, set_in_min, offset);                       \
 
688
static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,          \
 
689
                show_in_max, set_in_max, offset)
 
690
 
 
691
show_in_reg(0);
 
692
show_in_reg(1);
 
693
show_in_reg(2);
 
694
show_in_reg(3);
 
695
show_in_reg(4);
 
696
show_in_reg(5);
 
697
show_in_reg(6);
 
698
show_in_reg(7);
 
699
 
 
700
/* Temps */
 
701
 
 
702
static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
 
703
                char *buf)
 
704
{
 
705
        int nr = to_sensor_dev_attr(attr)->index;
 
706
        struct lm85_data *data = lm85_update_device(dev);
 
707
        return sprintf(buf, "%d\n", TEMPEXT_FROM_REG(data->temp[nr],
 
708
                                                     data->temp_ext[nr]));
 
709
}
 
710
 
 
711
static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
 
712
                char *buf)
 
713
{
 
714
        int nr = to_sensor_dev_attr(attr)->index;
 
715
        struct lm85_data *data = lm85_update_device(dev);
 
716
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
 
717
}
 
718
 
 
719
static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
 
720
                const char *buf, size_t count)
 
721
{
 
722
        int nr = to_sensor_dev_attr(attr)->index;
 
723
        struct i2c_client *client = to_i2c_client(dev);
 
724
        struct lm85_data *data = i2c_get_clientdata(client);
 
725
        long val = simple_strtol(buf, NULL, 10);
 
726
 
 
727
        if (IS_ADT7468_OFF64(data))
 
728
                val += 64;
 
729
 
 
730
        mutex_lock(&data->update_lock);
 
731
        data->temp_min[nr] = TEMP_TO_REG(val);
 
732
        lm85_write_value(client, LM85_REG_TEMP_MIN(nr), data->temp_min[nr]);
 
733
        mutex_unlock(&data->update_lock);
 
734
        return count;
 
735
}
 
736
 
 
737
static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
 
738
                char *buf)
 
739
{
 
740
        int nr = to_sensor_dev_attr(attr)->index;
 
741
        struct lm85_data *data = lm85_update_device(dev);
 
742
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
 
743
}
 
744
 
 
745
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 
746
                const char *buf, size_t count)
 
747
{
 
748
        int nr = to_sensor_dev_attr(attr)->index;
 
749
        struct i2c_client *client = to_i2c_client(dev);
 
750
        struct lm85_data *data = i2c_get_clientdata(client);
 
751
        long val = simple_strtol(buf, NULL, 10);
 
752
 
 
753
        if (IS_ADT7468_OFF64(data))
 
754
                val += 64;
 
755
 
 
756
        mutex_lock(&data->update_lock);
 
757
        data->temp_max[nr] = TEMP_TO_REG(val);
 
758
        lm85_write_value(client, LM85_REG_TEMP_MAX(nr), data->temp_max[nr]);
 
759
        mutex_unlock(&data->update_lock);
 
760
        return count;
 
761
}
 
762
 
 
763
#define show_temp_reg(offset)                                           \
 
764
static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
 
765
                show_temp, NULL, offset - 1);                           \
 
766
static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,        \
 
767
                show_temp_min, set_temp_min, offset - 1);               \
 
768
static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
 
769
                show_temp_max, set_temp_max, offset - 1);
 
770
 
 
771
show_temp_reg(1);
 
772
show_temp_reg(2);
 
773
show_temp_reg(3);
 
774
 
 
775
 
 
776
/* Automatic PWM control */
 
777
 
 
778
static ssize_t show_pwm_auto_channels(struct device *dev,
 
779
                struct device_attribute *attr, char *buf)
 
780
{
 
781
        int nr = to_sensor_dev_attr(attr)->index;
 
782
        struct lm85_data *data = lm85_update_device(dev);
 
783
        return sprintf(buf, "%d\n", ZONE_FROM_REG(data->autofan[nr].config));
 
784
}
 
785
 
 
786
static ssize_t set_pwm_auto_channels(struct device *dev,
 
787
                struct device_attribute *attr, const char *buf, size_t count)
 
788
{
 
789
        int nr = to_sensor_dev_attr(attr)->index;
 
790
        struct i2c_client *client = to_i2c_client(dev);
 
791
        struct lm85_data *data = i2c_get_clientdata(client);
 
792
        long val = simple_strtol(buf, NULL, 10);
 
793
 
 
794
        mutex_lock(&data->update_lock);
 
795
        data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))
 
796
                | ZONE_TO_REG(val);
 
797
        lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
 
798
                data->autofan[nr].config);
 
799
        mutex_unlock(&data->update_lock);
 
800
        return count;
 
801
}
 
802
 
 
803
static ssize_t show_pwm_auto_pwm_min(struct device *dev,
 
804
                struct device_attribute *attr, char *buf)
 
805
{
 
806
        int nr = to_sensor_dev_attr(attr)->index;
 
807
        struct lm85_data *data = lm85_update_device(dev);
 
808
        return sprintf(buf, "%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
 
809
}
 
810
 
 
811
static ssize_t set_pwm_auto_pwm_min(struct device *dev,
 
812
                struct device_attribute *attr, const char *buf, size_t count)
 
813
{
 
814
        int nr = to_sensor_dev_attr(attr)->index;
 
815
        struct i2c_client *client = to_i2c_client(dev);
 
816
        struct lm85_data *data = i2c_get_clientdata(client);
 
817
        long val = simple_strtol(buf, NULL, 10);
 
818
 
 
819
        mutex_lock(&data->update_lock);
 
820
        data->autofan[nr].min_pwm = PWM_TO_REG(val);
 
821
        lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr),
 
822
                data->autofan[nr].min_pwm);
 
823
        mutex_unlock(&data->update_lock);
 
824
        return count;
 
825
}
 
826
 
 
827
static ssize_t show_pwm_auto_pwm_minctl(struct device *dev,
 
828
                struct device_attribute *attr, char *buf)
 
829
{
 
830
        int nr = to_sensor_dev_attr(attr)->index;
 
831
        struct lm85_data *data = lm85_update_device(dev);
 
832
        return sprintf(buf, "%d\n", data->autofan[nr].min_off);
 
833
}
 
834
 
 
835
static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
 
836
                struct device_attribute *attr, const char *buf, size_t count)
 
837
{
 
838
        int nr = to_sensor_dev_attr(attr)->index;
 
839
        struct i2c_client *client = to_i2c_client(dev);
 
840
        struct lm85_data *data = i2c_get_clientdata(client);
 
841
        long val = simple_strtol(buf, NULL, 10);
 
842
        u8 tmp;
 
843
 
 
844
        mutex_lock(&data->update_lock);
 
845
        data->autofan[nr].min_off = val;
 
846
        tmp = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
 
847
        tmp &= ~(0x20 << nr);
 
848
        if (data->autofan[nr].min_off)
 
849
                tmp |= 0x20 << nr;
 
850
        lm85_write_value(client, LM85_REG_AFAN_SPIKE1, tmp);
 
851
        mutex_unlock(&data->update_lock);
 
852
        return count;
 
853
}
 
854
 
 
855
#define pwm_auto(offset)                                                \
 
856
static SENSOR_DEVICE_ATTR(pwm##offset##_auto_channels,                  \
 
857
                S_IRUGO | S_IWUSR, show_pwm_auto_channels,              \
 
858
                set_pwm_auto_channels, offset - 1);                     \
 
859
static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_min,                   \
 
860
                S_IRUGO | S_IWUSR, show_pwm_auto_pwm_min,               \
 
861
                set_pwm_auto_pwm_min, offset - 1);                      \
 
862
static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_minctl,                \
 
863
                S_IRUGO | S_IWUSR, show_pwm_auto_pwm_minctl,            \
 
864
                set_pwm_auto_pwm_minctl, offset - 1)
 
865
 
 
866
pwm_auto(1);
 
867
pwm_auto(2);
 
868
pwm_auto(3);
 
869
 
 
870
/* Temperature settings for automatic PWM control */
 
871
 
 
872
static ssize_t show_temp_auto_temp_off(struct device *dev,
 
873
                struct device_attribute *attr, char *buf)
 
874
{
 
875
        int nr = to_sensor_dev_attr(attr)->index;
 
876
        struct lm85_data *data = lm85_update_device(dev);
 
877
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
 
878
                HYST_FROM_REG(data->zone[nr].hyst));
 
879
}
 
880
 
 
881
static ssize_t set_temp_auto_temp_off(struct device *dev,
 
882
                struct device_attribute *attr, const char *buf, size_t count)
 
883
{
 
884
        int nr = to_sensor_dev_attr(attr)->index;
 
885
        struct i2c_client *client = to_i2c_client(dev);
 
886
        struct lm85_data *data = i2c_get_clientdata(client);
 
887
        int min;
 
888
        long val = simple_strtol(buf, NULL, 10);
 
889
 
 
890
        mutex_lock(&data->update_lock);
 
891
        min = TEMP_FROM_REG(data->zone[nr].limit);
 
892
        data->zone[nr].hyst = HYST_TO_REG(min - val);
 
893
        if (nr == 0 || nr == 1) {
 
894
                lm85_write_value(client, LM85_REG_AFAN_HYST1,
 
895
                        (data->zone[0].hyst << 4)
 
896
                        | data->zone[1].hyst);
 
897
        } else {
 
898
                lm85_write_value(client, LM85_REG_AFAN_HYST2,
 
899
                        (data->zone[2].hyst << 4));
 
900
        }
 
901
        mutex_unlock(&data->update_lock);
 
902
        return count;
 
903
}
 
904
 
 
905
static ssize_t show_temp_auto_temp_min(struct device *dev,
 
906
                struct device_attribute *attr, char *buf)
 
907
{
 
908
        int nr = to_sensor_dev_attr(attr)->index;
 
909
        struct lm85_data *data = lm85_update_device(dev);
 
910
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit));
 
911
}
 
912
 
 
913
static ssize_t set_temp_auto_temp_min(struct device *dev,
 
914
                struct device_attribute *attr, const char *buf, size_t count)
 
915
{
 
916
        int nr = to_sensor_dev_attr(attr)->index;
 
917
        struct i2c_client *client = to_i2c_client(dev);
 
918
        struct lm85_data *data = i2c_get_clientdata(client);
 
919
        long val = simple_strtol(buf, NULL, 10);
 
920
 
 
921
        mutex_lock(&data->update_lock);
 
922
        data->zone[nr].limit = TEMP_TO_REG(val);
 
923
        lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr),
 
924
                data->zone[nr].limit);
 
925
 
 
926
/* Update temp_auto_max and temp_auto_range */
 
927
        data->zone[nr].range = RANGE_TO_REG(
 
928
                TEMP_FROM_REG(data->zone[nr].max_desired) -
 
929
                TEMP_FROM_REG(data->zone[nr].limit));
 
930
        lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
 
931
                ((data->zone[nr].range & 0x0f) << 4)
 
932
                | (data->pwm_freq[nr] & 0x07));
 
933
 
 
934
        mutex_unlock(&data->update_lock);
 
935
        return count;
 
936
}
 
937
 
 
938
static ssize_t show_temp_auto_temp_max(struct device *dev,
 
939
                struct device_attribute *attr, char *buf)
 
940
{
 
941
        int nr = to_sensor_dev_attr(attr)->index;
 
942
        struct lm85_data *data = lm85_update_device(dev);
 
943
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
 
944
                RANGE_FROM_REG(data->zone[nr].range));
 
945
}
 
946
 
 
947
static ssize_t set_temp_auto_temp_max(struct device *dev,
 
948
                struct device_attribute *attr, const char *buf, size_t count)
 
949
{
 
950
        int nr = to_sensor_dev_attr(attr)->index;
 
951
        struct i2c_client *client = to_i2c_client(dev);
 
952
        struct lm85_data *data = i2c_get_clientdata(client);
 
953
        int min;
 
954
        long val = simple_strtol(buf, NULL, 10);
 
955
 
 
956
        mutex_lock(&data->update_lock);
 
957
        min = TEMP_FROM_REG(data->zone[nr].limit);
 
958
        data->zone[nr].max_desired = TEMP_TO_REG(val);
 
959
        data->zone[nr].range = RANGE_TO_REG(
 
960
                val - min);
 
961
        lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
 
962
                ((data->zone[nr].range & 0x0f) << 4)
 
963
                | (data->pwm_freq[nr] & 0x07));
 
964
        mutex_unlock(&data->update_lock);
 
965
        return count;
 
966
}
 
967
 
 
968
static ssize_t show_temp_auto_temp_crit(struct device *dev,
 
969
                struct device_attribute *attr, char *buf)
 
970
{
 
971
        int nr = to_sensor_dev_attr(attr)->index;
 
972
        struct lm85_data *data = lm85_update_device(dev);
 
973
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].critical));
 
974
}
 
975
 
 
976
static ssize_t set_temp_auto_temp_crit(struct device *dev,
 
977
                struct device_attribute *attr, const char *buf, size_t count)
 
978
{
 
979
        int nr = to_sensor_dev_attr(attr)->index;
 
980
        struct i2c_client *client = to_i2c_client(dev);
 
981
        struct lm85_data *data = i2c_get_clientdata(client);
 
982
        long val = simple_strtol(buf, NULL, 10);
 
983
 
 
984
        mutex_lock(&data->update_lock);
 
985
        data->zone[nr].critical = TEMP_TO_REG(val);
 
986
        lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr),
 
987
                data->zone[nr].critical);
 
988
        mutex_unlock(&data->update_lock);
 
989
        return count;
 
990
}
 
991
 
 
992
#define temp_auto(offset)                                               \
 
993
static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_off,                 \
 
994
                S_IRUGO | S_IWUSR, show_temp_auto_temp_off,             \
 
995
                set_temp_auto_temp_off, offset - 1);                    \
 
996
static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_min,                 \
 
997
                S_IRUGO | S_IWUSR, show_temp_auto_temp_min,             \
 
998
                set_temp_auto_temp_min, offset - 1);                    \
 
999
static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_max,                 \
 
1000
                S_IRUGO | S_IWUSR, show_temp_auto_temp_max,             \
 
1001
                set_temp_auto_temp_max, offset - 1);                    \
 
1002
static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_crit,                \
 
1003
                S_IRUGO | S_IWUSR, show_temp_auto_temp_crit,            \
 
1004
                set_temp_auto_temp_crit, offset - 1);
 
1005
 
 
1006
temp_auto(1);
 
1007
temp_auto(2);
 
1008
temp_auto(3);
 
1009
 
 
1010
static struct attribute *lm85_attributes[] = {
 
1011
        &sensor_dev_attr_fan1_input.dev_attr.attr,
 
1012
        &sensor_dev_attr_fan2_input.dev_attr.attr,
 
1013
        &sensor_dev_attr_fan3_input.dev_attr.attr,
 
1014
        &sensor_dev_attr_fan4_input.dev_attr.attr,
 
1015
        &sensor_dev_attr_fan1_min.dev_attr.attr,
 
1016
        &sensor_dev_attr_fan2_min.dev_attr.attr,
 
1017
        &sensor_dev_attr_fan3_min.dev_attr.attr,
 
1018
        &sensor_dev_attr_fan4_min.dev_attr.attr,
 
1019
        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 
1020
        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 
1021
        &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 
1022
        &sensor_dev_attr_fan4_alarm.dev_attr.attr,
 
1023
 
 
1024
        &sensor_dev_attr_pwm1.dev_attr.attr,
 
1025
        &sensor_dev_attr_pwm2.dev_attr.attr,
 
1026
        &sensor_dev_attr_pwm3.dev_attr.attr,
 
1027
        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
 
1028
        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
 
1029
        &sensor_dev_attr_pwm3_enable.dev_attr.attr,
 
1030
        &sensor_dev_attr_pwm1_freq.dev_attr.attr,
 
1031
        &sensor_dev_attr_pwm2_freq.dev_attr.attr,
 
1032
        &sensor_dev_attr_pwm3_freq.dev_attr.attr,
 
1033
 
 
1034
        &sensor_dev_attr_in0_input.dev_attr.attr,
 
1035
        &sensor_dev_attr_in1_input.dev_attr.attr,
 
1036
        &sensor_dev_attr_in2_input.dev_attr.attr,
 
1037
        &sensor_dev_attr_in3_input.dev_attr.attr,
 
1038
        &sensor_dev_attr_in0_min.dev_attr.attr,
 
1039
        &sensor_dev_attr_in1_min.dev_attr.attr,
 
1040
        &sensor_dev_attr_in2_min.dev_attr.attr,
 
1041
        &sensor_dev_attr_in3_min.dev_attr.attr,
 
1042
        &sensor_dev_attr_in0_max.dev_attr.attr,
 
1043
        &sensor_dev_attr_in1_max.dev_attr.attr,
 
1044
        &sensor_dev_attr_in2_max.dev_attr.attr,
 
1045
        &sensor_dev_attr_in3_max.dev_attr.attr,
 
1046
        &sensor_dev_attr_in0_alarm.dev_attr.attr,
 
1047
        &sensor_dev_attr_in1_alarm.dev_attr.attr,
 
1048
        &sensor_dev_attr_in2_alarm.dev_attr.attr,
 
1049
        &sensor_dev_attr_in3_alarm.dev_attr.attr,
 
1050
 
 
1051
        &sensor_dev_attr_temp1_input.dev_attr.attr,
 
1052
        &sensor_dev_attr_temp2_input.dev_attr.attr,
 
1053
        &sensor_dev_attr_temp3_input.dev_attr.attr,
 
1054
        &sensor_dev_attr_temp1_min.dev_attr.attr,
 
1055
        &sensor_dev_attr_temp2_min.dev_attr.attr,
 
1056
        &sensor_dev_attr_temp3_min.dev_attr.attr,
 
1057
        &sensor_dev_attr_temp1_max.dev_attr.attr,
 
1058
        &sensor_dev_attr_temp2_max.dev_attr.attr,
 
1059
        &sensor_dev_attr_temp3_max.dev_attr.attr,
 
1060
        &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 
1061
        &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 
1062
        &sensor_dev_attr_temp3_alarm.dev_attr.attr,
 
1063
        &sensor_dev_attr_temp1_fault.dev_attr.attr,
 
1064
        &sensor_dev_attr_temp3_fault.dev_attr.attr,
 
1065
 
 
1066
        &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,
 
1067
        &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,
 
1068
        &sensor_dev_attr_pwm3_auto_channels.dev_attr.attr,
 
1069
        &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
 
1070
        &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
 
1071
        &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
 
1072
 
 
1073
        &sensor_dev_attr_temp1_auto_temp_min.dev_attr.attr,
 
1074
        &sensor_dev_attr_temp2_auto_temp_min.dev_attr.attr,
 
1075
        &sensor_dev_attr_temp3_auto_temp_min.dev_attr.attr,
 
1076
        &sensor_dev_attr_temp1_auto_temp_max.dev_attr.attr,
 
1077
        &sensor_dev_attr_temp2_auto_temp_max.dev_attr.attr,
 
1078
        &sensor_dev_attr_temp3_auto_temp_max.dev_attr.attr,
 
1079
        &sensor_dev_attr_temp1_auto_temp_crit.dev_attr.attr,
 
1080
        &sensor_dev_attr_temp2_auto_temp_crit.dev_attr.attr,
 
1081
        &sensor_dev_attr_temp3_auto_temp_crit.dev_attr.attr,
 
1082
 
 
1083
        &dev_attr_vrm.attr,
 
1084
        &dev_attr_cpu0_vid.attr,
 
1085
        &dev_attr_alarms.attr,
 
1086
        NULL
 
1087
};
 
1088
 
 
1089
static const struct attribute_group lm85_group = {
 
1090
        .attrs = lm85_attributes,
 
1091
};
 
1092
 
 
1093
static struct attribute *lm85_attributes_minctl[] = {
 
1094
        &sensor_dev_attr_pwm1_auto_pwm_minctl.dev_attr.attr,
 
1095
        &sensor_dev_attr_pwm2_auto_pwm_minctl.dev_attr.attr,
 
1096
        &sensor_dev_attr_pwm3_auto_pwm_minctl.dev_attr.attr,
 
1097
        NULL
 
1098
};
 
1099
 
 
1100
static const struct attribute_group lm85_group_minctl = {
 
1101
        .attrs = lm85_attributes_minctl,
 
1102
};
 
1103
 
 
1104
static struct attribute *lm85_attributes_temp_off[] = {
 
1105
        &sensor_dev_attr_temp1_auto_temp_off.dev_attr.attr,
 
1106
        &sensor_dev_attr_temp2_auto_temp_off.dev_attr.attr,
 
1107
        &sensor_dev_attr_temp3_auto_temp_off.dev_attr.attr,
 
1108
        NULL
 
1109
};
 
1110
 
 
1111
static const struct attribute_group lm85_group_temp_off = {
 
1112
        .attrs = lm85_attributes_temp_off,
 
1113
};
 
1114
 
 
1115
static struct attribute *lm85_attributes_in4[] = {
 
1116
        &sensor_dev_attr_in4_input.dev_attr.attr,
 
1117
        &sensor_dev_attr_in4_min.dev_attr.attr,
 
1118
        &sensor_dev_attr_in4_max.dev_attr.attr,
 
1119
        &sensor_dev_attr_in4_alarm.dev_attr.attr,
 
1120
        NULL
 
1121
};
 
1122
 
 
1123
static const struct attribute_group lm85_group_in4 = {
 
1124
        .attrs = lm85_attributes_in4,
 
1125
};
 
1126
 
 
1127
static struct attribute *lm85_attributes_in567[] = {
 
1128
        &sensor_dev_attr_in5_input.dev_attr.attr,
 
1129
        &sensor_dev_attr_in6_input.dev_attr.attr,
 
1130
        &sensor_dev_attr_in7_input.dev_attr.attr,
 
1131
        &sensor_dev_attr_in5_min.dev_attr.attr,
 
1132
        &sensor_dev_attr_in6_min.dev_attr.attr,
 
1133
        &sensor_dev_attr_in7_min.dev_attr.attr,
 
1134
        &sensor_dev_attr_in5_max.dev_attr.attr,
 
1135
        &sensor_dev_attr_in6_max.dev_attr.attr,
 
1136
        &sensor_dev_attr_in7_max.dev_attr.attr,
 
1137
        &sensor_dev_attr_in5_alarm.dev_attr.attr,
 
1138
        &sensor_dev_attr_in6_alarm.dev_attr.attr,
 
1139
        &sensor_dev_attr_in7_alarm.dev_attr.attr,
 
1140
        NULL
 
1141
};
 
1142
 
 
1143
static const struct attribute_group lm85_group_in567 = {
 
1144
        .attrs = lm85_attributes_in567,
 
1145
};
 
1146
 
 
1147
static void lm85_init_client(struct i2c_client *client)
 
1148
{
 
1149
        int value;
 
1150
 
 
1151
        /* Start monitoring if needed */
 
1152
        value = lm85_read_value(client, LM85_REG_CONFIG);
 
1153
        if (!(value & 0x01)) {
 
1154
                dev_info(&client->dev, "Starting monitoring\n");
 
1155
                lm85_write_value(client, LM85_REG_CONFIG, value | 0x01);
 
1156
        }
 
1157
 
 
1158
        /* Warn about unusual configuration bits */
 
1159
        if (value & 0x02)
 
1160
                dev_warn(&client->dev, "Device configuration is locked\n");
 
1161
        if (!(value & 0x04))
 
1162
                dev_warn(&client->dev, "Device is not ready\n");
 
1163
}
 
1164
 
 
1165
static int lm85_is_fake(struct i2c_client *client)
 
1166
{
 
1167
        /*
 
1168
         * Differenciate between real LM96000 and Winbond WPCD377I. The latter
 
1169
         * emulate the former except that it has no hardware monitoring function
 
1170
         * so the readings are always 0.
 
1171
         */
 
1172
        int i;
 
1173
        u8 in_temp, fan;
 
1174
 
 
1175
        for (i = 0; i < 8; i++) {
 
1176
                in_temp = i2c_smbus_read_byte_data(client, 0x20 + i);
 
1177
                fan = i2c_smbus_read_byte_data(client, 0x28 + i);
 
1178
                if (in_temp != 0x00 || fan != 0xff)
 
1179
                        return 0;
 
1180
        }
 
1181
 
 
1182
        return 1;
 
1183
}
 
1184
 
 
1185
/* Return 0 if detection is successful, -ENODEV otherwise */
 
1186
static int lm85_detect(struct i2c_client *client, struct i2c_board_info *info)
 
1187
{
 
1188
        struct i2c_adapter *adapter = client->adapter;
 
1189
        int address = client->addr;
 
1190
        const char *type_name;
 
1191
        int company, verstep;
 
1192
 
 
1193
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 
1194
                /* We need to be able to do byte I/O */
 
1195
                return -ENODEV;
 
1196
        }
 
1197
 
 
1198
        /* Determine the chip type */
 
1199
        company = lm85_read_value(client, LM85_REG_COMPANY);
 
1200
        verstep = lm85_read_value(client, LM85_REG_VERSTEP);
 
1201
 
 
1202
        dev_dbg(&adapter->dev, "Detecting device at 0x%02x with "
 
1203
                "COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
 
1204
                address, company, verstep);
 
1205
 
 
1206
        /* All supported chips have the version in common */
 
1207
        if ((verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC &&
 
1208
            (verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC2) {
 
1209
                dev_dbg(&adapter->dev,
 
1210
                        "Autodetection failed: unsupported version\n");
 
1211
                return -ENODEV;
 
1212
        }
 
1213
        type_name = "lm85";
 
1214
 
 
1215
        /* Now, refine the detection */
 
1216
        if (company == LM85_COMPANY_NATIONAL) {
 
1217
                switch (verstep) {
 
1218
                case LM85_VERSTEP_LM85C:
 
1219
                        type_name = "lm85c";
 
1220
                        break;
 
1221
                case LM85_VERSTEP_LM85B:
 
1222
                        type_name = "lm85b";
 
1223
                        break;
 
1224
                case LM85_VERSTEP_LM96000_1:
 
1225
                case LM85_VERSTEP_LM96000_2:
 
1226
                        /* Check for Winbond WPCD377I */
 
1227
                        if (lm85_is_fake(client)) {
 
1228
                                dev_dbg(&adapter->dev,
 
1229
                                        "Found Winbond WPCD377I, ignoring\n");
 
1230
                                return -ENODEV;
 
1231
                        }
 
1232
                        break;
 
1233
                }
 
1234
        } else if (company == LM85_COMPANY_ANALOG_DEV) {
 
1235
                switch (verstep) {
 
1236
                case LM85_VERSTEP_ADM1027:
 
1237
                        type_name = "adm1027";
 
1238
                        break;
 
1239
                case LM85_VERSTEP_ADT7463:
 
1240
                case LM85_VERSTEP_ADT7463C:
 
1241
                        type_name = "adt7463";
 
1242
                        break;
 
1243
                case LM85_VERSTEP_ADT7468_1:
 
1244
                case LM85_VERSTEP_ADT7468_2:
 
1245
                        type_name = "adt7468";
 
1246
                        break;
 
1247
                }
 
1248
        } else if (company == LM85_COMPANY_SMSC) {
 
1249
                switch (verstep) {
 
1250
                case LM85_VERSTEP_EMC6D100_A0:
 
1251
                case LM85_VERSTEP_EMC6D100_A1:
 
1252
                        /* Note: we can't tell a '100 from a '101 */
 
1253
                        type_name = "emc6d100";
 
1254
                        break;
 
1255
                case LM85_VERSTEP_EMC6D102:
 
1256
                        type_name = "emc6d102";
 
1257
                        break;
 
1258
                case LM85_VERSTEP_EMC6D103_A0:
 
1259
                case LM85_VERSTEP_EMC6D103_A1:
 
1260
                        type_name = "emc6d103";
 
1261
                        break;
 
1262
                case LM85_VERSTEP_EMC6D103S:
 
1263
                        type_name = "emc6d103s";
 
1264
                        break;
 
1265
                }
 
1266
        } else {
 
1267
                dev_dbg(&adapter->dev,
 
1268
                        "Autodetection failed: unknown vendor\n");
 
1269
                return -ENODEV;
 
1270
        }
 
1271
 
 
1272
        strlcpy(info->type, type_name, I2C_NAME_SIZE);
 
1273
 
 
1274
        return 0;
 
1275
}
 
1276
 
 
1277
static void lm85_remove_files(struct i2c_client *client, struct lm85_data *data)
 
1278
{
 
1279
        sysfs_remove_group(&client->dev.kobj, &lm85_group);
 
1280
        if (data->type != emc6d103s) {
 
1281
                sysfs_remove_group(&client->dev.kobj, &lm85_group_minctl);
 
1282
                sysfs_remove_group(&client->dev.kobj, &lm85_group_temp_off);
 
1283
        }
 
1284
        if (!data->has_vid5)
 
1285
                sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
 
1286
        if (data->type == emc6d100)
 
1287
                sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
 
1288
}
 
1289
 
 
1290
static int lm85_probe(struct i2c_client *client,
 
1291
                      const struct i2c_device_id *id)
 
1292
{
 
1293
        struct lm85_data *data;
 
1294
        int err;
 
1295
 
 
1296
        data = kzalloc(sizeof(struct lm85_data), GFP_KERNEL);
 
1297
        if (!data)
 
1298
                return -ENOMEM;
 
1299
 
 
1300
        i2c_set_clientdata(client, data);
 
1301
        data->type = id->driver_data;
 
1302
        mutex_init(&data->update_lock);
 
1303
 
 
1304
        /* Fill in the chip specific driver values */
 
1305
        switch (data->type) {
 
1306
        case adm1027:
 
1307
        case adt7463:
 
1308
        case adt7468:
 
1309
        case emc6d100:
 
1310
        case emc6d102:
 
1311
        case emc6d103:
 
1312
        case emc6d103s:
 
1313
                data->freq_map = adm1027_freq_map;
 
1314
                break;
 
1315
        default:
 
1316
                data->freq_map = lm85_freq_map;
 
1317
        }
 
1318
 
 
1319
        /* Set the VRM version */
 
1320
        data->vrm = vid_which_vrm();
 
1321
 
 
1322
        /* Initialize the LM85 chip */
 
1323
        lm85_init_client(client);
 
1324
 
 
1325
        /* Register sysfs hooks */
 
1326
        err = sysfs_create_group(&client->dev.kobj, &lm85_group);
 
1327
        if (err)
 
1328
                goto err_kfree;
 
1329
 
 
1330
        /* minctl and temp_off exist on all chips except emc6d103s */
 
1331
        if (data->type != emc6d103s) {
 
1332
                err = sysfs_create_group(&client->dev.kobj, &lm85_group_minctl);
 
1333
                if (err)
 
1334
                        goto err_remove_files;
 
1335
                err = sysfs_create_group(&client->dev.kobj,
 
1336
                                         &lm85_group_temp_off);
 
1337
                if (err)
 
1338
                        goto err_remove_files;
 
1339
        }
 
1340
 
 
1341
        /* The ADT7463/68 have an optional VRM 10 mode where pin 21 is used
 
1342
           as a sixth digital VID input rather than an analog input. */
 
1343
        if (data->type == adt7463 || data->type == adt7468) {
 
1344
                u8 vid = lm85_read_value(client, LM85_REG_VID);
 
1345
                if (vid & 0x80)
 
1346
                        data->has_vid5 = true;
 
1347
        }
 
1348
 
 
1349
        if (!data->has_vid5)
 
1350
                if ((err = sysfs_create_group(&client->dev.kobj,
 
1351
                                        &lm85_group_in4)))
 
1352
                        goto err_remove_files;
 
1353
 
 
1354
        /* The EMC6D100 has 3 additional voltage inputs */
 
1355
        if (data->type == emc6d100)
 
1356
                if ((err = sysfs_create_group(&client->dev.kobj,
 
1357
                                        &lm85_group_in567)))
 
1358
                        goto err_remove_files;
 
1359
 
 
1360
        data->hwmon_dev = hwmon_device_register(&client->dev);
 
1361
        if (IS_ERR(data->hwmon_dev)) {
 
1362
                err = PTR_ERR(data->hwmon_dev);
 
1363
                goto err_remove_files;
 
1364
        }
 
1365
 
 
1366
        return 0;
 
1367
 
 
1368
        /* Error out and cleanup code */
 
1369
 err_remove_files:
 
1370
        lm85_remove_files(client, data);
 
1371
 err_kfree:
 
1372
        kfree(data);
 
1373
        return err;
 
1374
}
 
1375
 
 
1376
static int lm85_remove(struct i2c_client *client)
 
1377
{
 
1378
        struct lm85_data *data = i2c_get_clientdata(client);
 
1379
        hwmon_device_unregister(data->hwmon_dev);
 
1380
        lm85_remove_files(client, data);
 
1381
        kfree(data);
 
1382
        return 0;
 
1383
}
 
1384
 
 
1385
 
 
1386
static int lm85_read_value(struct i2c_client *client, u8 reg)
 
1387
{
 
1388
        int res;
 
1389
 
 
1390
        /* What size location is it? */
 
1391
        switch (reg) {
 
1392
        case LM85_REG_FAN(0):  /* Read WORD data */
 
1393
        case LM85_REG_FAN(1):
 
1394
        case LM85_REG_FAN(2):
 
1395
        case LM85_REG_FAN(3):
 
1396
        case LM85_REG_FAN_MIN(0):
 
1397
        case LM85_REG_FAN_MIN(1):
 
1398
        case LM85_REG_FAN_MIN(2):
 
1399
        case LM85_REG_FAN_MIN(3):
 
1400
        case LM85_REG_ALARM1:   /* Read both bytes at once */
 
1401
                res = i2c_smbus_read_byte_data(client, reg) & 0xff;
 
1402
                res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;
 
1403
                break;
 
1404
        default:        /* Read BYTE data */
 
1405
                res = i2c_smbus_read_byte_data(client, reg);
 
1406
                break;
 
1407
        }
 
1408
 
 
1409
        return res;
 
1410
}
 
1411
 
 
1412
static void lm85_write_value(struct i2c_client *client, u8 reg, int value)
 
1413
{
 
1414
        switch (reg) {
 
1415
        case LM85_REG_FAN(0):  /* Write WORD data */
 
1416
        case LM85_REG_FAN(1):
 
1417
        case LM85_REG_FAN(2):
 
1418
        case LM85_REG_FAN(3):
 
1419
        case LM85_REG_FAN_MIN(0):
 
1420
        case LM85_REG_FAN_MIN(1):
 
1421
        case LM85_REG_FAN_MIN(2):
 
1422
        case LM85_REG_FAN_MIN(3):
 
1423
        /* NOTE: ALARM is read only, so not included here */
 
1424
                i2c_smbus_write_byte_data(client, reg, value & 0xff);
 
1425
                i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
 
1426
                break;
 
1427
        default:        /* Write BYTE data */
 
1428
                i2c_smbus_write_byte_data(client, reg, value);
 
1429
                break;
 
1430
        }
 
1431
}
 
1432
 
 
1433
static struct lm85_data *lm85_update_device(struct device *dev)
 
1434
{
 
1435
        struct i2c_client *client = to_i2c_client(dev);
 
1436
        struct lm85_data *data = i2c_get_clientdata(client);
 
1437
        int i;
 
1438
 
 
1439
        mutex_lock(&data->update_lock);
 
1440
 
 
1441
        if (!data->valid ||
 
1442
             time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) {
 
1443
                /* Things that change quickly */
 
1444
                dev_dbg(&client->dev, "Reading sensor values\n");
 
1445
 
 
1446
                /* Have to read extended bits first to "freeze" the
 
1447
                 * more significant bits that are read later.
 
1448
                 * There are 2 additional resolution bits per channel and we
 
1449
                 * have room for 4, so we shift them to the left.
 
1450
                 */
 
1451
                if (data->type == adm1027 || data->type == adt7463 ||
 
1452
                    data->type == adt7468) {
 
1453
                        int ext1 = lm85_read_value(client,
 
1454
                                                   ADM1027_REG_EXTEND_ADC1);
 
1455
                        int ext2 =  lm85_read_value(client,
 
1456
                                                    ADM1027_REG_EXTEND_ADC2);
 
1457
                        int val = (ext1 << 8) + ext2;
 
1458
 
 
1459
                        for (i = 0; i <= 4; i++)
 
1460
                                data->in_ext[i] =
 
1461
                                        ((val >> (i * 2)) & 0x03) << 2;
 
1462
 
 
1463
                        for (i = 0; i <= 2; i++)
 
1464
                                data->temp_ext[i] =
 
1465
                                        (val >> ((i + 4) * 2)) & 0x0c;
 
1466
                }
 
1467
 
 
1468
                data->vid = lm85_read_value(client, LM85_REG_VID);
 
1469
 
 
1470
                for (i = 0; i <= 3; ++i) {
 
1471
                        data->in[i] =
 
1472
                            lm85_read_value(client, LM85_REG_IN(i));
 
1473
                        data->fan[i] =
 
1474
                            lm85_read_value(client, LM85_REG_FAN(i));
 
1475
                }
 
1476
 
 
1477
                if (!data->has_vid5)
 
1478
                        data->in[4] = lm85_read_value(client, LM85_REG_IN(4));
 
1479
 
 
1480
                if (data->type == adt7468)
 
1481
                        data->cfg5 = lm85_read_value(client, ADT7468_REG_CFG5);
 
1482
 
 
1483
                for (i = 0; i <= 2; ++i) {
 
1484
                        data->temp[i] =
 
1485
                            lm85_read_value(client, LM85_REG_TEMP(i));
 
1486
                        data->pwm[i] =
 
1487
                            lm85_read_value(client, LM85_REG_PWM(i));
 
1488
 
 
1489
                        if (IS_ADT7468_OFF64(data))
 
1490
                                data->temp[i] -= 64;
 
1491
                }
 
1492
 
 
1493
                data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
 
1494
 
 
1495
                if (data->type == emc6d100) {
 
1496
                        /* Three more voltage sensors */
 
1497
                        for (i = 5; i <= 7; ++i) {
 
1498
                                data->in[i] = lm85_read_value(client,
 
1499
                                                        EMC6D100_REG_IN(i));
 
1500
                        }
 
1501
                        /* More alarm bits */
 
1502
                        data->alarms |= lm85_read_value(client,
 
1503
                                                EMC6D100_REG_ALARM3) << 16;
 
1504
                } else if (data->type == emc6d102 || data->type == emc6d103 ||
 
1505
                           data->type == emc6d103s) {
 
1506
                        /* Have to read LSB bits after the MSB ones because
 
1507
                           the reading of the MSB bits has frozen the
 
1508
                           LSBs (backward from the ADM1027).
 
1509
                         */
 
1510
                        int ext1 = lm85_read_value(client,
 
1511
                                                   EMC6D102_REG_EXTEND_ADC1);
 
1512
                        int ext2 = lm85_read_value(client,
 
1513
                                                   EMC6D102_REG_EXTEND_ADC2);
 
1514
                        int ext3 = lm85_read_value(client,
 
1515
                                                   EMC6D102_REG_EXTEND_ADC3);
 
1516
                        int ext4 = lm85_read_value(client,
 
1517
                                                   EMC6D102_REG_EXTEND_ADC4);
 
1518
                        data->in_ext[0] = ext3 & 0x0f;
 
1519
                        data->in_ext[1] = ext4 & 0x0f;
 
1520
                        data->in_ext[2] = ext4 >> 4;
 
1521
                        data->in_ext[3] = ext3 >> 4;
 
1522
                        data->in_ext[4] = ext2 >> 4;
 
1523
 
 
1524
                        data->temp_ext[0] = ext1 & 0x0f;
 
1525
                        data->temp_ext[1] = ext2 & 0x0f;
 
1526
                        data->temp_ext[2] = ext1 >> 4;
 
1527
                }
 
1528
 
 
1529
                data->last_reading = jiffies;
 
1530
        }  /* last_reading */
 
1531
 
 
1532
        if (!data->valid ||
 
1533
             time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {
 
1534
                /* Things that don't change often */
 
1535
                dev_dbg(&client->dev, "Reading config values\n");
 
1536
 
 
1537
                for (i = 0; i <= 3; ++i) {
 
1538
                        data->in_min[i] =
 
1539
                            lm85_read_value(client, LM85_REG_IN_MIN(i));
 
1540
                        data->in_max[i] =
 
1541
                            lm85_read_value(client, LM85_REG_IN_MAX(i));
 
1542
                        data->fan_min[i] =
 
1543
                            lm85_read_value(client, LM85_REG_FAN_MIN(i));
 
1544
                }
 
1545
 
 
1546
                if (!data->has_vid5)  {
 
1547
                        data->in_min[4] = lm85_read_value(client,
 
1548
                                          LM85_REG_IN_MIN(4));
 
1549
                        data->in_max[4] = lm85_read_value(client,
 
1550
                                          LM85_REG_IN_MAX(4));
 
1551
                }
 
1552
 
 
1553
                if (data->type == emc6d100) {
 
1554
                        for (i = 5; i <= 7; ++i) {
 
1555
                                data->in_min[i] = lm85_read_value(client,
 
1556
                                                EMC6D100_REG_IN_MIN(i));
 
1557
                                data->in_max[i] = lm85_read_value(client,
 
1558
                                                EMC6D100_REG_IN_MAX(i));
 
1559
                        }
 
1560
                }
 
1561
 
 
1562
                for (i = 0; i <= 2; ++i) {
 
1563
                        int val;
 
1564
 
 
1565
                        data->temp_min[i] =
 
1566
                            lm85_read_value(client, LM85_REG_TEMP_MIN(i));
 
1567
                        data->temp_max[i] =
 
1568
                            lm85_read_value(client, LM85_REG_TEMP_MAX(i));
 
1569
 
 
1570
                        data->autofan[i].config =
 
1571
                            lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
 
1572
                        val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
 
1573
                        data->pwm_freq[i] = val & 0x07;
 
1574
                        data->zone[i].range = val >> 4;
 
1575
                        data->autofan[i].min_pwm =
 
1576
                            lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
 
1577
                        data->zone[i].limit =
 
1578
                            lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));
 
1579
                        data->zone[i].critical =
 
1580
                            lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));
 
1581
 
 
1582
                        if (IS_ADT7468_OFF64(data)) {
 
1583
                                data->temp_min[i] -= 64;
 
1584
                                data->temp_max[i] -= 64;
 
1585
                                data->zone[i].limit -= 64;
 
1586
                                data->zone[i].critical -= 64;
 
1587
                        }
 
1588
                }
 
1589
 
 
1590
                if (data->type != emc6d103s) {
 
1591
                        i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
 
1592
                        data->autofan[0].min_off = (i & 0x20) != 0;
 
1593
                        data->autofan[1].min_off = (i & 0x40) != 0;
 
1594
                        data->autofan[2].min_off = (i & 0x80) != 0;
 
1595
 
 
1596
                        i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
 
1597
                        data->zone[0].hyst = i >> 4;
 
1598
                        data->zone[1].hyst = i & 0x0f;
 
1599
 
 
1600
                        i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
 
1601
                        data->zone[2].hyst = i >> 4;
 
1602
                }
 
1603
 
 
1604
                data->last_config = jiffies;
 
1605
        }  /* last_config */
 
1606
 
 
1607
        data->valid = 1;
 
1608
 
 
1609
        mutex_unlock(&data->update_lock);
 
1610
 
 
1611
        return data;
 
1612
}
 
1613
 
 
1614
 
 
1615
static int __init sm_lm85_init(void)
 
1616
{
 
1617
        return i2c_add_driver(&lm85_driver);
 
1618
}
 
1619
 
 
1620
static void __exit sm_lm85_exit(void)
 
1621
{
 
1622
        i2c_del_driver(&lm85_driver);
 
1623
}
 
1624
 
 
1625
MODULE_LICENSE("GPL");
 
1626
MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
 
1627
        "Margit Schubert-While <margitsw@t-online.de>, "
 
1628
        "Justin Thiessen <jthiessen@penguincomputing.com>");
 
1629
MODULE_DESCRIPTION("LM85-B, LM85-C driver");
 
1630
 
 
1631
module_init(sm_lm85_init);
 
1632
module_exit(sm_lm85_exit);