Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/hwmon/nct6775.c

  1 /*
  2  * nct6775 - Driver for the hardware monitoring functionality of
  3  *             Nuvoton NCT677x Super-I/O chips
  4  *
  5  * Copyright (C) 2012  Guenter Roeck <linux@roeck-us.net>
  6  *
  7  * Derived from w83627ehf driver
  8  * Copyright (C) 2005-2012  Jean Delvare <jdelvare@suse.de>
  9  * Copyright (C) 2006  Yuan Mu (Winbond),
 10  *                     Rudolf Marek <r.marek@assembler.cz>
 11  *                     David Hubbard <david.c.hubbard@gmail.com>
 12  *                     Daniel J Blueman <daniel.blueman@gmail.com>
 13  * Copyright (C) 2010  Sheng-Yuan Huang (Nuvoton) (PS00)
 14  *
 15  * Shamelessly ripped from the w83627hf driver
 16  * Copyright (C) 2003  Mark Studebaker
 17  *
 18  * This program is free software; you can redistribute it and/or modify
 19  * it under the terms of the GNU General Public License as published by
 20  * the Free Software Foundation; either version 2 of the License, or
 21  * (at your option) any later version.
 22  *
 23  * This program is distributed in the hope that it will be useful,
 24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 26  * GNU General Public License for more details.
 27  *
 28  * You should have received a copy of the GNU General Public License
 29  * along with this program; if not, write to the Free Software
 30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 31  *
 32  *
 33  * Supports the following chips:
 34  *
 35  * Chip        #vin    #fan    #pwm    #temp  chip IDs       man ID
 36  * nct6106d     9      3       3       6+3    0xc450 0xc1    0x5ca3
 37  * nct6775f     9      4       3       6+3    0xb470 0xc1    0x5ca3
 38  * nct6776f     9      5       3       6+3    0xc330 0xc1    0x5ca3
 39  * nct6779d    15      5       5       2+6    0xc560 0xc1    0x5ca3
 40  * nct6791d    15      6       6       2+6    0xc800 0xc1    0x5ca3
 41  * nct6792d    15      6       6       2+6    0xc910 0xc1    0x5ca3
 42  *
 43  * #temp lists the number of monitored temperature sources (first value) plus
 44  * the number of directly connectable temperature sensors (second value).
 45  */
 46 
 47 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 48 
 49 #include <linux/module.h>
 50 #include <linux/init.h>
 51 #include <linux/slab.h>
 52 #include <linux/jiffies.h>
 53 #include <linux/platform_device.h>
 54 #include <linux/hwmon.h>
 55 #include <linux/hwmon-sysfs.h>
 56 #include <linux/hwmon-vid.h>
 57 #include <linux/err.h>
 58 #include <linux/mutex.h>
 59 #include <linux/acpi.h>
 60 #include <linux/dmi.h>
 61 #include <linux/io.h>
 62 #include "lm75.h"
 63 
 64 #define USE_ALTERNATE
 65 
 66 enum kinds { nct6106, nct6775, nct6776, nct6779, nct6791, nct6792 };
 67 
 68 /* used to set data->name = nct6775_device_names[data->sio_kind] */
 69 static const char * const nct6775_device_names[] = {
 70         "nct6106",
 71         "nct6775",
 72         "nct6776",
 73         "nct6779",
 74         "nct6791",
 75         "nct6792",
 76 };
 77 
 78 static unsigned short force_id;
 79 module_param(force_id, ushort, 0);
 80 MODULE_PARM_DESC(force_id, "Override the detected device ID");
 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 
 86 #define DRVNAME "nct6775"
 87 
 88 /*
 89  * Super-I/O constants and functions
 90  */
 91 
 92 #define NCT6775_LD_ACPI         0x0a
 93 #define NCT6775_LD_HWM          0x0b
 94 #define NCT6775_LD_VID          0x0d
 95 
 96 #define SIO_REG_LDSEL           0x07    /* Logical device select */
 97 #define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
 98 #define SIO_REG_ENABLE          0x30    /* Logical device enable */
 99 #define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
