← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/hwmon/w83627ehf.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/hwmon/w83627ehf.c
1
1
/*
2
2
    w83627ehf - Driver for the hardware monitoring functionality of
3
 
                the Winbond W83627EHF Super-I/O chip
 
3
                the Winbond W83627EHF Super-I/O chip
4
4
    Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
5
5
    Copyright (C) 2006  Yuan Mu (Winbond),
6
 
                        Rudolf Marek <r.marek@assembler.cz>
7
 
                        David Hubbard <david.c.hubbard@gmail.com>
 
6
                        Rudolf Marek <r.marek@assembler.cz>
 
7
                        David Hubbard <david.c.hubbard@gmail.com>
8
8
                        Daniel J Blueman <daniel.blueman@gmail.com>
 
9
    Copyright (C) 2010  Sheng-Yuan Huang (Nuvoton) (PS00)
9
10
 
10
11
    Shamelessly ripped from the w83627hf driver
11
12
    Copyright (C) 2003  Mark Studebaker
35
36
 
36
37
    Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
37
38
    w83627ehf   10      5       4       3      0x8850 0x88    0x5ca3
38
 
                                               0x8860 0xa1
 
39
                                               0x8860 0xa1
39
40
    w83627dhg    9      5       4       3      0xa020 0xc1    0x5ca3
40
41
    w83627dhg-p  9      5       4       3      0xb070 0xc1    0x5ca3
41
42
    w83667hg     9      5       3       3      0xa510 0xc1    0x5ca3
42
 
    w83667hg-b   9      5       3       3      0xb350 0xc1    0x5ca3
 
43
    w83667hg-b   9      5       3       4      0xb350 0xc1    0x5ca3
 
44
    nct6775f     9      4       3       9      0xb470 0xc1    0x5ca3
 
45
    nct6776f     9      5       3       9      0xC330 0xc1    0x5ca3
43
46
*/
44
47
 
45
48
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
58
61
#include <linux/io.h>
59
62
#include "lm75.h"
60
63
 
61
 
enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg, w83667hg_b };
 
64
enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg, w83667hg_b, nct6775,
 
65
        nct6776 };
62
66
 
63
67
/* used to set data->name = w83627ehf_device_names[data->sio_kind] */
64
 
static const char * w83627ehf_device_names[] = {
 
68
static const char * const w83627ehf_device_names[] = {
65
69
        "w83627ehf",
66
70
        "w83627dhg",
67
71
        "w83627dhg",
68
72
        "w83667hg",
69
73
        "w83667hg",
 
74
        "nct6775",
 
75
        "nct6776",
70
76
};
71
77
 
72
78
static unsigned short force_id;
73
79
module_param(force_id, ushort, 0);
74
80
MODULE_PARM_DESC(force_id, "Override the detected device ID");
75
81
 
 
82
static unsigned short fan_debounce;
 
83
module_param(fan_debounce, ushort, 0);
 
84
MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
 
85
 
76
86
#define DRVNAME "w83627ehf"
77
87
 
78
88
/*
80
90
 */
81
91
 
82
92
#define W83627EHF_LD_HWM        0x0b
83
 
#define W83667HG_LD_VID         0x0d
 
93
#define W83667HG_LD_VID         0x0d
84
94
 
85
95
#define SIO_REG_LDSEL           0x07    /* Logical device select */
86
96
#define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
94
104
#define SIO_W83627EHG_ID        0x8860
95
105
#define SIO_W83627DHG_ID        0xa020
96
106
#define SIO_W83627DHG_P_ID      0xb070
97
 
#define SIO_W83667HG_ID         0xa510
 
107
#define SIO_W83667HG_ID         0xa510
98
108
#define SIO_W83667HG_B_ID       0xb350
 
109
#define SIO_NCT6775_ID          0xb470
 
110
#define SIO_NCT6776_ID          0xc330
99
111
#define SIO_ID_MASK             0xFFF0
100
112
 
101
113
static inline void
138
150
 * ISA constants
139
151
 */
140
152
 
141
 
#define IOREGION_ALIGNMENT      ~7
 
153
#define IOREGION_ALIGNMENT      (~7)
142
154
#define IOREGION_OFFSET         5
143
155
#define IOREGION_LENGTH         2
144
156
#define ADDR_REG_OFFSET         0
164
176
#define W83627EHF_REG_IN(nr)            ((nr < 7) ? (0x20 + (nr)) : \
165
177
                                         (0x550 + (nr) - 7))
166
178
 
167
 
#define W83627EHF_REG_TEMP1             0x27
168
 
#define W83627EHF_REG_TEMP1_HYST        0x3a
169
 
#define W83627EHF_REG_TEMP1_OVER        0x39
170
 
static const u16 W83627EHF_REG_TEMP[] = { 0x150, 0x250 };
171
 
static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x153, 0x253 };
172
 
static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x155, 0x255 };
173
 
static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0x152, 0x252 };
 
179
static const u16 W83627EHF_REG_TEMP[] = { 0x27, 0x150, 0x250, 0x7e };
 
180
static const u16 W83627EHF_REG_TEMP_HYST[] = { 0x3a, 0x153, 0x253, 0 };
 
181
static const u16 W83627EHF_REG_TEMP_OVER[] = { 0x39, 0x155, 0x255, 0 };
 
182
static const u16 W83627EHF_REG_TEMP_CONFIG[] = { 0, 0x152, 0x252, 0 };
174
183
 
175
184
/* Fan clock dividers are spread over the following five registers */
176
185
#define W83627EHF_REG_FANDIV1           0x47
179
188
#define W83627EHF_REG_DIODE             0x59
180
189
#define W83627EHF_REG_SMI_OVT           0x4C
181
190
 
 
191
/* NCT6775F has its own fan divider registers */
 
192
#define NCT6775_REG_FANDIV1             0x506
 
193
#define NCT6775_REG_FANDIV2             0x507
 
194
#define NCT6775_REG_FAN_DEBOUNCE        0xf0
 
195
 
182
196
#define W83627EHF_REG_ALARM1            0x459
183
197
#define W83627EHF_REG_ALARM2            0x45A
184
198
#define W83627EHF_REG_ALARM3            0x45B
199
213
static const u8 W83627EHF_PWM_ENABLE_SHIFT[] = { 2, 4, 1, 4 };
200
214
 
201
215
/* FAN Duty Cycle, be used to control */
202
 
static const u8 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
203
 
static const u8 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
 
216
static const u16 W83627EHF_REG_PWM[] = { 0x01, 0x03, 0x11, 0x61 };
 
217
static const u16 W83627EHF_REG_TARGET[] = { 0x05, 0x06, 0x13, 0x63 };
204
218
static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
205
219
 
206
220
/* Advanced Fan control, some values are common for all fans */
207
 
static const u8 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 };
208
 
static const u8 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
209
 
static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 };
 
221
static const u16 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 };
 
222
static const u16 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
 
223
static const u16 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 };
210
224
 
211
 
static const u8 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON[]
 
225
static const u16 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON[]
212
226
                                                = { 0xff, 0x67, 0xff, 0x69 };
213
 
static const u8 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON[]
 
227
static const u16 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON[]
214
228
                                                = { 0xff, 0x68, 0xff, 0x6a };
215
229
 
216
 
static const u8 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B[] = { 0x67, 0x69, 0x6b };
217
 
static const u8 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B[] = { 0x68, 0x6a, 0x6c };
 
230
static const u16 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B[] = { 0x67, 0x69, 0x6b };
 
231
static const u16 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B[]
 
232
                                                = { 0x68, 0x6a, 0x6c };
 
233
 
 
234
static const u16 NCT6775_REG_TARGET[] = { 0x101, 0x201, 0x301 };
 
235
static const u16 NCT6775_REG_FAN_MODE[] = { 0x102, 0x202, 0x302 };
 
236
static const u16 NCT6775_REG_FAN_STOP_OUTPUT[] = { 0x105, 0x205, 0x305 };
 
237
static const u16 NCT6775_REG_FAN_START_OUTPUT[] = { 0x106, 0x206, 0x306 };
 
238
static const u16 NCT6775_REG_FAN_STOP_TIME[] = { 0x107, 0x207, 0x307 };
 
239
static const u16 NCT6775_REG_PWM[] = { 0x109, 0x209, 0x309 };
 
240
static const u16 NCT6775_REG_FAN_MAX_OUTPUT[] = { 0x10a, 0x20a, 0x30a };
 
241
static const u16 NCT6775_REG_FAN_STEP_OUTPUT[] = { 0x10b, 0x20b, 0x30b };
 
242
static const u16 NCT6775_REG_FAN[] = { 0x630, 0x632, 0x634, 0x636, 0x638 };
 
243
static const u16 NCT6776_REG_FAN_MIN[] = { 0x63a, 0x63c, 0x63e, 0x640, 0x642};
 
244
 
 
245
static const u16 NCT6775_REG_TEMP[]
 
246
        = { 0x27, 0x150, 0x250, 0x73, 0x75, 0x77, 0x62b, 0x62c, 0x62d };
 
247
static const u16 NCT6775_REG_TEMP_CONFIG[]
 
248
        = { 0, 0x152, 0x252, 0, 0, 0, 0x628, 0x629, 0x62A };
 
249
static const u16 NCT6775_REG_TEMP_HYST[]
 
250
        = { 0x3a, 0x153, 0x253, 0, 0, 0, 0x673, 0x678, 0x67D };
 
251
static const u16 NCT6775_REG_TEMP_OVER[]
 
252
        = { 0x39, 0x155, 0x255, 0, 0, 0, 0x672, 0x677, 0x67C };
 
253
static const u16 NCT6775_REG_TEMP_SOURCE[]
 
254
        = { 0x621, 0x622, 0x623, 0x100, 0x200, 0x300, 0x624, 0x625, 0x626 };
 
255
 
 
256
static const char *const w83667hg_b_temp_label[] = {
 
257
        "SYSTIN",
 
258
        "CPUTIN",
 
259
        "AUXTIN",
 
260
        "AMDTSI",
 
261
        "PECI Agent 1",
 
262
        "PECI Agent 2",
 
263
        "PECI Agent 3",
 
264
        "PECI Agent 4"
 
265
};
 
266
 
 
267
static const char *const nct6775_temp_label[] = {
 
268
        "",
 
269
        "SYSTIN",
 
270
        "CPUTIN",
 
271
        "AUXTIN",
 
272
        "AMD SB-TSI",
 
273
        "PECI Agent 0",
 
274
        "PECI Agent 1",
 
275
        "PECI Agent 2",
 
276
        "PECI Agent 3",
 
277
        "PECI Agent 4",
 
278
        "PECI Agent 5",
 
279
        "PECI Agent 6",
 
280
        "PECI Agent 7",
 
281
        "PCH_CHIP_CPU_MAX_TEMP",
 
282
        "PCH_CHIP_TEMP",
 
283
        "PCH_CPU_TEMP",
 
284
        "PCH_MCH_TEMP",
 
285
        "PCH_DIM0_TEMP",
 
286
        "PCH_DIM1_TEMP",
 
287
        "PCH_DIM2_TEMP",
 
288
        "PCH_DIM3_TEMP"
 
289
};
 
290
 
 
291
static const char *const nct6776_temp_label[] = {
 
292
        "",
 
293
        "SYSTIN",
 
294
        "CPUTIN",
 
295
        "AUXTIN",
 
296
        "SMBUSMASTER 0",
 
297
        "SMBUSMASTER 1",
 
298
        "SMBUSMASTER 2",
 
299
        "SMBUSMASTER 3",
 
300
        "SMBUSMASTER 4",
 
301
        "SMBUSMASTER 5",
 
302
        "SMBUSMASTER 6",
 
303
        "SMBUSMASTER 7",
 
304
        "PECI Agent 0",
 
305
        "PECI Agent 1",
 
306
        "PCH_CHIP_CPU_MAX_TEMP",
 
307
        "PCH_CHIP_TEMP",
 
308
        "PCH_CPU_TEMP",
 
309
        "PCH_MCH_TEMP",
 
310
        "PCH_DIM0_TEMP",
 
311
        "PCH_DIM1_TEMP",
 
312
        "PCH_DIM2_TEMP",
 
313
        "PCH_DIM3_TEMP",
 
314
        "BYTE_TEMP"
 
315
};
 
316
 
 
317
#define NUM_REG_TEMP    ARRAY_SIZE(NCT6775_REG_TEMP)
 
318
 
 
319
static inline int is_word_sized(u16 reg)
 
320
{
 
321
        return ((((reg & 0xff00) == 0x100
 
322
              || (reg & 0xff00) == 0x200)
 
323
             && ((reg & 0x00ff) == 0x50
 
324
              || (reg & 0x00ff) == 0x53
 
325
              || (reg & 0x00ff) == 0x55))
 
326
             || (reg & 0xfff0) == 0x630
 
327
             || reg == 0x640 || reg == 0x642
 
328
             || ((reg & 0xfff0) == 0x650
 
329
                 && (reg & 0x000f) >= 0x06)
 
330
             || reg == 0x73 || reg == 0x75 || reg == 0x77
 
331
                );
 
332
}
218
333
 
219
334
/*
220
335
 * Conversions
232
347
                                                (msec + 200) / 400), 1, 255);
233
348
}
234
349
 
235
 
static inline unsigned int
236
 
fan_from_reg(u8 reg, unsigned int div)
 
350
static unsigned int fan_from_reg8(u16 reg, unsigned int divreg)
237
351
{
238
352
        if (reg == 0 || reg == 255)
239
353
                return 0;
240
 
        return 1350000U / (reg * div);
 
354
        return 1350000U / (reg << divreg);
 
355
}
 
356
 
 
357
static unsigned int fan_from_reg13(u16 reg, unsigned int divreg)
 
358
{
 
359
        if ((reg & 0xff1f) == 0xff1f)
 
360
                return 0;
 
361
 
 
362
        reg = (reg & 0x1f) | ((reg & 0xff00) >> 3);
 
363
 
 
364
        if (reg == 0)
 
365
                return 0;
 
366
 
 
367
        return 1350000U / reg;
 
368
}
 
369
 
 
370
static unsigned int fan_from_reg16(u16 reg, unsigned int divreg)
 
371
{
 
372
        if (reg == 0 || reg == 0xffff)
 
373
                return 0;
 
374
 
 
375
        /*
 
376
         * Even though the registers are 16 bit wide, the fan divisor
 
377
         * still applies.
 
378
         */
 
379
        return 1350000U / (reg << divreg);
241
380
}
242
381
 
243
382
static inline unsigned int
247
386
}
248
387
 
249
388
static inline int
250
 
temp1_from_reg(s8 reg)
 
389
temp_from_reg(u16 reg, s16 regval)
251
390
{
252
 
        return reg * 1000;
 
391
        if (is_word_sized(reg))
 
392
                return LM75_TEMP_FROM_REG(regval);
 
393
        return regval * 1000;
253
394
}
254
395
 
255
 
static inline s8
256
 
temp1_to_reg(long temp, int min, int max)
 
396
static inline u16
 
397
temp_to_reg(u16 reg, long temp)
257
398
{
258
 
        if (temp <= min)
259
 
                return min / 1000;
260
 
        if (temp >= max)
261
 
                return max / 1000;
262
 
        if (temp < 0)
263
 
                return (temp - 500) / 1000;
264
 
        return (temp + 500) / 1000;
 
399
        if (is_word_sized(reg))
 
400
                return LM75_TEMP_TO_REG(temp);
 
401
        return DIV_ROUND_CLOSEST(SENSORS_LIMIT(temp, -127000, 128000), 1000);
265
402
}
266
403
 
267
404
/* Some of analog inputs have internal scaling (2x), 8mV is ADC LSB */
275
412
 
276
413
static inline u8 in_to_reg(u32 val, u8 nr)
277
414
{
278
 
        return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0, 255);
 
415
        return SENSORS_LIMIT(((val + (scale_in[nr] / 2)) / scale_in[nr]), 0,
 
416
                             255);
279
417
}
280
418
 
281
419
/*
289
427
        struct device *hwmon_dev;
290
428
        struct mutex lock;
291
429
 
292
 
        const u8 *REG_FAN_START_OUTPUT;
293
 
        const u8 *REG_FAN_STOP_OUTPUT;
294
 
        const u8 *REG_FAN_MAX_OUTPUT;
295
 
        const u8 *REG_FAN_STEP_OUTPUT;
 
430
        u16 reg_temp[NUM_REG_TEMP];
 
431
        u16 reg_temp_over[NUM_REG_TEMP];
 
432
        u16 reg_temp_hyst[NUM_REG_TEMP];
 
433
        u16 reg_temp_config[NUM_REG_TEMP];
 
434
        u8 temp_src[NUM_REG_TEMP];
 
435
        const char * const *temp_label;
 
436
 
 
437
        const u16 *REG_PWM;
 
438
        const u16 *REG_TARGET;
 
439
        const u16 *REG_FAN;
 
440
        const u16 *REG_FAN_MIN;
 
441
        const u16 *REG_FAN_START_OUTPUT;
 
442
        const u16 *REG_FAN_STOP_OUTPUT;
 
443
        const u16 *REG_FAN_STOP_TIME;
 
444
        const u16 *REG_FAN_MAX_OUTPUT;
 
445
        const u16 *REG_FAN_STEP_OUTPUT;
 
446
 
 
447
        unsigned int (*fan_from_reg)(u16 reg, unsigned int divreg);
 
448
        unsigned int (*fan_from_reg_min)(u16 reg, unsigned int divreg);
296
449
 
297
450
        struct mutex update_lock;
298
451
        char valid;             /* !=0 if following fields are valid */
299
452
        unsigned long last_updated;     /* In jiffies */
300
453
 
301
454
        /* Register values */
 
455
        u8 bank;                /* current register bank */
302
456
        u8 in_num;              /* number of in inputs we have */
303
457
        u8 in[10];              /* Register value */
304
458
        u8 in_max[10];          /* Register value */
305
459
        u8 in_min[10];          /* Register value */
306
 
        u8 fan[5];
307
 
        u8 fan_min[5];
 
460
        unsigned int rpm[5];
 
461
        u16 fan_min[5];
308
462
        u8 fan_div[5];
309
463
        u8 has_fan;             /* some fan inputs can be disabled */
 
464
        u8 has_fan_min;         /* some fans don't have min register */
 
465
        bool has_fan_div;
310
466
        u8 temp_type[3];
311
 
        s8 temp1;
312
 
        s8 temp1_max;
313
 
        s8 temp1_max_hyst;
314
 
        s16 temp[2];
315
 
        s16 temp_max[2];
316
 
        s16 temp_max_hyst[2];
 
467
        s16 temp[9];
 
468
        s16 temp_max[9];
 
469
        s16 temp_max_hyst[9];
317
470
        u32 alarms;
318
471
 
319
472
        u8 pwm_mode[4]; /* 0->DC variable voltage, 1->PWM variable duty cycle */
320
473
        u8 pwm_enable[4]; /* 1->manual
321
474
                             2->thermal cruise mode (also called SmartFan I)
322
475
                             3->fan speed cruise mode
323
 
                             4->variable thermal cruise (also called SmartFan III) */
 
476
                             4->variable thermal cruise (also called
 
477
                                SmartFan III)
 
478
                             5->enhanced variable thermal cruise (also called
 
479
                                SmartFan IV) */
 
480
        u8 pwm_enable_orig[4];  /* original value of pwm_enable */
324
481
        u8 pwm_num;             /* number of pwm */
325
482
        u8 pwm[4];
326
483
        u8 target_temp[4];
335
492
        u8 vid;
336
493
        u8 vrm;
337
494
 
338
 
        u8 temp3_disable;
 
495
        u16 have_temp;
339
496
        u8 in6_skip;
340
497
};
341
498
 
344
501
        enum kinds kind;
345
502
};
346
503
 
347
 
static inline int is_word_sized(u16 reg)
348
 
{
349
 
        return (((reg & 0xff00) == 0x100
350
 
              || (reg & 0xff00) == 0x200)
351
 
             && ((reg & 0x00ff) == 0x50
352
 
              || (reg & 0x00ff) == 0x53
353
 
              || (reg & 0x00ff) == 0x55));
354
 
}
355
 
 
356
 
/* Registers 0x50-0x5f are banked */
 
504
/*
 
505
 * On older chips, only registers 0x50-0x5f are banked.
 
506
 * On more recent chips, all registers are banked.
 
507
 * Assume that is the case and set the bank number for each access.
 
508
 * Cache the bank number so it only needs to be set if it changes.
 
509
 */
357
510
static inline void w83627ehf_set_bank(struct w83627ehf_data *data, u16 reg)
358
511
{
359
 
        if ((reg & 0x00f0) == 0x50) {
360
 
                outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
361
 
                outb_p(reg >> 8, data->addr + DATA_REG_OFFSET);
362
 
        }
363
 
}
364
 
 
365
 
/* Not strictly necessary, but play it safe for now */
366
 
static inline void w83627ehf_reset_bank(struct w83627ehf_data *data, u16 reg)
367
 
{
368
 
        if (reg & 0xff00) {
369
 
                outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
370
 
                outb_p(0, data->addr + DATA_REG_OFFSET);
 
512
        u8 bank = reg >> 8;
 
513
        if (data->bank != bank) {
 
514
                outb_p(W83627EHF_REG_BANK, data->addr + ADDR_REG_OFFSET);
 
515
                outb_p(bank, data->addr + DATA_REG_OFFSET);
 
516
                data->bank = bank;
371
517
        }
372
518
}
373
519
 
385
531
                       data->addr + ADDR_REG_OFFSET);
386
532
                res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
387
533
        }
388
 
        w83627ehf_reset_bank(data, reg);
389
534
 
390
535
        mutex_unlock(&data->lock);
391
 
 
392
536
        return res;
393
537
}
394
538
 
395
 
static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg, u16 value)
 
539
static int w83627ehf_write_value(struct w83627ehf_data *data, u16 reg,
 
540
                                 u16 value)
396
541
{
397
542
        int word_sized = is_word_sized(reg);
398
543
 
406
551
                       data->addr + ADDR_REG_OFFSET);
407
552
        }
408
553
        outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
409
 
        w83627ehf_reset_bank(data, reg);
410
554
 
411
555
        mutex_unlock(&data->lock);
412
556
        return 0;
413
557
}
414
558
 
415
559
/* This function assumes that the caller holds data->update_lock */
 
560
static void nct6775_write_fan_div(struct w83627ehf_data *data, int nr)
 
561
{
 
562
        u8 reg;
 
563
 
 
564
        switch (nr) {
 
565
        case 0:
 
566
                reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
 
567
                    | (data->fan_div[0] & 0x7);
 
568
                w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
 
569
                break;
 
570
        case 1:
 
571
                reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
 
572
                    | ((data->fan_div[1] << 4) & 0x70);
 
573
                w83627ehf_write_value(data, NCT6775_REG_FANDIV1, reg);
 
574
        case 2:
 
575
                reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
 
576
                    | (data->fan_div[2] & 0x7);
 
577
                w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
 
578
                break;
 
579
        case 3:
 
580
                reg = (w83627ehf_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
 
581
                    | ((data->fan_div[3] << 4) & 0x70);
 
582
                w83627ehf_write_value(data, NCT6775_REG_FANDIV2, reg);
 
583
                break;
 
584
        }
 
585
}
 
586
 
 
587
/* This function assumes that the caller holds data->update_lock */
416
588
static void w83627ehf_write_fan_div(struct w83627ehf_data *data, int nr)
417
589
{
418
590
        u8 reg;
463
635
        }
464
636
}
465
637
 
 
638
static void w83627ehf_write_fan_div_common(struct device *dev,
 
639
                                           struct w83627ehf_data *data, int nr)
 