100 
101 #define SIO_NCT6106_ID          0xc450
102 #define SIO_NCT6775_ID          0xb470
103 #define SIO_NCT6776_ID          0xc330
104 #define SIO_NCT6779_ID          0xc560
105 #define SIO_NCT6791_ID          0xc800
106 #define SIO_NCT6792_ID          0xc910
107 #define SIO_ID_MASK             0xFFF0
108 
109 enum pwm_enable { off, manual, thermal_cruise, speed_cruise, sf3, sf4 };
110 
111 static inline void
112 superio_outb(int ioreg, int reg, int val)
113 {
114         outb(reg, ioreg);
115         outb(val, ioreg + 1);
116 }
117 
118 static inline int
119 superio_inb(int ioreg, int reg)
120 {
121         outb(reg, ioreg);
122         return inb(ioreg + 1);
123 }
124 
125 static inline void
126 superio_select(int ioreg, int ld)
127 {
128         outb(SIO_REG_LDSEL, ioreg);
129         outb(ld, ioreg + 1);
130 }
131 
132 static inline int
133 superio_enter(int ioreg)
134 {
135         /*
136          * Try to reserve <ioreg> and <ioreg + 1> for exclusive access.
137          */
138         if (!request_muxed_region(ioreg, 2, DRVNAME))
139                 return -EBUSY;
140 
141         outb(0x87, ioreg);
142         outb(0x87, ioreg);
143 
144         return 0;
145 }
146 
147 static inline void
148 superio_exit(int ioreg)
149 {
150         outb(0xaa, ioreg);
151         outb(0x02, ioreg);
152         outb(0x02, ioreg + 1);
153         release_region(ioreg, 2);
154 }
155 
156 /*
157  * ISA constants
158  */
159 
160 #define IOREGION_ALIGNMENT      (~7)
161 #define IOREGION_OFFSET         5
162 #define IOREGION_LENGTH         2
163 #define ADDR_REG_OFFSET         0
164 #define DATA_REG_OFFSET         1
165 
166 #define NCT6775_REG_BANK        0x4E
167 #define NCT6775_REG_CONFIG      0x40
168 
169 /*
170  * Not currently used:
171  * REG_MAN_ID has the value 0x5ca3 for all supported chips.
172  * REG_CHIP_ID == 0x88/0xa1/0xc1 depending on chip model.
173  * REG_MAN_ID is at port 0x4f
174  * REG_CHIP_ID is at port 0x58
175  */
176 
177 #define NUM_TEMP        10      /* Max number of temp attribute sets w/ limits*/
178 #define NUM_TEMP_FIXED  6       /* Max number of fixed temp attribute sets */
179 
180 #define NUM_REG_ALARM   7       /* Max number of alarm registers */
181 #define NUM_REG_BEEP    5       /* Max number of beep registers */
182 
183 #define NUM_FAN         6
184 
185 /* Common and NCT6775 specific data */
186 
187 /* Voltage min/max registers for nr=7..14 are in bank 5 */
188 
189 static const u16 NCT6775_REG_IN_MAX[] = {
190         0x2b, 0x2d, 0x2f, 0x31, 0x33, 0x35, 0x37, 0x554, 0x556, 0x558, 0x55a,
191         0x55c, 0x55e, 0x560, 0x562 };
192 static const u16 NCT6775_REG_IN_MIN[] = {
193         0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x555, 0x557, 0x559, 0x55b,
194         0x55d, 0x55f, 0x561, 0x563 };
195 static const u16 NCT6775_REG_IN[] = {
196         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x550, 0x551, 0x552
197 };
198 
199 #define NCT6775_REG_VBAT                0x5D
200 #define NCT6775_REG_DIODE               0x5E
201 #define NCT6775_DIODE_MASK              0x02
202 
203 #define NCT6775_REG_FANDIV1             0x506
204 #define NCT6775_REG_FANDIV2             0x507
205 
206 #define NCT6775_REG_CR_FAN_DEBOUNCE     0xf0
207 
208 static const u16 NCT6775_REG_ALARM[NUM_REG_ALARM] = { 0x459, 0x45A, 0x45B };
209 
210 /* 0..15 voltages, 16..23 fans, 24..29 temperatures, 30..31 intrusion */
211 
212 static const s8 NCT6775_ALARM_BITS[] = {
213         0, 1, 2, 3, 8, 21, 20, 16,      /* in0.. in7 */
214         17, -1, -1, -1, -1, -1, -1,     /* in8..in14 */
215         -1,                             /* unused */
216         6, 7, 11, -1, -1,               /* fan1..fan5 */
217         -1, -1, -1,                     /* unused */
218         4, 5, 13, -1, -1, -1,           /* temp1..temp6 */
219         12, -1 };                       /* intrusion0, intrusion1 */
220 
221 #define FAN_ALARM_BASE          16
222 #define TEMP_ALARM_BASE         24
223 #define INTRUSION_ALARM_BASE    30
224 
225 static const u16 NCT6775_REG_BEEP[NUM_REG_BEEP] = { 0x56, 0x57, 0x453, 0x4e };
226 
227 /*
228  * 0..14 voltages, 15 global beep enable, 16..23 fans, 24..29 temperatures,
229  * 30..31 intrusion
230  */
231 static const s8 NCT6775_BEEP_BITS[] = {
232         0, 1, 2, 3, 8, 9, 10, 16,       /* in0.. in7 */
233         17, -1, -1, -1, -1, -1, -1,     /* in8..in14 */
234         21,                             /* global beep enable */
235         6, 7, 11, 28, -1,               /* fan1..fan5 */
236         -1, -1, -1,                     /* unused */
237         4, 5, 13, -1, -1, -1,           /* temp1..temp6 */
238         12, -1 };                       /* intrusion0, intrusion1 */
239 
240 #define BEEP_ENABLE_BASE                15
241 
242 static const u8 NCT6775_REG_CR_CASEOPEN_CLR[] = { 0xe6, 0xee };
243 static const u8 NCT6775_CR_CASEOPEN_CLR_MASK[] = { 0x20, 0x01 };
244 
245 /* DC or PWM output fan configuration */
246 static const u8 NCT6775_REG_PWM_MODE[] = { 0x04, 0x04, 0x12 };
247 static const u8 NCT6775_PWM_MODE_MASK[] = { 0x01, 0x02, 0x01 };
248 
249 /* Advanced Fan control, some values are common for all fans */
250 
251 static const u16 NCT6775_REG_TARGET[] = {
252         0x101, 0x201, 0x301, 0x801, 0x901, 0xa01 };
253 static const u16 NCT6775_REG_FAN_MODE[] = {
254         0x102, 0x202, 0x302, 0x802, 0x902, 0xa02 };
255 static const u16 NCT6775_REG_FAN_STEP_DOWN_TIME[] = {
256         0x103, 0x203, 0x303, 0x803, 0x903, 0xa03 };
257 static const u16 NCT6775_REG_FAN_STEP_UP_TIME[] = {
258         0x104, 0x204, 0x304, 0x804, 0x904, 0xa04 };
259 static const u16 NCT6775_REG_FAN_STOP_OUTPUT[] = {
260         0x105, 0x205, 0x305, 0x805, 0x905, 0xa05 };
261 static const u16 NCT6775_REG_FAN_START_OUTPUT[] = {
262         0x106, 0x206, 0x306, 0x806, 0x906, 0xa06 };
263 static const u16 NCT6775_REG_FAN_MAX_OUTPUT[] = { 0x10a, 0x20a, 0x30a };
264 static const u16 NCT6775_REG_FAN_STEP_OUTPUT[] = { 0x10b, 0x20b, 0x30b };
265 
266 static const u16 NCT6775_REG_FAN_STOP_TIME[] = {
267         0x107, 0x207, 0x307, 0x807, 0x907, 0xa07 };
268 static const u16 NCT6775_REG_PWM[] = {
269         0x109, 0x209, 0x309, 0x809, 0x909, 0xa09 };
270 static const u16 NCT6775_REG_PWM_READ[] = {
271         0x01, 0x03, 0x11, 0x13, 0x15, 0xa09 };
272 
273 static const u16 NCT6775_REG_FAN[] = { 0x630, 0x632, 0x634, 0x636, 0x638 };
274 static const u16 NCT6775_REG_FAN_MIN[] = { 0x3b, 0x3c, 0x3d };
275 static const u16 NCT6775_REG_FAN_PULSES[] = { 0x641, 0x642, 0x643, 0x644, 0 };
276 static const u16 NCT6775_FAN_PULSE_SHIFT[] = { 0, 0, 0, 0, 0, 0 };
277 
278 static const u16 NCT6775_REG_TEMP[] = {
279         0x27, 0x150, 0x250, 0x62b, 0x62c, 0x62d };
280 
281 static const u16 NCT6775_REG_TEMP_MON[] = { 0x73, 0x75, 0x77 };
282 
283 static const u16 NCT6775_REG_TEMP_CONFIG[ARRAY_SIZE(NCT6775_REG_TEMP)] = {
284         0, 0x152, 0x252, 0x628, 0x629, 0x62A };
285 static const u16 NCT6775_REG_TEMP_HYST[ARRAY_SIZE(NCT6775_REG_TEMP)] = {
286         0x3a, 0x153, 0x253, 0x673, 0x678, 0x67D };
287 static const u16 NCT6775_REG_TEMP_OVER[ARRAY_SIZE(NCT6775_REG_TEMP)] = {
288         0x39, 0x155, 0x255, 0x672, 0x677, 0x67C };
289 
290 static const u16 NCT6775_REG_TEMP_SOURCE[ARRAY_SIZE(NCT6775_REG_TEMP)] = {
291         0x621, 0x622, 0x623, 0x624, 0x625, 0x626 };
292 
293 static const u16 NCT6775_REG_TEMP_SEL[] = {
294         0x100, 0x200, 0x300, 0x800, 0x900, 0xa00 };
295 
296 static const u16 NCT6775_REG_WEIGHT_TEMP_SEL[] = {
297         0x139, 0x239, 0x339, 0x839, 0x939, 0xa39 };
298 static const u16 NCT6775_REG_WEIGHT_TEMP_STEP[] = {
299         0x13a, 0x23a, 0x33a, 0x83a, 0x93a, 0xa3a };
300 static const u16 NCT6775_REG_WEIGHT_TEMP_STEP_TOL[] = {
301         0x13b, 0x23b, 0x33b, 0x83b, 0x93b, 0xa3b };
302 static const u16 NCT6775_REG_WEIGHT_DUTY_STEP[] = {
303         0x13c, 0x23c, 0x33c, 0x83c, 0x93c, 0xa3c };
304 static const u16 NCT6775_REG_WEIGHT_TEMP_BASE[] = {
305         0x13d, 0x23d, 0x33d, 0x83d, 0x93d, 0xa3d };
306 
307 static const u16 NCT6775_REG_TEMP_OFFSET[] = { 0x454, 0x455, 0x456 };
308 
309 static const u16 NCT6775_REG_AUTO_TEMP[] = {
310         0x121, 0x221, 0x321, 0x821, 0x921, 0xa21 };
311 static const u16 NCT6775_REG_AUTO_PWM[] = {
312         0x127, 0x227, 0x327, 0x827, 0x927, 0xa27 };
313 
314 #define NCT6775_AUTO_TEMP(data, nr, p)  ((data)->REG_AUTO_TEMP[nr] + (p))
315 #define NCT6775_AUTO_PWM(data, nr, p)   ((data)->REG_AUTO_PWM[nr] + (p))
316 
317 static const u16 NCT6775_REG_CRITICAL_ENAB[] = { 0x134, 0x234, 0x334 };
318 
319 static const u16 NCT6775_REG_CRITICAL_TEMP[] = {
320         0x135, 0x235, 0x335, 0x835, 0x935, 0xa35 };
321 static const u16 NCT6775_REG_CRITICAL_TEMP_TOLERANCE[] = {
322         0x138, 0x238, 0x338, 0x838, 0x938, 0xa38 };
323 
324 static const char *const nct6775_temp_label[] = {
325         "",
326         "SYSTIN",
327         "CPUTIN",
328         "AUXTIN",
329         "AMD SB-TSI",
330         "PECI Agent 0",
331         "PECI Agent 1",
332         "PECI Agent 2",
333         "PECI Agent 3",
334         "PECI Agent 4",
335         "PECI Agent 5",
336         "PECI Agent 6",
337         "PECI Agent 7",
338         "PCH_CHIP_CPU_MAX_TEMP",
339         "PCH_CHIP_TEMP",
340         "PCH_CPU_TEMP",
341         "PCH_MCH_TEMP",
342         "PCH_DIM0_TEMP",
343         "PCH_DIM1_TEMP",
344         "PCH_DIM2_TEMP",
345         "PCH_DIM3_TEMP"
346 };
347 
348 static const u16 NCT6775_REG_TEMP_ALTERNATE[ARRAY_SIZE(nct6775_temp_label) - 1]
349         = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x661, 0x662, 0x664 };
350 
351 static const u16 NCT6775_REG_TEMP_CRIT[ARRAY_SIZE(nct6775_temp_label) - 1]
352         = { 0, 0, 0, 0, 0xa00, 0xa01, 0xa02, 0xa03, 0xa04, 0xa05, 0xa06,
353             0xa07 };
354 
355 /* NCT6776 specific data */
356 
357 static const s8 NCT6776_ALARM_BITS[] = {
358         0, 1, 2, 3, 8, 21, 20, 16,      /* in0.. in7 */
359         17, -1, -1, -1, -1, -1, -1,     /* in8..in14 */
360         -1,                             /* unused */
361         6, 7, 11, 10, 23,               /* fan1..fan5 */
362         -1, -1, -1,                     /* unused */
363         4, 5, 13, -1, -1, -1,           /* temp1..temp6 */
364         12, 9 };                        /* intrusion0, intrusion1 */
365 
366 static const u16 NCT6776_REG_BEEP[NUM_REG_BEEP] = { 0xb2, 0xb3, 0xb4, 0xb5 };
367 
368 static const s8 NCT6776_BEEP_BITS[] = {
369         0, 1, 2, 3, 4, 5, 6, 7,         /* in0.. in7 */
370         8, -1, -1, -1, -1, -1, -1,      /* in8..in14 */
371         24,                             /* global beep enable */
372         25, 26, 27, 28, 29,             /* fan1..fan5 */
373         -1, -1, -1,                     /* unused */
374         16, 17, 18, 19, 20, 21,         /* temp1..temp6 */
375         30, 31 };                       /* intrusion0, intrusion1 */
376 
377 static const u16 NCT6776_REG_TOLERANCE_H[] = {
378         0x10c, 0x20c, 0x30c, 0x80c, 0x90c, 0xa0c };
379 
380 static const u8 NCT6776_REG_PWM_MODE[] = { 0x04, 0, 0, 0, 0, 0 };
381 static const u8 NCT6776_PWM_MODE_MASK[] = { 0x01, 0, 0, 0, 0, 0 };
382 
383 static const u16 NCT6776_REG_FAN_MIN[] = { 0x63a, 0x63c, 0x63e, 0x640, 0x642 };
384 static const u16 NCT6776_REG_FAN_PULSES[] = { 0x644, 0x645, 0x646, 0, 0 };
385 
386 static const u16 NCT6776_REG_WEIGHT_DUTY_BASE[] = {
387         0x13e, 0x23e, 0x33e, 0x83e, 0x93e, 0xa3e };
388 
389 static const u16 NCT6776_REG_TEMP_CONFIG[ARRAY_SIZE(NCT6775_REG_TEMP)] = {
390         0x18, 0x152, 0x252, 0x628, 0x629, 0x62A };
391 
392 static const char *const nct6776_temp_label[] = {
393         "",
394         "SYSTIN",
395         "CPUTIN",
396         "AUXTIN",
397         "SMBUSMASTER 0",
398         "SMBUSMASTER 1",
399         "SMBUSMASTER 2",
400         "SMBUSMASTER 3",
401         "SMBUSMASTER 4",
402         "SMBUSMASTER 5",
403         "SMBUSMASTER 6",
404         "SMBUSMASTER 7",
405         "PECI Agent 0",
406         "PECI Agent 1",
407         "PCH_CHIP_CPU_MAX_TEMP",
408         "PCH_CHIP_TEMP",
409         "PCH_CPU_TEMP",
410         "PCH_MCH_TEMP",
411         "PCH_DIM0_TEMP",
412         "PCH_DIM1_TEMP",
413         "PCH_DIM2_TEMP",
414         "PCH_DIM3_TEMP",
415         "BYTE_TEMP"
416 };
417 
418 static const u16 NCT6776_REG_TEMP_ALTERNATE[ARRAY_SIZE(nct6776_temp_label) - 1]
419         = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x401, 0x402, 0x404 };
420 
421 static const u16 NCT6776_REG_TEMP_CRIT[ARRAY_SIZE(nct6776_temp_label) - 1]
422         = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x709, 0x70a };
423 
424 /* NCT6779 specific data */
425 
426 static const u16 NCT6779_REG_IN[] = {
427         0x480, 0x481, 0x482, 0x483, 0x484, 0x485, 0x486, 0x487,
428         0x488, 0x489, 0x48a, 0x48b, 0x48c, 0x48d, 0x48e };
429 
430 static const u16 NCT6779_REG_ALARM[NUM_REG_ALARM] = {
431         0x459, 0x45A, 0x45B, 0x568 };
432 
433 static const s8 NCT6779_ALARM_BITS[] = {
434         0, 1, 2, 3, 8, 21, 20, 16,      /* in0.. in7 */
435         17, 24, 25, 26, 27, 28, 29,     /* in8..in14 */
436         -1,                             /* unused */
437         6, 7, 11, 10, 23,               /* fan1..fan5 */
438         -1, -1, -1,                     /* unused */
439         4, 5, 13, -1, -1, -1,           /* temp1..temp6 */
440         12, 9 };                        /* intrusion0, intrusion1 */
441 
442 static const s8 NCT6779_BEEP_BITS[] = {
443         0, 1, 2, 3, 4, 5, 6, 7,         /* in0.. in7 */
444         8, 9, 10, 11, 12, 13, 14,       /* in8..in14 */
445         24,                             /* global beep enable */
446         25, 26, 27, 28, 29,             /* fan1..fan5 */
447         -1, -1, -1,                     /* unused */
448         16, 17, -1, -1, -1, -1,         /* temp1..temp6 */
449         30, 31 };                       /* intrusion0, intrusion1 */
450 
451 static const u16 NCT6779_REG_FAN[] = {
452         0x4b0, 0x4b2, 0x4b4, 0x4b6, 0x4b8, 0x4ba };
453 static const u16 NCT6779_REG_FAN_PULSES[] = {
454         0x644, 0x645, 0x646, 0x647, 0x648, 0x649 };
455 
456 static const u16 NCT6779_REG_CRITICAL_PWM_ENABLE[] = {
457         0x136, 0x236, 0x336, 0x836, 0x936, 0xa36 };
458 #define NCT6779_CRITICAL_PWM_ENABLE_MASK        0x01
459 static const u16 NCT6779_REG_CRITICAL_PWM[] = {
460         0x137, 0x237, 0x337, 0x837, 0x937, 0xa37 };
461 
462 static const u16 NCT6779_REG_TEMP[] = { 0x27, 0x150 };
463 static const u16 NCT6779_REG_TEMP_MON[] = { 0x73, 0x75, 0x77, 0x79, 0x7b };
464 static const u16 NCT6779_REG_TEMP_CONFIG[ARRAY_SIZE(NCT6779_REG_TEMP)] = {
465         0x18, 0x152 };
466 static const u16 NCT6779_REG_TEMP_HYST[ARRAY_SIZE(NCT6779_REG_TEMP)] = {
467         0x3a, 0x153 };
468 static const u16 NCT6779_REG_TEMP_OVER[ARRAY_SIZE(NCT6779_REG_TEMP)] = {
469         0x39, 0x155 };
470 
471 static const u16 NCT6779_REG_TEMP_OFFSET[] = {
472         0x454, 0x455, 0x456, 0x44a, 0x44b, 0x44c };
473 
474 static const char *const nct6779_temp_label[] = {
475         "",
476         "SYSTIN",
477         "CPUTIN",
478         "AUXTIN0",
479         "AUXTIN1",
480         "AUXTIN2",
481         "AUXTIN3",
482         "",
483         "SMBUSMASTER 0",
484         "SMBUSMASTER 1",
485         "SMBUSMASTER 2",
486         "SMBUSMASTER 3",
487         "SMBUSMASTER 4",
488         "SMBUSMASTER 5",
489         "SMBUSMASTER 6",
490         "SMBUSMASTER 7",
491         "PECI Agent 0",
492         "PECI Agent 1",
493         "PCH_CHIP_CPU_MAX_TEMP",
494         "PCH_CHIP_TEMP",
495         "PCH_CPU_TEMP",
496         "PCH_MCH_TEMP",
497         "PCH_DIM0_TEMP",
498         "PCH_DIM1_TEMP",
499         "PCH_DIM2_TEMP",
500         "PCH_DIM3_TEMP",
501         "BYTE_TEMP"
502 };
503 
504 static const u16 NCT6779_REG_TEMP_ALTERNATE[ARRAY_SIZE(nct6779_temp_label) - 1]
505         = { 0x490, 0x491, 0x492, 0x493, 0x494, 0x495, 0, 0,
506             0, 0, 0, 0, 0, 0, 0, 0,
507             0, 0x400, 0x401, 0x402, 0x404, 0x405, 0x406, 0x407,
508             0x408, 0 };
509 
510 static const u16 NCT6779_REG_TEMP_CRIT[ARRAY_SIZE(nct6779_temp_label) - 1]
511         = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x709, 0x70a };
512 
513 /* NCT6791 specific data */
514 
515 #define NCT6791_REG_HM_IO_SPACE_LOCK_ENABLE     0x28
516 
517 static const u16 NCT6791_REG_WEIGHT_TEMP_SEL[6] = { 0, 0x239 };
518 static const u16 NCT6791_REG_WEIGHT_TEMP_STEP[6] = { 0, 0x23a };
519 static const u16 NCT6791_REG_WEIGHT_TEMP_STEP_TOL[6] = { 0, 0x23b };
520 static const u16 NCT6791_REG_WEIGHT_DUTY_STEP[6] = { 0, 0x23c };
521 static const u16 NCT6791_REG_WEIGHT_TEMP_BASE[6] = { 0, 0x23d };
522 static const u16 NCT6791_REG_WEIGHT_DUTY_BASE[6] = { 0, 0x23e };
523 
524 static const u16 NCT6791_REG_ALARM[NUM_REG_ALARM] = {
525         0x459, 0x45A, 0x45B, 0x568, 0x45D };
526 
527 static const s8 NCT6791_ALARM_BITS[] = {
528         0, 1, 2, 3, 8, 21, 20, 16,      /* in0.. in7 */
529         17, 24, 25, 26, 27, 28, 29,     /* in8..in14 */
530         -1,                             /* unused */
531         6, 7, 11, 10, 23, 33,           /* fan1..fan6 */
532         -1, -1,                         /* unused */
533         4, 5, 13, -1, -1, -1,           /* temp1..temp6 */
534         12, 9 };                        /* intrusion0, intrusion1 */
535 
536 /* NCT6792 specific data */
537 
538 static const u16 NCT6792_REG_TEMP_MON[] = {
539         0x73, 0x75, 0x77, 0x79, 0x7b, 0x7d };
540 static const u16 NCT6792_REG_BEEP[NUM_REG_BEEP] = {
541         0xb2, 0xb3, 0xb4, 0xb5, 0xbf };
542 
543 /* NCT6102D/NCT6106D specific data */
544 
545 #define NCT6106_REG_VBAT        0x318
546 #define NCT6106_REG_DIODE       0x319
547 #define NCT6106_DIODE_MASK      0x01
548 
549 static const u16 NCT6106_REG_IN_MAX[] = {
550         0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9e, 0xa0, 0xa2 };
551 static const u16 NCT6106_REG_IN_MIN[] = {
552         0x91, 0x93, 0x95, 0x97, 0x99, 0x9b, 0x9f, 0xa1, 0xa3 };
553 static const u16 NCT6106_REG_IN[] = {
554         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09 };
555 
556 static const u16 NCT6106_REG_TEMP[] = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15 };
557 static const u16 NCT6106_REG_TEMP_MON[] = { 0x18, 0x19, 0x1a };
558 static const u16 NCT6106_REG_TEMP_HYST[] = {
559         0xc3, 0xc7, 0xcb, 0xcf, 0xd3, 0xd7 };
560 static const u16 NCT6106_REG_TEMP_OVER[] = {
561         0xc2, 0xc6, 0xca, 0xce, 0xd2, 0xd6 };
562 static const u16 NCT6106_REG_TEMP_CRIT_L[] = {
563         0xc0, 0xc4, 0xc8, 0xcc, 0xd0, 0xd4 };
564 static const u16 NCT6106_REG_TEMP_CRIT_H[] = {
565         0xc1, 0xc5, 0xc9, 0xcf, 0xd1, 0xd5 };
566 static const u16 NCT6106_REG_TEMP_OFFSET[] = { 0x311, 0x312, 0x313 };
567 static const u16 NCT6106_REG_TEMP_CONFIG[] = {
568         0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc };
569 
570 static const u16 NCT6106_REG_FAN[] = { 0x20, 0x22, 0x24 };
571 static const u16 NCT6106_REG_FAN_MIN[] = { 0xe0, 0xe2, 0xe4 };
572 static const u16 NCT6106_REG_FAN_PULSES[] = { 0xf6, 0xf6, 0xf6, 0, 0 };
573 static const u16 NCT6106_FAN_PULSE_SHIFT[] = { 0, 2, 4, 0, 0 };
574 
575 static const u8 NCT6106_REG_PWM_MODE[] = { 0xf3, 0xf3, 0xf3 };
576 static const u8 NCT6106_PWM_MODE_MASK[] = { 0x01, 0x02, 0x04 };
577 static const u16 NCT6106_REG_PWM[] = { 0x119, 0x129, 0x139 };
578 static const u16 NCT6106_REG_PWM_READ[] = { 0x4a, 0x4b, 0x4c };
579 static const u16 NCT6106_REG_FAN_MODE[] = { 0x113, 0x123, 0x133 };
580 static const u16 NCT6106_REG_TEMP_SEL[] = { 0x110, 0x120, 0x130 };
581 static const u16 NCT6106_REG_TEMP_SOURCE[] = {
582         0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5 };
583 
584 static const u16 NCT6106_REG_CRITICAL_TEMP[] = { 0x11a, 0x12a, 0x13a };
585 static const u16 NCT6106_REG_CRITICAL_TEMP_TOLERANCE[] = {
586         0x11b, 0x12b, 0x13b };
587 
588 static const u16 NCT6106_REG_CRITICAL_PWM_ENABLE[] = { 0x11c, 0x12c, 0x13c };
589 #define NCT6106_CRITICAL_PWM_ENABLE_MASK        0x10
590 static const u16 NCT6106_REG_CRITICAL_PWM[] = { 0x11d, 0x12d, 0x13d };
591 
592 static const u16 NCT6106_REG_FAN_STEP_UP_TIME[] = { 0x114, 0x124, 0x134 };
593 static const u16 NCT6106_REG_FAN_STEP_DOWN_TIME[] = { 0x115, 0x125, 0x135 };
594 static const u16 NCT6106_REG_FAN_STOP_OUTPUT[] = { 0x116, 0x126, 0x136 };
595 static const u16 NCT6106_REG_FAN_START_OUTPUT[] = { 0x117, 0x127, 0x137 };
596 static const u16 NCT6106_REG_FAN_STOP_TIME[] = { 0x118, 0x128, 0x138 };
597 static const u16 NCT6106_REG_TOLERANCE_H[] = { 0x112, 0x122, 0x132 };
598 
599 static const u16 NCT6106_REG_TARGET[] = { 0x111, 0x121, 0x131 };
600 
601 static const u16 NCT6106_REG_WEIGHT_TEMP_SEL[] = { 0x168, 0x178, 0x188 };
602 static const u16 NCT6106_REG_WEIGHT_TEMP_STEP[] = { 0x169, 0x179, 0x189 };
603 static const u16 NCT6106_REG_WEIGHT_TEMP_STEP_TOL[] = { 0x16a, 0x17a, 0x18a };
604 static const u16 NCT6106_REG_WEIGHT_DUTY_STEP[] = { 0x16b, 0x17b, 0x17c };
605 static const u16 NCT6106_REG_WEIGHT_TEMP_BASE[] = { 0x16c, 0x17c, 0x18c };
606 static const u16 NCT6106_REG_WEIGHT_DUTY_BASE[] = { 0x16d, 0x17d, 0x18d };
607 
608 static const u16 NCT6106_REG_AUTO_TEMP[] = { 0x160, 0x170, 0x180 };
609 static const u16 NCT6106_REG_AUTO_PWM[] = { 0x164, 0x174, 0x184 };
610 
611 static const u16 NCT6106_REG_ALARM[NUM_REG_ALARM] = {
612         0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d };
613 
614 static const s8 NCT6106_ALARM_BITS[] = {
615         0, 1, 2, 3, 4, 5, 7, 8,         /* in0.. in7 */
616         9, -1, -1, -1, -1, -1, -1,      /* in8..in14 */
617         -1,                             /* unused */
618         32, 33, 34, -1, -1,             /* fan1..fan5 */
619         -1, -1, -1,                     /* unused */
620         16, 17, 18, 19, 20, 21,         /* temp1..temp6 */
621         48, -1                          /* intrusion0, intrusion1 */
622 };
623 
624 static const u16 NCT6106_REG_BEEP[NUM_REG_BEEP] = {
625         0x3c0, 0x3c1, 0x3c2, 0x3c3, 0x3c4 };
626 
627 static const s8 NCT6106_BEEP_BITS[] = {
628         0, 1, 2, 3, 4, 5, 7, 8,         /* in0.. in7 */
629         9, 10, 11, 12, -1, -1, -1,      /* in8..in14 */
630         32,                             /* global beep enable */
631         24, 25, 26, 27, 28,             /* fan1..fan5 */
632         -1, -1, -1,                     /* unused */
633         16, 17, 18, 19, 20, 21,         /* temp1..temp6 */
634         34, -1                          /* intrusion0, intrusion1 */
635 };
636 
637 static const u16 NCT6106_REG_TEMP_ALTERNATE[ARRAY_SIZE(nct6776_temp_label) - 1]
638         = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x51, 0x52, 0x54 };
639 
640 static const u16 NCT6106_REG_TEMP_CRIT[ARRAY_SIZE(nct6776_temp_label) - 1]
641         = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x204, 0x205 };
642 
643 static enum pwm_enable reg_to_pwm_enable(int pwm, int mode)
644 {
645         if (mode == 0 && pwm == 255)
646                 return off;
647         return mode + 1;
648 }
649 
650 static int pwm_enable_to_reg(enum pwm_enable mode)
651 {
652         if (mode == off)
653                 return 0;
654         return mode - 1;
655 }
656 
657 /*
658  * Conversions
659  */
660 
661 /* 1 is DC mode, output in ms */
662 static unsigned int step_time_from_reg(u8 reg, u8 mode)
663 {
664         return mode ? 400 * reg : 100 * reg;
665 }
666 
667 static u8 step_time_to_reg(unsigned int msec, u8 mode)
668 {
669         return clamp_val((mode ? (msec + 200) / 400 :
670                                         (msec + 50) / 100), 1, 255);
671 }
672 
673 static unsigned int fan_from_reg8(u16 reg, unsigned int divreg)
674 {
675         if (reg == 0 || reg == 255)
676                 return 0;
677         return 1350000U / (reg << divreg);
678 }
679 
680 static unsigned int fan_from_reg13(u16 reg, unsigned int divreg)
681 {
682         if ((reg & 0xff1f) == 0xff1f)
683                 return 0;
684 
685         reg = (reg & 0x1f) | ((reg & 0xff00) >> 3);
686 
687         if (reg == 0)
688                 return 0;
689 
690         return 1350000U / reg;
691 }
692 
693 static unsigned int fan_from_reg16(u16 reg, unsigned int divreg)
694 {
695         if (reg == 0 || reg == 0xffff)
696                 return 0;
697 
698         /*
699          * Even though the registers are 16 bit wide, the fan divisor
700          * still applies.
701          */
702         return 1350000U / (reg << divreg);
703 }
704 
705 static u16 fan_to_reg(u32 fan, unsigned int divreg)
706 {
707         if (!fan)
708                 return 0;
709 
710         return (1350000U / fan) >> divreg;
711 }
712 
713 static inline unsigned int
714 div_from_reg(u8 reg)
715 {
716         return 1 << reg;
717 }
718 
719 /*
720  * Some of the voltage inputs have internal scaling, the tables below
721  * contain 8 (the ADC LSB in mV) * scaling factor * 100
722  */
723 static const u16 scale_in[15] = {
724         800, 800, 1600, 1600, 800, 800, 800, 1600, 1600, 800, 800, 800, 800,
725         800, 800
726 };
727 
728 static inline long in_from_reg(u8 reg, u8 nr)
729 {
730         return DIV_ROUND_CLOSEST(reg * scale_in[nr], 100);
731 }
732 
733 static inline u8 in_to_reg(u32 val, u8 nr)
734 {
735         return clamp_val(DIV_ROUND_CLOSEST(val * 100, scale_in[nr]), 0, 255);
736 }
737 
738 /*
739  * Data structures and manipulation thereof
740  */
741 
742 struct nct6775_data {
743         int addr;       /* IO base of hw monitor block */
744         int sioreg;     /* SIO register address */
745         enum kinds kind;
746         const char *name;
747 
748         const struct attribute_group *groups[6];
749 
750         u16 reg_temp[5][NUM_TEMP]; /* 0=temp, 1=temp_over, 2=temp_hyst,
751                                     * 3=temp_crit, 4=temp_lcrit
752                                     */
753         u8 temp_src[NUM_TEMP];
754         u16 reg_temp_config[NUM_TEMP];
755         const char * const *temp_label;
756         int temp_label_num;
757 
758         u16 REG_CONFIG;
759         u16 REG_VBAT;
760         u16 REG_DIODE;
761         u8 DIODE_MASK;
762 
763         const s8 *ALARM_BITS;
764         const s8 *BEEP_BITS;
765 
766         const u16 *REG_VIN;
767         const u16 *REG_IN_MINMAX[2];
768 
769         const u16 *REG_TARGET;
770         const u16 *REG_FAN;
771         const u16 *REG_FAN_MODE;
772         const u16 *REG_FAN_MIN;
773         const u16 *REG_FAN_PULSES;
774         const u16 *FAN_PULSE_SHIFT;
775         const u16 *REG_FAN_TIME[3];
776 
777         const u16 *REG_TOLERANCE_H;
778 
779         const u8 *REG_PWM_MODE;
780         const u8 *PWM_MODE_MASK;
781 
782         const u16 *REG_PWM[7];  /* [0]=pwm, [1]=pwm_start, [2]=pwm_floor,
783                                  * [3]=pwm_max, [4]=pwm_step,
784                                  * [5]=weight_duty_step, [6]=weight_duty_base
785                                  */
786         const u16 *REG_PWM_READ;
787 
788         const u16 *REG_CRITICAL_PWM_ENABLE;
789         u8 CRITICAL_PWM_ENABLE_MASK;
790         const u16 *REG_CRITICAL_PWM;
791 
792         const u16 *REG_AUTO_TEMP;
793         const u16 *REG_AUTO_PWM;
794 
795         const u16 *REG_CRITICAL_TEMP;
796         const u16 *REG_CRITICAL_TEMP_TOLERANCE;
797 
798         const u16 *REG_TEMP_SOURCE;     /* temp register sources */
799         const u16 *REG_TEMP_SEL;
800         const u16 *REG_WEIGHT_TEMP_SEL;
801         const u16 *REG_WEIGHT_TEMP[3];  /* 0=base, 1=tolerance, 2=step */
802 
803         const u16 *REG_TEMP_OFFSET;
804 
805         const u16 *REG_ALARM;
806         const u16 *REG_BEEP;
807 
808         unsigned int (*fan_from_reg)(u16 reg, unsigned int divreg);
809         unsigned int (*fan_from_reg_min)(u16 reg, unsigned int divreg);
810 
811         struct mutex update_lock;
812         bool valid;             /* true if following fields are valid */
813         unsigned long last_updated;     /* In jiffies */
814 
815         /* Register values */
816         u8 bank;                /* current register bank */
817         u8 in_num;              /* number of in inputs we have */
818         u8 in[15][3];           /* [0]=in, [1]=in_max, [2]=in_min */
819         unsigned int rpm[NUM_FAN];
820         u16 fan_min[NUM_FAN];
821         u8 fan_pulses[NUM_FAN];
822         u8 fan_div[NUM_FAN];
823         u8 has_pwm;
824         u8 has_fan;             /* some fan inputs can be disabled */
825         u8 has_fan_min;         /* some fans don't have min register */
826         bool has_fan_div;
827 
828         u8 num_temp_alarms;     /* 2, 3, or 6 */
829         u8 num_temp_beeps;      /* 2, 3, or 6 */
830         u8 temp_fixed_num;      /* 3 or 6 */
831         u8 temp_type[NUM_TEMP_FIXED];
832         s8 temp_offset[NUM_TEMP_FIXED];
833         s16 temp[5][NUM_TEMP]; /* 0=temp, 1=temp_over, 2=temp_hyst,
834                                 * 3=temp_crit, 4=temp_lcrit */
835         u64 alarms;
836         u64 beeps;
837 
838         u8 pwm_num;     /* number of pwm */
839         u8 pwm_mode[NUM_FAN];   /* 1->DC variable voltage,
840                                  * 0->PWM variable duty cycle
841                                  */
842         enum pwm_enable pwm_enable[NUM_FAN];
843                         /* 0->off
844                          * 1->manual
845                          * 2->thermal cruise mode (also called SmartFan I)
846                          * 3->fan speed cruise mode
847                          * 4->SmartFan III
848                          * 5->enhanced variable thermal cruise (SmartFan IV)
849                          */
850         u8 pwm[7][NUM_FAN];     /* [0]=pwm, [1]=pwm_start, [2]=pwm_floor,
851                                  * [3]=pwm_max, [4]=pwm_step,
852                                  * [5]=weight_duty_step, [6]=weight_duty_base
853                                  */
854 
855         u8 target_temp[NUM_FAN];
856         u8 target_temp_mask;
857         u32 target_speed[NUM_FAN];
858         u32 target_speed_tolerance[NUM_FAN];
859         u8 speed_tolerance_limit;
860 
861         u8 temp_tolerance[2][NUM_FAN];
862         u8 tolerance_mask;
863 
864         u8 fan_time[3][NUM_FAN]; /* 0 = stop_time, 1 = step_up, 2 = step_down */
865 
866         /* Automatic fan speed control registers */
867         int auto_pwm_num;
868         u8 auto_pwm[NUM_FAN][7];
869         u8 auto_temp[NUM_FAN][7];
870         u8 pwm_temp_sel[NUM_FAN];
871         u8 pwm_weight_temp_sel[NUM_FAN];
872         u8 weight_temp[3][NUM_FAN];     /* 0->temp_step, 1->temp_step_tol,
873                                          * 2->temp_base
874                                          */
875 
876         u8 vid;
877         u8 vrm;
878 
879         bool have_vid;
880 
881         u16 have_temp;
882         u16 have_temp_fixed;
883         u16 have_in;
884 
885         /* Remember extra register values over suspend/resume */
886         u8 vbat;
887         u8 fandiv1;
888         u8 fandiv2;
889         u8 sio_reg_enable;
890 };
891 
892 struct nct6775_sio_data {
893         int sioreg;
894         enum kinds kind;
895 };
896 
897 struct sensor_device_template {
898         struct device_attribute dev_attr;
899         union {
900                 struct {
901                         u8 nr;
902                         u8 index;
903                 } s;
904                 int index;
905         } u;
906         bool s2;        /* true if both index and nr are used */
907 };
908 
909 struct sensor_device_attr_u {
910         union {
911                 struct sensor_device_attribute a1;
912                 struct sensor_device_attribute_2 a2;
913         } u;
914         char name[32];
915 };
916 
917 #define __TEMPLATE_ATTR(_template, _mode, _show, _store) {      \
918         .attr = {.name = _template, .mode = _mode },            \
919         .show   = _show,                                        \
920         .store  = _store,                                       \
921 }
922 
923 #define SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store, _index) \
924         { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
925           .u.index = _index,                                            \
926           .s2 = false }
927 
928 #define SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,       \
929                                  _nr, _index)                           \
930         { .dev_attr = __TEMPLATE_ATTR(_template, _mode, _show, _store), \
931           .u.s.index = _index,                                          \
932           .u.s.nr = _nr,                                                \
933           .s2 = true }
934 
935 #define SENSOR_TEMPLATE(_name, _template, _mode, _show, _store, _index) \
936 static struct sensor_device_template sensor_dev_template_##_name        \
937         = SENSOR_DEVICE_TEMPLATE(_template, _mode, _show, _store,       \
938                                  _index)
939 
940 #define SENSOR_TEMPLATE_2(_name, _template, _mode, _show, _store,       \
941                           _nr, _index)                                  \
942 static struct sensor_device_template sensor_dev_template_##_name        \
943         = SENSOR_DEVICE_TEMPLATE_2(_template, _mode, _show, _store,     \
944                                  _nr, _index)
945 
946 struct sensor_template_group {
947         struct sensor_device_template **templates;
948         umode_t (*is_visible)(struct kobject *, struct attribute *, int);
949         int base;
950 };
951 
952 static struct attribute_group *
953 nct6775_create_attr_group(struct device *dev, struct sensor_template_group *tg,
954                           int repeat)
955 {
956         struct attribute_group *group;
957         struct sensor_device_attr_u *su;
958         struct sensor_device_attribute *a;
959         struct sensor_device_attribute_2 *a2;
960         struct attribute **attrs;
961         struct sensor_device_template **t;
962         int i, count;
963 
964         if (repeat <= 0)
965                 return ERR_PTR(-EINVAL);
966 
967         t = tg->templates;
968         for (count = 0; *t; t++, count++)
969                 ;
970 
971         if (count == 0)
972                 return ERR_PTR(-EINVAL);
973 
974         group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
975         if (group == NULL)
976                 return ERR_PTR(-ENOMEM);
977 
978         attrs = devm_kzalloc(dev, sizeof(*attrs) * (repeat * count + 1),
979                              GFP_KERNEL);
980         if (attrs == NULL)
981                 return ERR_PTR(-ENOMEM);
982 
983         su = devm_kzalloc(dev, sizeof(*su) * repeat * count,
984                                GFP_KERNEL);
985         if (su == NULL)
986                 return ERR_PTR(-ENOMEM);
987 
988         group->attrs = attrs;
989         group->is_visible = tg->is_visible;
990 
991         for (i = 0; i < repeat; i++) {
992                 t = tg->templates;
993                 while (*t != NULL) {
994                         snprintf(su->name, sizeof(su->name),
995                                  (*t)->dev_attr.attr.name, tg->base + i);
996                         if ((*t)->s2) {
997                                 a2 = &su->u.a2;
998                                 sysfs_attr_init(&a2->dev_attr.attr);
999                                 a2->dev_attr.attr.name = su->name;
1000                                 a2->nr = (*t)->u.s.nr + i;
1001                                 a2->index = (*t)->u.s.index;
1002                                 a2->dev_attr.attr.mode =
1003                                   (*t)->dev_attr.attr.mode;
1004                                 a2->dev_attr.show = (*t)->dev_attr.show;
1005                                 a2->dev_attr.store = (*t)->dev_attr.store;
1006                                 *attrs = &a2->dev_attr.attr;
1007                         } else {
1008                                 a = &su->u.a1;
1009                                 sysfs_attr_init(&a->dev_attr.attr);
1010                                 a->dev_attr.attr.name = su->name;
1011                                 a->index = (*t)->u.index + i;
1012                                 a->dev_attr.attr.mode =
1013                                   (*t)->dev_attr.attr.mode;
1014                                 a->dev_attr.show = (*t)->dev_attr.show;
1015                                 a->dev_attr.store = (*t)->dev_attr.store;
1016                                 *attrs = &a->dev_attr.attr;
1017                         }
1018                         attrs++;
1019                         su++;
1020                         t++;
1021                 }
1022         }
1023 
1024         return group;
1025 }
1026 
1027 static bool is_word_sized(struct nct6775_data *data, u16 reg)
1028 {
1029         switch (data->kind) {
1030         case nct6106:
1031                 return reg == 0x20 || reg == 0x22 || reg == 0x24 ||
1032                   reg == 0xe0 || reg == 0xe2 || reg == 0xe4 ||
1033                   reg == 0x111 || reg == 0x121 || reg == 0x131;
1034         case nct6775:
1035                 return (((reg & 0xff00) == 0x100 ||
1036                     (reg & 0xff00) == 0x200) &&
1037                    ((reg & 0x00ff) == 0x50 ||
1038                     (reg & 0x00ff) == 0x53 ||
1039                     (reg & 0x00ff) == 0x55)) ||
1040                   (reg & 0xfff0) == 0x630 ||
1041                   reg == 0x640 || reg == 0x642 ||
1042                   reg == 0x662 ||
1043                   ((reg & 0xfff0) == 0x650 && (reg & 0x000f) >= 0x06) ||
1044                   reg == 0x73 || reg == 0x75 || reg == 0x77;
1045         case nct6776:
1046                 return (((reg & 0xff00) == 0x100 ||
1047                     (reg & 0xff00) == 0x200) &&
1048                    ((reg & 0x00ff) == 0x50 ||
1049                     (reg & 0x00ff) == 0x53 ||
1050                     (reg & 0x00ff) == 0x55)) ||
1051                   (reg & 0xfff0) == 0x630 ||
1052                   reg == 0x402 ||
1053                   reg == 0x640 || reg == 0x642 ||
1054                   ((reg & 0xfff0) == 0x650 && (reg & 0x000f) >= 0x06) ||
1055                   reg == 0x73 || reg == 0x75 || reg == 0x77;
1056         case nct6779:
1057         case nct6791:
1058         case nct6792:
1059                 return reg == 0x150 || reg == 0x153 || reg == 0x155 ||
1060                   ((reg & 0xfff0) == 0x4b0 && (reg & 0x000f) < 0x0b) ||
1061                   reg == 0x402 ||
1062                   reg == 0x63a || reg == 0x63c || reg == 0x63e ||
1063                   reg == 0x640 || reg == 0x642 ||
1064                   reg == 0x73 || reg == 0x75 || reg == 0x77 || reg == 0x79 ||
1065                   reg == 0x7b || reg == 0x7d;
1066         }
1067         return false;
1068 }
1069 
1070 /*
1071  * On older chips, only registers 0x50-0x5f are banked.
1072  * On more recent chips, all registers are banked.
1073  * Assume that is the case and set the bank number for each access.
1074  * Cache the bank number so it only needs to be set if it changes.
1075  */
1076 static inline void nct6775_set_bank(struct nct6775_data *data, u16 reg)
1077 {
1078         u8 bank = reg >> 8;
1079 
1080         if (data->bank != bank) {
1081                 outb_p(NCT6775_REG_BANK, data->addr + ADDR_REG_OFFSET);
1082                 outb_p(bank, data->addr + DATA_REG_OFFSET);
1083                 data->bank = bank;
1084         }
1085 }
1086 
1087 static u16 nct6775_read_value(struct nct6775_data *data, u16 reg)
1088 {
1089         int res, word_sized = is_word_sized(data, reg);
1090 
1091         nct6775_set_bank(data, reg);
1092         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
1093         res = inb_p(data->addr + DATA_REG_OFFSET);
1094         if (word_sized) {
1095                 outb_p((reg & 0xff) + 1,
1096                        data->addr + ADDR_REG_OFFSET);
1097                 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
1098         }
1099         return res;
1100 }
1101 
1102 static int nct6775_write_value(struct nct6775_data *data, u16 reg, u16 value)
1103 {
1104         int word_sized = is_word_sized(data, reg);
1105 
1106         nct6775_set_bank(data, reg);
1107         outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
1108         if (word_sized) {
1109                 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
1110                 outb_p((reg & 0xff) + 1,
1111                        data->addr + ADDR_REG_OFFSET);
1112         }
1113         outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
1114         return 0;
1115 }
1116 
1117 /* We left-align 8-bit temperature values to make the code simpler */
1118 static u16 nct6775_read_temp(struct nct6775_data *data, u16 reg)
1119 {
1120         u16 res;
1121 
1122         res = nct6775_read_value(data, reg);
1123         if (!is_word_sized(data, reg))
1124                 res <<= 8;
1125 
1126         return res;
1127 }
1128 
1129 static int nct6775_write_temp(struct nct6775_data *data, u16 reg, u16 value)
1130 {
1131         if (!is_word_sized(data, reg))
1132                 value >>= 8;
1133         return nct6775_write_value(data, reg, value);
1134 }
1135 
1136 /* This function assumes that the caller holds data->update_lock */
1137 static void nct6775_write_fan_div(struct nct6775_data *data, int nr)
1138 {
1139         u8 reg;
1140 
1141         switch (nr) {
1142         case 0:
1143                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
1144                     | (data->fan_div[0] & 0x7);
1145                 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
1146                 break;
1147         case 1:
1148                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
1149                     | ((data->fan_div[1] << 4) & 0x70);
1150                 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
1151                 break;
1152         case 2:
1153                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
1154                     | (data->fan_div[2] & 0x7);
1155                 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
1156                 break;
1157         case 3:
1158                 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
1159                     | ((data->fan_div[3] << 4) & 0x70);
1160                 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
1161                 break;
1162         }
1163 }
1164 
1165 static void nct6775_write_fan_div_common(struct nct6775_data *data, int nr)
1166 {
1167         if (data->kind == nct6775)
1168                 nct6775_write_fan_div(data, nr);
1169 }
1170 
1171 static void nct6775_update_fan_div(struct nct6775_data *data)
1172 {
1173         u8 i;
1174 
1175         i = nct6775_read_value(data, NCT6775_REG_FANDIV1);
1176         data->fan_div[0] = i & 0x7;
1177         data->fan_div[1] = (i & 0x70) >> 4;
1178         i = nct6775_read_value(data, NCT6775_REG_FANDIV2);
1179         data->fan_div[2] = i & 0x7;
1180         if (data->has_fan & (1 << 3))
1181                 data->fan_div[3] = (i & 0x70) >> 4;
1182 }
1183 
1184 static void nct6775_update_fan_div_common(struct nct6775_data *data)
1185 {
1186         if (data->kind == nct6775)
1187                 nct6775_update_fan_div(data);
1188 }
1189 
1190 static void nct6775_init_fan_div(struct nct6775_data *data)
1191 {
1192         int i;
1193 
1194         nct6775_update_fan_div_common(data);
1195         /*
1196          * For all fans, start with highest divider value if the divider
1197          * register is not initialized. This ensures that we get a
1198          * reading from the fan count register, even if it is not optimal.
1199          * We'll compute a better divider later on.
1200          */
1201         for (i = 0; i < ARRAY_SIZE(data->fan_div); i++) {
1202                 if (!(data->has_fan & (1 << i)))
1203                         continue;
1204                 if (data->fan_div[i] == 0) {
1205                         data->fan_div[i] = 7;
1206                         nct6775_write_fan_div_common(data, i);
1207                 }
1208         }
1209 }
1210 
1211 static void nct6775_init_fan_common(struct device *dev,
1212                                     struct nct6775_data *data)
1213 {
1214         int i;
1215         u8 reg;
1216 
1217         if (data->has_fan_div)
1218                 nct6775_init_fan_div(data);
1219 
1220         /*
1221          * If fan_min is not set (0), set it to 0xff to disable it. This
1222          * prevents the unnecessary warning when fanX_min is reported as 0.
1223          */
1224         for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1225                 if (data->has_fan_min & (1 << i)) {
1226                         reg = nct6775_read_value(data, data->REG_FAN_MIN[i]);
1227                         if (!reg)
1228                                 nct6775_write_value(data, data->REG_FAN_MIN[i],
1229                                                     data->has_fan_div ? 0xff
1230                                                                       : 0xff1f);
1231                 }
1232         }
1233 }
1234 
1235 static void nct6775_select_fan_div(struct device *dev,
1236                                    struct nct6775_data *data, int nr, u16 reg)
1237 {
1238         u8 fan_div = data->fan_div[nr];
1239         u16 fan_min;
1240 
1241         if (!data->has_fan_div)
1242                 return;
1243 
1244         /*
1245          * If we failed to measure the fan speed, or the reported value is not
1246          * in the optimal range, and the clock divider can be modified,
1247          * let's try that for next time.
1248          */
1249         if (reg == 0x00 && fan_div < 0x07)
1250                 fan_div++;
1251         else if (reg != 0x00 && reg < 0x30 && fan_div > 0)
1252                 fan_div--;
1253 
1254         if (fan_div != data->fan_div[nr]) {
1255                 dev_dbg(dev, "Modifying fan%d clock divider from %u to %u\n",
1256                         nr + 1, div_from_reg(data->fan_div[nr]),
1257                         div_from_reg(fan_div));
1258 
1259                 /* Preserve min limit if possible */
1260                 if (data->has_fan_min & (1 << nr)) {
1261                         fan_min = data->fan_min[nr];
1262                         if (fan_div > data->fan_div[nr]) {
1263                                 if (fan_min != 255 && fan_min > 1)
1264                                         fan_min >>= 1;
1265                         } else {
1266                                 if (fan_min != 255) {
1267                                         fan_min <<= 1;
1268                                         if (fan_min > 254)
1269                                                 fan_min = 254;
1270                                 }
1271                         }
1272                         if (fan_min != data->fan_min[nr]) {
1273                                 data->fan_min[nr] = fan_min;
1274                                 nct6775_write_value(data, data->REG_FAN_MIN[nr],
1275                                                     fan_min);
1276                         }
1277                 }
1278                 data->fan_div[nr] = fan_div;
1279                 nct6775_write_fan_div_common(data, nr);
1280         }
1281 }
1282 
1283 static void nct6775_update_pwm(struct device *dev)
1284 {
1285         struct nct6775_data *data = dev_get_drvdata(dev);
1286         int i, j;
1287         int fanmodecfg, reg;
1288         bool duty_is_dc;
1289 
1290         for (i = 0; i < data->pwm_num; i++) {
1291                 if (!(data->has_pwm & (1 << i)))
1292                         continue;
1293 
1294                 duty_is_dc = data->REG_PWM_MODE[i] &&
1295                   (nct6775_read_value(data, data->REG_PWM_MODE[i])
1296                    & data->PWM_MODE_MASK[i]);
1297                 data->pwm_mode[i] = duty_is_dc;
1298 
1299                 fanmodecfg = nct6775_read_value(data, data->REG_FAN_MODE[i]);
1300                 for (j = 0; j < ARRAY_SIZE(data->REG_PWM); j++) {
1301                         if (data->REG_PWM[j] && data->REG_PWM[j][i]) {
1302                                 data->pwm[j][i]
1303                                   = nct6775_read_value(data,
1304                                                        data->REG_PWM[j][i]);
1305                         }
1306                 }
1307 
1308                 data->pwm_enable[i] = reg_to_pwm_enable(data->pwm[0][i],
1309                                                         (fanmodecfg >> 4) & 7);
1310 
1311                 if (!data->temp_tolerance[0][i] ||
1312                     data->pwm_enable[i] != speed_cruise)
1313                         data->temp_tolerance[0][i] = fanmodecfg & 0x0f;
1314                 if (!data->target_speed_tolerance[i] ||
1315                     data->pwm_enable[i] == speed_cruise) {
1316                         u8 t = fanmodecfg & 0x0f;
1317 
1318                         if (data->REG_TOLERANCE_H) {
1319                                 t |= (nct6775_read_value(data,
1320                                       data->REG_TOLERANCE_H[i]) & 0x70) >> 1;
1321                         }
1322                         data->target_speed_tolerance[i] = t;
1323                 }
1324 
1325                 data->temp_tolerance[1][i] =
1326                         nct6775_read_value(data,
1327                                         data->REG_CRITICAL_TEMP_TOLERANCE[i]);
1328 
1329                 reg = nct6775_read_value(data, data->REG_TEMP_SEL[i]);
1330                 data->pwm_temp_sel[i] = reg & 0x1f;
1331                 /* If fan can stop, report floor as 0 */
1332                 if (reg & 0x80)
1333                         data->pwm[2][i] = 0;
1334 
1335                 if (!data->REG_WEIGHT_TEMP_SEL[i])
1336                         continue;
1337 
1338                 reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[i]);
1339                 data->pwm_weight_temp_sel[i] = reg & 0x1f;
1340                 /* If weight is disabled, report weight source as 0 */
1341                 if (j == 1 && !(reg & 0x80))
1342                         data->pwm_weight_temp_sel[i] = 0;
1343 
1344                 /* Weight temp data */
1345                 for (j = 0; j < ARRAY_SIZE(data->weight_temp); j++) {
1346                         data->weight_temp[j][i]
1347                           = nct6775_read_value(data,
1348                                                data->REG_WEIGHT_TEMP[j][i]);
1349                 }
1350         }
1351 }
1352 
1353 static void nct6775_update_pwm_limits(struct device *dev)
1354 {
1355         struct nct6775_data *data = dev_get_drvdata(dev);
1356         int i, j;
1357         u8 reg;
1358         u16 reg_t;
1359 
1360         for (i = 0; i < data->pwm_num; i++) {
1361                 if (!(data->has_pwm & (1 << i)))
1362                         continue;
1363 
1364                 for (j = 0; j < ARRAY_SIZE(data->fan_time); j++) {
1365                         data->fan_time[j][i] =
1366                           nct6775_read_value(data, data->REG_FAN_TIME[j][i]);
1367                 }
1368 
1369                 reg_t = nct6775_read_value(data, data->REG_TARGET[i]);
1370                 /* Update only in matching mode or if never updated */
1371                 if (!data->target_temp[i] ||
1372                     data->pwm_enable[i] == thermal_cruise)
1373                         data->target_temp[i] = reg_t & data->target_temp_mask;
1374                 if (!data->target_speed[i] ||
1375                     data->pwm_enable[i] == speed_cruise) {
1376                         if (data->REG_TOLERANCE_H) {
1377                                 reg_t |= (nct6775_read_value(data,
1378                                         data->REG_TOLERANCE_H[i]) & 0x0f) << 8;
1379                         }
1380                         data->target_speed[i] = reg_t;
1381                 }
1382 
1383                 for (j = 0; j < data->auto_pwm_num; j++) {
1384                         data->auto_pwm[i][j] =
1385                           nct6775_read_value(data,
1386                                              NCT6775_AUTO_PWM(data, i, j));
1387                         data->auto_temp[i][j] =
1388                           nct6775_read_value(data,
1389                                              NCT6775_AUTO_TEMP(data, i, j));
1390                 }
1391 
1392                 /* critical auto_pwm temperature data */
1393                 data->auto_temp[i][data->auto_pwm_num] =
1394                         nct6775_read_value(data, data->REG_CRITICAL_TEMP[i]);
1395 
1396                 switch (data->kind) {
1397                 case nct6775:
1398                         reg = nct6775_read_value(data,
1399                                                  NCT6775_REG_CRITICAL_ENAB[i]);
1400                         data->auto_pwm[i][data->auto_pwm_num] =
1401                                                 (reg & 0x02) ? 0xff : 0x00;
1402                         break;
1403                 case nct6776:
1404                         data->auto_pwm[i][data->auto_pwm_num] = 0xff;
1405                         break;
1406                 case nct6106:
1407                 case nct6779:
1408                 case nct6791:
1409                 case nct6792:
1410                         reg = nct6775_read_value(data,
1411                                         data->REG_CRITICAL_PWM_ENABLE[i]);
1412                         if (reg & data->CRITICAL_PWM_ENABLE_MASK)
1413                                 reg = nct6775_read_value(data,
1414                                         data->REG_CRITICAL_PWM[i]);
1415                         else
1416                                 reg = 0xff;
1417                         data->auto_pwm[i][data->auto_pwm_num] = reg;
1418                         break;
1419                 }
1420         }
1421 }
1422 
1423 static struct nct6775_data *nct6775_update_device(struct device *dev)
1424 {
1425         struct nct6775_data *data = dev_get_drvdata(dev);
1426         int i, j;
1427 
1428         mutex_lock(&data->update_lock);
1429 
1430         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1431             || !data->valid) {
1432                 /* Fan clock dividers */
1433                 nct6775_update_fan_div_common(data);
1434 
1435                 /* Measured voltages and limits */
1436                 for (i = 0; i < data->in_num; i++) {
1437                         if (!(data->have_in & (1 << i)))
1438                                 continue;
1439 
1440                         data->in[i][0] = nct6775_read_value(data,
1441                                                             data->REG_VIN[i]);
1442                         data->in[i][1] = nct6775_read_value(data,
1443                                           data->REG_IN_MINMAX[0][i]);
1444                         data->in[i][2] = nct6775_read_value(data,
1445                                           data->REG_IN_MINMAX[1][i]);
1446                 }
1447 
1448                 /* Measured fan speeds and limits */
1449                 for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
1450                         u16 reg;
1451 
1452                         if (!(data->has_fan & (1 << i)))
1453                                 continue;
1454 
1455                         reg = nct6775_read_value(data, data->REG_FAN[i]);
1456                         data->rpm[i] = data->fan_from_reg(reg,
1457                                                           data->fan_div[i]);
1458 
1459                         if (data->has_fan_min & (1 << i))
1460                                 data->fan_min[i] = nct6775_read_value(data,
1461                                            data->REG_FAN_MIN[i]);
1462                         data->fan_pulses[i] =
1463                           (nct6775_read_value(data, data->REG_FAN_PULSES[i])
1464                                 >> data->FAN_PULSE_SHIFT[i]) & 0x03;
1465 
1466                         nct6775_select_fan_div(dev, data, i, reg);
1467                 }
1468 
1469                 nct6775_update_pwm(dev);
1470                 nct6775_update_pwm_limits(dev);
1471 
1472                 /* Measured temperatures and limits */
1473                 for (i = 0; i < NUM_TEMP; i++) {
1474                         if (!(data->have_temp & (1 << i)))
1475                                 continue;
1476                         for (j = 0; j < ARRAY_SIZE(data->reg_temp); j++) {
1477                                 if (data->reg_temp[j][i])
1478                                         data->temp[j][i]
1479                                           = nct6775_read_temp(data,
1480                                                 data->reg_temp[j][i]);
1481                         }
1482                         if (i >= NUM_TEMP_FIXED ||
1483                             !(data->have_temp_fixed & (1 << i)))
1484                                 continue;
1485                         data->temp_offset[i]
1486                           = nct6775_read_value(data, data->REG_TEMP_OFFSET[i]);
1487                 }
1488 
1489                 data->alarms = 0;
1490                 for (i = 0; i < NUM_REG_ALARM; i++) {
1491                         u8 alarm;
1492 
1493                         if (!data->REG_ALARM[i])
1494                                 continue;
1495                         alarm = nct6775_read_value(data, data->REG_ALARM[i]);
1496                         data->alarms |= ((u64)alarm) << (i << 3);
1497                 }
1498 
1499                 data->beeps = 0;
1500                 for (i = 0; i < NUM_REG_BEEP; i++) {
1501                         u8 beep;
1502 
1503                         if (!data->REG_BEEP[i])
1504                                 continue;
1505                         beep = nct6775_read_value(data, data->REG_BEEP[i]);
1506                         data->beeps |= ((u64)beep) << (i << 3);
1507                 }
1508 
1509                 data->last_updated = jiffies;
1510                 data->valid = true;
1511         }
1512 
1513         mutex_unlock(&data->update_lock);
1514         return data;
1515 }
1516 
1517 /*
1518  * Sysfs callback functions
1519  */
1520 static ssize_t
1521 show_in_reg(struct device *dev, struct device_attribute *attr, char *buf)
1522 {
1523         struct nct6775_data *data = nct6775_update_device(dev);
1524         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1525         int index = sattr->index;
1526         int nr = sattr->nr;
1527 
1528         return sprintf(buf, "%ld\n", in_from_reg(data->in[nr][index], nr));
1529 }
1530 
1531 static ssize_t
1532 store_in_reg(struct device *dev, struct device_attribute *attr, const char *buf,
1533              size_t count)
1534 {
1535         struct nct6775_data *data = dev_get_drvdata(dev);
1536         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1537         int index = sattr->index;
1538         int nr = sattr->nr;
1539         unsigned long val;
1540         int err;
1541 
1542         err = kstrtoul(buf, 10, &val);
1543         if (err < 0)
1544                 return err;
1545         mutex_lock(&data->update_lock);
1546         data->in[nr][index] = in_to_reg(val, nr);
1547         nct6775_write_value(data, data->REG_IN_MINMAX[index - 1][nr],
1548                             data->in[nr][index]);
1549         mutex_unlock(&data->update_lock);
1550         return count;
1551 }
1552 
1553 static ssize_t
1554 show_alarm(struct device *dev, struct device_attribute *attr, char *buf)
1555 {
1556         struct nct6775_data *data = nct6775_update_device(dev);
1557         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1558         int nr = data->ALARM_BITS[sattr->index];
1559 
1560         return sprintf(buf, "%u\n",
1561                        (unsigned int)((data->alarms >> nr) & 0x01));
1562 }
1563 
1564 static int find_temp_source(struct nct6775_data *data, int index, int count)
1565 {
1566         int source = data->temp_src[index];
1567         int nr;
1568 
1569         for (nr = 0; nr < count; nr++) {
1570                 int src;
1571 
1572                 src = nct6775_read_value(data,
1573                                          data->REG_TEMP_SOURCE[nr]) & 0x1f;
1574                 if (src == source)
1575                         return nr;
1576         }
1577         return -ENODEV;
1578 }
1579 
1580 static ssize_t
1581 show_temp_alarm(struct device *dev, struct device_attribute *attr, char *buf)
1582 {
1583         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1584         struct nct6775_data *data = nct6775_update_device(dev);
1585         unsigned int alarm = 0;
1586         int nr;
1587 
1588         /*
1589          * For temperatures, there is no fixed mapping from registers to alarm
1590          * bits. Alarm bits are determined by the temperature source mapping.
1591          */
1592         nr = find_temp_source(data, sattr->index, data->num_temp_alarms);
1593         if (nr >= 0) {
1594                 int bit = data->ALARM_BITS[nr + TEMP_ALARM_BASE];
1595 
1596                 alarm = (data->alarms >> bit) & 0x01;
1597         }
1598         return sprintf(buf, "%u\n", alarm);
1599 }
1600 
1601 static ssize_t
1602 show_beep(struct device *dev, struct device_attribute *attr, char *buf)
1603 {
1604         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1605         struct nct6775_data *data = nct6775_update_device(dev);
1606         int nr = data->BEEP_BITS[sattr->index];
1607 
1608         return sprintf(buf, "%u\n",
1609                        (unsigned int)((data->beeps >> nr) & 0x01));
1610 }
1611 
1612 static ssize_t
1613 store_beep(struct device *dev, struct device_attribute *attr, const char *buf,
1614            size_t count)
1615 {
1616         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1617         struct nct6775_data *data = dev_get_drvdata(dev);
1618         int nr = data->BEEP_BITS[sattr->index];
1619         int regindex = nr >> 3;
1620         unsigned long val;
1621         int err;
1622 
1623         err = kstrtoul(buf, 10, &val);
1624         if (err < 0)
1625                 return err;
1626         if (val > 1)
1627                 return -EINVAL;
1628 
1629         mutex_lock(&data->update_lock);
1630         if (val)
1631                 data->beeps |= (1ULL << nr);
1632         else
1633                 data->beeps &= ~(1ULL << nr);
1634         nct6775_write_value(data, data->REG_BEEP[regindex],
1635                             (data->beeps >> (regindex << 3)) & 0xff);
1636         mutex_unlock(&data->update_lock);
1637         return count;
1638 }
1639 
1640 static ssize_t
1641 show_temp_beep(struct device *dev, struct device_attribute *attr, char *buf)
1642 {
1643         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1644         struct nct6775_data *data = nct6775_update_device(dev);
1645         unsigned int beep = 0;
1646         int nr;
1647 
1648         /*
1649          * For temperatures, there is no fixed mapping from registers to beep
1650          * enable bits. Beep enable bits are determined by the temperature
1651          * source mapping.
1652          */
1653         nr = find_temp_source(data, sattr->index, data->num_temp_beeps);
1654         if (nr >= 0) {
1655                 int bit = data->BEEP_BITS[nr + TEMP_ALARM_BASE];
1656 
1657                 beep = (data->beeps >> bit) & 0x01;
1658         }
1659         return sprintf(buf, "%u\n", beep);
1660 }
1661 
1662 static ssize_t
1663 store_temp_beep(struct device *dev, struct device_attribute *attr,
1664                 const char *buf, size_t count)
1665 {
1666         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1667         struct nct6775_data *data = dev_get_drvdata(dev);
1668         int nr, bit, regindex;
1669         unsigned long val;
1670         int err;
1671 
1672         err = kstrtoul(buf, 10, &val);
1673         if (err < 0)
1674                 return err;
1675         if (val > 1)
1676                 return -EINVAL;
1677 
1678         nr = find_temp_source(data, sattr->index, data->num_temp_beeps);
1679         if (nr < 0)
1680                 return nr;
1681 
1682         bit = data->BEEP_BITS[nr + TEMP_ALARM_BASE];
1683         regindex = bit >> 3;
1684 
1685         mutex_lock(&data->update_lock);
1686         if (val)
1687                 data->beeps |= (1ULL << bit);
1688         else
1689                 data->beeps &= ~(1ULL << bit);
1690         nct6775_write_value(data, data->REG_BEEP[regindex],
1691                             (data->beeps >> (regindex << 3)) & 0xff);
1692         mutex_unlock(&data->update_lock);
1693 
1694         return count;
1695 }
1696 
1697 static umode_t nct6775_in_is_visible(struct kobject *kobj,
1698                                      struct attribute *attr, int index)
1699 {
1700         struct device *dev = container_of(kobj, struct device, kobj);
1701         struct nct6775_data *data = dev_get_drvdata(dev);
1702         int in = index / 5;     /* voltage index */
1703 
1704         if (!(data->have_in & (1 << in)))
1705                 return 0;
1706 
1707         return attr->mode;
1708 }
1709 
1710 SENSOR_TEMPLATE_2(in_input, "in%d_input", S_IRUGO, show_in_reg, NULL, 0, 0);
1711 SENSOR_TEMPLATE(in_alarm, "in%d_alarm", S_IRUGO, show_alarm, NULL, 0);
1712 SENSOR_TEMPLATE(in_beep, "in%d_beep", S_IWUSR | S_IRUGO, show_beep, store_beep,
1713                 0);
1714 SENSOR_TEMPLATE_2(in_min, "in%d_min", S_IWUSR | S_IRUGO, show_in_reg,
1715                   store_in_reg, 0, 1);
1716 SENSOR_TEMPLATE_2(in_max, "in%d_max", S_IWUSR | S_IRUGO, show_in_reg,
1717                   store_in_reg, 0, 2);
1718 
1719 /*
1720  * nct6775_in_is_visible uses the index into the following array
1721  * to determine if attributes should be created or not.
1722  * Any change in order or content must be matched.
1723  */
1724 static struct sensor_device_template *nct6775_attributes_in_template[] = {
1725         &sensor_dev_template_in_input,
1726         &sensor_dev_template_in_alarm,
1727         &sensor_dev_template_in_beep,
1728         &sensor_dev_template_in_min,
1729         &sensor_dev_template_in_max,
1730         NULL
1731 };
1732 
1733 static struct sensor_template_group nct6775_in_template_group = {
1734         .templates = nct6775_attributes_in_template,
1735         .is_visible = nct6775_in_is_visible,
1736 };
1737 
1738 static ssize_t
1739 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
1740 {
1741         struct nct6775_data *data = nct6775_update_device(dev);
1742         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1743         int nr = sattr->index;
1744 
1745         return sprintf(buf, "%d\n", data->rpm[nr]);
1746 }
1747 
1748 static ssize_t
1749 show_fan_min(struct device *dev, struct device_attribute *attr, char *buf)
1750 {
1751         struct nct6775_data *data = nct6775_update_device(dev);
1752         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1753         int nr = sattr->index;
1754 
1755         return sprintf(buf, "%d\n",
1756                        data->fan_from_reg_min(data->fan_min[nr],
1757                                               data->fan_div[nr]));
1758 }
1759 
1760 static ssize_t
1761 show_fan_div(struct device *dev, struct device_attribute *attr, char *buf)
1762 {
1763         struct nct6775_data *data = nct6775_update_device(dev);
1764         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1765         int nr = sattr->index;
1766 
1767         return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
1768 }
1769 
1770 static ssize_t
1771 store_fan_min(struct device *dev, struct device_attribute *attr,
1772               const char *buf, size_t count)
1773 {
1774         struct nct6775_data *data = dev_get_drvdata(dev);
1775         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1776         int nr = sattr->index;
1777         unsigned long val;
1778         unsigned int reg;
1779         u8 new_div;
1780         int err;
1781 
1782         err = kstrtoul(buf, 10, &val);
1783         if (err < 0)
1784                 return err;
1785 
1786         mutex_lock(&data->update_lock);
1787         if (!data->has_fan_div) {
1788                 /* NCT6776F or NCT6779D; we know this is a 13 bit register */
1789                 if (!val) {
1790                         val = 0xff1f;
1791                 } else {
1792                         if (val > 1350000U)
1793                                 val = 135000U;
1794                         val = 1350000U / val;
1795                         val = (val & 0x1f) | ((val << 3) & 0xff00);
1796                 }
1797                 data->fan_min[nr] = val;
1798                 goto write_min; /* Leave fan divider alone */
1799         }
1800         if (!val) {
1801                 /* No min limit, alarm disabled */
1802                 data->fan_min[nr] = 255;
1803                 new_div = data->fan_div[nr]; /* No change */
1804                 dev_info(dev, "fan%u low limit and alarm disabled\n", nr + 1);
1805                 goto write_div;
1806         }
1807         reg = 1350000U / val;
1808         if (reg >= 128 * 255) {
1809                 /*
1810                  * Speed below this value cannot possibly be represented,
1811                  * even with the highest divider (128)
1812                  */
1813                 data->fan_min[nr] = 254;
1814                 new_div = 7; /* 128 == (1 << 7) */
1815                 dev_warn(dev,
1816                          "fan%u low limit %lu below minimum %u, set to minimum\n",
1817                          nr + 1, val, data->fan_from_reg_min(254, 7));
1818         } else if (!reg) {
1819                 /*
1820                  * Speed above this value cannot possibly be represented,
1821                  * even with the lowest divider (1)
1822                  */
1823                 data->fan_min[nr] = 1;
1824                 new_div = 0; /* 1 == (1 << 0) */
1825                 dev_warn(dev,
1826                          "fan%u low limit %lu above maximum %u, set to maximum\n",
1827                          nr + 1, val, data->fan_from_reg_min(1, 0));
1828         } else {
1829                 /*
1830                  * Automatically pick the best divider, i.e. the one such
1831                  * that the min limit will correspond to a register value
1832                  * in the 96..192 range
1833                  */
1834                 new_div = 0;
1835                 while (reg > 192 && new_div < 7) {
1836                         reg >>= 1;
1837                         new_div++;
1838                 }
1839                 data->fan_min[nr] = reg;
1840         }
1841 
1842 write_div:
1843         /*
1844          * Write both the fan clock divider (if it changed) and the new
1845          * fan min (unconditionally)
1846          */
1847         if (new_div != data->fan_div[nr]) {
1848                 dev_dbg(dev, "fan%u clock divider changed from %u to %u\n",
1849                         nr + 1, div_from_reg(data->fan_div[nr]),
1850                         div_from_reg(new_div));
1851                 data->fan_div[nr] = new_div;
1852                 nct6775_write_fan_div_common(data, nr);
1853                 /* Give the chip time to sample a new speed value */
1854                 data->last_updated = jiffies;
1855         }
1856 
1857 write_min:
1858         nct6775_write_value(data, data->REG_FAN_MIN[nr], data->fan_min[nr]);
1859         mutex_unlock(&data->update_lock);
1860 
1861         return count;
1862 }
1863 
1864 static ssize_t
1865 show_fan_pulses(struct device *dev, struct device_attribute *attr, char *buf)
1866 {
1867         struct nct6775_data *data = nct6775_update_device(dev);
1868         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1869         int p = data->fan_pulses[sattr->index];
1870 
1871         return sprintf(buf, "%d\n", p ? : 4);
1872 }
1873 
1874 static ssize_t
1875 store_fan_pulses(struct device *dev, struct device_attribute *attr,
1876                  const char *buf, size_t count)
1877 {
1878         struct nct6775_data *data = dev_get_drvdata(dev);
1879         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1880         int nr = sattr->index;
1881         unsigned long val;
1882         int err;
1883         u8 reg;
1884 
1885         err = kstrtoul(buf, 10, &val);
1886         if (err < 0)
1887                 return err;
1888 
1889         if (val > 4)
1890                 return -EINVAL;
1891 
1892         mutex_lock(&data->update_lock);
1893         data->fan_pulses[nr] = val & 3;
1894         reg = nct6775_read_value(data, data->REG_FAN_PULSES[nr]);
1895         reg &= ~(0x03 << data->FAN_PULSE_SHIFT[nr]);
1896         reg |= (val & 3) << data->FAN_PULSE_SHIFT[nr];
1897         nct6775_write_value(data, data->REG_FAN_PULSES[nr], reg);
1898         mutex_unlock(&data->update_lock);
1899 
1900         return count;
1901 }
1902 
1903 static umode_t nct6775_fan_is_visible(struct kobject *kobj,
1904                                       struct attribute *attr, int index)
1905 {
1906         struct device *dev = container_of(kobj, struct device, kobj);
1907         struct nct6775_data *data = dev_get_drvdata(dev);
1908         int fan = index / 6;    /* fan index */
1909         int nr = index % 6;     /* attribute index */
1910 
1911         if (!(data->has_fan & (1 << fan)))
1912                 return 0;
1913 
1914         if (nr == 1 && data->ALARM_BITS[FAN_ALARM_BASE + fan] == -1)
1915                 return 0;
1916         if (nr == 2 && data->BEEP_BITS[FAN_ALARM_BASE + fan] == -1)
1917                 return 0;
1918         if (nr == 4 && !(data->has_fan_min & (1 << fan)))
1919                 return 0;
1920         if (nr == 5 && data->kind != nct6775)
1921                 return 0;
1922 
1923         return attr->mode;
1924 }
1925 
1926 SENSOR_TEMPLATE(fan_input, "fan%d_input", S_IRUGO, show_fan, NULL, 0);
1927 SENSOR_TEMPLATE(fan_alarm, "fan%d_alarm", S_IRUGO, show_alarm, NULL,
1928                 FAN_ALARM_BASE);
1929 SENSOR_TEMPLATE(fan_beep, "fan%d_beep", S_IWUSR | S_IRUGO, show_beep,
1930                 store_beep, FAN_ALARM_BASE);
1931 SENSOR_TEMPLATE(fan_pulses, "fan%d_pulses", S_IWUSR | S_IRUGO, show_fan_pulses,
1932                 store_fan_pulses, 0);
1933 SENSOR_TEMPLATE(fan_min, "fan%d_min", S_IWUSR | S_IRUGO, show_fan_min,
1934                 store_fan_min, 0);
1935 SENSOR_TEMPLATE(fan_div, "fan%d_div", S_IRUGO, show_fan_div, NULL, 0);
1936 
1937 /*
1938  * nct6775_fan_is_visible uses the index into the following array
1939  * to determine if attributes should be created or not.
1940  * Any change in order or content must be matched.
1941  */
1942 static struct sensor_device_template *nct6775_attributes_fan_template[] = {
1943         &sensor_dev_template_fan_input,
1944         &sensor_dev_template_fan_alarm, /* 1 */
1945         &sensor_dev_template_fan_beep,  /* 2 */
1946         &sensor_dev_template_fan_pulses,
1947         &sensor_dev_template_fan_min,   /* 4 */
1948         &sensor_dev_template_fan_div,   /* 5 */
1949         NULL
1950 };
1951 
1952 static struct sensor_template_group nct6775_fan_template_group = {
1953         .templates = nct6775_attributes_fan_template,
1954         .is_visible = nct6775_fan_is_visible,
1955         .base = 1,
1956 };
1957 
1958 static ssize_t
1959 show_temp_label(struct device *dev, struct device_attribute *attr, char *buf)
1960 {
1961         struct nct6775_data *data = nct6775_update_device(dev);
1962         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
1963         int nr = sattr->index;
1964 
1965         return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
1966 }
1967 
1968 static ssize_t
1969 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
1970 {
1971         struct nct6775_data *data = nct6775_update_device(dev);
1972         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1973         int nr = sattr->nr;
1974         int index = sattr->index;
1975 
1976         return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->temp[index][nr]));
1977 }
1978 
1979 static ssize_t
1980 store_temp(struct device *dev, struct device_attribute *attr, const char *buf,
1981            size_t count)
1982 {
1983         struct nct6775_data *data = dev_get_drvdata(dev);
1984         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
1985         int nr = sattr->nr;
1986         int index = sattr->index;
1987         int err;
1988         long val;
1989 
1990         err = kstrtol(buf, 10, &val);
1991         if (err < 0)
1992                 return err;
1993 
1994         mutex_lock(&data->update_lock);
1995         data->temp[index][nr] = LM75_TEMP_TO_REG(val);
1996         nct6775_write_temp(data, data->reg_temp[index][nr],
1997                            data->temp[index][nr]);
1998         mutex_unlock(&data->update_lock);
1999         return count;
2000 }
2001 
2002 static ssize_t
2003 show_temp_offset(struct device *dev, struct device_attribute *attr, char *buf)
2004 {
2005         struct nct6775_data *data = nct6775_update_device(dev);
2006         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2007 
2008         return sprintf(buf, "%d\n", data->temp_offset[sattr->index] * 1000);
2009 }
2010 
2011 static ssize_t
2012 store_temp_offset(struct device *dev, struct device_attribute *attr,
2013                   const char *buf, size_t count)
2014 {
2015         struct nct6775_data *data = dev_get_drvdata(dev);
2016         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2017         int nr = sattr->index;
2018         long val;
2019         int err;
2020 
2021         err = kstrtol(buf, 10, &val);
2022         if (err < 0)
2023                 return err;
2024 
2025         val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127);
2026 
2027         mutex_lock(&data->update_lock);
2028         data->temp_offset[nr] = val;
2029         nct6775_write_value(data, data->REG_TEMP_OFFSET[nr], val);
2030         mutex_unlock(&data->update_lock);
2031 
2032         return count;
2033 }
2034 
2035 static ssize_t
2036 show_temp_type(struct device *dev, struct device_attribute *attr, char *buf)
2037 {
2038         struct nct6775_data *data = nct6775_update_device(dev);
2039         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2040         int nr = sattr->index;
2041 
2042         return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
2043 }
2044 
2045 static ssize_t
2046 store_temp_type(struct device *dev, struct device_attribute *attr,
2047                 const char *buf, size_t count)
2048 {
2049         struct nct6775_data *data = nct6775_update_device(dev);
2050         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2051         int nr = sattr->index;
2052         unsigned long val;
2053         int err;
2054         u8 vbat, diode, vbit, dbit;
2055 
2056         err = kstrtoul(buf, 10, &val);
2057         if (err < 0)
2058                 return err;
2059 
2060         if (val != 1 && val != 3 && val != 4)
2061                 return -EINVAL;
2062 
2063         mutex_lock(&data->update_lock);
2064 
2065         data->temp_type[nr] = val;
2066         vbit = 0x02 << nr;
2067         dbit = data->DIODE_MASK << nr;
2068         vbat = nct6775_read_value(data, data->REG_VBAT) & ~vbit;
2069         diode = nct6775_read_value(data, data->REG_DIODE) & ~dbit;
2070         switch (val) {
2071         case 1: /* CPU diode (diode, current mode) */
2072                 vbat |= vbit;
2073                 diode |= dbit;
2074                 break;
2075         case 3: /* diode, voltage mode */
2076                 vbat |= dbit;
2077                 break;
2078         case 4: /* thermistor */
2079                 break;
2080         }
2081         nct6775_write_value(data, data->REG_VBAT, vbat);
2082         nct6775_write_value(data, data->REG_DIODE, diode);
2083 
2084         mutex_unlock(&data->update_lock);
2085         return count;
2086 }
2087 
2088 static umode_t nct6775_temp_is_visible(struct kobject *kobj,
2089                                        struct attribute *attr, int index)
2090 {
2091         struct device *dev = container_of(kobj, struct device, kobj);
2092         struct nct6775_data *data = dev_get_drvdata(dev);
2093         int temp = index / 10;  /* temp index */
2094         int nr = index % 10;    /* attribute index */
2095 
2096         if (!(data->have_temp & (1 << temp)))
2097                 return 0;
2098 
2099         if (nr == 2 && find_temp_source(data, temp, data->num_temp_alarms) < 0)
2100                 return 0;                               /* alarm */
2101 
2102         if (nr == 3 && find_temp_source(data, temp, data->num_temp_beeps) < 0)
2103                 return 0;                               /* beep */
2104 
2105         if (nr == 4 && !data->reg_temp[1][temp])        /* max */
2106                 return 0;
2107 
2108         if (nr == 5 && !data->reg_temp[2][temp])        /* max_hyst */
2109                 return 0;
2110 
2111         if (nr == 6 && !data->reg_temp[3][temp])        /* crit */
2112                 return 0;
2113 
2114         if (nr == 7 && !data->reg_temp[4][temp])        /* lcrit */
2115                 return 0;
2116 
2117         /* offset and type only apply to fixed sensors */
2118         if (nr > 7 && !(data->have_temp_fixed & (1 << temp)))
2119                 return 0;
2120 
2121         return attr->mode;
2122 }
2123 
2124 SENSOR_TEMPLATE_2(temp_input, "temp%d_input", S_IRUGO, show_temp, NULL, 0, 0);
2125 SENSOR_TEMPLATE(temp_label, "temp%d_label", S_IRUGO, show_temp_label, NULL, 0);
2126 SENSOR_TEMPLATE_2(temp_max, "temp%d_max", S_IRUGO | S_IWUSR, show_temp,
2127                   store_temp, 0, 1);
2128 SENSOR_TEMPLATE_2(temp_max_hyst, "temp%d_max_hyst", S_IRUGO | S_IWUSR,
2129                   show_temp, store_temp, 0, 2);
2130 SENSOR_TEMPLATE_2(temp_crit, "temp%d_crit", S_IRUGO | S_IWUSR, show_temp,
2131                   store_temp, 0, 3);
2132 SENSOR_TEMPLATE_2(temp_lcrit, "temp%d_lcrit", S_IRUGO | S_IWUSR, show_temp,
2133                   store_temp, 0, 4);
2134 SENSOR_TEMPLATE(temp_offset, "temp%d_offset", S_IRUGO | S_IWUSR,
2135                 show_temp_offset, store_temp_offset, 0);
2136 SENSOR_TEMPLATE(temp_type, "temp%d_type", S_IRUGO | S_IWUSR, show_temp_type,
2137                 store_temp_type, 0);
2138 SENSOR_TEMPLATE(temp_alarm, "temp%d_alarm", S_IRUGO, show_temp_alarm, NULL, 0);
2139 SENSOR_TEMPLATE(temp_beep, "temp%d_beep", S_IRUGO | S_IWUSR, show_temp_beep,
2140                 store_temp_beep, 0);
2141 
2142 /*
2143  * nct6775_temp_is_visible uses the index into the following array
2144  * to determine if attributes should be created or not.
2145  * Any change in order or content must be matched.
2146  */
2147 static struct sensor_device_template *nct6775_attributes_temp_template[] = {
2148         &sensor_dev_template_temp_input,
2149         &sensor_dev_template_temp_label,
2150         &sensor_dev_template_temp_alarm,        /* 2 */
2151         &sensor_dev_template_temp_beep,         /* 3 */
2152         &sensor_dev_template_temp_max,          /* 4 */
2153         &sensor_dev_template_temp_max_hyst,     /* 5 */
2154         &sensor_dev_template_temp_crit,         /* 6 */
2155         &sensor_dev_template_temp_lcrit,        /* 7 */
2156         &sensor_dev_template_temp_offset,       /* 8 */
2157         &sensor_dev_template_temp_type,         /* 9 */
2158         NULL
2159 };
2160 
2161 static struct sensor_template_group nct6775_temp_template_group = {
2162         .templates = nct6775_attributes_temp_template,
2163         .is_visible = nct6775_temp_is_visible,
2164         .base = 1,
2165 };
2166 
2167 static ssize_t
2168 show_pwm_mode(struct device *dev, struct device_attribute *attr, char *buf)
2169 {
2170         struct nct6775_data *data = nct6775_update_device(dev);
2171         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2172 
2173         return sprintf(buf, "%d\n", !data->pwm_mode[sattr->index]);
2174 }
2175 
2176 static ssize_t
2177 store_pwm_mode(struct device *dev, struct device_attribute *attr,
2178                const char *buf, size_t count)
2179 {
2180         struct nct6775_data *data = dev_get_drvdata(dev);
2181         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2182         int nr = sattr->index;
2183         unsigned long val;
2184         int err;
2185         u8 reg;
2186 
2187         err = kstrtoul(buf, 10, &val);
2188         if (err < 0)
2189                 return err;
2190 
2191         if (val > 1)
2192                 return -EINVAL;
2193 
2194         /* Setting DC mode is not supported for all chips/channels */
2195         if (data->REG_PWM_MODE[nr] == 0) {
2196                 if (val)
2197                         return -EINVAL;
2198                 return count;
2199         }
2200 
2201         mutex_lock(&data->update_lock);
2202         data->pwm_mode[nr] = val;
2203         reg = nct6775_read_value(data, data->REG_PWM_MODE[nr]);
2204         reg &= ~data->PWM_MODE_MASK[nr];
2205         if (val)
2206                 reg |= data->PWM_MODE_MASK[nr];
2207         nct6775_write_value(data, data->REG_PWM_MODE[nr], reg);
2208         mutex_unlock(&data->update_lock);
2209         return count;
2210 }
2211 
2212 static ssize_t
2213 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
2214 {
2215         struct nct6775_data *data = nct6775_update_device(dev);
2216         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2217         int nr = sattr->nr;
2218         int index = sattr->index;
2219         int pwm;
2220 
2221         /*
2222          * For automatic fan control modes, show current pwm readings.
2223          * Otherwise, show the configured value.
2224          */
2225         if (index == 0 && data->pwm_enable[nr] > manual)
2226                 pwm = nct6775_read_value(data, data->REG_PWM_READ[nr]);
2227         else
2228                 pwm = data->pwm[index][nr];
2229 
2230         return sprintf(buf, "%d\n", pwm);
2231 }
2232 
2233 static ssize_t
2234 store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
2235           size_t count)
2236 {
2237         struct nct6775_data *data = dev_get_drvdata(dev);
2238         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2239         int nr = sattr->nr;
2240         int index = sattr->index;
2241         unsigned long val;
2242         int minval[7] = { 0, 1, 1, data->pwm[2][nr], 0, 0, 0 };
2243         int maxval[7]
2244           = { 255, 255, data->pwm[3][nr] ? : 255, 255, 255, 255, 255 };
2245         int err;
2246         u8 reg;
2247 
2248         err = kstrtoul(buf, 10, &val);
2249         if (err < 0)
2250                 return err;
2251         val = clamp_val(val, minval[index], maxval[index]);
2252 
2253         mutex_lock(&data->update_lock);
2254         data->pwm[index][nr] = val;
2255         nct6775_write_value(data, data->REG_PWM[index][nr], val);
2256         if (index == 2) { /* floor: disable if val == 0 */
2257                 reg = nct6775_read_value(data, data->REG_TEMP_SEL[nr]);
2258                 reg &= 0x7f;
2259                 if (val)
2260                         reg |= 0x80;
2261                 nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg);
2262         }
2263         mutex_unlock(&data->update_lock);
2264         return count;
2265 }
2266 
2267 /* Returns 0 if OK, -EINVAL otherwise */
2268 static int check_trip_points(struct nct6775_data *data, int nr)
2269 {
2270         int i;
2271 
2272         for (i = 0; i < data->auto_pwm_num - 1; i++) {
2273                 if (data->auto_temp[nr][i] > data->auto_temp[nr][i + 1])
2274                         return -EINVAL;
2275         }
2276         for (i = 0; i < data->auto_pwm_num - 1; i++) {
2277                 if (data->auto_pwm[nr][i] > data->auto_pwm[nr][i + 1])
2278                         return -EINVAL;
2279         }
2280         /* validate critical temperature and pwm if enabled (pwm > 0) */
2281         if (data->auto_pwm[nr][data->auto_pwm_num]) {
2282                 if (data->auto_temp[nr][data->auto_pwm_num - 1] >
2283                                 data->auto_temp[nr][data->auto_pwm_num] ||
2284                     data->auto_pwm[nr][data->auto_pwm_num - 1] >
2285                                 data->auto_pwm[nr][data->auto_pwm_num])
2286                         return -EINVAL;
2287         }
2288         return 0;
2289 }
2290 
2291 static void pwm_update_registers(struct nct6775_data *data, int nr)
2292 {
2293         u8 reg;
2294 
2295         switch (data->pwm_enable[nr]) {
2296         case off:
2297         case manual:
2298                 break;
2299         case speed_cruise:
2300                 reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
2301                 reg = (reg & ~data->tolerance_mask) |
2302                   (data->target_speed_tolerance[nr] & data->tolerance_mask);
2303                 nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2304                 nct6775_write_value(data, data->REG_TARGET[nr],
2305                                     data->target_speed[nr] & 0xff);
2306                 if (data->REG_TOLERANCE_H) {
2307                         reg = (data->target_speed[nr] >> 8) & 0x0f;
2308                         reg |= (data->target_speed_tolerance[nr] & 0x38) << 1;
2309                         nct6775_write_value(data,
2310                                             data->REG_TOLERANCE_H[nr],
2311                                             reg);
2312                 }
2313                 break;
2314         case thermal_cruise:
2315                 nct6775_write_value(data, data->REG_TARGET[nr],
2316                                     data->target_temp[nr]);
2317                 /* intentional */
2318         default:
2319                 reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
2320                 reg = (reg & ~data->tolerance_mask) |
2321                   data->temp_tolerance[0][nr];
2322                 nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2323                 break;
2324         }
2325 }
2326 
2327 static ssize_t
2328 show_pwm_enable(struct device *dev, struct device_attribute *attr, char *buf)
2329 {
2330         struct nct6775_data *data = nct6775_update_device(dev);
2331         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2332 
2333         return sprintf(buf, "%d\n", data->pwm_enable[sattr->index]);
2334 }
2335 
2336 static ssize_t
2337 store_pwm_enable(struct device *dev, struct device_attribute *attr,
2338                  const char *buf, size_t count)
2339 {
2340         struct nct6775_data *data = dev_get_drvdata(dev);
2341         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2342         int nr = sattr->index;
2343         unsigned long val;
2344         int err;
2345         u16 reg;
2346 
2347         err = kstrtoul(buf, 10, &val);
2348         if (err < 0)
2349                 return err;
2350 
2351         if (val > sf4)
2352                 return -EINVAL;
2353 
2354         if (val == sf3 && data->kind != nct6775)
2355                 return -EINVAL;
2356 
2357         if (val == sf4 && check_trip_points(data, nr)) {
2358                 dev_err(dev, "Inconsistent trip points, not switching to SmartFan IV mode\n");
2359                 dev_err(dev, "Adjust trip points and try again\n");
2360                 return -EINVAL;
2361         }
2362 
2363         mutex_lock(&data->update_lock);
2364         data->pwm_enable[nr] = val;
2365         if (val == off) {
2366                 /*
2367                  * turn off pwm control: select manual mode, set pwm to maximum
2368                  */
2369                 data->pwm[0][nr] = 255;
2370                 nct6775_write_value(data, data->REG_PWM[0][nr], 255);
2371         }
2372         pwm_update_registers(data, nr);
2373         reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
2374         reg &= 0x0f;
2375         reg |= pwm_enable_to_reg(val) << 4;
2376         nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2377         mutex_unlock(&data->update_lock);
2378         return count;
2379 }
2380 
2381 static ssize_t
2382 show_pwm_temp_sel_common(struct nct6775_data *data, char *buf, int src)
2383 {
2384         int i, sel = 0;
2385 
2386         for (i = 0; i < NUM_TEMP; i++) {
2387                 if (!(data->have_temp & (1 << i)))
2388                         continue;
2389                 if (src == data->temp_src[i]) {
2390                         sel = i + 1;
2391                         break;
2392                 }
2393         }
2394 
2395         return sprintf(buf, "%d\n", sel);
2396 }
2397 
2398 static ssize_t
2399 show_pwm_temp_sel(struct device *dev, struct device_attribute *attr, char *buf)
2400 {
2401         struct nct6775_data *data = nct6775_update_device(dev);
2402         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2403         int index = sattr->index;
2404 
2405         return show_pwm_temp_sel_common(data, buf, data->pwm_temp_sel[index]);
2406 }
2407 
2408 static ssize_t
2409 store_pwm_temp_sel(struct device *dev, struct device_attribute *attr,
2410                    const char *buf, size_t count)
2411 {
2412         struct nct6775_data *data = nct6775_update_device(dev);
2413         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2414         int nr = sattr->index;
2415         unsigned long val;
2416         int err, reg, src;
2417 
2418         err = kstrtoul(buf, 10, &val);
2419         if (err < 0)
2420                 return err;
2421         if (val == 0 || val > NUM_TEMP)
2422                 return -EINVAL;
2423         if (!(data->have_temp & (1 << (val - 1))) || !data->temp_src[val - 1])
2424                 return -EINVAL;
2425 
2426         mutex_lock(&data->update_lock);
2427         src = data->temp_src[val - 1];
2428         data->pwm_temp_sel[nr] = src;
2429         reg = nct6775_read_value(data, data->REG_TEMP_SEL[nr]);
2430         reg &= 0xe0;
2431         reg |= src;
2432         nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg);
2433         mutex_unlock(&data->update_lock);
2434 
2435         return count;
2436 }
2437 
2438 static ssize_t
2439 show_pwm_weight_temp_sel(struct device *dev, struct device_attribute *attr,
2440                          char *buf)
2441 {
2442         struct nct6775_data *data = nct6775_update_device(dev);
2443         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2444         int index = sattr->index;
2445 
2446         return show_pwm_temp_sel_common(data, buf,
2447                                         data->pwm_weight_temp_sel[index]);
2448 }
2449 
2450 static ssize_t
2451 store_pwm_weight_temp_sel(struct device *dev, struct device_attribute *attr,
2452                           const char *buf, size_t count)
2453 {
2454         struct nct6775_data *data = nct6775_update_device(dev);
2455         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2456         int nr = sattr->index;
2457         unsigned long val;
2458         int err, reg, src;
2459 
2460         err = kstrtoul(buf, 10, &val);
2461         if (err < 0)
2462                 return err;
2463         if (val > NUM_TEMP)
2464                 return -EINVAL;
2465         if (val && (!(data->have_temp & (1 << (val - 1))) ||
2466                     !data->temp_src[val - 1]))
2467                 return -EINVAL;
2468 
2469         mutex_lock(&data->update_lock);
2470         if (val) {
2471                 src = data->temp_src[val - 1];
2472                 data->pwm_weight_temp_sel[nr] = src;
2473                 reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]);
2474                 reg &= 0xe0;
2475                 reg |= (src | 0x80);
2476                 nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
2477         } else {
2478                 data->pwm_weight_temp_sel[nr] = 0;
2479                 reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]);
2480                 reg &= 0x7f;
2481                 nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
2482         }
2483         mutex_unlock(&data->update_lock);
2484 
2485         return count;
2486 }
2487 
2488 static ssize_t
2489 show_target_temp(struct device *dev, struct device_attribute *attr, char *buf)
2490 {
2491         struct nct6775_data *data = nct6775_update_device(dev);
2492         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2493 
2494         return sprintf(buf, "%d\n", data->target_temp[sattr->index] * 1000);
2495 }
2496 
2497 static ssize_t
2498 store_target_temp(struct device *dev, struct device_attribute *attr,
2499                   const char *buf, size_t count)
2500 {
2501         struct nct6775_data *data = dev_get_drvdata(dev);
2502         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2503         int nr = sattr->index;
2504         unsigned long val;
2505         int err;
2506 
2507         err = kstrtoul(buf, 10, &val);
2508         if (err < 0)
2509                 return err;
2510 
2511         val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0,
2512                         data->target_temp_mask);
2513 
2514         mutex_lock(&data->update_lock);
2515         data->target_temp[nr] = val;
2516         pwm_update_registers(data, nr);
2517         mutex_unlock(&data->update_lock);
2518         return count;
2519 }
2520 
2521 static ssize_t
2522 show_target_speed(struct device *dev, struct device_attribute *attr, char *buf)
2523 {
2524         struct nct6775_data *data = nct6775_update_device(dev);
2525         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2526         int nr = sattr->index;
2527 
2528         return sprintf(buf, "%d\n",
2529                        fan_from_reg16(data->target_speed[nr],
2530                                       data->fan_div[nr]));
2531 }
2532 
2533 static ssize_t
2534 store_target_speed(struct device *dev, struct device_attribute *attr,
2535                    const char *buf, size_t count)
2536 {
2537         struct nct6775_data *data = dev_get_drvdata(dev);
2538         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2539         int nr = sattr->index;
2540         unsigned long val;
2541         int err;
2542         u16 speed;
2543 
2544         err = kstrtoul(buf, 10, &val);
2545         if (err < 0)
2546                 return err;
2547 
2548         val = clamp_val(val, 0, 1350000U);
2549         speed = fan_to_reg(val, data->fan_div[nr]);
2550 
2551         mutex_lock(&data->update_lock);
2552         data->target_speed[nr] = speed;
2553         pwm_update_registers(data, nr);
2554         mutex_unlock(&data->update_lock);
2555         return count;
2556 }
2557 
2558 static ssize_t
2559 show_temp_tolerance(struct device *dev, struct device_attribute *attr,
2560                     char *buf)
2561 {
2562         struct nct6775_data *data = nct6775_update_device(dev);
2563         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2564         int nr = sattr->nr;
2565         int index = sattr->index;
2566 
2567         return sprintf(buf, "%d\n", data->temp_tolerance[index][nr] * 1000);
2568 }
2569 
2570 static ssize_t
2571 store_temp_tolerance(struct device *dev, struct device_attribute *attr,
2572                      const char *buf, size_t count)
2573 {
2574         struct nct6775_data *data = dev_get_drvdata(dev);
2575         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2576         int nr = sattr->nr;
2577         int index = sattr->index;
2578         unsigned long val;
2579         int err;
2580 
2581         err = kstrtoul(buf, 10, &val);
2582         if (err < 0)
2583                 return err;
2584 
2585         /* Limit tolerance as needed */
2586         val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, data->tolerance_mask);
2587 
2588         mutex_lock(&data->update_lock);
2589         data->temp_tolerance[index][nr] = val;
2590         if (index)
2591                 pwm_update_registers(data, nr);
2592         else
2593                 nct6775_write_value(data,
2594                                     data->REG_CRITICAL_TEMP_TOLERANCE[nr],
2595                                     val);
2596         mutex_unlock(&data->update_lock);
2597         return count;
2598 }
2599 
2600 /*
2601  * Fan speed tolerance is a tricky beast, since the associated register is
2602  * a tick counter, but the value is reported and configured as rpm.
2603  * Compute resulting low and high rpm values and report the difference.
2604  */
2605 static ssize_t
2606 show_speed_tolerance(struct device *dev, struct device_attribute *attr,
2607                      char *buf)
2608 {
2609         struct nct6775_data *data = nct6775_update_device(dev);
2610         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2611         int nr = sattr->index;
2612         int low = data->target_speed[nr] - data->target_speed_tolerance[nr];
2613         int high = data->target_speed[nr] + data->target_speed_tolerance[nr];
2614         int tolerance;
2615 
2616         if (low <= 0)
2617                 low = 1;
2618         if (high > 0xffff)
2619                 high = 0xffff;
2620         if (high < low)
2621                 high = low;
2622 
2623         tolerance = (fan_from_reg16(low, data->fan_div[nr])
2624                      - fan_from_reg16(high, data->fan_div[nr])) / 2;
2625 
2626         return sprintf(buf, "%d\n", tolerance);
2627 }
2628 
2629 static ssize_t
2630 store_speed_tolerance(struct device *dev, struct device_attribute *attr,
2631                       const char *buf, size_t count)
2632 {
2633         struct nct6775_data *data = dev_get_drvdata(dev);
2634         struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr);
2635         int nr = sattr->index;
2636         unsigned long val;
2637         int err;
2638         int low, high;
2639 
2640         err = kstrtoul(buf, 10, &val);
2641         if (err < 0)
2642                 return err;
2643 
2644         high = fan_from_reg16(data->target_speed[nr],
2645                               data->fan_div[nr]) + val;
2646         low = fan_from_reg16(data->target_speed[nr],
2647                              data->fan_div[nr]) - val;
2648         if (low <= 0)
2649                 low = 1;
2650         if (high < low)
2651                 high = low;
2652 
2653         val = (fan_to_reg(low, data->fan_div[nr]) -
2654                fan_to_reg(high, data->fan_div[nr])) / 2;
2655 
2656         /* Limit tolerance as needed */
2657         val = clamp_val(val, 0, data->speed_tolerance_limit);
2658 
2659         mutex_lock(&data->update_lock);
2660         data->target_speed_tolerance[nr] = val;
2661         pwm_update_registers(data, nr);
2662         mutex_unlock(&data->update_lock);
2663         return count;
2664 }
2665 
2666 SENSOR_TEMPLATE_2(pwm, "pwm%d", S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0, 0);
2667 SENSOR_TEMPLATE(pwm_mode, "pwm%d_mode", S_IWUSR | S_IRUGO, show_pwm_mode,
2668                 store_pwm_mode, 0);
2669 SENSOR_TEMPLATE(pwm_enable, "pwm%d_enable", S_IWUSR | S_IRUGO, show_pwm_enable,
2670                 store_pwm_enable, 0);
2671 SENSOR_TEMPLATE(pwm_temp_sel, "pwm%d_temp_sel", S_IWUSR | S_IRUGO,
2672                 show_pwm_temp_sel, store_pwm_temp_sel, 0);
2673 SENSOR_TEMPLATE(pwm_target_temp, "pwm%d_target_temp", S_IWUSR | S_IRUGO,
2674                 show_target_temp, store_target_temp, 0);
2675 SENSOR_TEMPLATE(fan_target, "fan%d_target", S_IWUSR | S_IRUGO,
2676                 show_target_speed, store_target_speed, 0);
2677 SENSOR_TEMPLATE(fan_tolerance, "fan%d_tolerance", S_IWUSR | S_IRUGO,
2678                 show_speed_tolerance, store_speed_tolerance, 0);
2679 
2680 /* Smart Fan registers */
2681 
2682 static ssize_t
2683 show_weight_temp(struct device *dev, struct device_attribute *attr, char *buf)
2684 {
2685         struct nct6775_data *data = nct6775_update_device(dev);
2686         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2687         int nr = sattr->nr;
2688         int index = sattr->index;
2689 
2690         return sprintf(buf, "%d\n", data->weight_temp[index][nr] * 1000);
2691 }
2692 
2693 static ssize_t
2694 store_weight_temp(struct device *dev, struct device_attribute *attr,
2695                   const char *buf, size_t count)
2696 {
2697         struct nct6775_data *data = dev_get_drvdata(dev);
2698         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2699         int nr = sattr->nr;
2700         int index = sattr->index;
2701         unsigned long val;
2702         int err;
2703 
2704         err = kstrtoul(buf, 10, &val);
2705         if (err < 0)
2706                 return err;
2707 
2708         val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, 255);
2709 
2710         mutex_lock(&data->update_lock);
2711         data->weight_temp[index][nr] = val;
2712         nct6775_write_value(data, data->REG_WEIGHT_TEMP[index][nr], val);
2713         mutex_unlock(&data->update_lock);
2714         return count;
2715 }
2716 
2717 SENSOR_TEMPLATE(pwm_weight_temp_sel, "pwm%d_weight_temp_sel", S_IWUSR | S_IRUGO,
2718                   show_pwm_weight_temp_sel, store_pwm_weight_temp_sel, 0);
2719 SENSOR_TEMPLATE_2(pwm_weight_temp_step, "pwm%d_weight_temp_step",
2720                   S_IWUSR | S_IRUGO, show_weight_temp, store_weight_temp, 0, 0);
2721 SENSOR_TEMPLATE_2(pwm_weight_temp_step_tol, "pwm%d_weight_temp_step_tol",
2722                   S_IWUSR | S_IRUGO, show_weight_temp, store_weight_temp, 0, 1);
2723 SENSOR_TEMPLATE_2(pwm_weight_temp_step_base, "pwm%d_weight_temp_step_base",
2724                   S_IWUSR | S_IRUGO, show_weight_temp, store_weight_temp, 0, 2);
2725 SENSOR_TEMPLATE_2(pwm_weight_duty_step, "pwm%d_weight_duty_step",
2726                   S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0, 5);
2727 SENSOR_TEMPLATE_2(pwm_weight_duty_base, "pwm%d_weight_duty_base",
2728                   S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0, 6);
2729 
2730 static ssize_t
2731 show_fan_time(struct device *dev, struct device_attribute *attr, char *buf)
2732 {
2733         struct nct6775_data *data = nct6775_update_device(dev);
2734         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2735         int nr = sattr->nr;
2736         int index = sattr->index;
2737 
2738         return sprintf(buf, "%d\n",
2739                        step_time_from_reg(data->fan_time[index][nr],
2740                                           data->pwm_mode[nr]));
2741 }
2742 
2743 static ssize_t
2744 store_fan_time(struct device *dev, struct device_attribute *attr,
2745                const char *buf, size_t count)
2746 {
2747         struct nct6775_data *data = dev_get_drvdata(dev);
2748         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2749         int nr = sattr->nr;
2750         int index = sattr->index;
2751         unsigned long val;
2752         int err;
2753 
2754         err = kstrtoul(buf, 10, &val);
2755         if (err < 0)
2756                 return err;
2757 
2758         val = step_time_to_reg(val, data->pwm_mode[nr]);
2759         mutex_lock(&data->update_lock);
2760         data->fan_time[index][nr] = val;
2761         nct6775_write_value(data, data->REG_FAN_TIME[index][nr], val);
2762         mutex_unlock(&data->update_lock);
2763         return count;
2764 }
2765 
2766 static ssize_t
2767 show_auto_pwm(struct device *dev, struct device_attribute *attr, char *buf)
2768 {
2769         struct nct6775_data *data = nct6775_update_device(dev);
2770         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2771 
2772         return sprintf(buf, "%d\n", data->auto_pwm[sattr->nr][sattr->index]);
2773 }
2774 
2775 static ssize_t
2776 store_auto_pwm(struct device *dev, struct device_attribute *attr,
2777                const char *buf, size_t count)
2778 {
2779         struct nct6775_data *data = dev_get_drvdata(dev);
2780         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2781         int nr = sattr->nr;
2782         int point = sattr->index;
2783         unsigned long val;
2784         int err;
2785         u8 reg;
2786 
2787         err = kstrtoul(buf, 10, &val);
2788         if (err < 0)
2789                 return err;
2790         if (val > 255)
2791                 return -EINVAL;
2792 
2793         if (point == data->auto_pwm_num) {
2794                 if (data->kind != nct6775 && !val)
2795                         return -EINVAL;
2796                 if (data->kind != nct6779 && val)
2797                         val = 0xff;
2798         }
2799 
2800         mutex_lock(&data->update_lock);
2801         data->auto_pwm[nr][point] = val;
2802         if (point < data->auto_pwm_num) {
2803                 nct6775_write_value(data,
2804                                     NCT6775_AUTO_PWM(data, nr, point),
2805                                     data->auto_pwm[nr][point]);
2806         } else {
2807                 switch (data->kind) {
2808                 case nct6775:
2809                         /* disable if needed (pwm == 0) */
2810                         reg = nct6775_read_value(data,
2811                                                  NCT6775_REG_CRITICAL_ENAB[nr]);
2812                         if (val)
2813                                 reg |= 0x02;
2814                         else
2815                                 reg &= ~0x02;
2816                         nct6775_write_value(data, NCT6775_REG_CRITICAL_ENAB[nr],
2817                                             reg);
2818                         break;
2819                 case nct6776:
2820                         break; /* always enabled, nothing to do */
2821                 case nct6106:
2822                 case nct6779:
2823                 case nct6791:
2824                 case nct6792:
2825                         nct6775_write_value(data, data->REG_CRITICAL_PWM[nr],
2826                                             val);
2827                         reg = nct6775_read_value(data,
2828                                         data->REG_CRITICAL_PWM_ENABLE[nr]);
2829                         if (val == 255)
2830                                 reg &= ~data->CRITICAL_PWM_ENABLE_MASK;
2831                         else
2832                                 reg |= data->CRITICAL_PWM_ENABLE_MASK;
2833                         nct6775_write_value(data,
2834                                             data->REG_CRITICAL_PWM_ENABLE[nr],
2835                                             reg);
2836                         break;
2837                 }
2838         }
2839         mutex_unlock(&data->update_lock);
2840         return count;
2841 }
2842 
2843 static ssize_t
2844 show_auto_temp(struct device *dev, struct device_attribute *attr, char *buf)
2845 {
2846         struct nct6775_data *data = nct6775_update_device(dev);
2847         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2848         int nr = sattr->nr;
2849         int point = sattr->index;
2850 
2851         /*
2852          * We don't know for sure if the temperature is signed or unsigned.
2853          * Assume it is unsigned.
2854          */
2855         return sprintf(buf, "%d\n", data->auto_temp[nr][point] * 1000);
2856 }
2857 
2858 static ssize_t
2859 store_auto_temp(struct device *dev, struct device_attribute *attr,
2860                 const char *buf, size_t count)
2861 {
2862         struct nct6775_data *data = dev_get_drvdata(dev);
2863         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
2864         int nr = sattr->nr;
2865         int point = sattr->index;
2866         unsigned long val;
2867         int err;
2868 
2869         err = kstrtoul(buf, 10, &val);
2870         if (err)
2871                 return err;
2872         if (val > 255000)
2873                 return -EINVAL;
2874 
2875         mutex_lock(&data->update_lock);
2876         data->auto_temp[nr][point] = DIV_ROUND_CLOSEST(val, 1000);
2877         if (point < data->auto_pwm_num) {
2878                 nct6775_write_value(data,
2879                                     NCT6775_AUTO_TEMP(data, nr, point),
2880                                     data->auto_temp[nr][point]);
2881         } else {
2882                 nct6775_write_value(data, data->REG_CRITICAL_TEMP[nr],
2883                                     data->auto_temp[nr][point]);
2884         }
2885         mutex_unlock(&data->update_lock);
2886         return count;
2887 }
2888 
2889 static umode_t nct6775_pwm_is_visible(struct kobject *kobj,
2890                                       struct attribute *attr, int index)
2891 {
2892         struct device *dev = container_of(kobj, struct device, kobj);
2893         struct nct6775_data *data = dev_get_drvdata(dev);
2894         int pwm = index / 36;   /* pwm index */
2895         int nr = index % 36;    /* attribute index */
2896 
2897         if (!(data->has_pwm & (1 << pwm)))
2898                 return 0;
2899 
2900         if ((nr >= 14 && nr <= 18) || nr == 21)   /* weight */
2901                 if (!data->REG_WEIGHT_TEMP_SEL[pwm])
2902                         return 0;
2903         if (nr == 19 && data->REG_PWM[3] == NULL) /* pwm_max */
2904                 return 0;
2905         if (nr == 20 && data->REG_PWM[4] == NULL) /* pwm_step */
2906                 return 0;
2907         if (nr == 21 && data->REG_PWM[6] == NULL) /* weight_duty_base */
2908                 return 0;
2909 
2910         if (nr >= 22 && nr <= 35) {             /* auto point */
2911                 int api = (nr - 22) / 2;        /* auto point index */
2912 
2913                 if (api > data->auto_pwm_num)
2914                         return 0;
2915         }
2916         return attr->mode;
2917 }
2918 
2919 SENSOR_TEMPLATE_2(pwm_stop_time, "pwm%d_stop_time", S_IWUSR | S_IRUGO,
2920                   show_fan_time, store_fan_time, 0, 0);
2921 SENSOR_TEMPLATE_2(pwm_step_up_time, "pwm%d_step_up_time", S_IWUSR | S_IRUGO,
2922                   show_fan_time, store_fan_time, 0, 1);
2923 SENSOR_TEMPLATE_2(pwm_step_down_time, "pwm%d_step_down_time", S_IWUSR | S_IRUGO,
2924                   show_fan_time, store_fan_time, 0, 2);
2925 SENSOR_TEMPLATE_2(pwm_start, "pwm%d_start", S_IWUSR | S_IRUGO, show_pwm,
2926                   store_pwm, 0, 1);
2927 SENSOR_TEMPLATE_2(pwm_floor, "pwm%d_floor", S_IWUSR | S_IRUGO, show_pwm,
2928                   store_pwm, 0, 2);
2929 SENSOR_TEMPLATE_2(pwm_temp_tolerance, "pwm%d_temp_tolerance", S_IWUSR | S_IRUGO,
2930                   show_temp_tolerance, store_temp_tolerance, 0, 0);
2931 SENSOR_TEMPLATE_2(pwm_crit_temp_tolerance, "pwm%d_crit_temp_tolerance",
2932                   S_IWUSR | S_IRUGO, show_temp_tolerance, store_temp_tolerance,
2933                   0, 1);
2934 
2935 SENSOR_TEMPLATE_2(pwm_max, "pwm%d_max", S_IWUSR | S_IRUGO, show_pwm, store_pwm,
2936                   0, 3);
2937 
2938 SENSOR_TEMPLATE_2(pwm_step, "pwm%d_step", S_IWUSR | S_IRUGO, show_pwm,
2939                   store_pwm, 0, 4);
2940 
2941 SENSOR_TEMPLATE_2(pwm_auto_point1_pwm, "pwm%d_auto_point1_pwm",
2942                   S_IWUSR | S_IRUGO, show_auto_pwm, store_auto_pwm, 0, 0);
2943 SENSOR_TEMPLATE_2(pwm_auto_point1_temp, "pwm%d_auto_point1_temp",
2944                   S_IWUSR | S_IRUGO, show_auto_temp, store_auto_temp, 0, 0);
2945 
2946 SENSOR_TEMPLATE_2(pwm_auto_point2_pwm, "pwm%d_auto_point2_pwm",
2947                   S_IWUSR | S_IRUGO, show_auto_pwm, store_auto_pwm, 0, 1);
2948 SENSOR_TEMPLATE_2(pwm_auto_point2_temp, "pwm%d_auto_point2_temp",
2949                   S_IWUSR | S_IRUGO, show_auto_temp, store_auto_temp, 0, 1);
2950 
2951 SENSOR_TEMPLATE_2(pwm_auto_point3_pwm, "pwm%d_auto_point3_pwm",
2952                   S_IWUSR | S_IRUGO, show_auto_pwm, store_auto_pwm, 0, 2);
2953 SENSOR_TEMPLATE_2(pwm_auto_point3_temp, "pwm%d_auto_point3_temp",
2954                   S_IWUSR | S_IRUGO, show_auto_temp, store_auto_temp, 0, 2);
2955 
2956 SENSOR_TEMPLATE_2(pwm_auto_point4_pwm, "pwm%d_auto_point4_pwm",
2957                   S_IWUSR | S_IRUGO, show_auto_pwm, store_auto_pwm, 0, 3);
2958 SENSOR_TEMPLATE_2(pwm_auto_point4_temp, "pwm%d_auto_point4_temp",
2959                   S_IWUSR | S_IRUGO, show_auto_temp, store_auto_temp, 0, 3);
2960 
2961 SENSOR_TEMPLATE_2(pwm_auto_point5_pwm, "pwm%d_auto_point5_pwm",
2962                   S_IWUSR | S_IRUGO, show_auto_pwm, store_auto_pwm, 0, 4);
2963 SENSOR_TEMPLATE_2(pwm_auto_point5_temp, "pwm%d_auto_point5_temp",
2964                   S_IWUSR | S_IRUGO, show_auto_temp, store_auto_temp, 0, 4);
2965 
2966 SENSOR_TEMPLATE_2(pwm_auto_point6_pwm, "pwm%d_auto_point6_pwm",
2967                   S_IWUSR | S_IRUGO, show_auto_pwm, store_auto_pwm, 0, 5);
2968 SENSOR_TEMPLATE_2(pwm_auto_point6_temp, "pwm%d_auto_point6_temp",
2969                   S_IWUSR | S_IRUGO, show_auto_temp, store_auto_temp, 0, 5);
2970 
2971 SENSOR_TEMPLATE_2(pwm_auto_point7_pwm, "pwm%d_auto_point7_pwm",
2972                   S_IWUSR | S_IRUGO, show_auto_pwm, store_auto_pwm, 0, 6);
2973 SENSOR_TEMPLATE_2(pwm_auto_point7_temp, "pwm%d_auto_point7_temp",
2974                   S_IWUSR | S_IRUGO, show_auto_temp, store_auto_temp, 0, 6);
2975 
2976 /*
2977  * nct6775_pwm_is_visible uses the index into the following array
2978  * to determine if attributes should be created or not.
2979  * Any change in order or content must be matched.
2980  */
2981 static struct sensor_device_template *nct6775_attributes_pwm_template[] = {
2982         &sensor_dev_template_pwm,
2983         &sensor_dev_template_pwm_mode,
2984         &sensor_dev_template_pwm_enable,
2985         &sensor_dev_template_pwm_temp_sel,
2986         &sensor_dev_template_pwm_temp_tolerance,
2987         &sensor_dev_template_pwm_crit_temp_tolerance,
2988         &sensor_dev_template_pwm_target_temp,
2989         &sensor_dev_template_fan_target,
2990         &sensor_dev_template_fan_tolerance,
2991         &sensor_dev_template_pwm_stop_time,
2992         &sensor_dev_template_pwm_step_up_time,
2993         &sensor_dev_template_pwm_step_down_time,
2994         &sensor_dev_template_pwm_start,
2995         &sensor_dev_template_pwm_floor,
2996         &sensor_dev_template_pwm_weight_temp_sel,       /* 14 */
2997         &sensor_dev_template_pwm_weight_temp_step,
2998         &sensor_dev_template_pwm_weight_temp_step_tol,
2999         &sensor_dev_template_pwm_weight_temp_step_base,
3000         &sensor_dev_template_pwm_weight_duty_step,      /* 18 */
3001         &sensor_dev_template_pwm_max,                   /* 19 */
3002         &sensor_dev_template_pwm_step,                  /* 20 */
3003         &sensor_dev_template_pwm_weight_duty_base,      /* 21 */
3004         &sensor_dev_template_pwm_auto_point1_pwm,       /* 22 */
3005         &sensor_dev_template_pwm_auto_point1_temp,
3006         &sensor_dev_template_pwm_auto_point2_pwm,
3007         &sensor_dev_template_pwm_auto_point2_temp,
3008         &sensor_dev_template_pwm_auto_point3_pwm,
3009         &sensor_dev_template_pwm_auto_point3_temp,
3010         &sensor_dev_template_pwm_auto_point4_pwm,
3011         &sensor_dev_template_pwm_auto_point4_temp,
3012         &sensor_dev_template_pwm_auto_point5_pwm,
3013         &sensor_dev_template_pwm_auto_point5_temp,
3014         &sensor_dev_template_pwm_auto_point6_pwm,
3015         &sensor_dev_template_pwm_auto_point6_temp,
3016         &sensor_dev_template_pwm_auto_point7_pwm,
3017         &sensor_dev_template_pwm_auto_point7_temp,      /* 35 */
3018 
3019         NULL
3020 };
3021 
3022 static struct sensor_template_group nct6775_pwm_template_group = {
3023         .templates = nct6775_attributes_pwm_template,
3024         .is_visible = nct6775_pwm_is_visible,
3025         .base = 1,
3026 };
3027 
3028 static ssize_t
3029 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
3030 {
3031         struct nct6775_data *data = dev_get_drvdata(dev);
3032 
3033         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
3034 }
3035 
3036 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
3037 
3038 /* Case open detection */
3039 
3040 static ssize_t
3041 clear_caseopen(struct device *dev, struct device_attribute *attr,
3042                const char *buf, size_t count)
3043 {
3044         struct nct6775_data *data = dev_get_drvdata(dev);
3045         int nr = to_sensor_dev_attr(attr)->index - INTRUSION_ALARM_BASE;
3046         unsigned long val;
3047         u8 reg;
3048         int ret;
3049 
3050         if (kstrtoul(buf, 10, &val) || val != 0)
3051                 return -EINVAL;
3052 
3053         mutex_lock(&data->update_lock);
3054 
3055         /*
3056          * Use CR registers to clear caseopen status.
3057          * The CR registers are the same for all chips, and not all chips
3058          * support clearing the caseopen status through "regular" registers.
3059          */
3060         ret = superio_enter(data->sioreg);
3061         if (ret) {
3062                 count = ret;
3063                 goto error;
3064         }
3065 
3066         superio_select(data->sioreg, NCT6775_LD_ACPI);
3067         reg = superio_inb(data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr]);
3068         reg |= NCT6775_CR_CASEOPEN_CLR_MASK[nr];
3069         superio_outb(data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg);
3070         reg &= ~NCT6775_CR_CASEOPEN_CLR_MASK[nr];
3071         superio_outb(data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg);
3072         superio_exit(data->sioreg);
3073 
3074         data->valid = false;    /* Force cache refresh */
3075 error:
3076         mutex_unlock(&data->update_lock);
3077         return count;
3078 }
3079 
3080 static SENSOR_DEVICE_ATTR(intrusion0_alarm, S_IWUSR | S_IRUGO, show_alarm,
3081                           clear_caseopen, INTRUSION_ALARM_BASE);
3082 static SENSOR_DEVICE_ATTR(intrusion1_alarm, S_IWUSR | S_IRUGO, show_alarm,
3083                           clear_caseopen, INTRUSION_ALARM_BASE + 1);
3084 static SENSOR_DEVICE_ATTR(intrusion0_beep, S_IWUSR | S_IRUGO, show_beep,
3085                           store_beep, INTRUSION_ALARM_BASE);
3086 static SENSOR_DEVICE_ATTR(intrusion1_beep, S_IWUSR | S_IRUGO, show_beep,
3087                           store_beep, INTRUSION_ALARM_BASE + 1);
3088 static SENSOR_DEVICE_ATTR(beep_enable, S_IWUSR | S_IRUGO, show_beep,
3089                           store_beep, BEEP_ENABLE_BASE);
3090 
3091 static umode_t nct6775_other_is_visible(struct kobject *kobj,
3092                                         struct attribute *attr, int index)
3093 {
3094         struct device *dev = container_of(kobj, struct device, kobj);
3095         struct nct6775_data *data = dev_get_drvdata(dev);
3096 
3097         if (index == 0 && !data->have_vid)
3098                 return 0;
3099 
3100         if (index == 1 || index == 2) {
3101                 if (data->ALARM_BITS[INTRUSION_ALARM_BASE + index - 1] < 0)
3102                         return 0;
3103         }
3104 
3105         if (index == 3 || index == 4) {
3106                 if (data->BEEP_BITS[INTRUSION_ALARM_BASE + index - 3] < 0)
3107                         return 0;
3108         }
3109 
3110         return attr->mode;
3111 }
3112 
3113 /*
3114  * nct6775_other_is_visible uses the index into the following array
3115  * to determine if attributes should be created or not.
3116  * Any change in order or content must be matched.
3117  */
3118 static struct attribute *nct6775_attributes_other[] = {
3119         &dev_attr_cpu0_vid.attr,                                /* 0 */
3120         &sensor_dev_attr_intrusion0_alarm.dev_attr.attr,        /* 1 */
3121         &sensor_dev_attr_intrusion1_alarm.dev_attr.attr,        /* 2 */
3122         &sensor_dev_attr_intrusion0_beep.dev_attr.attr,         /* 3 */
3123         &sensor_dev_attr_intrusion1_beep.dev_attr.attr,         /* 4 */
3124         &sensor_dev_attr_beep_enable.dev_attr.attr,             /* 5 */
3125 
3126         NULL
3127 };
3128 
3129 static const struct attribute_group nct6775_group_other = {
3130         .attrs = nct6775_attributes_other,
3131         .is_visible = nct6775_other_is_visible,
3132 };
3133 
3134 static inline void nct6775_init_device(struct nct6775_data *data)
3135 {
3136         int i;
3137         u8 tmp, diode;
3138 
3139         /* Start monitoring if needed */
3140         if (data->REG_CONFIG) {
3141                 tmp = nct6775_read_value(data, data->REG_CONFIG);
3142                 if (!(tmp & 0x01))
3143                         nct6775_write_value(data, data->REG_CONFIG, tmp | 0x01);
3144         }
3145 
3146         /* Enable temperature sensors if needed */
3147         for (i = 0; i < NUM_TEMP; i++) {
3148                 if (!(data->have_temp & (1 << i)))
3149                         continue;
3150                 if (!data->reg_temp_config[i])
3151                         continue;
3152                 tmp = nct6775_read_value(data, data->reg_temp_config[i]);
3153                 if (tmp & 0x01)
3154                         nct6775_write_value(data, data->reg_temp_config[i],
3155                                             tmp & 0xfe);
3156         }
3157 
3158         /* Enable VBAT monitoring if needed */
3159         tmp = nct6775_read_value(data, data->REG_VBAT);
3160         if (!(tmp & 0x01))
3161                 nct6775_write_value(data, data->REG_VBAT, tmp | 0x01);
3162 
3163         diode = nct6775_read_value(data, data->REG_DIODE);
3164 
3165         for (i = 0; i < data->temp_fixed_num; i++) {
3166                 if (!(data->have_temp_fixed & (1 << i)))
3167                         continue;
3168                 if ((tmp & (data->DIODE_MASK << i)))    /* diode */
3169                         data->temp_type[i]
3170                           = 3 - ((diode >> i) & data->DIODE_MASK);
3171                 else                            /* thermistor */
3172                         data->temp_type[i] = 4;
3173         }
3174 }
3175 
3176 static void
3177 nct6775_check_fan_inputs(struct nct6775_data *data)
3178 {
3179         bool fan3pin, fan4pin, fan4min, fan5pin, fan6pin;
3180         bool pwm3pin, pwm4pin, pwm5pin, pwm6pin;
3181         int sioreg = data->sioreg;
3182         int regval;
3183 
3184         /* Store SIO_REG_ENABLE for use during resume */
3185         superio_select(sioreg, NCT6775_LD_HWM);
3186         data->sio_reg_enable = superio_inb(sioreg, SIO_REG_ENABLE);
3187 
3188         /* fan4 and fan5 share some pins with the GPIO and serial flash */
3189         if (data->kind == nct6775) {
3190                 regval = superio_inb(sioreg, 0x2c);
3191 
3192                 fan3pin = regval & (1 << 6);
3193                 pwm3pin = regval & (1 << 7);
3194 
3195                 /* On NCT6775, fan4 shares pins with the fdc interface */
3196                 fan4pin = !(superio_inb(sioreg, 0x2A) & 0x80);
3197                 fan4min = false;
3198                 fan5pin = false;
3199                 fan6pin = false;
3200                 pwm4pin = false;
3201                 pwm5pin = false;
3202                 pwm6pin = false;
3203         } else if (data->kind == nct6776) {
3204                 bool gpok = superio_inb(sioreg, 0x27) & 0x80;
3205                 const char *board_vendor, *board_name;
3206 
3207                 board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
3208                 board_name = dmi_get_system_info(DMI_BOARD_NAME);
3209 
3210                 if (board_name && board_vendor &&
3211                     !strcmp(board_vendor, "ASRock")) {
3212                         /*
3213                          * Auxiliary fan monitoring is not enabled on ASRock
3214                          * Z77 Pro4-M if booted in UEFI Ultra-FastBoot mode.
3215                          * Observed with BIOS version 2.00.
3216                          */
3217                         if (!strcmp(board_name, "Z77 Pro4-M")) {
3218                                 if ((data->sio_reg_enable & 0xe0) != 0xe0) {
3219                                         data->sio_reg_enable |= 0xe0;
3220                                         superio_outb(sioreg, SIO_REG_ENABLE,
3221                                                      data->sio_reg_enable);
3222                                 }
3223                         }
3224                 }
3225 
3226                 if (data->sio_reg_enable & 0x80)
3227                         fan3pin = gpok;
3228                 else
3229                         fan3pin = !(superio_inb(sioreg, 0x24) & 0x40);
3230 
3231                 if (data->sio_reg_enable & 0x40)
3232                         fan4pin = gpok;
3233                 else
3234                         fan4pin = superio_inb(sioreg, 0x1C) & 0x01;
3235 
3236                 if (data->sio_reg_enable & 0x20)
3237                         fan5pin = gpok;
3238                 else
3239                         fan5pin = superio_inb(sioreg, 0x1C) & 0x02;
3240 
3241                 fan4min = fan4pin;
3242                 fan6pin = false;
3243                 pwm3pin = fan3pin;
3244                 pwm4pin = false;
3245                 pwm5pin = false;
3246                 pwm6pin = false;
3247         } else if (data->kind == nct6106) {
3248                 regval = superio_inb(sioreg, 0x24);
3249                 fan3pin = !(regval & 0x80);
3250                 pwm3pin = regval & 0x08;
3251 
3252                 fan4pin = false;
3253                 fan4min = false;
3254                 fan5pin = false;
3255                 fan6pin = false;
3256                 pwm4pin = false;
3257                 pwm5pin = false;
3258                 pwm6pin = false;
3259         } else {        /* NCT6779D, NCT6791D, or NCT6792D */
3260                 regval = superio_inb(sioreg, 0x1c);
3261 
3262                 fan3pin = !(regval & (1 << 5));
3263                 fan4pin = !(regval & (1 << 6));
3264                 fan5pin = !(regval & (1 << 7));
3265 
3266                 pwm3pin = !(regval & (1 << 0));
3267                 pwm4pin = !(regval & (1 << 1));
3268                 pwm5pin = !(regval & (1 << 2));
3269 
3270                 fan4min = fan4pin;
3271 
3272                 if (data->kind == nct6791 || data->kind == nct6792) {
3273                         regval = superio_inb(sioreg, 0x2d);
3274                         fan6pin = (regval & (1 << 1));
3275                         pwm6pin = (regval & (1 << 0));
3276                 } else {        /* NCT6779D */
3277                         fan6pin = false;
3278                         pwm6pin = false;
3279                 }
3280         }
3281 
3282         /* fan 1 and 2 (0x03) are always present */
3283         data->has_fan = 0x03 | (fan3pin << 2) | (fan4pin << 3) |
3284                 (fan5pin << 4) | (fan6pin << 5);
3285         data->has_fan_min = 0x03 | (fan3pin << 2) | (fan4min << 3) |
3286                 (fan5pin << 4);
3287         data->has_pwm = 0x03 | (pwm3pin << 2) | (pwm4pin << 3) |
3288                 (pwm5pin << 4) | (pwm6pin << 5);
3289 }
3290 
3291 static void add_temp_sensors(struct nct6775_data *data, const u16 *regp,
3292                              int *available, int *mask)
3293 {
3294         int i;
3295         u8 src;
3296 
3297         for (i = 0; i < data->pwm_num && *available; i++) {
3298                 int index;
3299 
3300                 if (!regp[i])
3301                         continue;
3302                 src = nct6775_read_value(data, regp[i]);
3303                 src &= 0x1f;
3304                 if (!src || (*mask & (1 << src)))
3305                         continue;
3306                 if (src >= data->temp_label_num ||
3307                     !strlen(data->temp_label[src]))
3308                         continue;
3309 
3310                 index = __ffs(*available);
3311                 nct6775_write_value(data, data->REG_TEMP_SOURCE[index], src);
3312                 *available &= ~(1 << index);
3313                 *mask |= 1 << src;
3314         }
3315 }
3316 
3317 static int nct6775_probe(struct platform_device *pdev)
3318 {
3319         struct device *dev = &pdev->dev;
3320         struct nct6775_sio_data *sio_data = dev_get_platdata(dev);
3321         struct nct6775_data *data;
3322         struct resource *res;
3323         int i, s, err = 0;
3324         int src, mask, available;
3325         const u16 *reg_temp, *reg_temp_over, *reg_temp_hyst, *reg_temp_config;
3326         const u16 *reg_temp_mon, *reg_temp_alternate, *reg_temp_crit;
3327         const u16 *reg_temp_crit_l = NULL, *reg_temp_crit_h = NULL;
3328         int num_reg_temp, num_reg_temp_mon;
3329         u8 cr2a;
3330         struct attribute_group *group;
3331         struct device *hwmon_dev;
3332         int num_attr_groups = 0;
3333 
3334         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
3335         if (!devm_request_region(&pdev->dev, res->start, IOREGION_LENGTH,
3336                                  DRVNAME))
3337                 return -EBUSY;
3338 
3339         data = devm_kzalloc(&pdev->dev, sizeof(struct nct6775_data),
3340                             GFP_KERNEL);
3341         if (!data)
3342                 return -ENOMEM;
3343 
3344         data->kind = sio_data->kind;
3345         data->sioreg = sio_data->sioreg;
3346         data->addr = res->start;
3347         mutex_init(&data->update_lock);
3348         data->name = nct6775_device_names[data->kind];
3349         data->bank = 0xff;              /* Force initial bank selection */
3350         platform_set_drvdata(pdev, data);
3351 
3352         switch (data->kind) {
3353         case nct6106:
3354                 data->in_num = 9;
3355                 data->pwm_num = 3;
3356                 data->auto_pwm_num = 4;
3357                 data->temp_fixed_num = 3;
3358                 data->num_temp_alarms = 6;
3359                 data->num_temp_beeps = 6;
3360 
3361                 data->fan_from_reg = fan_from_reg13;
3362                 data->fan_from_reg_min = fan_from_reg13;
3363 
3364                 data->temp_label = nct6776_temp_label;
3365                 data->temp_label_num = ARRAY_SIZE(nct6776_temp_label);
3366 
3367                 data->REG_VBAT = NCT6106_REG_VBAT;
3368                 data->REG_DIODE = NCT6106_REG_DIODE;
3369                 data->DIODE_MASK = NCT6106_DIODE_MASK;
3370                 data->REG_VIN = NCT6106_REG_IN;
3371                 data->REG_IN_MINMAX[0] = NCT6106_REG_IN_MIN;
3372                 data->REG_IN_MINMAX[1] = NCT6106_REG_IN_MAX;
3373                 data->REG_TARGET = NCT6106_REG_TARGET;
3374                 data->REG_FAN = NCT6106_REG_FAN;
3375                 data->REG_FAN_MODE = NCT6106_REG_FAN_MODE;
3376                 data->REG_FAN_MIN = NCT6106_REG_FAN_MIN;
3377                 data->REG_FAN_PULSES = NCT6106_REG_FAN_PULSES;
3378                 data->FAN_PULSE_SHIFT = NCT6106_FAN_PULSE_SHIFT;
3379                 data->REG_FAN_TIME[0] = NCT6106_REG_FAN_STOP_TIME;
3380                 data->REG_FAN_TIME[1] = NCT6106_REG_FAN_STEP_UP_TIME;
3381                 data->REG_FAN_TIME[2] = NCT6106_REG_FAN_STEP_DOWN_TIME;
3382                 data->REG_PWM[0] = NCT6106_REG_PWM;
3383                 data->REG_PWM[1] = NCT6106_REG_FAN_START_OUTPUT;
3384                 data->REG_PWM[2] = NCT6106_REG_FAN_STOP_OUTPUT;
3385                 data->REG_PWM[5] = NCT6106_REG_WEIGHT_DUTY_STEP;
3386                 data->REG_PWM[6] = NCT6106_REG_WEIGHT_DUTY_BASE;
3387                 data->REG_PWM_READ = NCT6106_REG_PWM_READ;
3388                 data->REG_PWM_MODE = NCT6106_REG_PWM_MODE;
3389                 data->PWM_MODE_MASK = NCT6106_PWM_MODE_MASK;
3390                 data->REG_AUTO_TEMP = NCT6106_REG_AUTO_TEMP;
3391                 data->REG_AUTO_PWM = NCT6106_REG_AUTO_PWM;
3392                 data->REG_CRITICAL_TEMP = NCT6106_REG_CRITICAL_TEMP;
3393                 data->REG_CRITICAL_TEMP_TOLERANCE
3394                   = NCT6106_REG_CRITICAL_TEMP_TOLERANCE;
3395                 data->REG_CRITICAL_PWM_ENABLE = NCT6106_REG_CRITICAL_PWM_ENABLE;
3396                 data->CRITICAL_PWM_ENABLE_MASK
3397                   = NCT6106_CRITICAL_PWM_ENABLE_MASK;
3398                 data->REG_CRITICAL_PWM = NCT6106_REG_CRITICAL_PWM;
3399                 data->REG_TEMP_OFFSET = NCT6106_REG_TEMP_OFFSET;
3400                 data->REG_TEMP_SOURCE = NCT6106_REG_TEMP_SOURCE;
3401                 data->REG_TEMP_SEL = NCT6106_REG_TEMP_SEL;
3402                 data->REG_WEIGHT_TEMP_SEL = NCT6106_REG_WEIGHT_TEMP_SEL;
3403                 data->REG_WEIGHT_TEMP[0] = NCT6106_REG_WEIGHT_TEMP_STEP;
3404                 data->REG_WEIGHT_TEMP[1] = NCT6106_REG_WEIGHT_TEMP_STEP_TOL;
3405                 data->REG_WEIGHT_TEMP[2] = NCT6106_REG_WEIGHT_TEMP_BASE;
3406                 data->REG_ALARM = NCT6106_REG_ALARM;
3407                 data->ALARM_BITS = NCT6106_ALARM_BITS;
3408                 data->REG_BEEP = NCT6106_REG_BEEP;
3409                 data->BEEP_BITS = NCT6106_BEEP_BITS;
3410 
3411                 reg_temp = NCT6106_REG_TEMP;
3412                 reg_temp_mon = NCT6106_REG_TEMP_MON;
3413                 num_reg_temp = ARRAY_SIZE(NCT6106_REG_TEMP);
3414                 num_reg_temp_mon = ARRAY_SIZE(NCT6106_REG_TEMP_MON);
3415                 reg_temp_over = NCT6106_REG_TEMP_OVER;
3416                 reg_temp_hyst = NCT6106_REG_TEMP_HYST;
3417                 reg_temp_config = NCT6106_REG_TEMP_CONFIG;
3418                 reg_temp_alternate = NCT6106_REG_TEMP_ALTERNATE;
3419                 reg_temp_crit = NCT6106_REG_TEMP_CRIT;
3420                 reg_temp_crit_l = NCT6106_REG_TEMP_CRIT_L;
3421                 reg_temp_crit_h = NCT6106_REG_TEMP_CRIT_H;
3422 
3423                 break;
3424         case nct6775:
3425                 data->in_num = 9;
3426                 data->pwm_num = 3;
3427                 data->auto_pwm_num = 6;
3428                 data->has_fan_div = true;
3429                 data->temp_fixed_num = 3;
3430                 data->num_temp_alarms = 3;
3431                 data->num_temp_beeps = 3;
3432 
3433                 data->ALARM_BITS = NCT6775_ALARM_BITS;
3434                 data->BEEP_BITS = NCT6775_BEEP_BITS;
3435 
3436                 data->fan_from_reg = fan_from_reg16;
3437                 data->fan_from_reg_min = fan_from_reg8;
3438                 data->target_temp_mask = 0x7f;
3439                 data->tolerance_mask = 0x0f;
3440                 data->speed_tolerance_limit = 15;
3441 
3442                 data->temp_label = nct6775_temp_label;
3443                 data->temp_label_num = ARRAY_SIZE(nct6775_temp_label);
3444 
3445                 data->REG_CONFIG = NCT6775_REG_CONFIG;
3446                 data->REG_VBAT = NCT6775_REG_VBAT;
3447                 data->REG_DIODE = NCT6775_REG_DIODE;
3448                 data->DIODE_MASK = NCT6775_DIODE_MASK;
3449                 data->REG_VIN = NCT6775_REG_IN;
3450                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3451                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3452                 data->REG_TARGET = NCT6775_REG_TARGET;
3453                 data->REG_FAN = NCT6775_REG_FAN;
3454                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3455                 data->REG_FAN_MIN = NCT6775_REG_FAN_MIN;
3456                 data->REG_FAN_PULSES = NCT6775_REG_FAN_PULSES;
3457                 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3458                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3459                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
3460                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
3461                 data->REG_PWM[0] = NCT6775_REG_PWM;
3462                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3463                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3464                 data->REG_PWM[3] = NCT6775_REG_FAN_MAX_OUTPUT;
3465                 data->REG_PWM[4] = NCT6775_REG_FAN_STEP_OUTPUT;
3466                 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
3467                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3468                 data->REG_PWM_MODE = NCT6775_REG_PWM_MODE;
3469                 data->PWM_MODE_MASK = NCT6775_PWM_MODE_MASK;
3470                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3471                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3472                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3473                 data->REG_CRITICAL_TEMP_TOLERANCE
3474                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
3475                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
3476                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3477                 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
3478                 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
3479                 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3480                 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3481                 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3482                 data->REG_ALARM = NCT6775_REG_ALARM;
3483                 data->REG_BEEP = NCT6775_REG_BEEP;
3484 
3485                 reg_temp = NCT6775_REG_TEMP;
3486                 reg_temp_mon = NCT6775_REG_TEMP_MON;
3487                 num_reg_temp = ARRAY_SIZE(NCT6775_REG_TEMP);
3488                 num_reg_temp_mon = ARRAY_SIZE(NCT6775_REG_TEMP_MON);
3489                 reg_temp_over = NCT6775_REG_TEMP_OVER;
3490                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
3491                 reg_temp_config = NCT6775_REG_TEMP_CONFIG;
3492                 reg_temp_alternate = NCT6775_REG_TEMP_ALTERNATE;
3493                 reg_temp_crit = NCT6775_REG_TEMP_CRIT;
3494 
3495                 break;
3496         case nct6776:
3497                 data->in_num = 9;
3498                 data->pwm_num = 3;
3499                 data->auto_pwm_num = 4;
3500                 data->has_fan_div = false;
3501                 data->temp_fixed_num = 3;
3502                 data->num_temp_alarms = 3;
3503                 data->num_temp_beeps = 6;
3504 
3505                 data->ALARM_BITS = NCT6776_ALARM_BITS;
3506                 data->BEEP_BITS = NCT6776_BEEP_BITS;
3507 
3508                 data->fan_from_reg = fan_from_reg13;
3509                 data->fan_from_reg_min = fan_from_reg13;
3510                 data->target_temp_mask = 0xff;
3511                 data->tolerance_mask = 0x07;
3512                 data->speed_tolerance_limit = 63;
3513 
3514                 data->temp_label = nct6776_temp_label;
3515                 data->temp_label_num = ARRAY_SIZE(nct6776_temp_label);
3516 
3517                 data->REG_CONFIG = NCT6775_REG_CONFIG;
3518                 data->REG_VBAT = NCT6775_REG_VBAT;
3519                 data->REG_DIODE = NCT6775_REG_DIODE;
3520                 data->DIODE_MASK = NCT6775_DIODE_MASK;
3521                 data->REG_VIN = NCT6775_REG_IN;
3522                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3523                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3524                 data->REG_TARGET = NCT6775_REG_TARGET;
3525                 data->REG_FAN = NCT6775_REG_FAN;
3526                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3527                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3528                 data->REG_FAN_PULSES = NCT6776_REG_FAN_PULSES;
3529                 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3530                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3531                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
3532                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
3533                 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
3534                 data->REG_PWM[0] = NCT6775_REG_PWM;
3535                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3536                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3537                 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
3538                 data->REG_PWM[6] = NCT6776_REG_WEIGHT_DUTY_BASE;
3539                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3540                 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3541                 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3542                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3543                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3544                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3545                 data->REG_CRITICAL_TEMP_TOLERANCE
3546                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
3547                 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
3548                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3549                 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
3550                 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
3551                 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3552                 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3553                 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3554                 data->REG_ALARM = NCT6775_REG_ALARM;
3555                 data->REG_BEEP = NCT6776_REG_BEEP;
3556 
3557                 reg_temp = NCT6775_REG_TEMP;
3558                 reg_temp_mon = NCT6775_REG_TEMP_MON;
3559                 num_reg_temp = ARRAY_SIZE(NCT6775_REG_TEMP);
3560                 num_reg_temp_mon = ARRAY_SIZE(NCT6775_REG_TEMP_MON);
3561                 reg_temp_over = NCT6775_REG_TEMP_OVER;
3562                 reg_temp_hyst = NCT6775_REG_TEMP_HYST;
3563                 reg_temp_config = NCT6776_REG_TEMP_CONFIG;
3564                 reg_temp_alternate = NCT6776_REG_TEMP_ALTERNATE;
3565                 reg_temp_crit = NCT6776_REG_TEMP_CRIT;
3566 
3567                 break;
3568         case nct6779:
3569                 data->in_num = 15;
3570                 data->pwm_num = 5;
3571                 data->auto_pwm_num = 4;
3572                 data->has_fan_div = false;
3573                 data->temp_fixed_num = 6;
3574                 data->num_temp_alarms = 2;
3575                 data->num_temp_beeps = 2;
3576 
3577                 data->ALARM_BITS = NCT6779_ALARM_BITS;
3578                 data->BEEP_BITS = NCT6779_BEEP_BITS;
3579 
3580                 data->fan_from_reg = fan_from_reg13;
3581                 data->fan_from_reg_min = fan_from_reg13;
3582                 data->target_temp_mask = 0xff;
3583                 data->tolerance_mask = 0x07;
3584                 data->speed_tolerance_limit = 63;
3585 
3586                 data->temp_label = nct6779_temp_label;
3587                 data->temp_label_num = ARRAY_SIZE(nct6779_temp_label);
3588 
3589                 data->REG_CONFIG = NCT6775_REG_CONFIG;
3590                 data->REG_VBAT = NCT6775_REG_VBAT;
3591                 data->REG_DIODE = NCT6775_REG_DIODE;
3592                 data->DIODE_MASK = NCT6775_DIODE_MASK;
3593                 data->REG_VIN = NCT6779_REG_IN;
3594                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3595                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3596                 data->REG_TARGET = NCT6775_REG_TARGET;
3597                 data->REG_FAN = NCT6779_REG_FAN;
3598                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3599                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3600                 data->REG_FAN_PULSES = NCT6779_REG_FAN_PULSES;
3601                 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3602                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3603                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
3604                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
3605                 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
3606                 data->REG_PWM[0] = NCT6775_REG_PWM;
3607                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3608                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3609                 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
3610                 data->REG_PWM[6] = NCT6776_REG_WEIGHT_DUTY_BASE;
3611                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3612                 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3613                 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3614                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3615                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3616                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3617                 data->REG_CRITICAL_TEMP_TOLERANCE
3618                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
3619                 data->REG_CRITICAL_PWM_ENABLE = NCT6779_REG_CRITICAL_PWM_ENABLE;
3620                 data->CRITICAL_PWM_ENABLE_MASK
3621                   = NCT6779_CRITICAL_PWM_ENABLE_MASK;
3622                 data->REG_CRITICAL_PWM = NCT6779_REG_CRITICAL_PWM;
3623                 data->REG_TEMP_OFFSET = NCT6779_REG_TEMP_OFFSET;
3624                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3625                 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
3626                 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
3627                 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3628                 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3629                 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3630                 data->REG_ALARM = NCT6779_REG_ALARM;
3631                 data->REG_BEEP = NCT6776_REG_BEEP;
3632 
3633                 reg_temp = NCT6779_REG_TEMP;
3634                 reg_temp_mon = NCT6779_REG_TEMP_MON;
3635                 num_reg_temp = ARRAY_SIZE(NCT6779_REG_TEMP);
3636                 num_reg_temp_mon = ARRAY_SIZE(NCT6779_REG_TEMP_MON);
3637                 reg_temp_over = NCT6779_REG_TEMP_OVER;
3638                 reg_temp_hyst = NCT6779_REG_TEMP_HYST;
3639                 reg_temp_config = NCT6779_REG_TEMP_CONFIG;
3640                 reg_temp_alternate = NCT6779_REG_TEMP_ALTERNATE;
3641                 reg_temp_crit = NCT6779_REG_TEMP_CRIT;
3642 
3643                 break;
3644         case nct6791:
3645         case nct6792:
3646                 data->in_num = 15;
3647                 data->pwm_num = 6;
3648                 data->auto_pwm_num = 4;
3649                 data->has_fan_div = false;
3650                 data->temp_fixed_num = 6;
3651                 data->num_temp_alarms = 2;
3652                 data->num_temp_beeps = 2;
3653 
3654                 data->ALARM_BITS = NCT6791_ALARM_BITS;
3655                 data->BEEP_BITS = NCT6779_BEEP_BITS;
3656 
3657                 data->fan_from_reg = fan_from_reg13;
3658                 data->fan_from_reg_min = fan_from_reg13;
3659                 data->target_temp_mask = 0xff;
3660                 data->tolerance_mask = 0x07;
3661                 data->speed_tolerance_limit = 63;
3662 
3663                 data->temp_label = nct6779_temp_label;
3664                 data->temp_label_num = ARRAY_SIZE(nct6779_temp_label);
3665 
3666                 data->REG_CONFIG = NCT6775_REG_CONFIG;
3667                 data->REG_VBAT = NCT6775_REG_VBAT;
3668                 data->REG_DIODE = NCT6775_REG_DIODE;
3669                 data->DIODE_MASK = NCT6775_DIODE_MASK;
3670                 data->REG_VIN = NCT6779_REG_IN;
3671                 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3672                 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3673                 data->REG_TARGET = NCT6775_REG_TARGET;
3674                 data->REG_FAN = NCT6779_REG_FAN;
3675                 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3676                 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3677                 data->REG_FAN_PULSES = NCT6779_REG_FAN_PULSES;
3678                 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3679                 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3680                 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
3681                 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
3682                 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
3683                 data->REG_PWM[0] = NCT6775_REG_PWM;
3684                 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3685                 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3686                 data->REG_PWM[5] = NCT6791_REG_WEIGHT_DUTY_STEP;
3687                 data->REG_PWM[6] = NCT6791_REG_WEIGHT_DUTY_BASE;
3688                 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3689                 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3690                 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3691                 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3692                 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3693                 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3694                 data->REG_CRITICAL_TEMP_TOLERANCE
3695                   = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
3696                 data->REG_CRITICAL_PWM_ENABLE = NCT6779_REG_CRITICAL_PWM_ENABLE;
3697                 data->CRITICAL_PWM_ENABLE_MASK
3698                   = NCT6779_CRITICAL_PWM_ENABLE_MASK;
3699                 data->REG_CRITICAL_PWM = NCT6779_REG_CRITICAL_PWM;
3700                 data->REG_TEMP_OFFSET = NCT6779_REG_TEMP_OFFSET;
3701                 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3702                 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
3703                 data->REG_WEIGHT_TEMP_SEL = NCT6791_REG_WEIGHT_TEMP_SEL;
3704                 data->REG_WEIGHT_TEMP[0] = NCT6791_REG_WEIGHT_TEMP_STEP;
3705                 data->REG_WEIGHT_TEMP[1] = NCT6791_REG_WEIGHT_TEMP_STEP_TOL;
3706                 data->REG_WEIGHT_TEMP[2] = NCT6791_REG_WEIGHT_TEMP_BASE;
3707                 data->REG_ALARM = NCT6791_REG_ALARM;
3708                 if (data->kind == nct6791)
3709                         data->REG_BEEP = NCT6776_REG_BEEP;
3710                 else
3711                         data->REG_BEEP = NCT6792_REG_BEEP;
3712 
3713                 reg_temp = NCT6779_REG_TEMP;
3714                 num_reg_temp = ARRAY_SIZE(NCT6779_REG_TEMP);
3715                 if (data->kind == nct6791) {
3716                         reg_temp_mon = NCT6779_REG_TEMP_MON;
3717                         num_reg_temp_mon = ARRAY_SIZE(NCT6779_REG_TEMP_MON);
3718                 } else {
3719                         reg_temp_mon = NCT6792_REG_TEMP_MON;
3720                         num_reg_temp_mon = ARRAY_SIZE(NCT6792_REG_TEMP_MON);
3721                 }
3722                 reg_temp_over = NCT6779_REG_TEMP_OVER;
3723                 reg_temp_hyst = NCT6779_REG_TEMP_HYST;
3724                 reg_temp_config = NCT6779_REG_TEMP_CONFIG;
3725                 reg_temp_alternate = NCT6779_REG_TEMP_ALTERNATE;
3726                 reg_temp_crit = NCT6779_REG_TEMP_CRIT;
3727 
3728                 break;
3729         default:
3730                 return -ENODEV;
3731         }
3732         data->have_in = (1 << data->in_num) - 1;
3733         data->have_temp = 0;
3734 
3735         /*
3736          * On some boards, not all available temperature sources are monitored,
3737          * even though some of the monitoring registers are unused.
3738          * Get list of unused monitoring registers, then detect if any fan
3739          * controls are configured to use unmonitored temperature sources.
3740          * If so, assign the unmonitored temperature sources to available
3741          * monitoring registers.
3742          */
3743         mask = 0;
3744         available = 0;
3745         for (i = 0; i < num_reg_temp; i++) {
3746                 if (reg_temp[i] == 0)
3747                         continue;
3748 
3749                 src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f;
3750                 if (!src || (mask & (1 << src)))
3751                         available |= 1 << i;
3752 
3753                 mask |= 1 << src;
3754         }
3755 
3756         /*
3757          * Now find unmonitored temperature registers and enable monitoring
3758          * if additional monitoring registers are available.
3759          */
3760         add_temp_sensors(data, data->REG_TEMP_SEL, &available, &mask);
3761         add_temp_sensors(data, data->REG_WEIGHT_TEMP_SEL, &available, &mask);
3762 
3763         mask = 0;
3764         s = NUM_TEMP_FIXED;     /* First dynamic temperature attribute */
3765         for (i = 0; i < num_reg_temp; i++) {
3766                 if (reg_temp[i] == 0)
3767                         continue;
3768 
3769                 src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f;
3770                 if (!src || (mask & (1 << src)))
3771                         continue;
3772 
3773                 if (src >= data->temp_label_num ||
3774                     !strlen(data->temp_label[src])) {
3775                         dev_info(dev,
3776                                  "Invalid temperature source %d at index %d, source register 0x%x, temp register 0x%x\n",
3777                                  src, i, data->REG_TEMP_SOURCE[i], reg_temp[i]);
3778                         continue;
3779                 }
3780 
3781                 mask |= 1 << src;
3782 
3783                 /* Use fixed index for SYSTIN(1), CPUTIN(2), AUXTIN(3) */
3784                 if (src <= data->temp_fixed_num) {
3785                         data->have_temp |= 1 << (src - 1);
3786                         data->have_temp_fixed |= 1 << (src - 1);
3787                         data->reg_temp[0][src - 1] = reg_temp[i];
3788                         data->reg_temp[1][src - 1] = reg_temp_over[i];
3789                         data->reg_temp[2][src - 1] = reg_temp_hyst[i];
3790                         if (reg_temp_crit_h && reg_temp_crit_h[i])
3791                                 data->reg_temp[3][src - 1] = reg_temp_crit_h[i];
3792                         else if (reg_temp_crit[src - 1])
3793                                 data->reg_temp[3][src - 1]
3794                                   = reg_temp_crit[src - 1];
3795                         if (reg_temp_crit_l && reg_temp_crit_l[i])
3796                                 data->reg_temp[4][src - 1] = reg_temp_crit_l[i];
3797                         data->reg_temp_config[src - 1] = reg_temp_config[i];
3798                         data->temp_src[src - 1] = src;
3799                         continue;
3800                 }
3801 
3802                 if (s >= NUM_TEMP)
3803                         continue;
3804 
3805                 /* Use dynamic index for other sources */
3806                 data->have_temp |= 1 << s;
3807                 data->reg_temp[0][s] = reg_temp[i];
3808                 data->reg_temp[1][s] = reg_temp_over[i];
3809                 data->reg_temp[2][s] = reg_temp_hyst[i];
3810                 data->reg_temp_config[s] = reg_temp_config[i];
3811                 if (reg_temp_crit_h && reg_temp_crit_h[i])
3812                         data->reg_temp[3][s] = reg_temp_crit_h[i];
3813                 else if (reg_temp_crit[src - 1])
3814                         data->reg_temp[3][s] = reg_temp_crit[src - 1];
3815                 if (reg_temp_crit_l && reg_temp_crit_l[i])
3816                         data->reg_temp[4][s] = reg_temp_crit_l[i];
3817 
3818                 data->temp_src[s] = src;
3819                 s++;
3820         }
3821 
3822         /*
3823          * Repeat with temperatures used for fan control.
3824          * This set of registers does not support limits.
3825          */
3826         for (i = 0; i < num_reg_temp_mon; i++) {
3827                 if (reg_temp_mon[i] == 0)
3828                         continue;
3829 
3830                 src = nct6775_read_value(data, data->REG_TEMP_SEL[i]) & 0x1f;
3831                 if (!src || (mask & (1 << src)))
3832                         continue;
3833 
3834                 if (src >= data->temp_label_num ||
3835                     !strlen(data->temp_label[src])) {
3836                         dev_info(dev,
3837                                  "Invalid temperature source %d at index %d, source register 0x%x, temp register 0x%x\n",
3838                                  src, i, data->REG_TEMP_SEL[i],
3839                                  reg_temp_mon[i]);
3840                         continue;
3841                 }
3842 
3843                 mask |= 1 << src;
3844 
3845                 /* Use fixed index for SYSTIN(1), CPUTIN(2), AUXTIN(3) */
3846                 if (src <= data->temp_fixed_num) {
3847                         if (data->have_temp & (1 << (src - 1)))
3848                                 continue;
3849                         data->have_temp |= 1 << (src - 1);
3850                         data->have_temp_fixed |= 1 << (src - 1);
3851                         data->reg_temp[0][src - 1] = reg_temp_mon[i];
3852                         data->temp_src[src - 1] = src;
3853                         continue;
3854                 }
3855 
3856                 if (s >= NUM_TEMP)
3857                         continue;
3858 
3859                 /* Use dynamic index for other sources */
3860                 data->have_temp |= 1 << s;
3861                 data->reg_temp[0][s] = reg_temp_mon[i];
3862                 data->temp_src[s] = src;
3863                 s++;
3864         }
3865 
3866 #ifdef USE_ALTERNATE
3867         /*
3868          * Go through the list of alternate temp registers and enable
3869          * if possible.
3870          * The temperature is already monitored if the respective bit in <mask>
3871          * is set.
3872          */
3873         for (i = 0; i < data->temp_label_num - 1; i++) {
3874                 if (!reg_temp_alternate[i])
3875                         continue;
3876                 if (mask & (1 << (i + 1)))
3877                         continue;
3878                 if (i < data->temp_fixed_num) {
3879                         if (data->have_temp & (1 << i))
3880                                 continue;
3881                         data->have_temp |= 1 << i;
3882                         data->have_temp_fixed |= 1 << i;
3883                         data->reg_temp[0][i] = reg_temp_alternate[i];
3884                         if (i < num_reg_temp) {
3885                                 data->reg_temp[1][i] = reg_temp_over[i];
3886                                 data->reg_temp[2][i] = reg_temp_hyst[i];
3887                         }
3888                         data->temp_src[i] = i + 1;
3889                         continue;
3890                 }
3891 
3892                 if (s >= NUM_TEMP)      /* Abort if no more space */
3893                         break;
3894 
3895                 data->have_temp |= 1 << s;
3896                 data->reg_temp[0][s] = reg_temp_alternate[i];
3897                 data->temp_src[s] = i + 1;
3898                 s++;
3899         }
3900 #endif /* USE_ALTERNATE */
3901 
3902         /* Initialize the chip */
3903         nct6775_init_device(data);
3904 
3905         err = superio_enter(sio_data->sioreg);
3906         if (err)
3907                 return err;
3908 
3909         cr2a = superio_inb(sio_data->sioreg, 0x2a);
3910         switch (data->kind) {
3911         case nct6775:
3912                 data->have_vid = (cr2a & 0x40);
3913                 break;
3914         case nct6776:
3915                 data->have_vid = (cr2a & 0x60) == 0x40;
3916                 break;
3917         case nct6106:
3918         case nct6779:
3919         case nct6791:
3920         case nct6792:
3921                 break;
3922         }
3923 
3924         /*
3925          * Read VID value
3926          * We can get the VID input values directly at logical device D 0xe3.
3927          */
3928         if (data->have_vid) {
3929                 superio_select(sio_data->sioreg, NCT6775_LD_VID);
3930                 data->vid = superio_inb(sio_data->sioreg, 0xe3);
3931                 data->vrm = vid_which_vrm();
3932         }
3933 
3934         if (fan_debounce) {
3935                 u8 tmp;
3936 
3937                 superio_select(sio_data->sioreg, NCT6775_LD_HWM);
3938                 tmp = superio_inb(sio_data->sioreg,
3939                                   NCT6775_REG_CR_FAN_DEBOUNCE);
3940                 switch (data->kind) {
3941                 case nct6106:
3942                         tmp |= 0xe0;
3943                         break;
3944                 case nct6775:
3945                         tmp |= 0x1e;
3946                         break;
3947                 case nct6776:
3948                 case nct6779:
3949                         tmp |= 0x3e;
3950                         break;
3951                 case nct6791:
3952                 case nct6792:
3953                         tmp |= 0x7e;
3954                         break;
3955                 }
3956                 superio_outb(sio_data->sioreg, NCT6775_REG_CR_FAN_DEBOUNCE,
3957                              tmp);
3958                 dev_info(&pdev->dev, "Enabled fan debounce for chip %s\n",
3959                          data->name);
3960         }
3961 
3962         nct6775_check_fan_inputs(data);
3963 
3964         superio_exit(sio_data->sioreg);
3965 
3966         /* Read fan clock dividers immediately */
3967         nct6775_init_fan_common(dev, data);
3968 
3969         /* Register sysfs hooks */
3970         group = nct6775_create_attr_group(dev, &nct6775_pwm_template_group,
3971                                           data->pwm_num);
3972         if (IS_ERR(group))
3973                 return PTR_ERR(group);
3974 
3975         data->groups[num_attr_groups++] = group;
3976 
3977         group = nct6775_create_attr_group(dev, &nct6775_in_template_group,
3978                                           fls(data->have_in));
3979         if (IS_ERR(group))
3980                 return PTR_ERR(group);
3981 
3982         data->groups[num_attr_groups++] = group;
3983 
3984         group = nct6775_create_attr_group(dev, &nct6775_fan_template_group,
3985                                           fls(data->has_fan));
3986         if (IS_ERR(group))
3987                 return PTR_ERR(group);
3988 
3989         data->groups[num_attr_groups++] = group;
3990 
3991         group = nct6775_create_attr_group(dev, &nct6775_temp_template_group,
3992                                           fls(data->have_temp));
3993         if (IS_ERR(group))
3994                 return PTR_ERR(group);
3995 
3996         data->groups[num_attr_groups++] = group;
3997         data->groups[num_attr_groups++] = &nct6775_group_other;
3998 
3999         hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name,
4000                                                            data, data->groups);
4001         return PTR_ERR_OR_ZERO(hwmon_dev);
4002 }
4003 
4004 static void nct6791_enable_io_mapping(int sioaddr)
4005 {
4006         int val;
4007 
4008         val = superio_inb(sioaddr, NCT6791_REG_HM_IO_SPACE_LOCK_ENABLE);
4009         if (val & 0x10) {
4010                 pr_info("Enabling hardware monitor logical device mappings.\n");
4011                 superio_outb(sioaddr, NCT6791_REG_HM_IO_SPACE_LOCK_ENABLE,
4012                              val & ~0x10);
4013         }
4014 }
4015 
4016 static int __maybe_unused nct6775_suspend(struct device *dev)
4017 {
4018         struct nct6775_data *data = nct6775_update_device(dev);
4019 
4020         mutex_lock(&data->update_lock);
4021         data->vbat = nct6775_read_value(data, data->REG_VBAT);
4022         if (data->kind == nct6775) {
4023                 data->fandiv1 = nct6775_read_value(data, NCT6775_REG_FANDIV1);
4024                 data->fandiv2 = nct6775_read_value(data, NCT6775_REG_FANDIV2);
4025         }
4026         mutex_unlock(&data->update_lock);
4027 
4028         return 0;
4029 }
4030 
4031 static int __maybe_unused nct6775_resume(struct device *dev)
4032 {
4033         struct nct6775_data *data = dev_get_drvdata(dev);
4034         int sioreg = data->sioreg;
4035         int i, j, err = 0;
4036         u8 reg;
4037 
4038         mutex_lock(&data->update_lock);
4039         data->bank = 0xff;              /* Force initial bank selection */
4040 
4041         err = superio_enter(sioreg);
4042         if (err)
4043                 goto abort;
4044 
4045         superio_select(sioreg, NCT6775_LD_HWM);
4046         reg = superio_inb(sioreg, SIO_REG_ENABLE);
4047         if (reg != data->sio_reg_enable)
4048                 superio_outb(sioreg, SIO_REG_ENABLE, data->sio_reg_enable);
4049 
4050         if (data->kind == nct6791 || data->kind == nct6792)
4051                 nct6791_enable_io_mapping(sioreg);
4052 
4053         superio_exit(sioreg);
4054 
4055         /* Restore limits */
4056         for (i = 0; i < data->in_num; i++) {
4057                 if (!(data->have_in & (1 << i)))
4058                         continue;
4059 
4060                 nct6775_write_value(data, data->REG_IN_MINMAX[0][i],
4061                                     data->in[i][1]);
4062                 nct6775_write_value(data, data->REG_IN_MINMAX[1][i],
4063                                     data->in[i][2]);
4064         }
4065 
4066         for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
4067                 if (!(data->has_fan_min & (1 << i)))
4068                         continue;
4069 
4070                 nct6775_write_value(data, data->REG_FAN_MIN[i],
4071                                     data->fan_min[i]);
4072         }
4073 
4074         for (i = 0; i < NUM_TEMP; i++) {
4075                 if (!(data->have_temp & (1 << i)))
4076                         continue;
4077 
4078                 for (j = 1; j < ARRAY_SIZE(data->reg_temp); j++)
4079                         if (data->reg_temp[j][i])
4080                                 nct6775_write_temp(data, data->reg_temp[j][i],
4081                                                    data->temp[j][i]);
4082         }
4083 
4084         /* Restore other settings */
4085         nct6775_write_value(data, data->REG_VBAT, data->vbat);
4086         if (data->kind == nct6775) {
4087                 nct6775_write_value(data, NCT6775_REG_FANDIV1, data->fandiv1);
4088                 nct6775_write_value(data, NCT6775_REG_FANDIV2, data->fandiv2);
4089         }
4090 
4091 abort:
4092         /* Force re-reading all values */
4093         data->valid = false;
4094         mutex_unlock(&data->update_lock);
4095 
4096         return err;
4097 }
4098 
4099 static SIMPLE_DEV_PM_OPS(nct6775_dev_pm_ops, nct6775_suspend, nct6775_resume);
4100 
4101 static struct platform_driver nct6775_driver = {
4102         .driver = {
4103                 .name   = DRVNAME,
4104                 .pm     = &nct6775_dev_pm_ops,
4105         },
4106         .probe          = nct6775_probe,
4107 };
4108 
4109 static const char * const nct6775_sio_names[] __initconst = {
4110         "NCT6106D",
4111         "NCT6775F",
4112         "NCT6776D/F",
4113         "NCT6779D",
4114         "NCT6791D",
4115         "NCT6792D",
4116 };
4117 
4118 /* nct6775_find() looks for a '627 in the Super-I/O config space */
4119 static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data)
4120 {
4121         u16 val;
4122         int err;
4123         int addr;
4124 
4125         err = superio_enter(sioaddr);
4126         if (err)
4127                 return err;
4128 
4129         if (force_id)
4130                 val = force_id;
4131         else
4132                 val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8)
4133                     | superio_inb(sioaddr, SIO_REG_DEVID + 1);
4134         switch (val & SIO_ID_MASK) {
4135         case SIO_NCT6106_ID:
4136                 sio_data->kind = nct6106;
4137                 break;
4138         case SIO_NCT6775_ID:
4139                 sio_data->kind = nct6775;
4140                 break;
4141         case SIO_NCT6776_ID:
4142                 sio_data->kind = nct6776;
4143                 break;
4144         case SIO_NCT6779_ID:
4145                 sio_data->kind = nct6779;
4146                 break;
4147         case SIO_NCT6791_ID:
4148                 sio_data->kind = nct6791;
4149                 break;
4150         case SIO_NCT6792_ID:
4151                 sio_data->kind = nct6792;
4152                 break;
4153         default:
4154                 if (val != 0xffff)
4155                         pr_debug("unsupported chip ID: 0x%04x\n", val);
4156                 superio_exit(sioaddr);
4157                 return -ENODEV;
4158         }
4159 
4160         /* We have a known chip, find the HWM I/O address */
4161         superio_select(sioaddr, NCT6775_LD_HWM);
4162         val = (superio_inb(sioaddr, SIO_REG_ADDR) << 8)
4163             | superio_inb(sioaddr, SIO_REG_ADDR + 1);
4164         addr = val & IOREGION_ALIGNMENT;
4165         if (addr == 0) {
4166                 pr_err("Refusing to enable a Super-I/O device with a base I/O port 0\n");
4167                 superio_exit(sioaddr);
4168                 return -ENODEV;
4169         }
4170 
4171         /* Activate logical device if needed */
4172         val = superio_inb(sioaddr, SIO_REG_ENABLE);
4173         if (!(val & 0x01)) {
4174                 pr_warn("Forcibly enabling Super-I/O. Sensor is probably unusable.\n");
4175                 superio_outb(sioaddr, SIO_REG_ENABLE, val | 0x01);
4176         }
4177 
4178         if (sio_data->kind == nct6791 || sio_data->kind == nct6792)
4179                 nct6791_enable_io_mapping(sioaddr);
4180 
4181         superio_exit(sioaddr);
4182         pr_info("Found %s or compatible chip at %#x:%#x\n",
4183                 nct6775_sio_names[sio_data->kind], sioaddr, addr);
4184         sio_data->sioreg = sioaddr;
4185 
4186         return addr;
4187 }
4188 
4189 /*
4190  * when Super-I/O functions move to a separate file, the Super-I/O
4191  * bus will manage the lifetime of the device and this module will only keep
4192  * track of the nct6775 driver. But since we use platform_device_alloc(), we
4193  * must keep track of the device
4194  */
4195 static struct platform_device *pdev[2];
4196 
4197 static int __init sensors_nct6775_init(void)
4198 {
4199         int i, err;
4200         bool found = false;
4201         int address;
4202         struct resource res;
4203         struct nct6775_sio_data sio_data;
4204         int sioaddr[2] = { 0x2e, 0x4e };
4205 
4206         err = platform_driver_register(&nct6775_driver);
4207         if (err)
4208                 return err;
4209 
4210         /*
4211          * initialize sio_data->kind and sio_data->sioreg.
4212          *
4213          * when Super-I/O functions move to a separate file, the Super-I/O
4214          * driver will probe 0x2e and 0x4e and auto-detect the presence of a
4215          * nct6775 hardware monitor, and call probe()
4216          */
4217         for (i = 0; i < ARRAY_SIZE(pdev); i++) {
4218                 address = nct6775_find(sioaddr[i], &sio_data);
4219                 if (address <= 0)
4220                         continue;
4221 
4222                 found = true;
4223 
4224                 pdev[i] = platform_device_alloc(DRVNAME, address);
4225                 if (!pdev[i]) {
4226                         err = -ENOMEM;
4227                         goto exit_device_unregister;
4228                 }
4229 
4230                 err = platform_device_add_data(pdev[i], &sio_data,
4231                                                sizeof(struct nct6775_sio_data));
4232                 if (err)
4233                         goto exit_device_put;
4234 
4235                 memset(&res, 0, sizeof(res));
4236                 res.name = DRVNAME;
4237                 res.start = address + IOREGION_OFFSET;
4238                 res.end = address + IOREGION_OFFSET + IOREGION_LENGTH - 1;
4239                 res.flags = IORESOURCE_IO;
4240 
4241                 err = acpi_check_resource_conflict(&res);
4242                 if (err) {
4243                         platform_device_put(pdev[i]);
4244                         pdev[i] = NULL;
4245                         continue;
4246                 }
4247 
4248                 err = platform_device_add_resources(pdev[i], &res, 1);
4249                 if (err)
4250                         goto exit_device_put;
4251 
4252                 /* platform_device_add calls probe() */
4253                 err = platform_device_add(pdev[i]);
4254                 if (err)
4255                         goto exit_device_put;
4256         }
4257         if (!found) {
4258                 err = -ENODEV;
4259                 goto exit_unregister;
4260         }
4261 
4262         return 0;
4263 
4264 exit_device_put:
4265         platform_device_put(pdev[i]);
4266 exit_device_unregister:
4267         while (--i >= 0) {
4268                 if (pdev[i])
4269                         platform_device_unregister(pdev[i]);
4270         }
4271 exit_unregister:
4272         platform_driver_unregister(&nct6775_driver);
4273         return err;
4274 }
4275 
4276 static void __exit sensors_nct6775_exit(void)
4277 {
4278         int i;
4279 
4280         for (i = 0; i < ARRAY_SIZE(pdev); i++) {
4281                 if (pdev[i])
4282                         platform_device_unregister(pdev[i]);
4283         }
4284         platform_driver_unregister(&nct6775_driver);
4285 }
4286 
4287 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
4288 MODULE_DESCRIPTION("NCT6106D/NCT6775F/NCT6776F/NCT6779D/NCT6791D/NCT6792D driver");
4289 MODULE_LICENSE("GPL");
4290 
4291 module_init(sensors_nct6775_init);
4292 module_exit(sensors_nct6775_exit);
4293 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us