640
{
 
641
        struct w83627ehf_sio_data *sio_data = dev->platform_data;
 
642
 
 
643
        if (sio_data->kind == nct6776)
 
644
                ; /* no dividers, do nothing */
 
645
        else if (sio_data->kind == nct6775)
 
646
                nct6775_write_fan_div(data, nr);
 
647
        else
 
648
                w83627ehf_write_fan_div(data, nr);
 
649
}
 
650
 
 
651
static void nct6775_update_fan_div(struct w83627ehf_data *data)
 
652
{
 
653
        u8 i;
 
654
 
 
655
        i = w83627ehf_read_value(data, NCT6775_REG_FANDIV1);
 
656
        data->fan_div[0] = i & 0x7;
 
657
        data->fan_div[1] = (i & 0x70) >> 4;
 
658
        i = w83627ehf_read_value(data, NCT6775_REG_FANDIV2);
 
659
        data->fan_div[2] = i & 0x7;
 
660
        if (data->has_fan & (1<<3))
 
661
                data->fan_div[3] = (i & 0x70) >> 4;
 
662
}
 
663
 
466
664
static void w83627ehf_update_fan_div(struct w83627ehf_data *data)
467
665
{
468
666
        int i;
488
686
        }
489
687
}
490
688
 
 
689
static void w83627ehf_update_fan_div_common(struct device *dev,
 
690
                                            struct w83627ehf_data *data)
 
691
{
 
692
        struct w83627ehf_sio_data *sio_data = dev->platform_data;
 
693
 
 
694
        if (sio_data->kind == nct6776)
 
695
                ; /* no dividers, do nothing */
 
696
        else if (sio_data->kind == nct6775)
 
697
                nct6775_update_fan_div(data);
 
698
        else
 
699
                w83627ehf_update_fan_div(data);
 
700
}
 
701
 
 
702
static void nct6775_update_pwm(struct w83627ehf_data *data)
 
703
{
 
704
        int i;
 
705
        int pwmcfg, fanmodecfg;
 
706
 
 
707
        for (i = 0; i < data->pwm_num; i++) {
 
708
                pwmcfg = w83627ehf_read_value(data,
 
709
                                              W83627EHF_REG_PWM_ENABLE[i]);
 
710
                fanmodecfg = w83627ehf_read_value(data,
 
711
                                                  NCT6775_REG_FAN_MODE[i]);
 
712
                data->pwm_mode[i] =
 
713
                  ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
 
714
                data->pwm_enable[i] = ((fanmodecfg >> 4) & 7) + 1;
 
715
                data->tolerance[i] = fanmodecfg & 0x0f;
 
716
                data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
 
717
        }
 
718
}
 
719
 
 
720
static void w83627ehf_update_pwm(struct w83627ehf_data *data)
 
721
{
 
722
        int i;
 
723
        int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
 
724
 
 
725
        for (i = 0; i < data->pwm_num; i++) {
 
726
                if (!(data->has_fan & (1 << i)))
 
727
                        continue;
 
728
 
 
729
                /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
 
730
                if (i != 1) {
 
731
                        pwmcfg = w83627ehf_read_value(data,
 
732
                                        W83627EHF_REG_PWM_ENABLE[i]);
 
733
                        tolerance = w83627ehf_read_value(data,
 
734
                                        W83627EHF_REG_TOLERANCE[i]);
 
735
                }
 
736
                data->pwm_mode[i] =
 
737
                        ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1) ? 0 : 1;
 
738
                data->pwm_enable[i] = ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
 
739
                                       & 3) + 1;
 
740
                data->pwm[i] = w83627ehf_read_value(data, data->REG_PWM[i]);
 
741
 
 
742
                data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0)) & 0x0f;
 
743
        }
 
744
}
 
745
 
 
746
static void w83627ehf_update_pwm_common(struct device *dev,
 
747
                                        struct w83627ehf_data *data)
 
748
{
 
749
        struct w83627ehf_sio_data *sio_data = dev->platform_data;
 
750
 
 
751
        if (sio_data->kind == nct6775 || sio_data->kind == nct6776)
 
752
                nct6775_update_pwm(data);
 
753
        else
 
754
                w83627ehf_update_pwm(data);
 
755
}
 
756
 
491
757
static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
492
758
{
493
759
        struct w83627ehf_data *data = dev_get_drvdata(dev);
494
 
        int pwmcfg = 0, tolerance = 0; /* shut up the compiler */
 
760
        struct w83627ehf_sio_data *sio_data = dev->platform_data;
 
761
 
495
762
        int i;
496
763
 
497
764
        mutex_lock(&data->update_lock);
499
766
        if (time_after(jiffies, data->last_updated + HZ + HZ/2)
500
767
         || !data->valid) {
501
768
                /* Fan clock dividers */
502
 
                w83627ehf_update_fan_div(data);
 
769
                w83627ehf_update_fan_div_common(dev, data);
503
770
 
504
771
                /* Measured voltages and limits */
505
772
                for (i = 0; i < data->in_num; i++) {
513
780
 
514
781
                /* Measured fan speeds and limits */
515
782
                for (i = 0; i < 5; i++) {
 
783
                        u16 reg;
 
784
 
516
785
                        if (!(data->has_fan & (1 << i)))
517
786
                                continue;
518
787
 
519
 
                        data->fan[i] = w83627ehf_read_value(data,
520
 
                                       W83627EHF_REG_FAN[i]);
521
 
                        data->fan_min[i] = w83627ehf_read_value(data,
522
 
                                           W83627EHF_REG_FAN_MIN[i]);
 
788
                        reg = w83627ehf_read_value(data, data->REG_FAN[i]);
 
789
                        data->rpm[i] = data->fan_from_reg(reg,
 
790
                                                          data->fan_div[i]);
 
791
 
 
792
                        if (data->has_fan_min & (1 << i))
 
793
                                data->fan_min[i] = w83627ehf_read_value(data,
 
794
                                           data->REG_FAN_MIN[i]);
523
795
 
524
796
                        /* If we failed to measure the fan speed and clock
525
797
                           divider can be increased, let's try that for next
526
798
                           time */
527
 
                        if (data->fan[i] == 0xff
528
 
                         && data->fan_div[i] < 0x07) {
529
 
                                dev_dbg(dev, "Increasing fan%d "
 
799
                        if (data->has_fan_div
 
800
                            && (reg >= 0xff || (sio_data->kind == nct6775
 
801
                                                && reg == 0x00))
 
802
                            && data->fan_div[i] < 0x07) {
 
803
                                dev_dbg(dev, "Increasing fan%d "
530
804
                                        "clock divider from %u to %u\n",
531
805
                                        i + 1, div_from_reg(data->fan_div[i]),
532
806
                                        div_from_reg(data->fan_div[i] + 1));
533
807
                                data->fan_div[i]++;
534
 
                                w83627ehf_write_fan_div(data, i);
 
808
                                w83627ehf_write_fan_div_common(dev, data, i);
535
809
                                /* Preserve min limit if possible */
536
 
                                if (data->fan_min[i] >= 2
 
810
                                if ((data->has_fan_min & (1 << i))
 
811
                                 && data->fan_min[i] >= 2
537
812
                                 && data->fan_min[i] != 255)
538
813
                                        w83627ehf_write_value(data,
539
 
                                                W83627EHF_REG_FAN_MIN[i],
 
814
                                                data->REG_FAN_MIN[i],
540
815
                                                (data->fan_min[i] /= 2));
541
816
                        }
542
817
                }
543
818
 
 
819
                w83627ehf_update_pwm_common(dev, data);
 
820
 
544
821
                for (i = 0; i < data->pwm_num; i++) {
545
822
                        if (!(data->has_fan & (1 << i)))
546
823
                                continue;
547
824
 
548
 
                        /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
549
 
                        if (i != 1) {
550
 
                                pwmcfg = w83627ehf_read_value(data,
551
 
                                                W83627EHF_REG_PWM_ENABLE[i]);
552
 
                                tolerance = w83627ehf_read_value(data,
553
 
                                                W83627EHF_REG_TOLERANCE[i]);
554
 
                        }
555
 
                        data->pwm_mode[i] =
556
 
                                ((pwmcfg >> W83627EHF_PWM_MODE_SHIFT[i]) & 1)
557
 
                                ? 0 : 1;
558
 
                        data->pwm_enable[i] =
559
 
                                        ((pwmcfg >> W83627EHF_PWM_ENABLE_SHIFT[i])
560
 
                                                & 3) + 1;
561
 
                        data->pwm[i] = w83627ehf_read_value(data,
562
 
                                                W83627EHF_REG_PWM[i]);
563
 
                        data->fan_start_output[i] = w83627ehf_read_value(data,
564
 
                                                W83627EHF_REG_FAN_START_OUTPUT[i]);
565
 
                        data->fan_stop_output[i] = w83627ehf_read_value(data,
566
 
                                                W83627EHF_REG_FAN_STOP_OUTPUT[i]);
567
 
                        data->fan_stop_time[i] = w83627ehf_read_value(data,
568
 
                                                W83627EHF_REG_FAN_STOP_TIME[i]);
 
825
                        data->fan_start_output[i] =
 
826
                          w83627ehf_read_value(data,
 
827
                                               data->REG_FAN_START_OUTPUT[i]);
 
828
                        data->fan_stop_output[i] =
 
829
                          w83627ehf_read_value(data,
 
830
                                               data->REG_FAN_STOP_OUTPUT[i]);
 
831
                        data->fan_stop_time[i] =
 
832
                          w83627ehf_read_value(data,
 
833
                                               data->REG_FAN_STOP_TIME[i]);
569
834
 
570
 
                        if (data->REG_FAN_MAX_OUTPUT[i] != 0xff)
 
835
                        if (data->REG_FAN_MAX_OUTPUT &&
 
836
                            data->REG_FAN_MAX_OUTPUT[i] != 0xff)
571
837
                                data->fan_max_output[i] =
572
838
                                  w83627ehf_read_value(data,
573
 
                                               data->REG_FAN_MAX_OUTPUT[i]);
 
839
                                                data->REG_FAN_MAX_OUTPUT[i]);
574
840
 
575
 
                        if (data->REG_FAN_STEP_OUTPUT[i] != 0xff)
 
841
                        if (data->REG_FAN_STEP_OUTPUT &&
 
842
                            data->REG_FAN_STEP_OUTPUT[i] != 0xff)
576
843
                                data->fan_step_output[i] =
577
844
                                  w83627ehf_read_value(data,
578
 
                                               data->REG_FAN_STEP_OUTPUT[i]);
 
845
                                                data->REG_FAN_STEP_OUTPUT[i]);
579
846
 
580
847
                        data->target_temp[i] =
581
848
                                w83627ehf_read_value(data,
582
 
                                        W83627EHF_REG_TARGET[i]) &
 
849
                                        data->REG_TARGET[i]) &
583
850
                                        (data->pwm_mode[i] == 1 ? 0x7f : 0xff);
584
 
                        data->tolerance[i] = (tolerance >> (i == 1 ? 4 : 0))
585
 
                                                                        & 0x0f;
586
851
                }
587
852
 
588
853
                /* Measured temperatures and limits */
589
 
                data->temp1 = w83627ehf_read_value(data,
590
 
                              W83627EHF_REG_TEMP1);
591
 
                data->temp1_max = w83627ehf_read_value(data,
592
 
                                  W83627EHF_REG_TEMP1_OVER);
593
 
                data->temp1_max_hyst = w83627ehf_read_value(data,
594
 
                                       W83627EHF_REG_TEMP1_HYST);
595
 
                for (i = 0; i < 2; i++) {
 
854
                for (i = 0; i < NUM_REG_TEMP; i++) {
 
855
                        if (!(data->have_temp & (1 << i)))
 
856
                                continue;
596
857
                        data->temp[i] = w83627ehf_read_value(data,
597
 
                                        W83627EHF_REG_TEMP[i]);
598
 
                        data->temp_max[i] = w83627ehf_read_value(data,
599
 
                                            W83627EHF_REG_TEMP_OVER[i]);
600
 
                        data->temp_max_hyst[i] = w83627ehf_read_value(data,
601
 
                                                 W83627EHF_REG_TEMP_HYST[i]);
 
858
                                                data->reg_temp[i]);
 
859
                        if (data->reg_temp_over[i])
 
860
                                data->temp_max[i]
 
861
                                  = w83627ehf_read_value(data,
 
862
                                                data->reg_temp_over[i]);
 
863
                        if (data->reg_temp_hyst[i])
 
864
                                data->temp_max_hyst[i]
 
865
                                  = w83627ehf_read_value(data,
 
866
                                                data->reg_temp_hyst[i]);
602
867
                }
603
868
 
604
869
                data->alarms = w83627ehf_read_value(data,
625
890
           char *buf) \
626
891
{ \
627
892
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
628
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
893
        struct sensor_device_attribute *sensor_attr = \
 
894
                to_sensor_dev_attr(attr); \
629
895
        int nr = sensor_attr->index; \
630
896
        return sprintf(buf, "%ld\n", in_from_reg(data->reg[nr], nr)); \
631
897
}
635
901
 
636
902
#define store_in_reg(REG, reg) \
637
903
static ssize_t \
638
 
store_in_##reg (struct device *dev, struct device_attribute *attr, \
639
 
                        const char *buf, size_t count) \
 
904
store_in_##reg(struct device *dev, struct device_attribute *attr, \
 
905
               const char *buf, size_t count) \
640
906
{ \
641
907
        struct w83627ehf_data *data = dev_get_drvdata(dev); \
642
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
908
        struct sensor_device_attribute *sensor_attr = \
 
909
                to_sensor_dev_attr(attr); \
643
910
        int nr = sensor_attr->index; \
644
 
        u32 val = simple_strtoul(buf, NULL, 10); \
645
 
 \
 
911
        unsigned long val; \
 
912
        int err; \
 
913
        err = strict_strtoul(buf, 10, &val); \
 
914
        if (err < 0) \
 
915
                return err; \
646
916
        mutex_lock(&data->update_lock); \
647
917
        data->in_##reg[nr] = in_to_reg(val, nr); \
648
918
        w83627ehf_write_value(data, W83627EHF_REG_IN_##REG(nr), \
654
924
store_in_reg(MIN, min)
655
925
store_in_reg(MAX, max)
656
926
 
657
 
static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
 
927
static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
 
928
                          char *buf)
658
929
{
659
930
        struct w83627ehf_data *data = w83627ehf_update_device(dev);
660
931
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
689
960
};
690
961
 
691
962
static struct sensor_device_attribute sda_in_min[] = {
692
 
       SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
693
 
       SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
694
 
       SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
695
 
       SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
696
 
       SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
697
 
       SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
698
 
       SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
699
 
       SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
700
 
       SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
701
 
       SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
 
963
        SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
 
964
        SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
 
965
        SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
 
966
        SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
 
967
        SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
 
968
        SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
 
969
        SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
 
970
        SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
 
971
        SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
 
972
        SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 9),
702
973
};
703
974
 
704
975
static struct sensor_device_attribute sda_in_max[] = {
705
 
       SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
706
 
       SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
707
 
       SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
708
 
       SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
709
 
       SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
710
 
       SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
711
 
       SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
712
 
       SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
713
 
       SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
714
 
       SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
 
976
        SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
 
977
        SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
 
978
        SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
 
979
        SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
 
980
        SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
 
981
        SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
 
982
        SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
 
983
        SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
 
984
        SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
 
985
        SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 9),
715
986
};
716
987
 
717
 
#define show_fan_reg(reg) \
718
 
static ssize_t \
719
 
show_##reg(struct device *dev, struct device_attribute *attr, \
720
 
           char *buf) \
721
 
{ \
722
 
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
723
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
724
 
        int nr = sensor_attr->index; \
725
 
        return sprintf(buf, "%d\n", \
726
 
                       fan_from_reg(data->reg[nr], \
727
 
                                    div_from_reg(data->fan_div[nr]))); \
728
 
}
729
 
show_fan_reg(fan);
730
 
show_fan_reg(fan_min);
 
988
static ssize_t
 
989
show_fan(struct device *dev, struct device_attribute *attr, char *buf)
 
990
{
 
991
        struct w83627ehf_data *data = w83627ehf_update_device(dev);
 
992
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 
993
        int nr = sensor_attr->index;
 
994
        return sprintf(buf, "%d\n", data->rpm[nr]);
 
995
}
 
996
 
 
997
static ssize_t
 
998
show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
 
999
{
 
1000
        struct w83627ehf_data *data = w83627ehf_update_device(dev);
 
1001
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 
1002
        int nr = sensor_attr->index;
 
1003
        return sprintf(buf, "%d\n",
 
1004
                       data->fan_from_reg_min(data->fan_min[nr],
 
1005
                                              data->fan_div[nr]));
 
1006
}
731
1007
 
732
1008
static ssize_t
733
1009
show_fan_div(struct device *dev, struct device_attribute *attr,
746
1022
        struct w83627ehf_data *data = dev_get_drvdata(dev);
747
1023
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
748
1024
        int nr = sensor_attr->index;
749
 
        unsigned int val = simple_strtoul(buf, NULL, 10);
 
1025
        unsigned long val;
 
1026
        int err;
750
1027
        unsigned int reg;
751
1028
        u8 new_div;
752
1029
 
 
1030
        err = strict_strtoul(buf, 10, &val);
 
1031
        if (err < 0)
 
1032
                return err;
 
1033
 
753
1034
        mutex_lock(&data->update_lock);
 
1035
        if (!data->has_fan_div) {
 
1036
                /*
 
1037
                 * Only NCT6776F for now, so we know that this is a 13 bit
 
1038
                 * register
 
1039
                 */
 
1040
                if (!val) {
 
1041
                        val = 0xff1f;
 
1042
                } else {
 
1043
                        if (val > 1350000U)
 
1044
                                val = 135000U;
 
1045
                        val = 1350000U / val;
 
1046
                        val = (val & 0x1f) | ((val << 3) & 0xff00);
 
1047
                }
 
1048
                data->fan_min[nr] = val;
 
1049
                goto done;      /* Leave fan divider alone */
 
1050
        }
754
1051
        if (!val) {
755
1052
                /* No min limit, alarm disabled */
756
1053
                data->fan_min[nr] = 255;
761
1058
                   even with the highest divider (128) */
762
1059
                data->fan_min[nr] = 254;
763
1060
                new_div = 7; /* 128 == (1 << 7) */
764
 
                dev_warn(dev, "fan%u low limit %u below minimum %u, set to "
765
 
                         "minimum\n", nr + 1, val, fan_from_reg(254, 128));
 
1061
                dev_warn(dev, "fan%u low limit %lu below minimum %u, set to "
 
1062
                         "minimum\n", nr + 1, val,
 
1063
                         data->fan_from_reg_min(254, 7));
766
1064
        } else if (!reg) {
767
1065
                /* Speed above this value cannot possibly be represented,
768
1066
                   even with the lowest divider (1) */
769
1067
                data->fan_min[nr] = 1;
770
1068
                new_div = 0; /* 1 == (1 << 0) */
771
 
                dev_warn(dev, "fan%u low limit %u above maximum %u, set to "
772
 
                         "maximum\n", nr + 1, val, fan_from_reg(1, 1));
 
1069
                dev_warn(dev, "fan%u low limit %lu above maximum %u, set to "
 
1070
                         "maximum\n", nr + 1, val,
 
1071
                         data->fan_from_reg_min(1, 0));
773
1072
        } else {
774
1073
                /* Automatically pick the best divider, i.e. the one such
775
1074
                   that the min limit will correspond to a register value
785
1084
        /* Write both the fan clock divider (if it changed) and the new
786
1085
           fan min (unconditionally) */
787
1086
        if (new_div != data->fan_div[nr]) {
788
 
                /* Preserve the fan speed reading */
789
 
                if (data->fan[nr] != 0xff) {
790
 
                        if (new_div > data->fan_div[nr])
791
 
                                data->fan[nr] >>= new_div - data->fan_div[nr];
792
 
                        else if (data->fan[nr] & 0x80)
793
 
                                data->fan[nr] = 0xff;
794
 
                        else
795
 
                                data->fan[nr] <<= data->fan_div[nr] - new_div;
796
 
                }
797
 
 
798
1087
                dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
799
1088
                        nr + 1, div_from_reg(data->fan_div[nr]),
800
1089
                        div_from_reg(new_div));
801
1090
                data->fan_div[nr] = new_div;
802
 
                w83627ehf_write_fan_div(data, nr);
 
1091
                w83627ehf_write_fan_div_common(dev, data, nr);
803
1092
                /* Give the chip time to sample a new speed value */
804
1093
                data->last_updated = jiffies;
805
1094
        }
806
 
        w83627ehf_write_value(data, W83627EHF_REG_FAN_MIN[nr],
 
1095
done:
 
1096
        w83627ehf_write_value(data, data->REG_FAN_MIN[nr],
807
1097
                              data->fan_min[nr]);
808
1098
        mutex_unlock(&data->update_lock);
809
1099
 
847
1137
        SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
848
1138
};
849
1139
 
850
 
#define show_temp1_reg(reg) \
851
 
static ssize_t \
852
 
show_##reg(struct device *dev, struct device_attribute *attr, \
853
 
           char *buf) \
854
 
{ \
855
 
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
856
 
        return sprintf(buf, "%d\n", temp1_from_reg(data->reg)); \
857
 
}
858
 
show_temp1_reg(temp1);
859
 
show_temp1_reg(temp1_max);
860
 
show_temp1_reg(temp1_max_hyst);
861
 
 
862
 
#define store_temp1_reg(REG, reg) \
863
 
static ssize_t \
864
 
store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
865
 
                  const char *buf, size_t count) \
866
 
{ \
867
 
        struct w83627ehf_data *data = dev_get_drvdata(dev); \
868
 
        long val = simple_strtol(buf, NULL, 10); \
869
 
 \
870
 
        mutex_lock(&data->update_lock); \
871
 
        data->temp1_##reg = temp1_to_reg(val, -128000, 127000); \
872
 
        w83627ehf_write_value(data, W83627EHF_REG_TEMP1_##REG, \
873
 
                              data->temp1_##reg); \
874
 
        mutex_unlock(&data->update_lock); \
875
 
        return count; \
876
 
}
877
 
store_temp1_reg(OVER, max);
878
 
store_temp1_reg(HYST, max_hyst);
879
 
 
880
 
#define show_temp_reg(reg) \
881
 
static ssize_t \
882
 
show_##reg(struct device *dev, struct device_attribute *attr, \
883
 
           char *buf) \
884
 
{ \
885
 
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
886
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1140
static ssize_t
 
1141
show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
 
1142
{
 
1143
        struct w83627ehf_data *data = w83627ehf_update_device(dev);
 
1144
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
 
1145
        int nr = sensor_attr->index;
 
1146
        return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
 
1147
}
 
1148
 
 
1149
#define show_temp_reg(addr, reg) \
 
1150
static ssize_t \
 
1151
show_##reg(struct device *dev, struct device_attribute *attr, \
 
1152
           char *buf) \
 
1153
{ \
 
1154
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
 
1155
        struct sensor_device_attribute *sensor_attr = \
 
1156
                to_sensor_dev_attr(attr); \
887
1157
        int nr = sensor_attr->index; \
888
1158
        return sprintf(buf, "%d\n", \
889
 
                       LM75_TEMP_FROM_REG(data->reg[nr])); \
 
1159
                       temp_from_reg(data->addr[nr], data->reg[nr])); \
890
1160
}
891
 
show_temp_reg(temp);
892
 
show_temp_reg(temp_max);
893
 
show_temp_reg(temp_max_hyst);
 
1161
show_temp_reg(reg_temp, temp);
 
1162
show_temp_reg(reg_temp_over, temp_max);
 
1163
show_temp_reg(reg_temp_hyst, temp_max_hyst);
894
1164
 
895
 
#define store_temp_reg(REG, reg) \
 
1165
#define store_temp_reg(addr, reg) \
896
1166
static ssize_t \
897
1167
store_##reg(struct device *dev, struct device_attribute *attr, \
898
1168
            const char *buf, size_t count) \
899
1169
{ \
900
1170
        struct w83627ehf_data *data = dev_get_drvdata(dev); \
901
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1171
        struct sensor_device_attribute *sensor_attr = \
 
1172
                to_sensor_dev_attr(attr); \
902
1173
        int nr = sensor_attr->index; \
903
 
        long val = simple_strtol(buf, NULL, 10); \
904
 
 \
 
1174
        int err; \
 
1175
        long val; \
 
1176
        err = strict_strtol(buf, 10, &val); \
 
1177
        if (err < 0) \
 
1178
                return err; \
905
1179
        mutex_lock(&data->update_lock); \
906
 
        data->reg[nr] = LM75_TEMP_TO_REG(val); \
907
 
        w83627ehf_write_value(data, W83627EHF_REG_TEMP_##REG[nr], \
 
1180
        data->reg[nr] = temp_to_reg(data->addr[nr], val); \
 
1181
        w83627ehf_write_value(data, data->addr[nr], \
908
1182
                              data->reg[nr]); \
909
1183
        mutex_unlock(&data->update_lock); \
910
1184
        return count; \
911
1185
}
912
 
store_temp_reg(OVER, temp_max);
913
 
store_temp_reg(HYST, temp_max_hyst);
 
1186
store_temp_reg(reg_temp_over, temp_max);
 
1187
store_temp_reg(reg_temp_hyst, temp_max_hyst);
914
1188
 
915
1189
static ssize_t
916
1190
show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
922
1196
}
923
1197
 
924
1198
static struct sensor_device_attribute sda_temp_input[] = {
925
 
        SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
926
 
        SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
927
 
        SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
 
1199
        SENSOR_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0),
 
1200
        SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1),
 
1201
        SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2),
 
1202
        SENSOR_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3),
 
1203
        SENSOR_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4),
 
1204
        SENSOR_ATTR(temp6_input, S_IRUGO, show_temp, NULL, 5),
 
1205
        SENSOR_ATTR(temp7_input, S_IRUGO, show_temp, NULL, 6),
 
1206
        SENSOR_ATTR(temp8_input, S_IRUGO, show_temp, NULL, 7),
 
1207
        SENSOR_ATTR(temp9_input, S_IRUGO, show_temp, NULL, 8),
 
1208
};
 
1209
 
 
1210
static struct sensor_device_attribute sda_temp_label[] = {
 
1211
        SENSOR_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0),
 
1212
        SENSOR_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1),
 
1213
        SENSOR_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2),
 
1214
        SENSOR_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3),
 
1215
        SENSOR_ATTR(temp5_label, S_IRUGO, show_temp_label, NULL, 4),
 
1216
        SENSOR_ATTR(temp6_label, S_IRUGO, show_temp_label, NULL, 5),
 
1217
        SENSOR_ATTR(temp7_label, S_IRUGO, show_temp_label, NULL, 6),
 
1218
        SENSOR_ATTR(temp8_label, S_IRUGO, show_temp_label, NULL, 7),
 
1219
        SENSOR_ATTR(temp9_label, S_IRUGO, show_temp_label, NULL, 8),
928
1220
};
929
1221
 
930
1222
static struct sensor_device_attribute sda_temp_max[] = {
931
 
        SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
932
 
                    store_temp1_max, 0),
 
1223
        SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
 
1224
                    store_temp_max, 0),
933
1225
        SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
934
 
                    store_temp_max, 0),
 
1226
                    store_temp_max, 1),
935
1227
        SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
936
 
                    store_temp_max, 1),
 
1228
                    store_temp_max, 2),
 
1229
        SENSOR_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
 
1230
                    store_temp_max, 3),
 
1231
        SENSOR_ATTR(temp5_max, S_IRUGO | S_IWUSR, show_temp_max,
 
1232
                    store_temp_max, 4),
 
1233
        SENSOR_ATTR(temp6_max, S_IRUGO | S_IWUSR, show_temp_max,
 
1234
                    store_temp_max, 5),
 
1235
        SENSOR_ATTR(temp7_max, S_IRUGO | S_IWUSR, show_temp_max,
 
1236
                    store_temp_max, 6),
 
1237
        SENSOR_ATTR(temp8_max, S_IRUGO | S_IWUSR, show_temp_max,
 
1238
                    store_temp_max, 7),
 
1239
        SENSOR_ATTR(temp9_max, S_IRUGO | S_IWUSR, show_temp_max,
 
1240
                    store_temp_max, 8),
937
1241
};
938
1242
 
939
1243
static struct sensor_device_attribute sda_temp_max_hyst[] = {
940
 
        SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
941
 
                    store_temp1_max_hyst, 0),
 
1244
        SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 
1245
                    store_temp_max_hyst, 0),
942
1246
        SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
943
 
                    store_temp_max_hyst, 0),
 
1247
                    store_temp_max_hyst, 1),
944
1248
        SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
945
 
                    store_temp_max_hyst, 1),
 
1249
                    store_temp_max_hyst, 2),
 
1250
        SENSOR_ATTR(temp4_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 
1251
                    store_temp_max_hyst, 3),
 
1252
        SENSOR_ATTR(temp5_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 
1253
                    store_temp_max_hyst, 4),
 
1254
        SENSOR_ATTR(temp6_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 
1255
                    store_temp_max_hyst, 5),
 
1256
        SENSOR_ATTR(temp7_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 
1257
                    store_temp_max_hyst, 6),
 
1258
        SENSOR_ATTR(temp8_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 
1259
                    store_temp_max_hyst, 7),
 
1260
        SENSOR_ATTR(temp9_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
 
1261
                    store_temp_max_hyst, 8),
946
1262
};
947
1263
 
948
1264
static struct sensor_device_attribute sda_temp_alarm[] = {
958
1274
};
959
1275
 
960
1276
#define show_pwm_reg(reg) \
961
 
static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
962
 
                                char *buf) \
 
1277
static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 
1278
                          char *buf) \
963
1279
{ \
964
1280
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
965
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1281
        struct sensor_device_attribute *sensor_attr = \
 
1282
                to_sensor_dev_attr(attr); \
966
1283
        int nr = sensor_attr->index; \
967
1284
        return sprintf(buf, "%d\n", data->reg[nr]); \
968
1285
}
978
1295
        struct w83627ehf_data *data = dev_get_drvdata(dev);
979
1296
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
980
1297
        int nr = sensor_attr->index;
981
 
        u32 val = simple_strtoul(buf, NULL, 10);
 
1298
        unsigned long val;
 
1299
        int err;
982
1300
        u16 reg;
983
1301
 
 
1302
        err = strict_strtoul(buf, 10, &val);
 
1303
        if (err < 0)
 
1304
                return err;
 
1305
 
984
1306
        if (val > 1)
985
1307
                return -EINVAL;
986
1308
        mutex_lock(&data->update_lock);
1001
1323
        struct w83627ehf_data *data = dev_get_drvdata(dev);
1002
1324
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1003
1325
        int nr = sensor_attr->index;
1004
 
        u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
 
1326
        unsigned long val;
 
1327
        int err;
 
1328
 
 
1329
        err = strict_strtoul(buf, 10, &val);
 
1330
        if (err < 0)
 
1331
                return err;
 
1332
 
 
1333
        val = SENSORS_LIMIT(val, 0, 255);
1005
1334
 
1006
1335
        mutex_lock(&data->update_lock);
1007
1336
        data->pwm[nr] = val;
1008
 
        w83627ehf_write_value(data, W83627EHF_REG_PWM[nr], val);
 
1337
        w83627ehf_write_value(data, data->REG_PWM[nr], val);
1009
1338
        mutex_unlock(&data->update_lock);
1010
1339
        return count;
1011
1340
}
1015
1344
                        const char *buf, size_t count)
1016
1345
{
1017
1346
        struct w83627ehf_data *data = dev_get_drvdata(dev);
 
1347
        struct w83627ehf_sio_data *sio_data = dev->platform_data;
1018
1348
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1019
1349
        int nr = sensor_attr->index;
1020
 
        u32 val = simple_strtoul(buf, NULL, 10);
 
1350
        unsigned long val;
 
1351
        int err;
1021
1352
        u16 reg;
1022
1353
 
1023
 
        if (!val || (val > 4))
1024
 
                return -EINVAL;
 
1354
        err = strict_strtoul(buf, 10, &val);
 
1355
        if (err < 0)
 
1356
                return err;
 
1357
 
 
1358
        if (!val || (val > 4 && val != data->pwm_enable_orig[nr]))
 
1359
                return -EINVAL;
 
1360
        /* SmartFan III mode is not supported on NCT6776F */
 
1361
        if (sio_data->kind == nct6776 && val == 4)
 
1362
                return -EINVAL;
 
1363
 
1025
1364
        mutex_lock(&data->update_lock);
1026
 
        reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
1027
1365
        data->pwm_enable[nr] = val;
1028
 
        reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
1029
 
        reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
1030
 
        w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
 
1366
        if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
 
1367
                reg = w83627ehf_read_value(data,
 
1368
                                           NCT6775_REG_FAN_MODE[nr]);
 
1369
                reg &= 0x0f;
 
1370
                reg |= (val - 1) << 4;
 
1371
                w83627ehf_write_value(data,
 
1372
                                      NCT6775_REG_FAN_MODE[nr], reg);
 
1373
        } else {
 
1374
                reg = w83627ehf_read_value(data, W83627EHF_REG_PWM_ENABLE[nr]);
 
1375
                reg &= ~(0x03 << W83627EHF_PWM_ENABLE_SHIFT[nr]);
 
1376
                reg |= (val - 1) << W83627EHF_PWM_ENABLE_SHIFT[nr];
 
1377
                w83627ehf_write_value(data, W83627EHF_REG_PWM_ENABLE[nr], reg);
 
1378
        }
1031
1379
        mutex_unlock(&data->update_lock);
1032
1380
        return count;
1033
1381
}
1038
1386
                                char *buf) \
1039
1387
{ \
1040
1388
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1041
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1389
        struct sensor_device_attribute *sensor_attr = \
 
1390
                to_sensor_dev_attr(attr); \
1042
1391
        int nr = sensor_attr->index; \
1043
 
        return sprintf(buf, "%d\n", temp1_from_reg(data->reg[nr])); \
 
1392
        return sprintf(buf, "%d\n", data->reg[nr] * 1000); \
1044
1393
}
1045
1394
 
1046
1395
show_tol_temp(tolerance)
1053
1402
        struct w83627ehf_data *data = dev_get_drvdata(dev);
1054
1403
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1055
1404
        int nr = sensor_attr->index;
1056
 
        u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 127000);
 
1405
        long val;
 
1406
        int err;
 
1407
 
 
1408
        err = strict_strtol(buf, 10, &val);
 
1409
        if (err < 0)
 
1410
                return err;
 
1411
 
 
1412
        val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 127);
1057
1413
 
1058
1414
        mutex_lock(&data->update_lock);
1059
1415
        data->target_temp[nr] = val;
1060
 
        w83627ehf_write_value(data, W83627EHF_REG_TARGET[nr], val);
 
1416
        w83627ehf_write_value(data, data->REG_TARGET[nr], val);
1061
1417
        mutex_unlock(&data->update_lock);
1062
1418
        return count;
1063
1419
}
1067
1423
                        const char *buf, size_t count)
1068
1424
{
1069
1425
        struct w83627ehf_data *data = dev_get_drvdata(dev);
 
1426
        struct w83627ehf_sio_data *sio_data = dev->platform_data;
1070
1427
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
1071
1428
        int nr = sensor_attr->index;
1072
1429
        u16 reg;
 
1430
        long val;
 
1431
        int err;
 
1432
 
 
1433
        err = strict_strtol(buf, 10, &val);
 
1434
        if (err < 0)
 
1435
                return err;
 
1436
 
1073
1437
        /* Limit the temp to 0C - 15C */
1074
 
        u8 val = temp1_to_reg(simple_strtoul(buf, NULL, 10), 0, 15000);
 
1438
        val = SENSORS_LIMIT(DIV_ROUND_CLOSEST(val, 1000), 0, 15);
1075
1439
 
1076
1440
        mutex_lock(&data->update_lock);
1077
 
        reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
 
1441
        if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
 
1442
                /* Limit tolerance further for NCT6776F */
 
1443
                if (sio_data->kind == nct6776 && val > 7)
 
1444
                        val = 7;
 
1445
                reg = w83627ehf_read_value(data, NCT6775_REG_FAN_MODE[nr]);
 
1446
                reg = (reg & 0xf0) | val;
 
1447
                w83627ehf_write_value(data, NCT6775_REG_FAN_MODE[nr], reg);
 
1448
        } else {
 
1449
                reg = w83627ehf_read_value(data, W83627EHF_REG_TOLERANCE[nr]);
 
1450
                if (nr == 1)
 
1451
                        reg = (reg & 0x0f) | (val << 4);
 
1452
                else
 
1453
                        reg = (reg & 0xf0) | val;
 
1454
                w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
 
1455
        }
1078
1456
        data->tolerance[nr] = val;
1079
 
        if (nr == 1)
1080
 
                reg = (reg & 0x0f) | (val << 4);
1081
 
        else
1082
 
                reg = (reg & 0xf0) | val;
1083
 
        w83627ehf_write_value(data, W83627EHF_REG_TOLERANCE[nr], reg);
1084
1457
        mutex_unlock(&data->update_lock);
1085
1458
        return count;
1086
1459
}
1143
1516
                       char *buf) \
1144
1517
{ \
1145
1518
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1146
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1519
        struct sensor_device_attribute *sensor_attr = \
 
1520
                to_sensor_dev_attr(attr); \
1147
1521
        int nr = sensor_attr->index; \
1148
1522
        return sprintf(buf, "%d\n", data->reg[nr]); \
1149
 
}\
 
1523
} \
1150
1524
static ssize_t \
1151
1525
store_##reg(struct device *dev, struct device_attribute *attr, \
1152
1526
                            const char *buf, size_t count) \
1153
 
{\
 
1527
{ \
1154
1528
        struct w83627ehf_data *data = dev_get_drvdata(dev); \
1155
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1529
        struct sensor_device_attribute *sensor_attr = \
 
1530
                to_sensor_dev_attr(attr); \
1156
1531
        int nr = sensor_attr->index; \
1157
 
        u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
 
1532
        unsigned long val; \
 
1533
        int err; \
 
1534
        err = strict_strtoul(buf, 10, &val); \
 
1535
        if (err < 0) \
 
1536
                return err; \
 
1537
        val = SENSORS_LIMIT(val, 1, 255); \
1158
1538
        mutex_lock(&data->update_lock); \
1159
1539
        data->reg[nr] = val; \
1160
1540
        w83627ehf_write_value(data, data->REG_##REG[nr], val); \
1172
1552
                                char *buf) \
1173
1553
{ \
1174
1554
        struct w83627ehf_data *data = w83627ehf_update_device(dev); \
1175
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1555
        struct sensor_device_attribute *sensor_attr = \
 
1556
                to_sensor_dev_attr(attr); \
1176
1557
        int nr = sensor_attr->index; \
1177
1558
        return sprintf(buf, "%d\n", \
1178
 
                        step_time_from_reg(data->reg[nr], data->pwm_mode[nr])); \
 
1559
                        step_time_from_reg(data->reg[nr], \
 
1560
                                           data->pwm_mode[nr])); \
1179
1561
} \
1180
1562
\
1181
1563
static ssize_t \
1183
1565
                        const char *buf, size_t count) \
1184
1566
{ \
1185
1567
        struct w83627ehf_data *data = dev_get_drvdata(dev); \
1186
 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
 
1568
        struct sensor_device_attribute *sensor_attr = \
 
1569
                to_sensor_dev_attr(attr); \
1187
1570
        int nr = sensor_attr->index; \
1188
 
        u8 val = step_time_to_reg(simple_strtoul(buf, NULL, 10), \
1189
 
                                        data->pwm_mode[nr]); \
 
1571
        unsigned long val; \
 
1572
        int err; \
 
1573
        err = strict_strtoul(buf, 10, &val); \
 
1574
        if (err < 0) \
 
1575
                return err; \
 
1576
        val = step_time_to_reg(val, data->pwm_mode[nr]); \
1190
1577
        mutex_lock(&data->update_lock); \
1191
1578
        data->reg[nr] = val; \
1192
1579
        w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
1283
1670
        for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
1284
1671
                struct sensor_device_attribute *attr =
1285
1672
                  &sda_sf3_max_step_arrays[i];
1286
 
                if (data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff)
 
1673
                if (data->REG_FAN_STEP_OUTPUT &&
 
1674
                    data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff)
1287
1675
                        device_remove_file(dev, &attr->dev_attr);
1288
1676
        }
1289
1677
        for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
1309
1697
                device_remove_file(dev, &sda_target_temp[i].dev_attr);
1310
1698
                device_remove_file(dev, &sda_tolerance[i].dev_attr);
1311
1699
        }
1312
 
        for (i = 0; i < 3; i++) {
1313
 
                if ((i == 2) && data->temp3_disable)
 
1700
        for (i = 0; i < NUM_REG_TEMP; i++) {
 
1701
                if (!(data->have_temp & (1 << i)))
1314
1702
                        continue;
1315
1703
                device_remove_file(dev, &sda_temp_input[i].dev_attr);
 
1704
                device_remove_file(dev, &sda_temp_label[i].dev_attr);
1316
1705
                device_remove_file(dev, &sda_temp_max[i].dev_attr);
1317
1706
                device_remove_file(dev, &sda_temp_max_hyst[i].dev_attr);
 
1707
                if (i > 2)
 
1708
                        continue;
1318
1709
                device_remove_file(dev, &sda_temp_alarm[i].dev_attr);
1319
1710
                device_remove_file(dev, &sda_temp_type[i].dev_attr);
1320
1711
        }
1335
1726
                w83627ehf_write_value(data, W83627EHF_REG_CONFIG,
1336
1727
                                      tmp | 0x01);
1337
1728
 
1338
 
        /* Enable temp2 and temp3 if needed */
1339
 
        for (i = 0; i < 2; i++) {
 
1729
        /* Enable temperature sensors if needed */
 
1730
        for (i = 0; i < NUM_REG_TEMP; i++) {
 
1731
                if (!(data->have_temp & (1 << i)))
 
1732
                        continue;
 
1733
                if (!data->reg_temp_config[i])
 
1734
                        continue;
1340
1735
                tmp = w83627ehf_read_value(data,
1341
 
                                           W83627EHF_REG_TEMP_CONFIG[i]);
1342
 
                if ((i == 1) && data->temp3_disable)
1343
 
                        continue;
 
1736
                                           data->reg_temp_config[i]);
1344
1737
                if (tmp & 0x01)
1345
1738
                        w83627ehf_write_value(data,
1346
 
                                              W83627EHF_REG_TEMP_CONFIG[i],
 
1739
                                              data->reg_temp_config[i],
1347
1740
                                              tmp & 0xfe);
1348
1741
        }
1349
1742
 
1362
1755
        }
1363
1756
}
1364
1757
 
 
1758
static void w82627ehf_swap_tempreg(struct w83627ehf_data *data,
 
1759
                                   int r1, int r2)
 
1760
{
 
1761
        u16 tmp;
 
1762
 
 
1763
        tmp = data->temp_src[r1];
 
1764
        data->temp_src[r1] = data->temp_src[r2];
 
1765
        data->temp_src[r2] = tmp;
 
1766
 
 
1767
        tmp = data->reg_temp[r1];
 
1768
        data->reg_temp[r1] = data->reg_temp[r2];
 
1769
        data->reg_temp[r2] = tmp;
 
1770
 
 
1771
        tmp = data->reg_temp_over[r1];
 
1772
        data->reg_temp_over[r1] = data->reg_temp_over[r2];
 
1773
        data->reg_temp_over[r2] = tmp;
 
1774
 
 
1775
        tmp = data->reg_temp_hyst[r1];
 
1776
        data->reg_temp_hyst[r1] = data->reg_temp_hyst[r2];
 
1777
        data->reg_temp_hyst[r2] = tmp;
 
1778
 
 
1779
        tmp = data->reg_temp_config[r1];
 
1780
        data->reg_temp_config[r1] = data->reg_temp_config[r2];
 
1781
        data->reg_temp_config[r2] = tmp;
 
1782
}
 
1783
 
1365
1784
static int __devinit w83627ehf_probe(struct platform_device *pdev)
1366
1785
{
1367
1786
        struct device *dev = &pdev->dev;
1368
1787
        struct w83627ehf_sio_data *sio_data = dev->platform_data;
1369
1788
        struct w83627ehf_data *data;
1370
1789
        struct resource *res;
1371
 
        u8 fan4pin, fan5pin, en_vrm10;
 
1790
        u8 fan3pin, fan4pin, fan4min, fan5pin, en_vrm10;
1372
1791
        int i, err = 0;
1373
1792
 
1374
1793
        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1380
1799
                goto exit;
1381
1800
        }
1382
1801
 
1383
 
        if (!(data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL))) {
 
1802
        data = kzalloc(sizeof(struct w83627ehf_data), GFP_KERNEL);
 
1803
        if (!data) {
1384
1804
                err = -ENOMEM;
1385
1805
                goto exit_release;
1386
1806
        }
1393
1813
 
1394
1814
        /* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
1395
1815
        data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
1396
 
        /* 667HG has 3 pwms */
 
1816
        /* 667HG, NCT6775F, and NCT6776F have 3 pwms */
1397
1817
        data->pwm_num = (sio_data->kind == w83667hg
1398
 
                         || sio_data->kind == w83667hg_b) ? 3 : 4;
 
1818
                         || sio_data->kind == w83667hg_b
 
1819
                         || sio_data->kind == nct6775
 
1820
                         || sio_data->kind == nct6776) ? 3 : 4;
1399
1821
 
 
1822
        data->have_temp = 0x07;
1400
1823
        /* Check temp3 configuration bit for 667HG */
1401
 
        if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
1402
 
                data->temp3_disable = w83627ehf_read_value(data,
1403
 
                                        W83627EHF_REG_TEMP_CONFIG[1]) & 0x01;
1404
 
                data->in6_skip = !data->temp3_disable;
1405
 
        }
1406
 
 
1407
 
        data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
1408
 
        data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
1409
 
        if (sio_data->kind == w83667hg_b) {
 
1824
        if (sio_data->kind == w83667hg) {
 
1825
                u8 reg;
 
1826
 
 
1827
                reg = w83627ehf_read_value(data, W83627EHF_REG_TEMP_CONFIG[2]);
 
1828
                if (reg & 0x01)
 
1829
                        data->have_temp &= ~(1 << 2);
 
1830
                else
 
1831
                        data->in6_skip = 1;     /* either temp3 or in6 */
 
1832
        }
 
1833
 
 
1834
        /* Deal with temperature register setup first. */
 
1835
        if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
 
1836
                int mask = 0;
 
1837
 
 
1838
                /*
 
1839
                 * Display temperature sensor output only if it monitors
 
1840
                 * a source other than one already reported. Always display
 
1841
                 * first three temperature registers, though.
 
1842
                 */
 
1843
                for (i = 0; i < NUM_REG_TEMP; i++) {
 
1844
                        u8 src;
 
1845
 
 
1846
                        data->reg_temp[i] = NCT6775_REG_TEMP[i];
 
1847
                        data->reg_temp_over[i] = NCT6775_REG_TEMP_OVER[i];
 
1848
                        data->reg_temp_hyst[i] = NCT6775_REG_TEMP_HYST[i];
 
1849
                        data->reg_temp_config[i] = NCT6775_REG_TEMP_CONFIG[i];
 
1850
 
 
1851
                        src = w83627ehf_read_value(data,
 
1852
                                                   NCT6775_REG_TEMP_SOURCE[i]);
 
1853
                        src &= 0x1f;
 
1854
                        if (src && !(mask & (1 << src))) {
 
1855
                                data->have_temp |= 1 << i;
 
1856
                                mask |= 1 << src;
 
1857
                        }
 
1858
 
 
1859
                        data->temp_src[i] = src;
 
1860
 
 
1861
                        /*
 
1862
                         * Now do some register swapping if index 0..2 don't
 
1863
                         * point to SYSTIN(1), CPUIN(2), and AUXIN(3).
 
1864
                         * Idea is to have the first three attributes
 
1865
                         * report SYSTIN, CPUIN, and AUXIN if possible
 
1866
                         * without overriding the basic system configuration.
 
1867
                         */
 
1868
                        if (i > 0 && data->temp_src[0] != 1
 
1869
                            && data->temp_src[i] == 1)
 
1870
                                w82627ehf_swap_tempreg(data, 0, i);
 
1871
                        if (i > 1 && data->temp_src[1] != 2
 
1872
                            && data->temp_src[i] == 2)
 
1873
                                w82627ehf_swap_tempreg(data, 1, i);
 
1874
                        if (i > 2 && data->temp_src[2] != 3
 
1875
                            && data->temp_src[i] == 3)
 
1876
                                w82627ehf_swap_tempreg(data, 2, i);
 
1877
                }
 
1878
                if (sio_data->kind == nct6776) {
 
1879
                        /*
 
1880
                         * On NCT6776, AUXTIN and VIN3 pins are shared.
 
1881
                         * Only way to detect it is to check if AUXTIN is used
 
1882
                         * as a temperature source, and if that source is
 
1883
                         * enabled.
 
1884
                         *
 
1885
                         * If that is the case, disable in6, which reports VIN3.
 
1886
                         * Otherwise disable temp3.
 
1887
                         */
 
1888
                        if (data->temp_src[2] == 3) {
 
1889
                                u8 reg;
 
1890
 
 
1891
                                if (data->reg_temp_config[2])
 
1892
                                        reg = w83627ehf_read_value(data,
 
1893
                                                data->reg_temp_config[2]);
 
1894
                                else
 
1895
                                        reg = 0; /* Assume AUXTIN is used */
 
1896
 
 
1897
                                if (reg & 0x01)
 
1898
                                        data->have_temp &= ~(1 << 2);
 
1899
                                else
 
1900
                                        data->in6_skip = 1;
 
1901
                        }
 
1902
                        data->temp_label = nct6776_temp_label;
 
1903
                } else {
 
1904
                        data->temp_label = nct6775_temp_label;
 
1905
                }
 
1906
        } else if (sio_data->kind == w83667hg_b) {
 
1907
                u8 reg;
 
1908
 
 
1909
                /*
 
1910
                 * Temperature sources are selected with bank 0, registers 0x49
 
1911
                 * and 0x4a.
 
1912
                 */
 
1913
                for (i = 0; i < ARRAY_SIZE(W83627EHF_REG_TEMP); i++) {
 
1914
                        data->reg_temp[i] = W83627EHF_REG_TEMP[i];
 
1915
                        data->reg_temp_over[i] = W83627EHF_REG_TEMP_OVER[i];
 
1916
                        data->reg_temp_hyst[i] = W83627EHF_REG_TEMP_HYST[i];
 
1917
                        data->reg_temp_config[i] = W83627EHF_REG_TEMP_CONFIG[i];
 
1918
                }
 
1919
                reg = w83627ehf_read_value(data, 0x4a);
 
1920
                data->temp_src[0] = reg >> 5;
 
1921
                reg = w83627ehf_read_value(data, 0x49);
 
1922
                data->temp_src[1] = reg & 0x07;
 
1923
                data->temp_src[2] = (reg >> 4) & 0x07;
 
1924
 
 
1925
                /*
 
1926
                 * W83667HG-B has another temperature register at 0x7e.
 
1927
                 * The temperature source is selected with register 0x7d.
 
1928
                 * Support it if the source differs from already reported
 
1929
                 * sources.
 
1930
                 */
 
1931
                reg = w83627ehf_read_value(data, 0x7d);
 
1932
                reg &= 0x07;
 
1933
                if (reg != data->temp_src[0] && reg != data->temp_src[1]
 
1934
                    && reg != data->temp_src[2]) {
 
1935
                        data->temp_src[3] = reg;
 
1936
                        data->have_temp |= 1 << 3;
 
1937
                }
 
1938
 
 
1939
                /*
 
1940
                 * Chip supports either AUXTIN or VIN3. Try to find out which
 
1941
                 * one.
 
1942
                 */
 
1943
                reg = w83627ehf_read_value(data, W83627EHF_REG_TEMP_CONFIG[2]);
 
1944
                if (data->temp_src[2] == 2 && (reg & 0x01))
 
1945
                        data->have_temp &= ~(1 << 2);
 
1946
 
 
1947
                if ((data->temp_src[2] == 2 && (data->have_temp & (1 << 2)))
 
1948
                    || (data->temp_src[3] == 2 && (data->have_temp & (1 << 3))))
 
1949
                        data->in6_skip = 1;
 
1950
 
 
1951
                data->temp_label = w83667hg_b_temp_label;
 
1952
        } else {
 
1953
                /* Temperature sources are fixed */
 
1954
                for (i = 0; i < 3; i++) {
 
1955
                        data->reg_temp[i] = W83627EHF_REG_TEMP[i];
 
1956
                        data->reg_temp_over[i] = W83627EHF_REG_TEMP_OVER[i];
 
1957
                        data->reg_temp_hyst[i] = W83627EHF_REG_TEMP_HYST[i];
 
1958
                        data->reg_temp_config[i] = W83627EHF_REG_TEMP_CONFIG[i];
 
1959
                }
 
1960
        }
 
1961
 
 
1962
        if (sio_data->kind == nct6775) {
 
1963
                data->has_fan_div = true;
 
1964
                data->fan_from_reg = fan_from_reg16;
 
1965
                data->fan_from_reg_min = fan_from_reg8;
 
1966
                data->REG_PWM = NCT6775_REG_PWM;
 
1967
                data->REG_TARGET = NCT6775_REG_TARGET;
 
1968
                data->REG_FAN = NCT6775_REG_FAN;
 
1969
                data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
 
1970
                data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
 
1971
                data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
 
1972
                data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
 
1973
                data->REG_FAN_MAX_OUTPUT = NCT6775_REG_FAN_MAX_OUTPUT;
 
1974
                data->REG_FAN_STEP_OUTPUT = NCT6775_REG_FAN_STEP_OUTPUT;
 
1975
        } else if (sio_data->kind == nct6776) {
 
1976
                data->has_fan_div = false;
 
1977
                data->fan_from_reg = fan_from_reg13;
 
1978
                data->fan_from_reg_min = fan_from_reg13;
 
1979
                data->REG_PWM = NCT6775_REG_PWM;
 
1980
                data->REG_TARGET = NCT6775_REG_TARGET;
 
1981
                data->REG_FAN = NCT6775_REG_FAN;
 
1982
                data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
 
1983
                data->REG_FAN_START_OUTPUT = NCT6775_REG_FAN_START_OUTPUT;
 
1984
                data->REG_FAN_STOP_OUTPUT = NCT6775_REG_FAN_STOP_OUTPUT;
 
1985
                data->REG_FAN_STOP_TIME = NCT6775_REG_FAN_STOP_TIME;
 
1986
        } else if (sio_data->kind == w83667hg_b) {
 
1987
                data->has_fan_div = true;
 
1988
                data->fan_from_reg = fan_from_reg8;
 
1989
                data->fan_from_reg_min = fan_from_reg8;
 
1990
                data->REG_PWM = W83627EHF_REG_PWM;
 
1991
                data->REG_TARGET = W83627EHF_REG_TARGET;
 
1992
                data->REG_FAN = W83627EHF_REG_FAN;
 
1993
                data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
 
1994
                data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
 
1995
                data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
 
1996
                data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
1410
1997
                data->REG_FAN_MAX_OUTPUT =
1411
1998
                  W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B;
1412
1999
                data->REG_FAN_STEP_OUTPUT =
1413
2000
                  W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B;
1414
2001
        } else {
 
2002
                data->has_fan_div = true;
 
2003
                data->fan_from_reg = fan_from_reg8;
 
2004
                data->fan_from_reg_min = fan_from_reg8;
 
2005
                data->REG_PWM = W83627EHF_REG_PWM;
 
2006
                data->REG_TARGET = W83627EHF_REG_TARGET;
 
2007
                data->REG_FAN = W83627EHF_REG_FAN;
 
2008
                data->REG_FAN_MIN = W83627EHF_REG_FAN_MIN;
 
2009
                data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
 
2010
                data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
 
2011
                data->REG_FAN_STOP_TIME = W83627EHF_REG_FAN_STOP_TIME;
1415
2012
                data->REG_FAN_MAX_OUTPUT =
1416
2013
                  W83627EHF_REG_FAN_MAX_OUTPUT_COMMON;
1417
2014
                data->REG_FAN_STEP_OUTPUT =
1424
2021
        data->vrm = vid_which_vrm();
1425
2022
        superio_enter(sio_data->sioreg);
1426
2023
        /* Read VID value */
1427
 
        if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
 
2024
        if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b ||
 
2025
            sio_data->kind == nct6775 || sio_data->kind == nct6776) {
1428
2026
                /* W83667HG has different pins for VID input and output, so
1429
2027
                we can get the VID input values directly at logical device D
1430
2028
                0xe3. */
1475
2073
        }
1476
2074
 
1477
2075
        /* fan4 and fan5 share some pins with the GPIO and serial flash */
1478
 
        if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
 
2076
        if (sio_data->kind == nct6775) {
 
2077
                /* On NCT6775, fan4 shares pins with the fdc interface */
 
2078
                fan3pin = 1;
 
2079
                fan4pin = !(superio_inb(sio_data->sioreg, 0x2A) & 0x80);
 
2080
                fan4min = 0;
 
2081
                fan5pin = 0;
 
2082
        } else if (sio_data->kind == nct6776) {
 
2083
                fan3pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x40);
 
2084
                fan4pin = !!(superio_inb(sio_data->sioreg, 0x1C) & 0x01);
 
2085
                fan5pin = !!(superio_inb(sio_data->sioreg, 0x1C) & 0x02);
 
2086
                fan4min = fan4pin;
 
2087
        } else if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
 
2088
                fan3pin = 1;
 
2089
                fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
1479
2090
                fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
1480
 
                fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
 
2091
                fan4min = fan4pin;
1481
2092
        } else {
 
2093
                fan3pin = 1;
 
2094
                fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
1482
2095
                fan5pin = !(superio_inb(sio_data->sioreg, 0x24) & 0x02);
1483
 
                fan4pin = !(superio_inb(sio_data->sioreg, 0x29) & 0x06);
1484
 
        }
 
2096
                fan4min = fan4pin;
 
2097
        }
 
2098
 
 
2099
        if (fan_debounce &&
 
2100
            (sio_data->kind == nct6775 || sio_data->kind == nct6776)) {
 
2101
                u8 tmp;
 
2102
 
 
2103
                superio_select(sio_data->sioreg, W83627EHF_LD_HWM);
 
2104
                tmp = superio_inb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE);
 
2105
                if (sio_data->kind == nct6776)
 
2106
                        superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
 
2107
                                     0x3e | tmp);
 
2108
                else
 
2109
                        superio_outb(sio_data->sioreg, NCT6775_REG_FAN_DEBOUNCE,
 
2110
                                     0x1e | tmp);
 
2111
                pr_info("Enabled fan debounce for chip %s\n", data->name);
 
2112
        }
 
2113
 
1485
2114
        superio_exit(sio_data->sioreg);
1486
2115
 
1487
2116
        /* It looks like fan4 and fan5 pins can be alternatively used
1490
2119
           connected fan5 as input unless they are emitting log 1, which
1491
2120
           is not the default. */
1492
2121
 
1493
 
        data->has_fan = 0x07; /* fan1, fan2 and fan3 */
1494
 
        i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
1495
 
        if ((i & (1 << 2)) && fan4pin)
1496
 
                data->has_fan |= (1 << 3);
1497
 
        if (!(i & (1 << 1)) && fan5pin)
1498
 
                data->has_fan |= (1 << 4);
 
2122
        data->has_fan = data->has_fan_min = 0x03; /* fan1 and fan2 */
 
2123
 
 
2124
        data->has_fan |= (fan3pin << 2);
 
2125
        data->has_fan_min |= (fan3pin << 2);
 
2126
 
 
2127
        /*
 
2128
         * NCT6775F and NCT6776F don't have the W83627EHF_REG_FANDIV1 register
 
2129
         */
 
2130
        if (sio_data->kind == nct6775 || sio_data->kind == nct6776) {
 
2131
                data->has_fan |= (fan4pin << 3) | (fan5pin << 4);
 
2132
                data->has_fan_min |= (fan4min << 3) | (fan5pin << 4);
 
2133
        } else {
 
2134
                i = w83627ehf_read_value(data, W83627EHF_REG_FANDIV1);
 
2135
                if ((i & (1 << 2)) && fan4pin) {
 
2136
                        data->has_fan |= (1 << 3);
 
2137
                        data->has_fan_min |= (1 << 3);
 
2138
                }
 
2139
                if (!(i & (1 << 1)) && fan5pin) {
 
2140
                        data->has_fan |= (1 << 4);
 
2141
                        data->has_fan_min |= (1 << 4);
 
2142
                }
 
2143
        }
1499
2144
 
1500
2145
        /* Read fan clock dividers immediately */
1501
 
        w83627ehf_update_fan_div(data);
 
2146
        w83627ehf_update_fan_div_common(dev, data);
 
2147
 
 
2148
        /* Read pwm data to save original values */
 
2149
        w83627ehf_update_pwm_common(dev, data);
 
2150
        for (i = 0; i < data->pwm_num; i++)
 
2151
                data->pwm_enable_orig[i] = data->pwm_enable[i];
 
2152
 
 
2153
        /* Read pwm data to save original values */
 
2154
        w83627ehf_update_pwm_common(dev, data);
 
2155
        for (i = 0; i < data->pwm_num; i++)
 
2156
                data->pwm_enable_orig[i] = data->pwm_enable[i];
1502
2157
 
1503
2158
        /* Register sysfs hooks */
1504
 
        for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
1505
 
                if ((err = device_create_file(dev,
1506
 
                        &sda_sf3_arrays[i].dev_attr)))
 
2159
        for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++) {
 
2160
                err = device_create_file(dev, &sda_sf3_arrays[i].dev_attr);
 
2161
                if (err)
1507
2162
                        goto exit_remove;
 
2163
        }
1508
2164
 
1509
2165
        for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
1510
2166
                struct sensor_device_attribute *attr =
1511
2167
                  &sda_sf3_max_step_arrays[i];
1512
 
                if (data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff) {
 
2168
                if (data->REG_FAN_STEP_OUTPUT &&
 
2169
                    data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff) {
1513
2170
                        err = device_create_file(dev, &attr->dev_attr);
1514
2171
                        if (err)
1515
2172
                                goto exit_remove;
1518
2175
        /* if fan4 is enabled create the sf3 files for it */
1519
2176
        if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
1520
2177
                for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
1521
 
                        if ((err = device_create_file(dev,
1522
 
                                &sda_sf3_arrays_fan4[i].dev_attr)))
 
2178
                        err = device_create_file(dev,
 
2179
                                        &sda_sf3_arrays_fan4[i].dev_attr);
 
2180
                        if (err)
1523
2181
                                goto exit_remove;
1524
2182
                }
1525
2183
 
1541
2199
                        if ((err = device_create_file(dev,
1542
2200
                                        &sda_fan_input[i].dev_attr))
1543
2201
                                || (err = device_create_file(dev,
1544
 
                                        &sda_fan_alarm[i].dev_attr))
1545
 
                                || (err = device_create_file(dev,
1546
 
                                        &sda_fan_div[i].dev_attr))
1547
 
                                || (err = device_create_file(dev,
1548
 
                                        &sda_fan_min[i].dev_attr)))
 
2202
                                        &sda_fan_alarm[i].dev_attr)))
1549
2203
                                goto exit_remove;
 
2204
                        if (sio_data->kind != nct6776) {
 
2205
                                err = device_create_file(dev,
 
2206
                                                &sda_fan_div[i].dev_attr);
 
2207
                                if (err)
 
2208
                                        goto exit_remove;
 
2209
                        }
 
2210
                        if (data->has_fan_min & (1 << i)) {
 
2211
                                err = device_create_file(dev,
 
2212
                                                &sda_fan_min[i].dev_attr);
 
2213
                                if (err)
 
2214
                                        goto exit_remove;
 
2215
                        }
1550
2216
                        if (i < data->pwm_num &&
1551
2217
                                ((err = device_create_file(dev,
1552
2218
                                        &sda_pwm[i].dev_attr))
1562
2228
                }
1563
2229
        }
1564
2230
 
1565
 
        for (i = 0; i < 3; i++) {
1566
 
                if ((i == 2) && data->temp3_disable)
 
2231
        for (i = 0; i < NUM_REG_TEMP; i++) {
 
2232
                if (!(data->have_temp & (1 << i)))
 
2233
                        continue;
 
2234
                err = device_create_file(dev, &sda_temp_input[i].dev_attr);
 
2235
                if (err)
 
2236
                        goto exit_remove;
 
2237
                if (data->temp_label) {
 
2238
                        err = device_create_file(dev,
 
2239
                                                 &sda_temp_label[i].dev_attr);
 
2240
                        if (err)
 
2241
                                goto exit_remove;
 
2242
                }
 
2243
                if (data->reg_temp_over[i]) {
 
2244
                        err = device_create_file(dev,
 
2245
                                &sda_temp_max[i].dev_attr);
 
2246
                        if (err)
 
2247
                                goto exit_remove;
 
2248
                }
 
2249
                if (data->reg_temp_hyst[i]) {
 
2250
                        err = device_create_file(dev,
 
2251
                                &sda_temp_max_hyst[i].dev_attr);
 
2252
                        if (err)
 
2253
                                goto exit_remove;
 
2254
                }
 
2255
                if (i > 2)
1567
2256
                        continue;
1568
2257
                if ((err = device_create_file(dev,
1569
 
                                &sda_temp_input[i].dev_attr))
1570
 
                        || (err = device_create_file(dev,
1571
 
                                &sda_temp_max[i].dev_attr))
1572
 
                        || (err = device_create_file(dev,
1573
 
                                &sda_temp_max_hyst[i].dev_attr))
1574
 
                        || (err = device_create_file(dev,
1575
2258
                                &sda_temp_alarm[i].dev_attr))
1576
2259
                        || (err = device_create_file(dev,
1577
2260
                                &sda_temp_type[i].dev_attr)))
1632
2315
        static const char __initdata sio_name_W83627DHG_P[] = "W83627DHG-P";
1633
2316
        static const char __initdata sio_name_W83667HG[] = "W83667HG";
1634
2317
        static const char __initdata sio_name_W83667HG_B[] = "W83667HG-B";
 
2318
        static const char __initdata sio_name_NCT6775[] = "NCT6775F";
 
2319
        static const char __initdata sio_name_NCT6776[] = "NCT6776F";
1635
2320
 
1636
2321
        u16 val;
1637
2322
        const char *sio_name;
1668
2353
                sio_data->kind = w83667hg_b;
1669
2354
                sio_name = sio_name_W83667HG_B;
1670
2355
                break;
 
2356
        case SIO_NCT6775_ID:
 
2357
                sio_data->kind = nct6775;
 
2358
                sio_name = sio_name_NCT6775;
 
2359
                break;
 
2360
        case SIO_NCT6776_ID:
 
2361
                sio_data->kind = nct6776;
 
2362
                sio_name = sio_name_NCT6776;
 
2363
                break;
1671
2364
        default:
1672
2365
                if (val != 0xffff)
1673
2366
                        pr_debug("unsupported chip ID: 0x%04x\n", val);
1689
2382
        /* Activate logical device if needed */
1690
2383
        val = superio_inb(sioaddr, SIO_REG_ENABLE);
1691
2384
        if (!(val & 0x01)) {
1692
 
                pr_warn("Forcibly enabling Super-I/O. Sensor is probably unusable.\n");
 
2385
                pr_warn("Forcibly enabling Super-I/O. "
 
2386
                        "Sensor is probably unusable.\n");
1693
2387
                superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
1694
2388
        }
1695
2389
 
1726
2420
        if (err)
1727
2421
                goto exit;
1728
2422
 
1729
 
        if (!(pdev = platform_device_alloc(DRVNAME, address))) {
 
2423
        pdev = platform_device_alloc(DRVNAME, address);
 
2424
        if (!pdev) {
1730
2425
                err = -ENOMEM;
1731
2426
                pr_err("Device allocation failed\n");
1732
2427
                goto exit_unregister;